Fix opaque template test to exercise the cannot derive case

And also not just fields, but also base members.

Author: fitzgen

tests/expectations/tests/opaque-template-inst-member.rs

@@ -12,14 +12,13 @@ impl Default for OpaqueTemplate {
     fn default() -> Self { unsafe { ::std::mem::zeroed() } }
 }
 #[repr(C)]
-#[derive(Debug, Default, Copy)]
 pub struct ContainsOpaqueTemplate {
-    pub mBlah: [u32; 11usize],
+    pub mBlah: [u32; 101usize],
     pub mBaz: ::std::os::raw::c_int,
 }
 #[test]
 fn bindgen_test_layout_ContainsOpaqueTemplate() {
-    assert_eq!(::std::mem::size_of::<ContainsOpaqueTemplate>() , 48usize ,
+    assert_eq!(::std::mem::size_of::<ContainsOpaqueTemplate>() , 408usize ,
                concat ! ( "Size of: " , stringify ! ( ContainsOpaqueTemplate )
                ));
     assert_eq! (::std::mem::align_of::<ContainsOpaqueTemplate>() , 4usize ,
@@ -32,10 +31,32 @@ fn bindgen_test_layout_ContainsOpaqueTemplate() {
                 ) , "::" , stringify ! ( mBlah ) ));
     assert_eq! (unsafe {
                 & ( * ( 0 as * const ContainsOpaqueTemplate ) ) . mBaz as *
-                const _ as usize } , 44usize , concat ! (
+                const _ as usize } , 404usize , concat ! (
                 "Alignment of field: " , stringify ! ( ContainsOpaqueTemplate
                 ) , "::" , stringify ! ( mBaz ) ));
 }
-impl Clone for ContainsOpaqueTemplate {
-    fn clone(&self) -> Self { *self }
+impl Default for ContainsOpaqueTemplate {
+    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
+}
+#[repr(C)]
+pub struct InheritsOpaqueTemplate {
+    pub _base: [u8; 401usize],
+    pub wow: *mut ::std::os::raw::c_char,
+}
+#[test]
+fn bindgen_test_layout_InheritsOpaqueTemplate() {
+    assert_eq!(::std::mem::size_of::<InheritsOpaqueTemplate>() , 416usize ,
+               concat ! ( "Size of: " , stringify ! ( InheritsOpaqueTemplate )
+               ));
+    assert_eq! (::std::mem::align_of::<InheritsOpaqueTemplate>() , 8usize ,
+                concat ! (
+                "Alignment of " , stringify ! ( InheritsOpaqueTemplate ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const InheritsOpaqueTemplate ) ) . wow as *
+                const _ as usize } , 408usize , concat ! (
+                "Alignment of field: " , stringify ! ( InheritsOpaqueTemplate
+                ) , "::" , stringify ! ( wow ) ));
+}
+impl Default for InheritsOpaqueTemplate {
+    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
 }

tests/headers/opaque-template-inst-member.hpp

@@ -3,10 +3,18 @@
 template<typename T>
 class OpaqueTemplate {
     T mData;
-    bool mCannotDebug[40];
+    bool mCannotDebug[400];
 };
 
+// This should not end up deriving Debug because its `mBlah` field cannot derive
+// Debug because the instantiation's definition cannot derive Debug.
 class ContainsOpaqueTemplate {
     OpaqueTemplate<int> mBlah;
     int mBaz;
 };
+
+// This shold not end up deriving Debug either, for similar reasons, although
+// we're exercising base member edges now.
+class InheritsOpaqueTemplate : public OpaqueTemplate<bool> {
+    char* wow;
+};