Auto merge of #1179 - fitzgen:add-regression-test-for-issue-816, r=emilio

Add a regression test for issue #816

r? @emilio

2 files changed, 857 insertions, 0 deletions

diff --git a/tests/expectations/tests/issue-816.rs b/tests/expectations/tests/issue-816.rs
new file mode 100644
index 00000000..bb8a323a
--- /dev/null
+++ b/tests/expectations/tests/issue-816.rs
@@ -0,0 +1,808 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
+
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage, Align>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    storage: Storage,
+    align: [Align; 0],
+}
+
+impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn new(storage: Storage) -> Self {
+        Self { storage, align: [] }
+    }
+
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+
+        let bit_index = index % 8;
+        let mask = 1 << bit_index;
+
+        byte & mask == mask
+    }
+
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+
+        let bit_index = index % 8;
+        let mask = 1 << bit_index;
+
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
+
+        let mut val = 0;
+
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                val |= 1 << i;
+            }
+        }
+
+        val
+    }
+
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
+
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            self.set_bit(i + bit_offset, val_bit_is_set);
+        }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct jvmtiCapabilities {
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize], u8>,
+    pub __bindgen_align: [u32; 0usize],
+}
+#[test]
+fn bindgen_test_layout_jvmtiCapabilities() {
+    assert_eq!(
+        ::std::mem::size_of::<jvmtiCapabilities>(),
+        16usize,
+        concat!("Size of: ", stringify!(jvmtiCapabilities))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<jvmtiCapabilities>(),
+        4usize,
+        concat!("Alignment of ", stringify!(jvmtiCapabilities))
+    );
+}
+impl jvmtiCapabilities {
+    #[inline]
+    pub fn can_tag_objects(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_tag_objects(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_generate_field_modification_events(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_generate_field_modification_events(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(1usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_generate_field_access_events(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_generate_field_access_events(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(2usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_get_bytecodes(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_get_bytecodes(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(3usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_get_synthetic_attribute(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_get_synthetic_attribute(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(4usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_get_owned_monitor_info(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_get_owned_monitor_info(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(5usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_get_current_contended_monitor(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_get_current_contended_monitor(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(6usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_get_monitor_info(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_get_monitor_info(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(7usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_pop_frame(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_pop_frame(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(8usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_redefine_classes(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_redefine_classes(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(9usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_signal_thread(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_signal_thread(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(10usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_get_source_file_name(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_get_source_file_name(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(11usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_get_line_numbers(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_get_line_numbers(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(12usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_get_source_debug_extension(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_get_source_debug_extension(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(13usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_access_local_variables(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_access_local_variables(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(14usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_maintain_original_method_order(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_maintain_original_method_order(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(15usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_generate_single_step_events(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_generate_single_step_events(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(16usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_generate_exception_events(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_generate_exception_events(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(17usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_generate_frame_pop_events(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_generate_frame_pop_events(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(18usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_generate_breakpoint_events(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_generate_breakpoint_events(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(19usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_suspend(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_suspend(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(20usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_redefine_any_class(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_redefine_any_class(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(21usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_get_current_thread_cpu_time(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_get_current_thread_cpu_time(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(22usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_get_thread_cpu_time(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_get_thread_cpu_time(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(23usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_generate_method_entry_events(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_generate_method_entry_events(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(24usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_generate_method_exit_events(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_generate_method_exit_events(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(25usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_generate_all_class_hook_events(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_generate_all_class_hook_events(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(26usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_generate_compiled_method_load_events(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_generate_compiled_method_load_events(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(27usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_generate_monitor_events(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_generate_monitor_events(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(28usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_generate_vm_object_alloc_events(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_generate_vm_object_alloc_events(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(29usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_generate_native_method_bind_events(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_generate_native_method_bind_events(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(30usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_generate_garbage_collection_events(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_generate_garbage_collection_events(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(31usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_generate_object_free_events(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_generate_object_free_events(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(32usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_force_early_return(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(33usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_force_early_return(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(33usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_get_owned_monitor_stack_depth_info(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(34usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_get_owned_monitor_stack_depth_info(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(34usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_get_constant_pool(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(35usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_get_constant_pool(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(35usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_set_native_method_prefix(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(36usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_set_native_method_prefix(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(36usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_retransform_classes(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(37usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_retransform_classes(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(37usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_retransform_any_class(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(38usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_retransform_any_class(&mut self, val: ::std::os::raw::c_uint) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(38usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_generate_resource_exhaustion_heap_events(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(39usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_generate_resource_exhaustion_heap_events(
+        &mut self,
+        val: ::std::os::raw::c_uint,
+    ) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(39usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn can_generate_resource_exhaustion_threads_events(&self) -> ::std::os::raw::c_uint {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_generate_resource_exhaustion_threads_events(
+        &mut self,
+        val: ::std::os::raw::c_uint,
+    ) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(40usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        can_tag_objects: ::std::os::raw::c_uint,
+        can_generate_field_modification_events: ::std::os::raw::c_uint,
+        can_generate_field_access_events: ::std::os::raw::c_uint,
+        can_get_bytecodes: ::std::os::raw::c_uint,
+        can_get_synthetic_attribute: ::std::os::raw::c_uint,
+        can_get_owned_monitor_info: ::std::os::raw::c_uint,
+        can_get_current_contended_monitor: ::std::os::raw::c_uint,
+        can_get_monitor_info: ::std::os::raw::c_uint,
+        can_pop_frame: ::std::os::raw::c_uint,
+        can_redefine_classes: ::std::os::raw::c_uint,
+        can_signal_thread: ::std::os::raw::c_uint,
+        can_get_source_file_name: ::std::os::raw::c_uint,
+        can_get_line_numbers: ::std::os::raw::c_uint,
+        can_get_source_debug_extension: ::std::os::raw::c_uint,
+        can_access_local_variables: ::std::os::raw::c_uint,
+        can_maintain_original_method_order: ::std::os::raw::c_uint,
+        can_generate_single_step_events: ::std::os::raw::c_uint,
+        can_generate_exception_events: ::std::os::raw::c_uint,
+        can_generate_frame_pop_events: ::std::os::raw::c_uint,
+        can_generate_breakpoint_events: ::std::os::raw::c_uint,
+        can_suspend: ::std::os::raw::c_uint,
+        can_redefine_any_class: ::std::os::raw::c_uint,
+        can_get_current_thread_cpu_time: ::std::os::raw::c_uint,
+        can_get_thread_cpu_time: ::std::os::raw::c_uint,
+        can_generate_method_entry_events: ::std::os::raw::c_uint,
+        can_generate_method_exit_events: ::std::os::raw::c_uint,
+        can_generate_all_class_hook_events: ::std::os::raw::c_uint,
+        can_generate_compiled_method_load_events: ::std::os::raw::c_uint,
+        can_generate_monitor_events: ::std::os::raw::c_uint,
+        can_generate_vm_object_alloc_events: ::std::os::raw::c_uint,
+        can_generate_native_method_bind_events: ::std::os::raw::c_uint,
+        can_generate_garbage_collection_events: ::std::os::raw::c_uint,
+        can_generate_object_free_events: ::std::os::raw::c_uint,
+        can_force_early_return: ::std::os::raw::c_uint,
+        can_get_owned_monitor_stack_depth_info: ::std::os::raw::c_uint,
+        can_get_constant_pool: ::std::os::raw::c_uint,
+        can_set_native_method_prefix: ::std::os::raw::c_uint,
+        can_retransform_classes: ::std::os::raw::c_uint,
+        can_retransform_any_class: ::std::os::raw::c_uint,
+        can_generate_resource_exhaustion_heap_events: ::std::os::raw::c_uint,
+        can_generate_resource_exhaustion_threads_events: ::std::os::raw::c_uint,
+    ) -> __BindgenBitfieldUnit<[u8; 16usize], u8> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize], u8> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let can_tag_objects: u32 = unsafe { ::std::mem::transmute(can_tag_objects) };
+            can_tag_objects as u64
+        });
+        __bindgen_bitfield_unit.set(1usize, 1u8, {
+            let can_generate_field_modification_events: u32 =
+                unsafe { ::std::mem::transmute(can_generate_field_modification_events) };
+            can_generate_field_modification_events as u64
+        });
+        __bindgen_bitfield_unit.set(2usize, 1u8, {
+            let can_generate_field_access_events: u32 =
+                unsafe { ::std::mem::transmute(can_generate_field_access_events) };
+            can_generate_field_access_events as u64
+        });
+        __bindgen_bitfield_unit.set(3usize, 1u8, {
+            let can_get_bytecodes: u32 = unsafe { ::std::mem::transmute(can_get_bytecodes) };
+            can_get_bytecodes as u64
+        });
+        __bindgen_bitfield_unit.set(4usize, 1u8, {
+            let can_get_synthetic_attribute: u32 =
+                unsafe { ::std::mem::transmute(can_get_synthetic_attribute) };
+            can_get_synthetic_attribute as u64
+        });
+        __bindgen_bitfield_unit.set(5usize, 1u8, {
+            let can_get_owned_monitor_info: u32 =
+                unsafe { ::std::mem::transmute(can_get_owned_monitor_info) };
+            can_get_owned_monitor_info as u64
+        });
+        __bindgen_bitfield_unit.set(6usize, 1u8, {
+            let can_get_current_contended_monitor: u32 =
+                unsafe { ::std::mem::transmute(can_get_current_contended_monitor) };
+            can_get_current_contended_monitor as u64
+        });
+        __bindgen_bitfield_unit.set(7usize, 1u8, {
+            let can_get_monitor_info: u32 = unsafe { ::std::mem::transmute(can_get_monitor_info) };
+            can_get_monitor_info as u64
+        });
+        __bindgen_bitfield_unit.set(8usize, 1u8, {
+            let can_pop_frame: u32 = unsafe { ::std::mem::transmute(can_pop_frame) };
+            can_pop_frame as u64
+        });
+        __bindgen_bitfield_unit.set(9usize, 1u8, {
+            let can_redefine_classes: u32 = unsafe { ::std::mem::transmute(can_redefine_classes) };
+            can_redefine_classes as u64
+        });
+        __bindgen_bitfield_unit.set(10usize, 1u8, {
+            let can_signal_thread: u32 = unsafe { ::std::mem::transmute(can_signal_thread) };
+            can_signal_thread as u64
+        });
+        __bindgen_bitfield_unit.set(11usize, 1u8, {
+            let can_get_source_file_name: u32 =
+                unsafe { ::std::mem::transmute(can_get_source_file_name) };
+            can_get_source_file_name as u64
+        });
+        __bindgen_bitfield_unit.set(12usize, 1u8, {
+            let can_get_line_numbers: u32 = unsafe { ::std::mem::transmute(can_get_line_numbers) };
+            can_get_line_numbers as u64
+        });
+        __bindgen_bitfield_unit.set(13usize, 1u8, {
+            let can_get_source_debug_extension: u32 =
+                unsafe { ::std::mem::transmute(can_get_source_debug_extension) };
+            can_get_source_debug_extension as u64
+        });
+        __bindgen_bitfield_unit.set(14usize, 1u8, {
+            let can_access_local_variables: u32 =
+                unsafe { ::std::mem::transmute(can_access_local_variables) };
+            can_access_local_variables as u64
+        });
+        __bindgen_bitfield_unit.set(15usize, 1u8, {
+            let can_maintain_original_method_order: u32 =
+                unsafe { ::std::mem::transmute(can_maintain_original_method_order) };
+            can_maintain_original_method_order as u64
+        });
+        __bindgen_bitfield_unit.set(16usize, 1u8, {
+            let can_generate_single_step_events: u32 =
+                unsafe { ::std::mem::transmute(can_generate_single_step_events) };
+            can_generate_single_step_events as u64
+        });
+        __bindgen_bitfield_unit.set(17usize, 1u8, {
+            let can_generate_exception_events: u32 =
+                unsafe { ::std::mem::transmute(can_generate_exception_events) };
+            can_generate_exception_events as u64
+        });
+        __bindgen_bitfield_unit.set(18usize, 1u8, {
+            let can_generate_frame_pop_events: u32 =
+                unsafe { ::std::mem::transmute(can_generate_frame_pop_events) };
+            can_generate_frame_pop_events as u64
+        });
+        __bindgen_bitfield_unit.set(19usize, 1u8, {
+            let can_generate_breakpoint_events: u32 =
+                unsafe { ::std::mem::transmute(can_generate_breakpoint_events) };
+            can_generate_breakpoint_events as u64
+        });
+        __bindgen_bitfield_unit.set(20usize, 1u8, {
+            let can_suspend: u32 = unsafe { ::std::mem::transmute(can_suspend) };
+            can_suspend as u64
+        });
+        __bindgen_bitfield_unit.set(21usize, 1u8, {
+            let can_redefine_any_class: u32 =
+                unsafe { ::std::mem::transmute(can_redefine_any_class) };
+            can_redefine_any_class as u64
+        });
+        __bindgen_bitfield_unit.set(22usize, 1u8, {
+            let can_get_current_thread_cpu_time: u32 =
+                unsafe { ::std::mem::transmute(can_get_current_thread_cpu_time) };
+            can_get_current_thread_cpu_time as u64
+        });
+        __bindgen_bitfield_unit.set(23usize, 1u8, {
+            let can_get_thread_cpu_time: u32 =
+                unsafe { ::std::mem::transmute(can_get_thread_cpu_time) };
+            can_get_thread_cpu_time as u64
+        });
+        __bindgen_bitfield_unit.set(24usize, 1u8, {
+            let can_generate_method_entry_events: u32 =
+                unsafe { ::std::mem::transmute(can_generate_method_entry_events) };
+            can_generate_method_entry_events as u64
+        });
+        __bindgen_bitfield_unit.set(25usize, 1u8, {
+            let can_generate_method_exit_events: u32 =
+                unsafe { ::std::mem::transmute(can_generate_method_exit_events) };
+            can_generate_method_exit_events as u64
+        });
+        __bindgen_bitfield_unit.set(26usize, 1u8, {
+            let can_generate_all_class_hook_events: u32 =
+                unsafe { ::std::mem::transmute(can_generate_all_class_hook_events) };
+            can_generate_all_class_hook_events as u64
+        });
+        __bindgen_bitfield_unit.set(27usize, 1u8, {
+            let can_generate_compiled_method_load_events: u32 =
+                unsafe { ::std::mem::transmute(can_generate_compiled_method_load_events) };
+            can_generate_compiled_method_load_events as u64
+        });
+        __bindgen_bitfield_unit.set(28usize, 1u8, {
+            let can_generate_monitor_events: u32 =
+                unsafe { ::std::mem::transmute(can_generate_monitor_events) };
+            can_generate_monitor_events as u64
+        });
+        __bindgen_bitfield_unit.set(29usize, 1u8, {
+            let can_generate_vm_object_alloc_events: u32 =
+                unsafe { ::std::mem::transmute(can_generate_vm_object_alloc_events) };
+            can_generate_vm_object_alloc_events as u64
+        });
+        __bindgen_bitfield_unit.set(30usize, 1u8, {
+            let can_generate_native_method_bind_events: u32 =
+                unsafe { ::std::mem::transmute(can_generate_native_method_bind_events) };
+            can_generate_native_method_bind_events as u64
+        });
+        __bindgen_bitfield_unit.set(31usize, 1u8, {
+            let can_generate_garbage_collection_events: u32 =
+                unsafe { ::std::mem::transmute(can_generate_garbage_collection_events) };
+            can_generate_garbage_collection_events as u64
+        });
+        __bindgen_bitfield_unit.set(32usize, 1u8, {
+            let can_generate_object_free_events: u32 =
+                unsafe { ::std::mem::transmute(can_generate_object_free_events) };
+            can_generate_object_free_events as u64
+        });
+        __bindgen_bitfield_unit.set(33usize, 1u8, {
+            let can_force_early_return: u32 =
+                unsafe { ::std::mem::transmute(can_force_early_return) };
+            can_force_early_return as u64
+        });
+        __bindgen_bitfield_unit.set(34usize, 1u8, {
+            let can_get_owned_monitor_stack_depth_info: u32 =
+                unsafe { ::std::mem::transmute(can_get_owned_monitor_stack_depth_info) };
+            can_get_owned_monitor_stack_depth_info as u64
+        });
+        __bindgen_bitfield_unit.set(35usize, 1u8, {
+            let can_get_constant_pool: u32 =
+                unsafe { ::std::mem::transmute(can_get_constant_pool) };
+            can_get_constant_pool as u64
+        });
+        __bindgen_bitfield_unit.set(36usize, 1u8, {
+            let can_set_native_method_prefix: u32 =
+                unsafe { ::std::mem::transmute(can_set_native_method_prefix) };
+            can_set_native_method_prefix as u64
+        });
+        __bindgen_bitfield_unit.set(37usize, 1u8, {
+            let can_retransform_classes: u32 =
+                unsafe { ::std::mem::transmute(can_retransform_classes) };
+            can_retransform_classes as u64
+        });
+        __bindgen_bitfield_unit.set(38usize, 1u8, {
+            let can_retransform_any_class: u32 =
+                unsafe { ::std::mem::transmute(can_retransform_any_class) };
+            can_retransform_any_class as u64
+        });
+        __bindgen_bitfield_unit.set(39usize, 1u8, {
+            let can_generate_resource_exhaustion_heap_events: u32 =
+                unsafe { ::std::mem::transmute(can_generate_resource_exhaustion_heap_events) };
+            can_generate_resource_exhaustion_heap_events as u64
+        });
+        __bindgen_bitfield_unit.set(40usize, 1u8, {
+            let can_generate_resource_exhaustion_threads_events: u32 =
+                unsafe { ::std::mem::transmute(can_generate_resource_exhaustion_threads_events) };
+            can_generate_resource_exhaustion_threads_events as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
diff --git a/tests/headers/issue-816.h b/tests/headers/issue-816.h
new file mode 100644
index 00000000..cacb0260
--- /dev/null
+++ b/tests/headers/issue-816.h
@@ -0,0 +1,49 @@
+typedef struct {
+    unsigned int can_tag_objects : 1;
+    unsigned int can_generate_field_modification_events : 1;
+    unsigned int can_generate_field_access_events : 1;
+    unsigned int can_get_bytecodes : 1;
+    unsigned int can_get_synthetic_attribute : 1;
+    unsigned int can_get_owned_monitor_info : 1;
+    unsigned int can_get_current_contended_monitor : 1;
+    unsigned int can_get_monitor_info : 1;
+    unsigned int can_pop_frame : 1;
+    unsigned int can_redefine_classes : 1;
+    unsigned int can_signal_thread : 1;
+    unsigned int can_get_source_file_name : 1;
+    unsigned int can_get_line_numbers : 1;
+    unsigned int can_get_source_debug_extension : 1;
+    unsigned int can_access_local_variables : 1;
+    unsigned int can_maintain_original_method_order : 1;
+    unsigned int can_generate_single_step_events : 1;
+    unsigned int can_generate_exception_events : 1;
+    unsigned int can_generate_frame_pop_events : 1;
+    unsigned int can_generate_breakpoint_events : 1;
+    unsigned int can_suspend : 1;
+    unsigned int can_redefine_any_class : 1;
+    unsigned int can_get_current_thread_cpu_time : 1;
+    unsigned int can_get_thread_cpu_time : 1;
+    unsigned int can_generate_method_entry_events : 1;
+    unsigned int can_generate_method_exit_events : 1;
+    unsigned int can_generate_all_class_hook_events : 1;
+    unsigned int can_generate_compiled_method_load_events : 1;
+    unsigned int can_generate_monitor_events : 1;
+    unsigned int can_generate_vm_object_alloc_events : 1;
+    unsigned int can_generate_native_method_bind_events : 1;
+    unsigned int can_generate_garbage_collection_events : 1;
+    unsigned int can_generate_object_free_events : 1;
+    unsigned int can_force_early_return : 1;
+    unsigned int can_get_owned_monitor_stack_depth_info : 1;
+    unsigned int can_get_constant_pool : 1;
+    unsigned int can_set_native_method_prefix : 1;
+    unsigned int can_retransform_classes : 1;
+    unsigned int can_retransform_any_class : 1;
+    unsigned int can_generate_resource_exhaustion_heap_events : 1;
+    unsigned int can_generate_resource_exhaustion_threads_events : 1;
+    unsigned int : 7;
+    unsigned int : 16;
+    unsigned int : 16;
+    unsigned int : 16;
+    unsigned int : 16;
+    unsigned int : 16;
+} jvmtiCapabilities;