#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct char1 {
pub x: ::std::os::raw::c_schar,
}
#[test]
fn bindgen_test_layout_char1() {
assert_eq!(
::std::mem::size_of::<char1>(),
1usize,
concat!("Size of: ", stringify!(char1))
);
assert_eq!(
::std::mem::align_of::<char1>(),
1usize,
concat!("Alignment of ", stringify!(char1))
);
assert_eq!(
unsafe { &(*(0 as *const char1)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(char1), "::", stringify!(x))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct uchar1 {
pub x: ::std::os::raw::c_uchar,
}
#[test]
fn bindgen_test_layout_uchar1() {
assert_eq!(
::std::mem::size_of::<uchar1>(),
1usize,
concat!("Size of: ", stringify!(uchar1))
);
assert_eq!(
::std::mem::align_of::<uchar1>(),
1usize,
concat!("Alignment of ", stringify!(uchar1))
);
assert_eq!(
unsafe { &(*(0 as *const uchar1)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(uchar1), "::", stringify!(x))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct char2 {
pub x: ::std::os::raw::c_schar,
pub y: ::std::os::raw::c_schar,
pub __bindgen_align: [u16; 0usize],
}
#[test]
fn bindgen_test_layout_char2() {
assert_eq!(
::std::mem::size_of::<char2>(),
2usize,
concat!("Size of: ", stringify!(char2))
);
assert_eq!(
::std::mem::align_of::<char2>(),
2usize,
concat!("Alignment of ", stringify!(char2))
);
assert_eq!(
unsafe { &(*(0 as *const char2)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(char2), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const char2)).y as *const _ as usize },
1usize,
concat!("Offset of field: ", stringify!(char2), "::", stringify!(y))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct uchar2 {
pub x: ::std::os::raw::c_uchar,
pub y: ::std::os::raw::c_uchar,
pub __bindgen_align: [u16; 0usize],
}
#[test]
fn bindgen_test_layout_uchar2() {
assert_eq!(
::std::mem::size_of::<uchar2>(),
2usize,
concat!("Size of: ", stringify!(uchar2))
);
assert_eq!(
::std::mem::align_of::<uchar2>(),
2usize,
concat!("Alignment of ", stringify!(uchar2))
);
assert_eq!(
unsafe { &(*(0 as *const uchar2)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(uchar2), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const uchar2)).y as *const _ as usize },
1usize,
concat!("Offset of field: ", stringify!(uchar2), "::", stringify!(y))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct char3 {
pub x: ::std::os::raw::c_schar,
pub y: ::std::os::raw::c_schar,
pub z: ::std::os::raw::c_schar,
}
#[test]
fn bindgen_test_layout_char3() {
assert_eq!(
::std::mem::size_of::<char3>(),
3usize,
concat!("Size of: ", stringify!(char3))
);
assert_eq!(
::std::mem::align_of::<char3>(),
1usize,
concat!("Alignment of ", stringify!(char3))
);
assert_eq!(
unsafe { &(*(0 as *const char3)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(char3), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const char3)).y as *const _ as usize },
1usize,
concat!("Offset of field: ", stringify!(char3), "::", stringify!(y))
);
assert_eq!(
unsafe { &(*(0 as *const char3)).z as *const _ as usize },
2usize,
concat!("Offset of field: ", stringify!(char3), "::", stringify!(z))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct uchar3 {
pub x: ::std::os::raw::c_uchar,
pub y: ::std::os::raw::c_uchar,
pub z: ::std::os::raw::c_uchar,
}
#[test]
fn bindgen_test_layout_uchar3() {
assert_eq!(
::std::mem::size_of::<uchar3>(),
3usize,
concat!("Size of: ", stringify!(uchar3))
);
assert_eq!(
::std::mem::align_of::<uchar3>(),
1usize,
concat!("Alignment of ", stringify!(uchar3))
);
assert_eq!(
unsafe { &(*(0 as *const uchar3)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(uchar3), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const uchar3)).y as *const _ as usize },
1usize,
concat!("Offset of field: ", stringify!(uchar3), "::", stringify!(y))
);
assert_eq!(
unsafe { &(*(0 as *const uchar3)).z as *const _ as usize },
2usize,
concat!("Offset of field: ", stringify!(uchar3), "::", stringify!(z))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct char4 {
pub x: ::std::os::raw::c_schar,
pub y: ::std::os::raw::c_schar,
pub z: ::std::os::raw::c_schar,
pub w: ::std::os::raw::c_schar,
pub __bindgen_align: [u32; 0usize],
}
#[test]
fn bindgen_test_layout_char4() {
assert_eq!(
::std::mem::size_of::<char4>(),
4usize,
concat!("Size of: ", stringify!(char4))
);
assert_eq!(
::std::mem::align_of::<char4>(),
4usize,
concat!("Alignment of ", stringify!(char4))
);
assert_eq!(
unsafe { &(*(0 as *const char4)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(char4), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const char4)).y as *const _ as usize },
1usize,
concat!("Offset of field: ", stringify!(char4), "::", stringify!(y))
);
assert_eq!(
unsafe { &(*(0 as *const char4)).z as *const _ as usize },
2usize,
concat!("Offset of field: ", stringify!(char4), "::", stringify!(z))
);
assert_eq!(
unsafe { &(*(0 as *const char4)).w as *const _ as usize },
3usize,
concat!("Offset of field: ", stringify!(char4), "::", stringify!(w))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct uchar4 {
pub x: ::std::os::raw::c_uchar,
pub y: ::std::os::raw::c_uchar,
pub z: ::std::os::raw::c_uchar,
pub w: ::std::os::raw::c_uchar,
pub __bindgen_align: [u32; 0usize],
}
#[test]
fn bindgen_test_layout_uchar4() {
assert_eq!(
::std::mem::size_of::<uchar4>(),
4usize,
concat!("Size of: ", stringify!(uchar4))
);
assert_eq!(
::std::mem::align_of::<uchar4>(),
4usize,
concat!("Alignment of ", stringify!(uchar4))
);
assert_eq!(
unsafe { &(*(0 as *const uchar4)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(uchar4), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const uchar4)).y as *const _ as usize },
1usize,
concat!("Offset of field: ", stringify!(uchar4), "::", stringify!(y))
);
assert_eq!(
unsafe { &(*(0 as *const uchar4)).z as *const _ as usize },
2usize,
concat!("Offset of field: ", stringify!(uchar4), "::", stringify!(z))
);
assert_eq!(
unsafe { &(*(0 as *const uchar4)).w as *const _ as usize },
3usize,
concat!("Offset of field: ", stringify!(uchar4), "::", stringify!(w))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct short1 {
pub x: ::std::os::raw::c_short,
}
#[test]
fn bindgen_test_layout_short1() {
assert_eq!(
::std::mem::size_of::<short1>(),
2usize,
concat!("Size of: ", stringify!(short1))
);
assert_eq!(
::std::mem::align_of::<short1>(),
2usize,
concat!("Alignment of ", stringify!(short1))
);
assert_eq!(
unsafe { &(*(0 as *const short1)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(short1), "::", stringify!(x))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ushort1 {
pub x: ::std::os::raw::c_ushort,
}
#[test]
fn bindgen_test_layout_ushort1() {
assert_eq!(
::std::mem::size_of::<ushort1>(),
2usize,
concat!("Size of: ", stringify!(ushort1))
);
assert_eq!(
::std::mem::align_of::<ushort1>(),
2usize,
concat!("Alignment of ", stringify!(ushort1))
);
assert_eq!(
unsafe { &(*(0 as *const ushort1)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(ushort1), "::", stringify!(x))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct short2 {
pub x: ::std::os::raw::c_short,
pub y: ::std::os::raw::c_short,
pub __bindgen_align: [u32; 0usize],
}
#[test]
fn bindgen_test_layout_short2() {
assert_eq!(
::std::mem::size_of::<short2>(),
4usize,
concat!("Size of: ", stringify!(short2))
);
assert_eq!(
::std::mem::align_of::<short2>(),
4usize,
concat!("Alignment of ", stringify!(short2))
);
assert_eq!(
unsafe { &(*(0 as *const short2)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(short2), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const short2)).y as *const _ as usize },
2usize,
concat!("Offset of field: ", stringify!(short2), "::", stringify!(y))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ushort2 {
pub x: ::std::os::raw::c_ushort,
pub y: ::std::os::raw::c_ushort,
pub __bindgen_align: [u32; 0usize],
}
#[test]
fn bindgen_test_layout_ushort2() {
assert_eq!(
::std::mem::size_of::<ushort2>(),
4usize,
concat!("Size of: ", stringify!(ushort2))
);
assert_eq!(
::std::mem::align_of::<ushort2>(),
4usize,
concat!("Alignment of ", stringify!(ushort2))
);
assert_eq!(
unsafe { &(*(0 as *const ushort2)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(ushort2), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const ushort2)).y as *const _ as usize },
2usize,
concat!("Offset of field: ", stringify!(ushort2), "::", stringify!(y))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct short3 {
pub x: ::std::os::raw::c_short,
pub y: ::std::os::raw::c_short,
pub z: ::std::os::raw::c_short,
}
#[test]
fn bindgen_test_layout_short3() {
assert_eq!(
::std::mem::size_of::<short3>(),
6usize,
concat!("Size of: ", stringify!(short3))
);
assert_eq!(
::std::mem::align_of::<short3>(),
2usize,
concat!("Alignment of ", stringify!(short3))
);
assert_eq!(
unsafe { &(*(0 as *const short3)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(short3), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const short3)).y as *const _ as usize },
2usize,
concat!("Offset of field: ", stringify!(short3), "::", stringify!(y))
);
assert_eq!(
unsafe { &(*(0 as *const short3)).z as *const _ as usize },
4usize,
concat!("Offset of field: ", stringify!(short3), "::", stringify!(z))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ushort3 {
pub x: ::std::os::raw::c_ushort,
pub y: ::std::os::raw::c_ushort,
pub z: ::std::os::raw::c_ushort,
}
#[test]
fn bindgen_test_layout_ushort3() {
assert_eq!(
::std::mem::size_of::<ushort3>(),
6usize,
concat!("Size of: ", stringify!(ushort3))
);
assert_eq!(
::std::mem::align_of::<ushort3>(),
2usize,
concat!("Alignment of ", stringify!(ushort3))
);
assert_eq!(
unsafe { &(*(0 as *const ushort3)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(ushort3), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const ushort3)).y as *const _ as usize },
2usize,
concat!("Offset of field: ", stringify!(ushort3), "::", stringify!(y))
);
assert_eq!(
unsafe { &(*(0 as *const ushort3)).z as *const _ as usize },
4usize,
concat!("Offset of field: ", stringify!(ushort3), "::", stringify!(z))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct short4 {
pub x: ::std::os::raw::c_short,
pub y: ::std::os::raw::c_short,
pub z: ::std::os::raw::c_short,
pub w: ::std::os::raw::c_short,
pub __bindgen_align: [u64; 0usize],
}
#[test]
fn bindgen_test_layout_short4() {
assert_eq!(
::std::mem::size_of::<short4>(),
8usize,
concat!("Size of: ", stringify!(short4))
);
assert_eq!(
::std::mem::align_of::<short4>(),
8usize,
concat!("Alignment of ", stringify!(short4))
);
assert_eq!(
unsafe { &(*(0 as *const short4)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(short4), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const short4)).y as *const _ as usize },
2usize,
concat!("Offset of field: ", stringify!(short4), "::", stringify!(y))
);
assert_eq!(
unsafe { &(*(0 as *const short4)).z as *const _ as usize },
4usize,
concat!("Offset of field: ", stringify!(short4), "::", stringify!(z))
);
assert_eq!(
unsafe { &(*(0 as *const short4)).w as *const _ as usize },
6usize,
concat!("Offset of field: ", stringify!(short4), "::", stringify!(w))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ushort4 {
pub x: ::std::os::raw::c_ushort,
pub y: ::std::os::raw::c_ushort,
pub z: ::std::os::raw::c_ushort,
pub w: ::std::os::raw::c_ushort,
pub __bindgen_align: [u64; 0usize],
}
#[test]
fn bindgen_test_layout_ushort4() {
assert_eq!(
::std::mem::size_of::<ushort4>(),
8usize,
concat!("Size of: ", stringify!(ushort4))
);
assert_eq!(
::std::mem::align_of::<ushort4>(),
8usize,
concat!("Alignment of ", stringify!(ushort4))
);
assert_eq!(
unsafe { &(*(0 as *const ushort4)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(ushort4), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const ushort4)).y as *const _ as usize },
2usize,
concat!("Offset of field: ", stringify!(ushort4), "::", stringify!(y))
);
assert_eq!(
unsafe { &(*(0 as *const ushort4)).z as *const _ as usize },
4usize,
concat!("Offset of field: ", stringify!(ushort4), "::", stringify!(z))
);
assert_eq!(
unsafe { &(*(0 as *const ushort4)).w as *const _ as usize },
6usize,
concat!("Offset of field: ", stringify!(ushort4), "::", stringify!(w))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct int1 {
pub x: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_int1() {
assert_eq!(
::std::mem::size_of::<int1>(),
4usize,
concat!("Size of: ", stringify!(int1))
);
assert_eq!(
::std::mem::align_of::<int1>(),
4usize,
concat!("Alignment of ", stringify!(int1))
);
assert_eq!(
unsafe { &(*(0 as *const int1)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(int1), "::", stringify!(x))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct uint1 {
pub x: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_uint1() {
assert_eq!(
::std::mem::size_of::<uint1>(),
4usize,
concat!("Size of: ", stringify!(uint1))
);
assert_eq!(
::std::mem::align_of::<uint1>(),
4usize,
concat!("Alignment of ", stringify!(uint1))
);
assert_eq!(
unsafe { &(*(0 as *const uint1)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(uint1), "::", stringify!(x))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct int2 {
pub x: ::std::os::raw::c_int,
pub y: ::std::os::raw::c_int,
pub __bindgen_align: [u64; 0usize],
}
#[test]
fn bindgen_test_layout_int2() {
assert_eq!(
::std::mem::size_of::<int2>(),
8usize,
concat!("Size of: ", stringify!(int2))
);
assert_eq!(
::std::mem::align_of::<int2>(),
8usize,
concat!("Alignment of ", stringify!(int2))
);
assert_eq!(
unsafe { &(*(0 as *const int2)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(int2), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const int2)).y as *const _ as usize },
4usize,
concat!("Offset of field: ", stringify!(int2), "::", stringify!(y))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct uint2 {
pub x: ::std::os::raw::c_uint,
pub y: ::std::os::raw::c_uint,
pub __bindgen_align: [u64; 0usize],
}
#[test]
fn bindgen_test_layout_uint2() {
assert_eq!(
::std::mem::size_of::<uint2>(),
8usize,
concat!("Size of: ", stringify!(uint2))
);
assert_eq!(
::std::mem::align_of::<uint2>(),
8usize,
concat!("Alignment of ", stringify!(uint2))
);
assert_eq!(
unsafe { &(*(0 as *const uint2)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(uint2), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const uint2)).y as *const _ as usize },
4usize,
concat!("Offset of field: ", stringify!(uint2), "::", stringify!(y))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct int3 {
pub x: ::std::os::raw::c_int,
pub y: ::std::os::raw::c_int,
pub z: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_int3() {
assert_eq!(
::std::mem::size_of::<int3>(),
12usize,
concat!("Size of: ", stringify!(int3))
);
assert_eq!(
::std::mem::align_of::<int3>(),
4usize,
concat!("Alignment of ", stringify!(int3))
);
assert_eq!(
unsafe { &(*(0 as *const int3)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(int3), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const int3)).y as *const _ as usize },
4usize,
concat!("Offset of field: ", stringify!(int3), "::", stringify!(y))
);
assert_eq!(
unsafe { &(*(0 as *const int3)).z as *const _ as usize },
8usize,
concat!("Offset of field: ", stringify!(int3), "::", stringify!(z))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct uint3 {
pub x: ::std::os::raw::c_uint,
pub y: ::std::os::raw::c_uint,
pub z: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_uint3() {
assert_eq!(
::std::mem::size_of::<uint3>(),
12usize,
concat!("Size of: ", stringify!(uint3))
);
assert_eq!(
::std::mem::align_of::<uint3>(),
4usize,
concat!("Alignment of ", stringify!(uint3))
);
assert_eq!(
unsafe { &(*(0 as *const uint3)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(uint3), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const uint3)).y as *const _ as usize },
4usize,
concat!("Offset of field: ", stringify!(uint3), "::", stringify!(y))
);
assert_eq!(
unsafe { &(*(0 as *const uint3)).z as *const _ as usize },
8usize,
concat!("Offset of field: ", stringify!(uint3), "::", stringify!(z))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct int4 {
pub x: ::std::os::raw::c_int,
pub y: ::std::os::raw::c_int,
pub z: ::std::os::raw::c_int,
pub w: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_int4() {
assert_eq!(
::std::mem::size_of::<int4>(),
16usize,
concat!("Size of: ", stringify!(int4))
);
assert_eq!(
unsafe { &(*(0 as *const int4)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(int4), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const int4)).y as *const _ as usize },
4usize,
concat!("Offset of field: ", stringify!(int4), "::", stringify!(y))
);
assert_eq!(
unsafe { &(*(0 as *const int4)).z as *const _ as usize },
8usize,
concat!("Offset of field: ", stringify!(int4), "::", stringify!(z))
);
assert_eq!(
unsafe { &(*(0 as *const int4)).w as *const _ as usize },
12usize,
concat!("Offset of field: ", stringify!(int4), "::", stringify!(w))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct uint4 {
pub x: ::std::os::raw::c_uint,
pub y: ::std::os::raw::c_uint,
pub z: ::std::os::raw::c_uint,
pub w: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_uint4() {
assert_eq!(
::std::mem::size_of::<uint4>(),
16usize,
concat!("Size of: ", stringify!(uint4))
);
assert_eq!(
unsafe { &(*(0 as *const uint4)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(uint4), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const uint4)).y as *const _ as usize },
4usize,
concat!("Offset of field: ", stringify!(uint4), "::", stringify!(y))
);
assert_eq!(
unsafe { &(*(0 as *const uint4)).z as *const _ as usize },
8usize,
concat!("Offset of field: ", stringify!(uint4), "::", stringify!(z))
);
assert_eq!(
unsafe { &(*(0 as *const uint4)).w as *const _ as usize },
12usize,
concat!("Offset of field: ", stringify!(uint4), "::", stringify!(w))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct long1 {
pub x: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_long1() {
assert_eq!(
::std::mem::size_of::<long1>(),
8usize,
concat!("Size of: ", stringify!(long1))
);
assert_eq!(
::std::mem::align_of::<long1>(),
8usize,
concat!("Alignment of ", stringify!(long1))
);
assert_eq!(
unsafe { &(*(0 as *const long1)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(long1), "::", stringify!(x))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ulong1 {
pub x: ::std::os::raw::c_ulong,
}
#[test]
fn bindgen_test_layout_ulong1() {
assert_eq!(
::std::mem::size_of::<ulong1>(),
8usize,
concat!("Size of: ", stringify!(ulong1))
);
assert_eq!(
::std::mem::align_of::<ulong1>(),
8usize,
concat!("Alignment of ", stringify!(ulong1))
);
assert_eq!(
unsafe { &(*(0 as *const ulong1)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(ulong1), "::", stringify!(x))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct long2 {
pub x: ::std::os::raw::c_long,
pub y: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_long2() {
assert_eq!(
::std::mem::size_of::<long2>(),
16usize,
concat!("Size of: ", stringify!(long2))
);
assert_eq!(
unsafe { &(*(0 as *const long2)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(long2), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const long2)).y as *const _ as usize },
8usize,
concat!("Offset of field: ", stringify!(long2), "::", stringify!(y))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ulong2 {
pub x: ::std::os::raw::c_ulong,
pub y: ::std::os::raw::c_ulong,
}
#[test]
fn bindgen_test_layout_ulong2() {
assert_eq!(
::std::mem::size_of::<ulong2>(),
16usize,
concat!("Size of: ", stringify!(ulong2))
);
assert_eq!(
unsafe { &(*(0 as *const ulong2)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(ulong2), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const ulong2)).y as *const _ as usize },
8usize,
concat!("Offset of field: ", stringify!(ulong2), "::", stringify!(y))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct long3 {
pub x: ::std::os::raw::c_long,
pub y: ::std::os::raw::c_long,
pub z: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_long3() {
assert_eq!(
::std::mem::size_of::<long3>(),
24usize,
concat!("Size of: ", stringify!(long3))
);
assert_eq!(
::std::mem::align_of::<long3>(),
8usize,
concat!("Alignment of ", stringify!(long3))
);
assert_eq!(
unsafe { &(*(0 as *const long3)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(long3), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const long3)).y as *const _ as usize },
8usize,
concat!("Offset of field: ", stringify!(long3), "::", stringify!(y))
);
assert_eq!(
unsafe { &(*(0 as *const long3)).z as *const _ as usize },
16usize,
concat!("Offset of field: ", stringify!(long3), "::", stringify!(z))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ulong3 {
pub x: ::std::os::raw::c_ulong,
pub y: ::std::os::raw::c_ulong,
pub z: ::std::os::raw::c_ulong,
}
#[test]
fn bindgen_test_layout_ulong3() {
assert_eq!(
::std::mem::size_of::<ulong3>(),
24usize,
concat!("Size of: ", stringify!(ulong3))
);
assert_eq!(
::std::mem::align_of::<ulong3>(),
8usize,
concat!("Alignment of ", stringify!(ulong3))
);
assert_eq!(
unsafe { &(*(0 as *const ulong3)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(ulong3), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const ulong3)).y as *const _ as usize },
8usize,
concat!("Offset of field: ", stringify!(ulong3), "::", stringify!(y))
);
assert_eq!(
unsafe { &(*(0 as *const ulong3)).z as *const _ as usize },
16usize,
concat!("Offset of field: ", stringify!(ulong3), "::", stringify!(z))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct long4 {
pub x: ::std::os::raw::c_long,
pub y: ::std::os::raw::c_long,
pub z: ::std::os::raw::c_long,
pub w: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_long4() {
assert_eq!(
::std::mem::size_of::<long4>(),
32usize,
concat!("Size of: ", stringify!(long4))
);
assert_eq!(
unsafe { &(*(0 as *const long4)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(long4), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const long4)).y as *const _ as usize },
8usize,
concat!("Offset of field: ", stringify!(long4), "::", stringify!(y))
);
assert_eq!(
unsafe { &(*(0 as *const long4)).z as *const _ as usize },
16usize,
concat!("Offset of field: ", stringify!(long4), "::", stringify!(z))
);
assert_eq!(
unsafe { &(*(0 as *const long4)).w as *const _ as usize },
24usize,
concat!("Offset of field: ", stringify!(long4), "::", stringify!(w))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ulong4 {
pub x: ::std::os::raw::c_ulong,
pub y: ::std::os::raw::c_ulong,
pub z: ::std::os::raw::c_ulong,
pub w: ::std::os::raw::c_ulong,
}
#[test]
fn bindgen_test_layout_ulong4() {
assert_eq!(
::std::mem::size_of::<ulong4>(),
32usize,
concat!("Size of: ", stringify!(ulong4))
);
assert_eq!(
unsafe { &(*(0 as *const ulong4)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(ulong4), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const ulong4)).y as *const _ as usize },
8usize,
concat!("Offset of field: ", stringify!(ulong4), "::", stringify!(y))
);
assert_eq!(
unsafe { &(*(0 as *const ulong4)).z as *const _ as usize },
16usize,
concat!("Offset of field: ", stringify!(ulong4), "::", stringify!(z))
);
assert_eq!(
unsafe { &(*(0 as *const ulong4)).w as *const _ as usize },
24usize,
concat!("Offset of field: ", stringify!(ulong4), "::", stringify!(w))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct float1 {
pub x: f32,
}
#[test]
fn bindgen_test_layout_float1() {
assert_eq!(
::std::mem::size_of::<float1>(),
4usize,
concat!("Size of: ", stringify!(float1))
);
assert_eq!(
::std::mem::align_of::<float1>(),
4usize,
concat!("Alignment of ", stringify!(float1))
);
assert_eq!(
unsafe { &(*(0 as *const float1)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(float1), "::", stringify!(x))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct float2 {
pub x: f32,
pub y: f32,
pub __bindgen_align: [u64; 0usize],
}
#[test]
fn bindgen_test_layout_float2() {
assert_eq!(
::std::mem::size_of::<float2>(),
8usize,
concat!("Size of: ", stringify!(float2))
);
assert_eq!(
::std::mem::align_of::<float2>(),
8usize,
concat!("Alignment of ", stringify!(float2))
);
assert_eq!(
unsafe { &(*(0 as *const float2)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(float2), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const float2)).y as *const _ as usize },
4usize,
concat!("Offset of field: ", stringify!(float2), "::", stringify!(y))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct float3 {
pub x: f32,
pub y: f32,
pub z: f32,
}
#[test]
fn bindgen_test_layout_float3() {
assert_eq!(
::std::mem::size_of::<float3>(),
12usize,
concat!("Size of: ", stringify!(float3))
);
assert_eq!(
::std::mem::align_of::<float3>(),
4usize,
concat!("Alignment of ", stringify!(float3))
);
assert_eq!(
unsafe { &(*(0 as *const float3)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(float3), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const float3)).y as *const _ as usize },
4usize,
concat!("Offset of field: ", stringify!(float3), "::", stringify!(y))
);
assert_eq!(
unsafe { &(*(0 as *const float3)).z as *const _ as usize },
8usize,
concat!("Offset of field: ", stringify!(float3), "::", stringify!(z))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct float4 {
pub x: f32,
pub y: f32,
pub z: f32,
pub w: f32,
}
#[test]
fn bindgen_test_layout_float4() {
assert_eq!(
::std::mem::size_of::<float4>(),
16usize,
concat!("Size of: ", stringify!(float4))
);
assert_eq!(
unsafe { &(*(0 as *const float4)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(float4), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const float4)).y as *const _ as usize },
4usize,
concat!("Offset of field: ", stringify!(float4), "::", stringify!(y))
);
assert_eq!(
unsafe { &(*(0 as *const float4)).z as *const _ as usize },
8usize,
concat!("Offset of field: ", stringify!(float4), "::", stringify!(z))
);
assert_eq!(
unsafe { &(*(0 as *const float4)).w as *const _ as usize },
12usize,
concat!("Offset of field: ", stringify!(float4), "::", stringify!(w))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct longlong1 {
pub x: ::std::os::raw::c_longlong,
}
#[test]
fn bindgen_test_layout_longlong1() {
assert_eq!(
::std::mem::size_of::<longlong1>(),
8usize,
concat!("Size of: ", stringify!(longlong1))
);
assert_eq!(
::std::mem::align_of::<longlong1>(),
8usize,
concat!("Alignment of ", stringify!(longlong1))
);
assert_eq!(
unsafe { &(*(0 as *const longlong1)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(longlong1), "::", stringify!(x))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ulonglong1 {
pub x: ::std::os::raw::c_ulonglong,
}
#[test]
fn bindgen_test_layout_ulonglong1() {
assert_eq!(
::std::mem::size_of::<ulonglong1>(),
8usize,
concat!("Size of: ", stringify!(ulonglong1))
);
assert_eq!(
::std::mem::align_of::<ulonglong1>(),
8usize,
concat!("Alignment of ", stringify!(ulonglong1))
);
assert_eq!(
unsafe { &(*(0 as *const ulonglong1)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(ulonglong1), "::", stringify!(x))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct longlong2 {
pub x: ::std::os::raw::c_longlong,
pub y: ::std::os::raw::c_longlong,
}
#[test]
fn bindgen_test_layout_longlong2() {
assert_eq!(
::std::mem::size_of::<longlong2>(),
16usize,
concat!("Size of: ", stringify!(longlong2))
);
assert_eq!(
unsafe { &(*(0 as *const longlong2)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(longlong2), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const longlong2)).y as *const _ as usize },
8usize,
concat!("Offset of field: ", stringify!(longlong2), "::", stringify!(y))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ulonglong2 {
pub x: ::std::os::raw::c_ulonglong,
pub y: ::std::os::raw::c_ulonglong,
}
#[test]
fn bindgen_test_layout_ulonglong2() {
assert_eq!(
::std::mem::size_of::<ulonglong2>(),
16usize,
concat!("Size of: ", stringify!(ulonglong2))
);
assert_eq!(
unsafe { &(*(0 as *const ulonglong2)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(ulonglong2), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const ulonglong2)).y as *const _ as usize },
8usize,
concat!("Offset of field: ", stringify!(ulonglong2), "::", stringify!(y))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct longlong3 {
pub x: ::std::os::raw::c_longlong,
pub y: ::std::os::raw::c_longlong,
pub z: ::std::os::raw::c_longlong,
}
#[test]
fn bindgen_test_layout_longlong3() {
assert_eq!(
::std::mem::size_of::<longlong3>(),
24usize,
concat!("Size of: ", stringify!(longlong3))
);
assert_eq!(
::std::mem::align_of::<longlong3>(),
8usize,
concat!("Alignment of ", stringify!(longlong3))
);
assert_eq!(
unsafe { &(*(0 as *const longlong3)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(longlong3), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const longlong3)).y as *const _ as usize },
8usize,
concat!("Offset of field: ", stringify!(longlong3), "::", stringify!(y))
);
assert_eq!(
unsafe { &(*(0 as *const longlong3)).z as *const _ as usize },
16usize,
concat!("Offset of field: ", stringify!(longlong3), "::", stringify!(z))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ulonglong3 {
pub x: ::std::os::raw::c_ulonglong,
pub y: ::std::os::raw::c_ulonglong,
pub z: ::std::os::raw::c_ulonglong,
}
#[test]
fn bindgen_test_layout_ulonglong3() {
assert_eq!(
::std::mem::size_of::<ulonglong3>(),
24usize,
concat!("Size of: ", stringify!(ulonglong3))
);
assert_eq!(
::std::mem::align_of::<ulonglong3>(),
8usize,
concat!("Alignment of ", stringify!(ulonglong3))
);
assert_eq!(
unsafe { &(*(0 as *const ulonglong3)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(ulonglong3), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const ulonglong3)).y as *const _ as usize },
8usize,
concat!("Offset of field: ", stringify!(ulonglong3), "::", stringify!(y))
);
assert_eq!(
unsafe { &(*(0 as *const ulonglong3)).z as *const _ as usize },
16usize,
concat!("Offset of field: ", stringify!(ulonglong3), "::", stringify!(z))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct longlong4 {
pub x: ::std::os::raw::c_longlong,
pub y: ::std::os::raw::c_longlong,
pub z: ::std::os::raw::c_longlong,
pub w: ::std::os::raw::c_longlong,
}
#[test]
fn bindgen_test_layout_longlong4() {
assert_eq!(
::std::mem::size_of::<longlong4>(),
32usize,
concat!("Size of: ", stringify!(longlong4))
);
assert_eq!(
unsafe { &(*(0 as *const longlong4)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(longlong4), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const longlong4)).y as *const _ as usize },
8usize,
concat!("Offset of field: ", stringify!(longlong4), "::", stringify!(y))
);
assert_eq!(
unsafe { &(*(0 as *const longlong4)).z as *const _ as usize },
16usize,
concat!("Offset of field: ", stringify!(longlong4), "::", stringify!(z))
);
assert_eq!(
unsafe { &(*(0 as *const longlong4)).w as *const _ as usize },
24usize,
concat!("Offset of field: ", stringify!(longlong4), "::", stringify!(w))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ulonglong4 {
pub x: ::std::os::raw::c_ulonglong,
pub y: ::std::os::raw::c_ulonglong,
pub z: ::std::os::raw::c_ulonglong,
pub w: ::std::os::raw::c_ulonglong,
}
#[test]
fn bindgen_test_layout_ulonglong4() {
assert_eq!(
::std::mem::size_of::<ulonglong4>(),
32usize,
concat!("Size of: ", stringify!(ulonglong4))
);
assert_eq!(
unsafe { &(*(0 as *const ulonglong4)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(ulonglong4), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const ulonglong4)).y as *const _ as usize },
8usize,
concat!("Offset of field: ", stringify!(ulonglong4), "::", stringify!(y))
);
assert_eq!(
unsafe { &(*(0 as *const ulonglong4)).z as *const _ as usize },
16usize,
concat!("Offset of field: ", stringify!(ulonglong4), "::", stringify!(z))
);
assert_eq!(
unsafe { &(*(0 as *const ulonglong4)).w as *const _ as usize },
24usize,
concat!("Offset of field: ", stringify!(ulonglong4), "::", stringify!(w))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct double1 {
pub x: f64,
}
#[test]
fn bindgen_test_layout_double1() {
assert_eq!(
::std::mem::size_of::<double1>(),
8usize,
concat!("Size of: ", stringify!(double1))
);
assert_eq!(
::std::mem::align_of::<double1>(),
8usize,
concat!("Alignment of ", stringify!(double1))
);
assert_eq!(
unsafe { &(*(0 as *const double1)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(double1), "::", stringify!(x))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct double2 {
pub x: f64,
pub y: f64,
}
#[test]
fn bindgen_test_layout_double2() {
assert_eq!(
::std::mem::size_of::<double2>(),
16usize,
concat!("Size of: ", stringify!(double2))
);
assert_eq!(
unsafe { &(*(0 as *const double2)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(double2), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const double2)).y as *const _ as usize },
8usize,
concat!("Offset of field: ", stringify!(double2), "::", stringify!(y))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct double3 {
pub x: f64,
pub y: f64,
pub z: f64,
}
#[test]
fn bindgen_test_layout_double3() {
assert_eq!(
::std::mem::size_of::<double3>(),
24usize,
concat!("Size of: ", stringify!(double3))
);
assert_eq!(
::std::mem::align_of::<double3>(),
8usize,
concat!("Alignment of ", stringify!(double3))
);
assert_eq!(
unsafe { &(*(0 as *const double3)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(double3), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const double3)).y as *const _ as usize },
8usize,
concat!("Offset of field: ", stringify!(double3), "::", stringify!(y))
);
assert_eq!(
unsafe { &(*(0 as *const double3)).z as *const _ as usize },
16usize,
concat!("Offset of field: ", stringify!(double3), "::", stringify!(z))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct double4 {
pub x: f64,
pub y: f64,
pub z: f64,
pub w: f64,
}
#[test]
fn bindgen_test_layout_double4() {
assert_eq!(
::std::mem::size_of::<double4>(),
32usize,
concat!("Size of: ", stringify!(double4))
);
assert_eq!(
unsafe { &(*(0 as *const double4)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(double4), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const double4)).y as *const _ as usize },
8usize,
concat!("Offset of field: ", stringify!(double4), "::", stringify!(y))
);
assert_eq!(
unsafe { &(*(0 as *const double4)).z as *const _ as usize },
16usize,
concat!("Offset of field: ", stringify!(double4), "::", stringify!(z))
);
assert_eq!(
unsafe { &(*(0 as *const double4)).w as *const _ as usize },
24usize,
concat!("Offset of field: ", stringify!(double4), "::", stringify!(w))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dim3 {
pub x: ::std::os::raw::c_uint,
pub y: ::std::os::raw::c_uint,
pub z: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_dim3() {
assert_eq!(
::std::mem::size_of::<dim3>(),
12usize,
concat!("Size of: ", stringify!(dim3))
);
assert_eq!(
::std::mem::align_of::<dim3>(),
4usize,
concat!("Alignment of ", stringify!(dim3))
);
assert_eq!(
unsafe { &(*(0 as *const dim3)).x as *const _ as usize },
0usize,
concat!("Offset of field: ", stringify!(dim3), "::", stringify!(x))
);
assert_eq!(
unsafe { &(*(0 as *const dim3)).y as *const _ as usize },
4usize,
concat!("Offset of field: ", stringify!(dim3), "::", stringify!(y))
);
assert_eq!(
unsafe { &(*(0 as *const dim3)).z as *const _ as usize },
8usize,
concat!("Offset of field: ", stringify!(dim3), "::", stringify!(z))
);
}