Tests for namespaced opaque extern types.

Author: adetaylor

tests/ffi/extra.rs

@@ -12,20 +12,26 @@
 pub mod ffi2 {
     impl UniquePtr<D> {}
     impl UniquePtr<E> {}
+    impl UniquePtr<F> {}
 
     extern "C" {
         include!("tests/ffi/tests.h");
 
         type D = crate::other::D;
         type E = crate::other::E;
+        #[namespace (namespace = F)]
+        type F = crate::other::f::F;
 
         fn c_take_trivial_ptr(d: UniquePtr<D>);
         fn c_take_trivial_ref(d: &D);
         fn c_take_trivial(d: D);
         fn c_take_opaque_ptr(e: UniquePtr<E>);
         fn c_take_opaque_ref(e: &E);
+        fn c_take_opaque_ns_ptr(e: UniquePtr<F>);
+        fn c_take_opaque_ns_ref(e: &F);
         fn c_return_trivial_ptr() -> UniquePtr<D>;
         fn c_return_trivial() -> D;
         fn c_return_opaque_ptr() -> UniquePtr<E>;
+        fn c_return_ns_opaque_ptr() -> UniquePtr<F>;  
     }
 }

tests/ffi/lib.rs

@@ -25,6 +25,22 @@ mod other {
         e_str: CxxString,
     }
 
+    pub mod f {
+        use cxx::kind::Opaque;
+        use cxx::{type_id, CxxString, ExternType};
+
+        #[repr(C)]
+        pub struct F {
+            e: u64,
+            e_str: CxxString,
+        }
+
+        unsafe impl ExternType for F {
+            type Id = type_id!("F::F");
+            type Kind = Opaque;
+        }
+    }
+
     unsafe impl ExternType for D {
         type Id = type_id!("tests::D");
         type Kind = Trivial;

tests/ffi/tests.cc

@@ -478,12 +478,25 @@ void c_take_opaque_ptr(std::unique_ptr<E> e) {
   }
 }
 
+void c_take_opaque_ns_ptr(std::unique_ptr<::F::F> f) {
+  if (f->f == 40) {
+    cxx_test_suite_set_correct();
+  }
+}
+
 void c_take_opaque_ref(const E& e) {
   if (e.e == 40 && e.e_str == "hello") {
     cxx_test_suite_set_correct();
   }
 }
 
+void c_take_opaque_ns_ref(const ::F::F& f) {
+  if (f.f == 40 && f.f_str == "hello") {
+    cxx_test_suite_set_correct();
+  }
+}
+
+
 std::unique_ptr<D> c_return_trivial_ptr() {
   auto d = std::unique_ptr<D>(new D());
   d->d = 30;
@@ -503,6 +516,13 @@ std::unique_ptr<E> c_return_opaque_ptr() {
   return e;
 }
 
+std::unique_ptr<::F::F> c_return_ns_opaque_ptr() {
+  auto f = std::unique_ptr<::F::F>(new ::F::F());
+  f->f = 40;
+  f->f_str = std::string("hello");
+  return f;
+}
+
 extern "C" const char *cxx_run_test() noexcept {
 #define STRINGIFY(x) #x
 #define TOSTRING(x) STRINGIFY(x)

tests/ffi/tests.h

@@ -12,6 +12,13 @@ namespace A {
   } // namespace B
 } // namespace A
 
+namespace F {
+  struct F {
+    uint64_t f;
+    std::string f_str;
+  };
+}
+
 namespace tests {
 
 struct R;
@@ -137,10 +144,13 @@ void c_take_trivial_ptr(std::unique_ptr<D> d);
 void c_take_trivial_ref(const D& d);
 void c_take_trivial(D d);
 void c_take_opaque_ptr(std::unique_ptr<E> e);
+void c_take_opaque_ns_ptr(std::unique_ptr<::F::F> f);
 void c_take_opaque_ref(const E& e);
+void c_take_opaque_ns_ref(const ::F::F& f);
 std::unique_ptr<D> c_return_trivial_ptr();
 D c_return_trivial();
 std::unique_ptr<E> c_return_opaque_ptr();
+std::unique_ptr<::F::F> c_return_ns_opaque_ptr();
 
 rust::String cOverloadedFunction(int32_t x);
 rust::String cOverloadedFunction(rust::Str x);

tests/test.rs

@@ -230,4 +230,8 @@ fn test_extern_opaque() {
     let e = ffi2::c_return_opaque_ptr();
     check!(ffi2::c_take_opaque_ref(e.as_ref().unwrap()));
     check!(ffi2::c_take_opaque_ptr(e));
+
+    let f = ffi2::c_return_ns_opaque_ptr();
+    check!(ffi2::c_take_opaque_ns_ref(f.as_ref().unwrap()));
+    check!(ffi2::c_take_opaque_ns_ptr(f));
 }