1#[repr(C)]
4#[derive(Debug, Copy, Clone)]
5pub struct char1 {
6 pub x: ::std::os::raw::c_schar,
7}
8#[test]
9fn bindgen_test_layout_char1() {
10 assert_eq!(
11 ::std::mem::size_of::<char1>(),
12 1usize,
13 concat!("Size of: ", stringify!(char1))
14 );
15 assert_eq!(
16 ::std::mem::align_of::<char1>(),
17 1usize,
18 concat!("Alignment of ", stringify!(char1))
19 );
20 assert_eq!(
21 unsafe { &(*(0 as *const char1)).x as *const _ as usize },
22 0usize,
23 concat!("Offset of field: ", stringify!(char1), "::", stringify!(x))
24 );
25}
26#[repr(C)]
27#[derive(Debug, Copy, Clone)]
28pub struct uchar1 {
29 pub x: ::std::os::raw::c_uchar,
30}
31#[test]
32fn bindgen_test_layout_uchar1() {
33 assert_eq!(
34 ::std::mem::size_of::<uchar1>(),
35 1usize,
36 concat!("Size of: ", stringify!(uchar1))
37 );
38 assert_eq!(
39 ::std::mem::align_of::<uchar1>(),
40 1usize,
41 concat!("Alignment of ", stringify!(uchar1))
42 );
43 assert_eq!(
44 unsafe { &(*(0 as *const uchar1)).x as *const _ as usize },
45 0usize,
46 concat!("Offset of field: ", stringify!(uchar1), "::", stringify!(x))
47 );
48}
49#[repr(C)]
50#[derive(Debug, Copy, Clone)]
51pub struct char2 {
52 pub x: ::std::os::raw::c_schar,
53 pub y: ::std::os::raw::c_schar,
54 pub __bindgen_align: [u16; 0usize],
55}
56#[test]
57fn bindgen_test_layout_char2() {
58 assert_eq!(
59 ::std::mem::size_of::<char2>(),
60 2usize,
61 concat!("Size of: ", stringify!(char2))
62 );
63 assert_eq!(
64 ::std::mem::align_of::<char2>(),
65 2usize,
66 concat!("Alignment of ", stringify!(char2))
67 );
68 assert_eq!(
69 unsafe { &(*(0 as *const char2)).x as *const _ as usize },
70 0usize,
71 concat!("Offset of field: ", stringify!(char2), "::", stringify!(x))
72 );
73 assert_eq!(
74 unsafe { &(*(0 as *const char2)).y as *const _ as usize },
75 1usize,
76 concat!("Offset of field: ", stringify!(char2), "::", stringify!(y))
77 );
78}
79#[repr(C)]
80#[derive(Debug, Copy, Clone)]
81pub struct uchar2 {
82 pub x: ::std::os::raw::c_uchar,
83 pub y: ::std::os::raw::c_uchar,
84 pub __bindgen_align: [u16; 0usize],
85}
86#[test]
87fn bindgen_test_layout_uchar2() {
88 assert_eq!(
89 ::std::mem::size_of::<uchar2>(),
90 2usize,
91 concat!("Size of: ", stringify!(uchar2))
92 );
93 assert_eq!(
94 ::std::mem::align_of::<uchar2>(),
95 2usize,
96 concat!("Alignment of ", stringify!(uchar2))
97 );
98 assert_eq!(
99 unsafe { &(*(0 as *const uchar2)).x as *const _ as usize },
100 0usize,
101 concat!("Offset of field: ", stringify!(uchar2), "::", stringify!(x))
102 );
103 assert_eq!(
104 unsafe { &(*(0 as *const uchar2)).y as *const _ as usize },
105 1usize,
106 concat!("Offset of field: ", stringify!(uchar2), "::", stringify!(y))
107 );
108}
109#[repr(C)]
110#[derive(Debug, Copy, Clone)]
111pub struct char3 {
112 pub x: ::std::os::raw::c_schar,
113 pub y: ::std::os::raw::c_schar,
114 pub z: ::std::os::raw::c_schar,
115}
116#[test]
117fn bindgen_test_layout_char3() {
118 assert_eq!(
119 ::std::mem::size_of::<char3>(),
120 3usize,
121 concat!("Size of: ", stringify!(char3))
122 );
123 assert_eq!(
124 ::std::mem::align_of::<char3>(),
125 1usize,
126 concat!("Alignment of ", stringify!(char3))
127 );
128 assert_eq!(
129 unsafe { &(*(0 as *const char3)).x as *const _ as usize },
130 0usize,
131 concat!("Offset of field: ", stringify!(char3), "::", stringify!(x))
132 );
133 assert_eq!(
134 unsafe { &(*(0 as *const char3)).y as *const _ as usize },
135 1usize,
136 concat!("Offset of field: ", stringify!(char3), "::", stringify!(y))
137 );
138 assert_eq!(
139 unsafe { &(*(0 as *const char3)).z as *const _ as usize },
140 2usize,
141 concat!("Offset of field: ", stringify!(char3), "::", stringify!(z))
142 );
143}
144#[repr(C)]
145#[derive(Debug, Copy, Clone)]
146pub struct uchar3 {
147 pub x: ::std::os::raw::c_uchar,
148 pub y: ::std::os::raw::c_uchar,
149 pub z: ::std::os::raw::c_uchar,
150}
151#[test]
152fn bindgen_test_layout_uchar3() {
153 assert_eq!(
154 ::std::mem::size_of::<uchar3>(),
155 3usize,
156 concat!("Size of: ", stringify!(uchar3))
157 );
158 assert_eq!(
159 ::std::mem::align_of::<uchar3>(),
160 1usize,
161 concat!("Alignment of ", stringify!(uchar3))
162 );
163 assert_eq!(
164 unsafe { &(*(0 as *const uchar3)).x as *const _ as usize },
165 0usize,
166 concat!("Offset of field: ", stringify!(uchar3), "::", stringify!(x))
167 );
168 assert_eq!(
169 unsafe { &(*(0 as *const uchar3)).y as *const _ as usize },
170 1usize,
171 concat!("Offset of field: ", stringify!(uchar3), "::", stringify!(y))
172 );
173 assert_eq!(
174 unsafe { &(*(0 as *const uchar3)).z as *const _ as usize },
175 2usize,
176 concat!("Offset of field: ", stringify!(uchar3), "::", stringify!(z))
177 );
178}
179#[repr(C)]
180#[derive(Debug, Copy, Clone)]
181pub struct char4 {
182 pub x: ::std::os::raw::c_schar,
183 pub y: ::std::os::raw::c_schar,
184 pub z: ::std::os::raw::c_schar,
185 pub w: ::std::os::raw::c_schar,
186 pub __bindgen_align: [u32; 0usize],
187}
188#[test]
189fn bindgen_test_layout_char4() {
190 assert_eq!(
191 ::std::mem::size_of::<char4>(),
192 4usize,
193 concat!("Size of: ", stringify!(char4))
194 );
195 assert_eq!(
196 ::std::mem::align_of::<char4>(),
197 4usize,
198 concat!("Alignment of ", stringify!(char4))
199 );
200 assert_eq!(
201 unsafe { &(*(0 as *const char4)).x as *const _ as usize },
202 0usize,
203 concat!("Offset of field: ", stringify!(char4), "::", stringify!(x))
204 );
205 assert_eq!(
206 unsafe { &(*(0 as *const char4)).y as *const _ as usize },
207 1usize,
208 concat!("Offset of field: ", stringify!(char4), "::", stringify!(y))
209 );
210 assert_eq!(
211 unsafe { &(*(0 as *const char4)).z as *const _ as usize },
212 2usize,
213 concat!("Offset of field: ", stringify!(char4), "::", stringify!(z))
214 );
215 assert_eq!(
216 unsafe { &(*(0 as *const char4)).w as *const _ as usize },
217 3usize,
218 concat!("Offset of field: ", stringify!(char4), "::", stringify!(w))
219 );
220}
221#[repr(C)]
222#[derive(Debug, Copy, Clone)]
223pub struct uchar4 {
224 pub x: ::std::os::raw::c_uchar,
225 pub y: ::std::os::raw::c_uchar,
226 pub z: ::std::os::raw::c_uchar,
227 pub w: ::std::os::raw::c_uchar,
228 pub __bindgen_align: [u32; 0usize],
229}
230#[test]
231fn bindgen_test_layout_uchar4() {
232 assert_eq!(
233 ::std::mem::size_of::<uchar4>(),
234 4usize,
235 concat!("Size of: ", stringify!(uchar4))
236 );
237 assert_eq!(
238 ::std::mem::align_of::<uchar4>(),
239 4usize,
240 concat!("Alignment of ", stringify!(uchar4))
241 );
242 assert_eq!(
243 unsafe { &(*(0 as *const uchar4)).x as *const _ as usize },
244 0usize,
245 concat!("Offset of field: ", stringify!(uchar4), "::", stringify!(x))
246 );
247 assert_eq!(
248 unsafe { &(*(0 as *const uchar4)).y as *const _ as usize },
249 1usize,
250 concat!("Offset of field: ", stringify!(uchar4), "::", stringify!(y))
251 );
252 assert_eq!(
253 unsafe { &(*(0 as *const uchar4)).z as *const _ as usize },
254 2usize,
255 concat!("Offset of field: ", stringify!(uchar4), "::", stringify!(z))
256 );
257 assert_eq!(
258 unsafe { &(*(0 as *const uchar4)).w as *const _ as usize },
259 3usize,
260 concat!("Offset of field: ", stringify!(uchar4), "::", stringify!(w))
261 );
262}
263#[repr(C)]
264#[derive(Debug, Copy, Clone)]
265pub struct short1 {
266 pub x: ::std::os::raw::c_short,
267}
268#[test]
269fn bindgen_test_layout_short1() {
270 assert_eq!(
271 ::std::mem::size_of::<short1>(),
272 2usize,
273 concat!("Size of: ", stringify!(short1))
274 );
275 assert_eq!(
276 ::std::mem::align_of::<short1>(),
277 2usize,
278 concat!("Alignment of ", stringify!(short1))
279 );
280 assert_eq!(
281 unsafe { &(*(0 as *const short1)).x as *const _ as usize },
282 0usize,
283 concat!("Offset of field: ", stringify!(short1), "::", stringify!(x))
284 );
285}
286#[repr(C)]
287#[derive(Debug, Copy, Clone)]
288pub struct ushort1 {
289 pub x: ::std::os::raw::c_ushort,
290}
291#[test]
292fn bindgen_test_layout_ushort1() {
293 assert_eq!(
294 ::std::mem::size_of::<ushort1>(),
295 2usize,
296 concat!("Size of: ", stringify!(ushort1))
297 );
298 assert_eq!(
299 ::std::mem::align_of::<ushort1>(),
300 2usize,
301 concat!("Alignment of ", stringify!(ushort1))
302 );
303 assert_eq!(
304 unsafe { &(*(0 as *const ushort1)).x as *const _ as usize },
305 0usize,
306 concat!("Offset of field: ", stringify!(ushort1), "::", stringify!(x))
307 );
308}
309#[repr(C)]
310#[derive(Debug, Copy, Clone)]
311pub struct short2 {
312 pub x: ::std::os::raw::c_short,
313 pub y: ::std::os::raw::c_short,
314 pub __bindgen_align: [u32; 0usize],
315}
316#[test]
317fn bindgen_test_layout_short2() {
318 assert_eq!(
319 ::std::mem::size_of::<short2>(),
320 4usize,
321 concat!("Size of: ", stringify!(short2))
322 );
323 assert_eq!(
324 ::std::mem::align_of::<short2>(),
325 4usize,
326 concat!("Alignment of ", stringify!(short2))
327 );
328 assert_eq!(
329 unsafe { &(*(0 as *const short2)).x as *const _ as usize },
330 0usize,
331 concat!("Offset of field: ", stringify!(short2), "::", stringify!(x))
332 );
333 assert_eq!(
334 unsafe { &(*(0 as *const short2)).y as *const _ as usize },
335 2usize,
336 concat!("Offset of field: ", stringify!(short2), "::", stringify!(y))
337 );
338}
339#[repr(C)]
340#[derive(Debug, Copy, Clone)]
341pub struct ushort2 {
342 pub x: ::std::os::raw::c_ushort,
343 pub y: ::std::os::raw::c_ushort,
344 pub __bindgen_align: [u32; 0usize],
345}
346#[test]
347fn bindgen_test_layout_ushort2() {
348 assert_eq!(
349 ::std::mem::size_of::<ushort2>(),
350 4usize,
351 concat!("Size of: ", stringify!(ushort2))
352 );
353 assert_eq!(
354 ::std::mem::align_of::<ushort2>(),
355 4usize,
356 concat!("Alignment of ", stringify!(ushort2))
357 );
358 assert_eq!(
359 unsafe { &(*(0 as *const ushort2)).x as *const _ as usize },
360 0usize,
361 concat!("Offset of field: ", stringify!(ushort2), "::", stringify!(x))
362 );
363 assert_eq!(
364 unsafe { &(*(0 as *const ushort2)).y as *const _ as usize },
365 2usize,
366 concat!("Offset of field: ", stringify!(ushort2), "::", stringify!(y))
367 );
368}
369#[repr(C)]
370#[derive(Debug, Copy, Clone)]
371pub struct short3 {
372 pub x: ::std::os::raw::c_short,
373 pub y: ::std::os::raw::c_short,
374 pub z: ::std::os::raw::c_short,
375}
376#[test]
377fn bindgen_test_layout_short3() {
378 assert_eq!(
379 ::std::mem::size_of::<short3>(),
380 6usize,
381 concat!("Size of: ", stringify!(short3))
382 );
383 assert_eq!(
384 ::std::mem::align_of::<short3>(),
385 2usize,
386 concat!("Alignment of ", stringify!(short3))
387 );
388 assert_eq!(
389 unsafe { &(*(0 as *const short3)).x as *const _ as usize },
390 0usize,
391 concat!("Offset of field: ", stringify!(short3), "::", stringify!(x))
392 );
393 assert_eq!(
394 unsafe { &(*(0 as *const short3)).y as *const _ as usize },
395 2usize,
396 concat!("Offset of field: ", stringify!(short3), "::", stringify!(y))
397 );
398 assert_eq!(
399 unsafe { &(*(0 as *const short3)).z as *const _ as usize },
400 4usize,
401 concat!("Offset of field: ", stringify!(short3), "::", stringify!(z))
402 );
403}
404#[repr(C)]
405#[derive(Debug, Copy, Clone)]
406pub struct ushort3 {
407 pub x: ::std::os::raw::c_ushort,
408 pub y: ::std::os::raw::c_ushort,
409 pub z: ::std::os::raw::c_ushort,
410}
411#[test]
412fn bindgen_test_layout_ushort3() {
413 assert_eq!(
414 ::std::mem::size_of::<ushort3>(),
415 6usize,
416 concat!("Size of: ", stringify!(ushort3))
417 );
418 assert_eq!(
419 ::std::mem::align_of::<ushort3>(),
420 2usize,
421 concat!("Alignment of ", stringify!(ushort3))
422 );
423 assert_eq!(
424 unsafe { &(*(0 as *const ushort3)).x as *const _ as usize },
425 0usize,
426 concat!("Offset of field: ", stringify!(ushort3), "::", stringify!(x))
427 );
428 assert_eq!(
429 unsafe { &(*(0 as *const ushort3)).y as *const _ as usize },
430 2usize,
431 concat!("Offset of field: ", stringify!(ushort3), "::", stringify!(y))
432 );
433 assert_eq!(
434 unsafe { &(*(0 as *const ushort3)).z as *const _ as usize },
435 4usize,
436 concat!("Offset of field: ", stringify!(ushort3), "::", stringify!(z))
437 );
438}
439#[repr(C)]
440#[derive(Debug, Copy, Clone)]
441pub struct short4 {
442 pub x: ::std::os::raw::c_short,
443 pub y: ::std::os::raw::c_short,
444 pub z: ::std::os::raw::c_short,
445 pub w: ::std::os::raw::c_short,
446 pub __bindgen_align: [u64; 0usize],
447}
448#[test]
449fn bindgen_test_layout_short4() {
450 assert_eq!(
451 ::std::mem::size_of::<short4>(),
452 8usize,
453 concat!("Size of: ", stringify!(short4))
454 );
455 assert_eq!(
456 ::std::mem::align_of::<short4>(),
457 8usize,
458 concat!("Alignment of ", stringify!(short4))
459 );
460 assert_eq!(
461 unsafe { &(*(0 as *const short4)).x as *const _ as usize },
462 0usize,
463 concat!("Offset of field: ", stringify!(short4), "::", stringify!(x))
464 );
465 assert_eq!(
466 unsafe { &(*(0 as *const short4)).y as *const _ as usize },
467 2usize,
468 concat!("Offset of field: ", stringify!(short4), "::", stringify!(y))
469 );
470 assert_eq!(
471 unsafe { &(*(0 as *const short4)).z as *const _ as usize },
472 4usize,
473 concat!("Offset of field: ", stringify!(short4), "::", stringify!(z))
474 );
475 assert_eq!(
476 unsafe { &(*(0 as *const short4)).w as *const _ as usize },
477 6usize,
478 concat!("Offset of field: ", stringify!(short4), "::", stringify!(w))
479 );
480}
481#[repr(C)]
482#[derive(Debug, Copy, Clone)]
483pub struct ushort4 {
484 pub x: ::std::os::raw::c_ushort,
485 pub y: ::std::os::raw::c_ushort,
486 pub z: ::std::os::raw::c_ushort,
487 pub w: ::std::os::raw::c_ushort,
488 pub __bindgen_align: [u64; 0usize],
489}
490#[test]
491fn bindgen_test_layout_ushort4() {
492 assert_eq!(
493 ::std::mem::size_of::<ushort4>(),
494 8usize,
495 concat!("Size of: ", stringify!(ushort4))
496 );
497 assert_eq!(
498 ::std::mem::align_of::<ushort4>(),
499 8usize,
500 concat!("Alignment of ", stringify!(ushort4))
501 );
502 assert_eq!(
503 unsafe { &(*(0 as *const ushort4)).x as *const _ as usize },
504 0usize,
505 concat!("Offset of field: ", stringify!(ushort4), "::", stringify!(x))
506 );
507 assert_eq!(
508 unsafe { &(*(0 as *const ushort4)).y as *const _ as usize },
509 2usize,
510 concat!("Offset of field: ", stringify!(ushort4), "::", stringify!(y))
511 );
512 assert_eq!(
513 unsafe { &(*(0 as *const ushort4)).z as *const _ as usize },
514 4usize,
515 concat!("Offset of field: ", stringify!(ushort4), "::", stringify!(z))
516 );
517 assert_eq!(
518 unsafe { &(*(0 as *const ushort4)).w as *const _ as usize },
519 6usize,
520 concat!("Offset of field: ", stringify!(ushort4), "::", stringify!(w))
521 );
522}
523#[repr(C)]
524#[derive(Debug, Copy, Clone)]
525pub struct int1 {
526 pub x: ::std::os::raw::c_int,
527}
528#[test]
529fn bindgen_test_layout_int1() {
530 assert_eq!(
531 ::std::mem::size_of::<int1>(),
532 4usize,
533 concat!("Size of: ", stringify!(int1))
534 );
535 assert_eq!(
536 ::std::mem::align_of::<int1>(),
537 4usize,
538 concat!("Alignment of ", stringify!(int1))
539 );
540 assert_eq!(
541 unsafe { &(*(0 as *const int1)).x as *const _ as usize },
542 0usize,
543 concat!("Offset of field: ", stringify!(int1), "::", stringify!(x))
544 );
545}
546#[repr(C)]
547#[derive(Debug, Copy, Clone)]
548pub struct uint1 {
549 pub x: ::std::os::raw::c_uint,
550}
551#[test]
552fn bindgen_test_layout_uint1() {
553 assert_eq!(
554 ::std::mem::size_of::<uint1>(),
555 4usize,
556 concat!("Size of: ", stringify!(uint1))
557 );
558 assert_eq!(
559 ::std::mem::align_of::<uint1>(),
560 4usize,
561 concat!("Alignment of ", stringify!(uint1))
562 );
563 assert_eq!(
564 unsafe { &(*(0 as *const uint1)).x as *const _ as usize },
565 0usize,
566 concat!("Offset of field: ", stringify!(uint1), "::", stringify!(x))
567 );
568}
569#[repr(C)]
570#[derive(Debug, Copy, Clone)]
571pub struct int2 {
572 pub x: ::std::os::raw::c_int,
573 pub y: ::std::os::raw::c_int,
574 pub __bindgen_align: [u64; 0usize],
575}
576#[test]
577fn bindgen_test_layout_int2() {
578 assert_eq!(
579 ::std::mem::size_of::<int2>(),
580 8usize,
581 concat!("Size of: ", stringify!(int2))
582 );
583 assert_eq!(
584 ::std::mem::align_of::<int2>(),
585 8usize,
586 concat!("Alignment of ", stringify!(int2))
587 );
588 assert_eq!(
589 unsafe { &(*(0 as *const int2)).x as *const _ as usize },
590 0usize,
591 concat!("Offset of field: ", stringify!(int2), "::", stringify!(x))
592 );
593 assert_eq!(
594 unsafe { &(*(0 as *const int2)).y as *const _ as usize },
595 4usize,
596 concat!("Offset of field: ", stringify!(int2), "::", stringify!(y))
597 );
598}
599#[repr(C)]
600#[derive(Debug, Copy, Clone)]
601pub struct uint2 {
602 pub x: ::std::os::raw::c_uint,
603 pub y: ::std::os::raw::c_uint,
604 pub __bindgen_align: [u64; 0usize],
605}
606#[test]
607fn bindgen_test_layout_uint2() {
608 assert_eq!(
609 ::std::mem::size_of::<uint2>(),
610 8usize,
611 concat!("Size of: ", stringify!(uint2))
612 );
613 assert_eq!(
614 ::std::mem::align_of::<uint2>(),
615 8usize,
616 concat!("Alignment of ", stringify!(uint2))
617 );
618 assert_eq!(
619 unsafe { &(*(0 as *const uint2)).x as *const _ as usize },
620 0usize,
621 concat!("Offset of field: ", stringify!(uint2), "::", stringify!(x))
622 );
623 assert_eq!(
624 unsafe { &(*(0 as *const uint2)).y as *const _ as usize },
625 4usize,
626 concat!("Offset of field: ", stringify!(uint2), "::", stringify!(y))
627 );
628}
629#[repr(C)]
630#[derive(Debug, Copy, Clone)]
631pub struct int3 {
632 pub x: ::std::os::raw::c_int,
633 pub y: ::std::os::raw::c_int,
634 pub z: ::std::os::raw::c_int,
635}
636#[test]
637fn bindgen_test_layout_int3() {
638 assert_eq!(
639 ::std::mem::size_of::<int3>(),
640 12usize,
641 concat!("Size of: ", stringify!(int3))
642 );
643 assert_eq!(
644 ::std::mem::align_of::<int3>(),
645 4usize,
646 concat!("Alignment of ", stringify!(int3))
647 );
648 assert_eq!(
649 unsafe { &(*(0 as *const int3)).x as *const _ as usize },
650 0usize,
651 concat!("Offset of field: ", stringify!(int3), "::", stringify!(x))
652 );
653 assert_eq!(
654 unsafe { &(*(0 as *const int3)).y as *const _ as usize },
655 4usize,
656 concat!("Offset of field: ", stringify!(int3), "::", stringify!(y))
657 );
658 assert_eq!(
659 unsafe { &(*(0 as *const int3)).z as *const _ as usize },
660 8usize,
661 concat!("Offset of field: ", stringify!(int3), "::", stringify!(z))
662 );
663}
664#[repr(C)]
665#[derive(Debug, Copy, Clone)]
666pub struct uint3 {
667 pub x: ::std::os::raw::c_uint,
668 pub y: ::std::os::raw::c_uint,
669 pub z: ::std::os::raw::c_uint,
670}
671#[test]
672fn bindgen_test_layout_uint3() {
673 assert_eq!(
674 ::std::mem::size_of::<uint3>(),
675 12usize,
676 concat!("Size of: ", stringify!(uint3))
677 );
678 assert_eq!(
679 ::std::mem::align_of::<uint3>(),
680 4usize,
681 concat!("Alignment of ", stringify!(uint3))
682 );
683 assert_eq!(
684 unsafe { &(*(0 as *const uint3)).x as *const _ as usize },
685 0usize,
686 concat!("Offset of field: ", stringify!(uint3), "::", stringify!(x))
687 );
688 assert_eq!(
689 unsafe { &(*(0 as *const uint3)).y as *const _ as usize },
690 4usize,
691 concat!("Offset of field: ", stringify!(uint3), "::", stringify!(y))
692 );
693 assert_eq!(
694 unsafe { &(*(0 as *const uint3)).z as *const _ as usize },
695 8usize,
696 concat!("Offset of field: ", stringify!(uint3), "::", stringify!(z))
697 );
698}
699#[repr(C)]
700#[derive(Debug, Copy, Clone)]
701pub struct int4 {
702 pub x: ::std::os::raw::c_int,
703 pub y: ::std::os::raw::c_int,
704 pub z: ::std::os::raw::c_int,
705 pub w: ::std::os::raw::c_int,
706}
707#[test]
708fn bindgen_test_layout_int4() {
709 assert_eq!(
710 ::std::mem::size_of::<int4>(),
711 16usize,
712 concat!("Size of: ", stringify!(int4))
713 );
714 assert_eq!(
715 unsafe { &(*(0 as *const int4)).x as *const _ as usize },
716 0usize,
717 concat!("Offset of field: ", stringify!(int4), "::", stringify!(x))
718 );
719 assert_eq!(
720 unsafe { &(*(0 as *const int4)).y as *const _ as usize },
721 4usize,
722 concat!("Offset of field: ", stringify!(int4), "::", stringify!(y))
723 );
724 assert_eq!(
725 unsafe { &(*(0 as *const int4)).z as *const _ as usize },
726 8usize,
727 concat!("Offset of field: ", stringify!(int4), "::", stringify!(z))
728 );
729 assert_eq!(
730 unsafe { &(*(0 as *const int4)).w as *const _ as usize },
731 12usize,
732 concat!("Offset of field: ", stringify!(int4), "::", stringify!(w))
733 );
734}
735#[repr(C)]
736#[derive(Debug, Copy, Clone)]
737pub struct uint4 {
738 pub x: ::std::os::raw::c_uint,
739 pub y: ::std::os::raw::c_uint,
740 pub z: ::std::os::raw::c_uint,
741 pub w: ::std::os::raw::c_uint,
742}
743#[test]
744fn bindgen_test_layout_uint4() {
745 assert_eq!(
746 ::std::mem::size_of::<uint4>(),
747 16usize,
748 concat!("Size of: ", stringify!(uint4))
749 );
750 assert_eq!(
751 unsafe { &(*(0 as *const uint4)).x as *const _ as usize },
752 0usize,
753 concat!("Offset of field: ", stringify!(uint4), "::", stringify!(x))
754 );
755 assert_eq!(
756 unsafe { &(*(0 as *const uint4)).y as *const _ as usize },
757 4usize,
758 concat!("Offset of field: ", stringify!(uint4), "::", stringify!(y))
759 );
760 assert_eq!(
761 unsafe { &(*(0 as *const uint4)).z as *const _ as usize },
762 8usize,
763 concat!("Offset of field: ", stringify!(uint4), "::", stringify!(z))
764 );
765 assert_eq!(
766 unsafe { &(*(0 as *const uint4)).w as *const _ as usize },
767 12usize,
768 concat!("Offset of field: ", stringify!(uint4), "::", stringify!(w))
769 );
770}
771#[repr(C)]
772#[derive(Debug, Copy, Clone)]
773pub struct long1 {
774 pub x: ::std::os::raw::c_long,
775}
776#[test]
777fn bindgen_test_layout_long1() {
778 assert_eq!(
779 ::std::mem::size_of::<long1>(),
780 8usize,
781 concat!("Size of: ", stringify!(long1))
782 );
783 assert_eq!(
784 ::std::mem::align_of::<long1>(),
785 8usize,
786 concat!("Alignment of ", stringify!(long1))
787 );
788 assert_eq!(
789 unsafe { &(*(0 as *const long1)).x as *const _ as usize },
790 0usize,
791 concat!("Offset of field: ", stringify!(long1), "::", stringify!(x))
792 );
793}
794#[repr(C)]
795#[derive(Debug, Copy, Clone)]
796pub struct ulong1 {
797 pub x: ::std::os::raw::c_ulong,
798}
799#[test]
800fn bindgen_test_layout_ulong1() {
801 assert_eq!(
802 ::std::mem::size_of::<ulong1>(),
803 8usize,
804 concat!("Size of: ", stringify!(ulong1))
805 );
806 assert_eq!(
807 ::std::mem::align_of::<ulong1>(),
808 8usize,
809 concat!("Alignment of ", stringify!(ulong1))
810 );
811 assert_eq!(
812 unsafe { &(*(0 as *const ulong1)).x as *const _ as usize },
813 0usize,
814 concat!("Offset of field: ", stringify!(ulong1), "::", stringify!(x))
815 );
816}
817#[repr(C)]
818#[derive(Debug, Copy, Clone)]
819pub struct long2 {
820 pub x: ::std::os::raw::c_long,
821 pub y: ::std::os::raw::c_long,
822}
823#[test]
824fn bindgen_test_layout_long2() {
825 assert_eq!(
826 ::std::mem::size_of::<long2>(),
827 16usize,
828 concat!("Size of: ", stringify!(long2))
829 );
830 assert_eq!(
831 unsafe { &(*(0 as *const long2)).x as *const _ as usize },
832 0usize,
833 concat!("Offset of field: ", stringify!(long2), "::", stringify!(x))
834 );
835 assert_eq!(
836 unsafe { &(*(0 as *const long2)).y as *const _ as usize },
837 8usize,
838 concat!("Offset of field: ", stringify!(long2), "::", stringify!(y))
839 );
840}
841#[repr(C)]
842#[derive(Debug, Copy, Clone)]
843pub struct ulong2 {
844 pub x: ::std::os::raw::c_ulong,
845 pub y: ::std::os::raw::c_ulong,
846}
847#[test]
848fn bindgen_test_layout_ulong2() {
849 assert_eq!(
850 ::std::mem::size_of::<ulong2>(),
851 16usize,
852 concat!("Size of: ", stringify!(ulong2))
853 );
854 assert_eq!(
855 unsafe { &(*(0 as *const ulong2)).x as *const _ as usize },
856 0usize,
857 concat!("Offset of field: ", stringify!(ulong2), "::", stringify!(x))
858 );
859 assert_eq!(
860 unsafe { &(*(0 as *const ulong2)).y as *const _ as usize },
861 8usize,
862 concat!("Offset of field: ", stringify!(ulong2), "::", stringify!(y))
863 );
864}
865#[repr(C)]
866#[derive(Debug, Copy, Clone)]
867pub struct long3 {
868 pub x: ::std::os::raw::c_long,
869 pub y: ::std::os::raw::c_long,
870 pub z: ::std::os::raw::c_long,
871}
872#[test]
873fn bindgen_test_layout_long3() {
874 assert_eq!(
875 ::std::mem::size_of::<long3>(),
876 24usize,
877 concat!("Size of: ", stringify!(long3))
878 );
879 assert_eq!(
880 ::std::mem::align_of::<long3>(),
881 8usize,
882 concat!("Alignment of ", stringify!(long3))
883 );
884 assert_eq!(
885 unsafe { &(*(0 as *const long3)).x as *const _ as usize },
886 0usize,
887 concat!("Offset of field: ", stringify!(long3), "::", stringify!(x))
888 );
889 assert_eq!(
890 unsafe { &(*(0 as *const long3)).y as *const _ as usize },
891 8usize,
892 concat!("Offset of field: ", stringify!(long3), "::", stringify!(y))
893 );
894 assert_eq!(
895 unsafe { &(*(0 as *const long3)).z as *const _ as usize },
896 16usize,
897 concat!("Offset of field: ", stringify!(long3), "::", stringify!(z))
898 );
899}
900#[repr(C)]
901#[derive(Debug, Copy, Clone)]
902pub struct ulong3 {
903 pub x: ::std::os::raw::c_ulong,
904 pub y: ::std::os::raw::c_ulong,
905 pub z: ::std::os::raw::c_ulong,
906}
907#[test]
908fn bindgen_test_layout_ulong3() {
909 assert_eq!(
910 ::std::mem::size_of::<ulong3>(),
911 24usize,
912 concat!("Size of: ", stringify!(ulong3))
913 );
914 assert_eq!(
915 ::std::mem::align_of::<ulong3>(),
916 8usize,
917 concat!("Alignment of ", stringify!(ulong3))
918 );
919 assert_eq!(
920 unsafe { &(*(0 as *const ulong3)).x as *const _ as usize },
921 0usize,
922 concat!("Offset of field: ", stringify!(ulong3), "::", stringify!(x))
923 );
924 assert_eq!(
925 unsafe { &(*(0 as *const ulong3)).y as *const _ as usize },
926 8usize,
927 concat!("Offset of field: ", stringify!(ulong3), "::", stringify!(y))
928 );
929 assert_eq!(
930 unsafe { &(*(0 as *const ulong3)).z as *const _ as usize },
931 16usize,
932 concat!("Offset of field: ", stringify!(ulong3), "::", stringify!(z))
933 );
934}
935#[repr(C)]
936#[derive(Debug, Copy, Clone)]
937pub struct long4 {
938 pub x: ::std::os::raw::c_long,
939 pub y: ::std::os::raw::c_long,
940 pub z: ::std::os::raw::c_long,
941 pub w: ::std::os::raw::c_long,
942}
943#[test]
944fn bindgen_test_layout_long4() {
945 assert_eq!(
946 ::std::mem::size_of::<long4>(),
947 32usize,
948 concat!("Size of: ", stringify!(long4))
949 );
950 assert_eq!(
951 unsafe { &(*(0 as *const long4)).x as *const _ as usize },
952 0usize,
953 concat!("Offset of field: ", stringify!(long4), "::", stringify!(x))
954 );
955 assert_eq!(
956 unsafe { &(*(0 as *const long4)).y as *const _ as usize },
957 8usize,
958 concat!("Offset of field: ", stringify!(long4), "::", stringify!(y))
959 );
960 assert_eq!(
961 unsafe { &(*(0 as *const long4)).z as *const _ as usize },
962 16usize,
963 concat!("Offset of field: ", stringify!(long4), "::", stringify!(z))
964 );
965 assert_eq!(
966 unsafe { &(*(0 as *const long4)).w as *const _ as usize },
967 24usize,
968 concat!("Offset of field: ", stringify!(long4), "::", stringify!(w))
969 );
970}
971#[repr(C)]
972#[derive(Debug, Copy, Clone)]
973pub struct ulong4 {
974 pub x: ::std::os::raw::c_ulong,
975 pub y: ::std::os::raw::c_ulong,
976 pub z: ::std::os::raw::c_ulong,
977 pub w: ::std::os::raw::c_ulong,
978}
979#[test]
980fn bindgen_test_layout_ulong4() {
981 assert_eq!(
982 ::std::mem::size_of::<ulong4>(),
983 32usize,
984 concat!("Size of: ", stringify!(ulong4))
985 );
986 assert_eq!(
987 unsafe { &(*(0 as *const ulong4)).x as *const _ as usize },
988 0usize,
989 concat!("Offset of field: ", stringify!(ulong4), "::", stringify!(x))
990 );
991 assert_eq!(
992 unsafe { &(*(0 as *const ulong4)).y as *const _ as usize },
993 8usize,
994 concat!("Offset of field: ", stringify!(ulong4), "::", stringify!(y))
995 );
996 assert_eq!(
997 unsafe { &(*(0 as *const ulong4)).z as *const _ as usize },
998 16usize,
999 concat!("Offset of field: ", stringify!(ulong4), "::", stringify!(z))
1000 );
1001 assert_eq!(
1002 unsafe { &(*(0 as *const ulong4)).w as *const _ as usize },
1003 24usize,
1004 concat!("Offset of field: ", stringify!(ulong4), "::", stringify!(w))
1005 );
1006}
1007#[repr(C)]
1008#[derive(Debug, Copy, Clone)]
1009pub struct float1 {
1010 pub x: f32,
1011}
1012#[test]
1013fn bindgen_test_layout_float1() {
1014 assert_eq!(
1015 ::std::mem::size_of::<float1>(),
1016 4usize,
1017 concat!("Size of: ", stringify!(float1))
1018 );
1019 assert_eq!(
1020 ::std::mem::align_of::<float1>(),
1021 4usize,
1022 concat!("Alignment of ", stringify!(float1))
1023 );
1024 assert_eq!(
1025 unsafe { &(*(0 as *const float1)).x as *const _ as usize },
1026 0usize,
1027 concat!("Offset of field: ", stringify!(float1), "::", stringify!(x))
1028 );
1029}
1030#[repr(C)]
1031#[derive(Debug, Copy, Clone)]
1032pub struct float2 {
1033 pub x: f32,
1034 pub y: f32,
1035 pub __bindgen_align: [u64; 0usize],
1036}
1037#[test]
1038fn bindgen_test_layout_float2() {
1039 assert_eq!(
1040 ::std::mem::size_of::<float2>(),
1041 8usize,
1042 concat!("Size of: ", stringify!(float2))
1043 );
1044 assert_eq!(
1045 ::std::mem::align_of::<float2>(),
1046 8usize,
1047 concat!("Alignment of ", stringify!(float2))
1048 );
1049 assert_eq!(
1050 unsafe { &(*(0 as *const float2)).x as *const _ as usize },
1051 0usize,
1052 concat!("Offset of field: ", stringify!(float2), "::", stringify!(x))
1053 );
1054 assert_eq!(
1055 unsafe { &(*(0 as *const float2)).y as *const _ as usize },
1056 4usize,
1057 concat!("Offset of field: ", stringify!(float2), "::", stringify!(y))
1058 );
1059}
1060#[repr(C)]
1061#[derive(Debug, Copy, Clone)]
1062pub struct float3 {
1063 pub x: f32,
1064 pub y: f32,
1065 pub z: f32,
1066}
1067#[test]
1068fn bindgen_test_layout_float3() {
1069 assert_eq!(
1070 ::std::mem::size_of::<float3>(),
1071 12usize,
1072 concat!("Size of: ", stringify!(float3))
1073 );
1074 assert_eq!(
1075 ::std::mem::align_of::<float3>(),
1076 4usize,
1077 concat!("Alignment of ", stringify!(float3))
1078 );
1079 assert_eq!(
1080 unsafe { &(*(0 as *const float3)).x as *const _ as usize },
1081 0usize,
1082 concat!("Offset of field: ", stringify!(float3), "::", stringify!(x))
1083 );
1084 assert_eq!(
1085 unsafe { &(*(0 as *const float3)).y as *const _ as usize },
1086 4usize,
1087 concat!("Offset of field: ", stringify!(float3), "::", stringify!(y))
1088 );
1089 assert_eq!(
1090 unsafe { &(*(0 as *const float3)).z as *const _ as usize },
1091 8usize,
1092 concat!("Offset of field: ", stringify!(float3), "::", stringify!(z))
1093 );
1094}
1095#[repr(C)]
1096#[derive(Debug, Copy, Clone)]
1097pub struct float4 {
1098 pub x: f32,
1099 pub y: f32,
1100 pub z: f32,
1101 pub w: f32,
1102}
1103#[test]
1104fn bindgen_test_layout_float4() {
1105 assert_eq!(
1106 ::std::mem::size_of::<float4>(),
1107 16usize,
1108 concat!("Size of: ", stringify!(float4))
1109 );
1110 assert_eq!(
1111 unsafe { &(*(0 as *const float4)).x as *const _ as usize },
1112 0usize,
1113 concat!("Offset of field: ", stringify!(float4), "::", stringify!(x))
1114 );
1115 assert_eq!(
1116 unsafe { &(*(0 as *const float4)).y as *const _ as usize },
1117 4usize,
1118 concat!("Offset of field: ", stringify!(float4), "::", stringify!(y))
1119 );
1120 assert_eq!(
1121 unsafe { &(*(0 as *const float4)).z as *const _ as usize },
1122 8usize,
1123 concat!("Offset of field: ", stringify!(float4), "::", stringify!(z))
1124 );
1125 assert_eq!(
1126 unsafe { &(*(0 as *const float4)).w as *const _ as usize },
1127 12usize,
1128 concat!("Offset of field: ", stringify!(float4), "::", stringify!(w))
1129 );
1130}
1131#[repr(C)]
1132#[derive(Debug, Copy, Clone)]
1133pub struct longlong1 {
1134 pub x: ::std::os::raw::c_longlong,
1135}
1136#[test]
1137fn bindgen_test_layout_longlong1() {
1138 assert_eq!(
1139 ::std::mem::size_of::<longlong1>(),
1140 8usize,
1141 concat!("Size of: ", stringify!(longlong1))
1142 );
1143 assert_eq!(
1144 ::std::mem::align_of::<longlong1>(),
1145 8usize,
1146 concat!("Alignment of ", stringify!(longlong1))
1147 );
1148 assert_eq!(
1149 unsafe { &(*(0 as *const longlong1)).x as *const _ as usize },
1150 0usize,
1151 concat!("Offset of field: ", stringify!(longlong1), "::", stringify!(x))
1152 );
1153}
1154#[repr(C)]
1155#[derive(Debug, Copy, Clone)]
1156pub struct ulonglong1 {
1157 pub x: ::std::os::raw::c_ulonglong,
1158}
1159#[test]
1160fn bindgen_test_layout_ulonglong1() {
1161 assert_eq!(
1162 ::std::mem::size_of::<ulonglong1>(),
1163 8usize,
1164 concat!("Size of: ", stringify!(ulonglong1))
1165 );
1166 assert_eq!(
1167 ::std::mem::align_of::<ulonglong1>(),
1168 8usize,
1169 concat!("Alignment of ", stringify!(ulonglong1))
1170 );
1171 assert_eq!(
1172 unsafe { &(*(0 as *const ulonglong1)).x as *const _ as usize },
1173 0usize,
1174 concat!("Offset of field: ", stringify!(ulonglong1), "::", stringify!(x))
1175 );
1176}
1177#[repr(C)]
1178#[derive(Debug, Copy, Clone)]
1179pub struct longlong2 {
1180 pub x: ::std::os::raw::c_longlong,
1181 pub y: ::std::os::raw::c_longlong,
1182}
1183#[test]
1184fn bindgen_test_layout_longlong2() {
1185 assert_eq!(
1186 ::std::mem::size_of::<longlong2>(),
1187 16usize,
1188 concat!("Size of: ", stringify!(longlong2))
1189 );
1190 assert_eq!(
1191 unsafe { &(*(0 as *const longlong2)).x as *const _ as usize },
1192 0usize,
1193 concat!("Offset of field: ", stringify!(longlong2), "::", stringify!(x))
1194 );
1195 assert_eq!(
1196 unsafe { &(*(0 as *const longlong2)).y as *const _ as usize },
1197 8usize,
1198 concat!("Offset of field: ", stringify!(longlong2), "::", stringify!(y))
1199 );
1200}
1201#[repr(C)]
1202#[derive(Debug, Copy, Clone)]
1203pub struct ulonglong2 {
1204 pub x: ::std::os::raw::c_ulonglong,
1205 pub y: ::std::os::raw::c_ulonglong,
1206}
1207#[test]
1208fn bindgen_test_layout_ulonglong2() {
1209 assert_eq!(
1210 ::std::mem::size_of::<ulonglong2>(),
1211 16usize,
1212 concat!("Size of: ", stringify!(ulonglong2))
1213 );
1214 assert_eq!(
1215 unsafe { &(*(0 as *const ulonglong2)).x as *const _ as usize },
1216 0usize,
1217 concat!("Offset of field: ", stringify!(ulonglong2), "::", stringify!(x))
1218 );
1219 assert_eq!(
1220 unsafe { &(*(0 as *const ulonglong2)).y as *const _ as usize },
1221 8usize,
1222 concat!("Offset of field: ", stringify!(ulonglong2), "::", stringify!(y))
1223 );
1224}
1225#[repr(C)]
1226#[derive(Debug, Copy, Clone)]
1227pub struct longlong3 {
1228 pub x: ::std::os::raw::c_longlong,
1229 pub y: ::std::os::raw::c_longlong,
1230 pub z: ::std::os::raw::c_longlong,
1231}
1232#[test]
1233fn bindgen_test_layout_longlong3() {
1234 assert_eq!(
1235 ::std::mem::size_of::<longlong3>(),
1236 24usize,
1237 concat!("Size of: ", stringify!(longlong3))
1238 );
1239 assert_eq!(
1240 ::std::mem::align_of::<longlong3>(),
1241 8usize,
1242 concat!("Alignment of ", stringify!(longlong3))
1243 );
1244 assert_eq!(
1245 unsafe { &(*(0 as *const longlong3)).x as *const _ as usize },
1246 0usize,
1247 concat!("Offset of field: ", stringify!(longlong3), "::", stringify!(x))
1248 );
1249 assert_eq!(
1250 unsafe { &(*(0 as *const longlong3)).y as *const _ as usize },
1251 8usize,
1252 concat!("Offset of field: ", stringify!(longlong3), "::", stringify!(y))
1253 );
1254 assert_eq!(
1255 unsafe { &(*(0 as *const longlong3)).z as *const _ as usize },
1256 16usize,
1257 concat!("Offset of field: ", stringify!(longlong3), "::", stringify!(z))
1258 );
1259}
1260#[repr(C)]
1261#[derive(Debug, Copy, Clone)]
1262pub struct ulonglong3 {
1263 pub x: ::std::os::raw::c_ulonglong,
1264 pub y: ::std::os::raw::c_ulonglong,
1265 pub z: ::std::os::raw::c_ulonglong,
1266}
1267#[test]
1268fn bindgen_test_layout_ulonglong3() {
1269 assert_eq!(
1270 ::std::mem::size_of::<ulonglong3>(),
1271 24usize,
1272 concat!("Size of: ", stringify!(ulonglong3))
1273 );
1274 assert_eq!(
1275 ::std::mem::align_of::<ulonglong3>(),
1276 8usize,
1277 concat!("Alignment of ", stringify!(ulonglong3))
1278 );
1279 assert_eq!(
1280 unsafe { &(*(0 as *const ulonglong3)).x as *const _ as usize },
1281 0usize,
1282 concat!("Offset of field: ", stringify!(ulonglong3), "::", stringify!(x))
1283 );
1284 assert_eq!(
1285 unsafe { &(*(0 as *const ulonglong3)).y as *const _ as usize },
1286 8usize,
1287 concat!("Offset of field: ", stringify!(ulonglong3), "::", stringify!(y))
1288 );
1289 assert_eq!(
1290 unsafe { &(*(0 as *const ulonglong3)).z as *const _ as usize },
1291 16usize,
1292 concat!("Offset of field: ", stringify!(ulonglong3), "::", stringify!(z))
1293 );
1294}
1295#[repr(C)]
1296#[derive(Debug, Copy, Clone)]
1297pub struct longlong4 {
1298 pub x: ::std::os::raw::c_longlong,
1299 pub y: ::std::os::raw::c_longlong,
1300 pub z: ::std::os::raw::c_longlong,
1301 pub w: ::std::os::raw::c_longlong,
1302}
1303#[test]
1304fn bindgen_test_layout_longlong4() {
1305 assert_eq!(
1306 ::std::mem::size_of::<longlong4>(),
1307 32usize,
1308 concat!("Size of: ", stringify!(longlong4))
1309 );
1310 assert_eq!(
1311 unsafe { &(*(0 as *const longlong4)).x as *const _ as usize },
1312 0usize,
1313 concat!("Offset of field: ", stringify!(longlong4), "::", stringify!(x))
1314 );
1315 assert_eq!(
1316 unsafe { &(*(0 as *const longlong4)).y as *const _ as usize },
1317 8usize,
1318 concat!("Offset of field: ", stringify!(longlong4), "::", stringify!(y))
1319 );
1320 assert_eq!(
1321 unsafe { &(*(0 as *const longlong4)).z as *const _ as usize },
1322 16usize,
1323 concat!("Offset of field: ", stringify!(longlong4), "::", stringify!(z))
1324 );
1325 assert_eq!(
1326 unsafe { &(*(0 as *const longlong4)).w as *const _ as usize },
1327 24usize,
1328 concat!("Offset of field: ", stringify!(longlong4), "::", stringify!(w))
1329 );
1330}
1331#[repr(C)]
1332#[derive(Debug, Copy, Clone)]
1333pub struct ulonglong4 {
1334 pub x: ::std::os::raw::c_ulonglong,
1335 pub y: ::std::os::raw::c_ulonglong,
1336 pub z: ::std::os::raw::c_ulonglong,
1337 pub w: ::std::os::raw::c_ulonglong,
1338}
1339#[test]
1340fn bindgen_test_layout_ulonglong4() {
1341 assert_eq!(
1342 ::std::mem::size_of::<ulonglong4>(),
1343 32usize,
1344 concat!("Size of: ", stringify!(ulonglong4))
1345 );
1346 assert_eq!(
1347 unsafe { &(*(0 as *const ulonglong4)).x as *const _ as usize },
1348 0usize,
1349 concat!("Offset of field: ", stringify!(ulonglong4), "::", stringify!(x))
1350 );
1351 assert_eq!(
1352 unsafe { &(*(0 as *const ulonglong4)).y as *const _ as usize },
1353 8usize,
1354 concat!("Offset of field: ", stringify!(ulonglong4), "::", stringify!(y))
1355 );
1356 assert_eq!(
1357 unsafe { &(*(0 as *const ulonglong4)).z as *const _ as usize },
1358 16usize,
1359 concat!("Offset of field: ", stringify!(ulonglong4), "::", stringify!(z))
1360 );
1361 assert_eq!(
1362 unsafe { &(*(0 as *const ulonglong4)).w as *const _ as usize },
1363 24usize,
1364 concat!("Offset of field: ", stringify!(ulonglong4), "::", stringify!(w))
1365 );
1366}
1367#[repr(C)]
1368#[derive(Debug, Copy, Clone)]
1369pub struct double1 {
1370 pub x: f64,
1371}
1372#[test]
1373fn bindgen_test_layout_double1() {
1374 assert_eq!(
1375 ::std::mem::size_of::<double1>(),
1376 8usize,
1377 concat!("Size of: ", stringify!(double1))
1378 );
1379 assert_eq!(
1380 ::std::mem::align_of::<double1>(),
1381 8usize,
1382 concat!("Alignment of ", stringify!(double1))
1383 );
1384 assert_eq!(
1385 unsafe { &(*(0 as *const double1)).x as *const _ as usize },
1386 0usize,
1387 concat!("Offset of field: ", stringify!(double1), "::", stringify!(x))
1388 );
1389}
1390#[repr(C)]
1391#[derive(Debug, Copy, Clone)]
1392pub struct double2 {
1393 pub x: f64,
1394 pub y: f64,
1395}
1396#[test]
1397fn bindgen_test_layout_double2() {
1398 assert_eq!(
1399 ::std::mem::size_of::<double2>(),
1400 16usize,
1401 concat!("Size of: ", stringify!(double2))
1402 );
1403 assert_eq!(
1404 unsafe { &(*(0 as *const double2)).x as *const _ as usize },
1405 0usize,
1406 concat!("Offset of field: ", stringify!(double2), "::", stringify!(x))
1407 );
1408 assert_eq!(
1409 unsafe { &(*(0 as *const double2)).y as *const _ as usize },
1410 8usize,
1411 concat!("Offset of field: ", stringify!(double2), "::", stringify!(y))
1412 );
1413}
1414#[repr(C)]
1415#[derive(Debug, Copy, Clone)]
1416pub struct double3 {
1417 pub x: f64,
1418 pub y: f64,
1419 pub z: f64,
1420}
1421#[test]
1422fn bindgen_test_layout_double3() {
1423 assert_eq!(
1424 ::std::mem::size_of::<double3>(),
1425 24usize,
1426 concat!("Size of: ", stringify!(double3))
1427 );
1428 assert_eq!(
1429 ::std::mem::align_of::<double3>(),
1430 8usize,
1431 concat!("Alignment of ", stringify!(double3))
1432 );
1433 assert_eq!(
1434 unsafe { &(*(0 as *const double3)).x as *const _ as usize },
1435 0usize,
1436 concat!("Offset of field: ", stringify!(double3), "::", stringify!(x))
1437 );
1438 assert_eq!(
1439 unsafe { &(*(0 as *const double3)).y as *const _ as usize },
1440 8usize,
1441 concat!("Offset of field: ", stringify!(double3), "::", stringify!(y))
1442 );
1443 assert_eq!(
1444 unsafe { &(*(0 as *const double3)).z as *const _ as usize },
1445 16usize,
1446 concat!("Offset of field: ", stringify!(double3), "::", stringify!(z))
1447 );
1448}
1449#[repr(C)]
1450#[derive(Debug, Copy, Clone)]
1451pub struct double4 {
1452 pub x: f64,
1453 pub y: f64,
1454 pub z: f64,
1455 pub w: f64,
1456}
1457#[test]
1458fn bindgen_test_layout_double4() {
1459 assert_eq!(
1460 ::std::mem::size_of::<double4>(),
1461 32usize,
1462 concat!("Size of: ", stringify!(double4))
1463 );
1464 assert_eq!(
1465 unsafe { &(*(0 as *const double4)).x as *const _ as usize },
1466 0usize,
1467 concat!("Offset of field: ", stringify!(double4), "::", stringify!(x))
1468 );
1469 assert_eq!(
1470 unsafe { &(*(0 as *const double4)).y as *const _ as usize },
1471 8usize,
1472 concat!("Offset of field: ", stringify!(double4), "::", stringify!(y))
1473 );
1474 assert_eq!(
1475 unsafe { &(*(0 as *const double4)).z as *const _ as usize },
1476 16usize,
1477 concat!("Offset of field: ", stringify!(double4), "::", stringify!(z))
1478 );
1479 assert_eq!(
1480 unsafe { &(*(0 as *const double4)).w as *const _ as usize },
1481 24usize,
1482 concat!("Offset of field: ", stringify!(double4), "::", stringify!(w))
1483 );
1484}
1485#[repr(C)]
1486#[derive(Debug, Copy, Clone)]
1487pub struct dim3 {
1488 pub x: ::std::os::raw::c_uint,
1489 pub y: ::std::os::raw::c_uint,
1490 pub z: ::std::os::raw::c_uint,
1491}
1492#[test]
1493fn bindgen_test_layout_dim3() {
1494 assert_eq!(
1495 ::std::mem::size_of::<dim3>(),
1496 12usize,
1497 concat!("Size of: ", stringify!(dim3))
1498 );
1499 assert_eq!(
1500 ::std::mem::align_of::<dim3>(),
1501 4usize,
1502 concat!("Alignment of ", stringify!(dim3))
1503 );
1504 assert_eq!(
1505 unsafe { &(*(0 as *const dim3)).x as *const _ as usize },
1506 0usize,
1507 concat!("Offset of field: ", stringify!(dim3), "::", stringify!(x))
1508 );
1509 assert_eq!(
1510 unsafe { &(*(0 as *const dim3)).y as *const _ as usize },
1511 4usize,
1512 concat!("Offset of field: ", stringify!(dim3), "::", stringify!(y))
1513 );
1514 assert_eq!(
1515 unsafe { &(*(0 as *const dim3)).z as *const _ as usize },
1516 8usize,
1517 concat!("Offset of field: ", stringify!(dim3), "::", stringify!(z))
1518 );
1519}