ctest: Update TestCStr and TestConst tests

Apply the following changes:

* Separate `id` (a valid identifier) from `rust_const` (potentially an
  invalid indentifier with `::`) since for the future we can't assume we
  will always have top-level items. Rename a few other fields to be
  consistent.
* Change the `CStr` tests to be single-indirection, which is possible
  because we know the type.
* Split up some `unsafe` blocks and add safety comments.
* Rename test functions to start with `ctest_` rather than `__`.
* Rename `TestCstr` to `TestCStr` (casing).

Author: tgross35

ctest-next/src/template.rs

@@ -46,7 +46,7 @@ impl CTestTemplate {
 /// Stores all information necessary for generation of tests for all items.
 #[derive(Clone, Debug, Default)]
 pub(crate) struct TestTemplate {
-    pub const_cstr_tests: Vec<TestCstr>,
+    pub const_cstr_tests: Vec<TestCStr>,
     pub const_tests: Vec<TestConst>,
     pub test_idents: Vec<BoxStr>,
 }
@@ -76,28 +76,29 @@ impl TestTemplate {
                 && path.path.segments.last().unwrap().ident == "c_char"
                 && ptr.mutability.is_none()
             {
-                let item = TestCstr {
-                    test_ident: cstr_test_ident(constant.ident()),
-                    rust_ident: constant.ident().into(),
-                    c_ident: helper.c_ident(constant).into(),
-                    c_type: helper.c_type(constant)?.into(),
+                let item = TestCStr {
+                    id: constant.ident().into(),
+                    test_name: cstr_test_ident(constant.ident()),
+                    rust_val: constant.ident().into(),
+                    c_val: helper.c_ident(constant).into(),
                 };
                 const_cstr_tests.push(item)
             } else {
                 let item = TestConst {
-                    test_ident: const_test_ident(constant.ident()),
-                    rust_ident: constant.ident.clone(),
-                    rust_type: constant.ty.to_token_stream().to_string().into_boxed_str(),
-                    c_ident: helper.c_ident(constant).into(),
-                    c_type: helper.c_type(constant)?.into(),
+                    id: constant.ident().into(),
+                    test_name: const_test_ident(constant.ident()),
+                    rust_val: constant.ident.clone(),
+                    rust_ty: constant.ty.to_token_stream().to_string().into_boxed_str(),
+                    c_val: helper.c_ident(constant).into(),
+                    c_ty: helper.c_type(constant)?.into(),
                 };
                 const_tests.push(item)
             }
         }
 
         let mut test_idents = vec![];
-        test_idents.extend(const_cstr_tests.iter().map(|test| test.test_ident.clone()));
-        test_idents.extend(const_tests.iter().map(|test| test.test_ident.clone()));
+        test_idents.extend(const_cstr_tests.iter().map(|test| test.test_name.clone()));
+        test_idents.extend(const_tests.iter().map(|test| test.test_name.clone()));
 
         Ok(Self {
             const_cstr_tests,
@@ -107,23 +108,35 @@ impl TestTemplate {
     }
 }
 
+/* Many test structures have the following fields:
+ *
+ * - `test_name`: The function name.
+ * - `id`: An identifier that can be used to create functions related to this type without conflict,
+ *    usually also part of `test_name`.
+ * - `rust_val`: Identifier for a Rust value, with path qualifications if needed.
+ * - `rust_ty`: The Rust type of the relevant item, with path qualifications if needed.
+ * - `c_val`: Identifier for a C value (e.g. `#define`)
+ * - `c_ty`: The C type of the constant, qualified with `struct` or `union` if needed.
+ */
+
 /// Information required to test a constant CStr.
 #[derive(Clone, Debug)]
-pub(crate) struct TestCstr {
-    pub(crate) test_ident: BoxStr,
-    pub(crate) rust_ident: BoxStr,
-    pub(crate) c_ident: BoxStr,
-    pub(crate) c_type: BoxStr,
+pub(crate) struct TestCStr {
+    pub test_name: BoxStr,
+    pub id: BoxStr,
+    pub rust_val: BoxStr,
+    pub c_val: BoxStr,
 }
 
 /// Information required to test a constant.
 #[derive(Clone, Debug)]
 pub(crate) struct TestConst {
-    pub(crate) test_ident: BoxStr,
-    pub(crate) rust_ident: BoxStr,
-    pub(crate) rust_type: BoxStr,
-    pub(crate) c_ident: BoxStr,
-    pub(crate) c_type: BoxStr,
+    pub test_name: BoxStr,
+    pub id: BoxStr,
+    pub rust_val: BoxStr,
+    pub c_val: BoxStr,
+    pub rust_ty: BoxStr,
+    pub c_ty: BoxStr,
 }
 
 /// The Rust name of the cstr test.

ctest-next/templates/test.c

@@ -15,23 +15,22 @@
 
 {%- for const_cstr in ctx.const_cstr_tests +%}
 
-static {{ const_cstr.c_type }} ctest_const_{{ const_cstr.rust_ident }}_val_static = {{ const_cstr.c_ident }};
+static char *ctest_const_{{ const_cstr.id }}_val_static = {{ const_cstr.c_val }};
 
 // Define a function that returns a pointer to the value of the constant to test.
 // This will later be called on the Rust side via FFI.
-{{ const_cstr.c_type }}* __{{ const_cstr.test_ident }}(void) {
-    return &ctest_const_{{ const_cstr.rust_ident }}_val_static;
+char *ctest_const_cstr__{{ const_cstr.id }}(void) {
+    return ctest_const_{{ const_cstr.id }}_val_static;
 }
 {%- endfor +%}
 
 {%- for constant in ctx.const_tests +%}
 
-static {{ constant.c_type }} ctest_const_{{ constant.rust_ident }}_val_static = {{ constant.c_ident }};
+static {{ constant.c_ty }} ctest_const_{{ constant.id }}_val_static = {{ constant.c_val }};
 
 // Define a function that returns a pointer to the value of the constant to test.
 // This will later be called on the Rust side via FFI.
-{{ constant.c_type }}* __{{ constant.test_ident }}(void) {
-    return &ctest_const_{{ constant.rust_ident }}_val_static;
+{{ constant.c_ty }} *ctest_const__{{ constant.id }}(void) {
+    return &ctest_const_{{ constant.id }}_val_static;
 }
 {%- endfor +%}
-

ctest-next/templates/test.rs

@@ -48,41 +48,53 @@ mod generated_tests {
 
     // Test that the string constant is the same in both Rust and C.
     // While fat pointers can't be translated, we instead use * const c_char.
-    pub fn {{ const_cstr.test_ident }}() {
+    pub fn {{ const_cstr.test_name }}() {
         extern "C" {
-            fn __{{ const_cstr.test_ident }}() -> *const *const u8;
-        }
-        let val = {{ const_cstr.rust_ident }};
-        unsafe {
-            let ptr = *__{{ const_cstr.test_ident }}();
-            let val = CStr::from_ptr(ptr.cast::<c_char>());
-            let val = val.to_str().expect("const {{ const_cstr.rust_ident }} not utf8");
-            let c = ::std::ffi::CStr::from_ptr(ptr as *const _);
-            let c = c.to_str().expect("const {{ const_cstr.rust_ident }} not utf8");
-            check_same(val, c, "{{ const_cstr.rust_ident }} string");
+            fn ctest_const_cstr__{{ const_cstr.id }}() -> *const c_char;
         }
+
+        // SAFETY: we assume that `c_char` pointer consts are for C strings.
+        let r_val = unsafe {
+            let r_ptr: *const c_char = {{ const_cstr.rust_val }};
+            assert!(!r_ptr.is_null(), "const {{ const_cstr.rust_val }} is null");
+            CStr::from_ptr(r_ptr)
+        };
+
+        // SAFETY: FFI call returns a valid C string.
+        let c_val = unsafe {
+            let c_ptr: *const c_char = unsafe { ctest_const_cstr__{{ const_cstr.id }}()  };
+            CStr::from_ptr(c_ptr)
+        };
+
+        check_same(r_val, c_val, "const {{ const_cstr.rust_val }} string");
     }
 {%- endfor +%}
 
 {%- for constant in ctx.const_tests +%}
 
     // Test that the value of the constant is the same in both Rust and C.
     // This performs a byte by byte comparision of the constant value.
-    pub fn {{ constant.test_ident }}() {
+    pub fn {{ constant.test_name }}() {
+        type T = {{ constant.rust_ty }};
         extern "C" {
-            fn __{{ constant.test_ident }}() -> *const {{ constant.rust_type }};
+            fn ctest_const__{{ constant.id }}() -> *const T;
         }
-        let val = {{ constant.rust_ident }};
-        unsafe {
-            let ptr1 = ptr::from_ref(&val).cast::<u8>();
-            let ptr2 = __{{ constant.test_ident }}().cast::<u8>();
-            let ptr1_bytes = slice::from_raw_parts(ptr1, mem::size_of::<{{ constant.rust_type }}>());
-            let ptr2_bytes = slice::from_raw_parts(ptr2, mem::size_of::<{{ constant.rust_type }}>());
-            for (i, (&b1, &b2)) in ptr1_bytes.iter().zip(ptr2_bytes.iter()).enumerate() {
-                // HACK: This may read uninitialized data! We do this because
-                // there isn't a good way to recursively iterate all fields.
-                check_same_hex(b1, b2, &format!("{{ constant.rust_ident }} value at byte {}", i));
-            }
+
+        /* HACK: The slices may contian uninitialized data! We do this because
+         * there isn't a good way to recursively iterate all fields. */
+
+        let r_val: T = {{ constant.rust_val }};
+        let r_bytes = unsafe {
+            slice::from_raw_parts(ptr::from_ref(&r_val).cast::<u8>(), size_of::<T>())
+        };
+
+        let c_bytes = unsafe {
+            let c_ptr: *const T = unsafe { ctest_const__{{ constant.id }}() };
+            slice::from_raw_parts(c_ptr.cast::<u8>(), size_of::<T>())
+        };
+
+        for (i, (&b1, &b2)) in r_bytes.iter().zip(c_bytes.iter()).enumerate() {
+            check_same_hex(b1, b2, &format!("{{ constant.rust_val }} value at byte {}", i));
         }
     }
 {%- endfor +%}

ctest-next/tests/input/hierarchy.out.c

@@ -11,6 +11,6 @@ static bool ctest_const_ON_val_static = ON;
 
 // Define a function that returns a pointer to the value of the constant to test.
 // This will later be called on the Rust side via FFI.
-bool* __ctest_const_ON(void) {
+bool *ctest_const__ON(void) {
     return &ctest_const_ON_val_static;
 }

ctest-next/tests/input/hierarchy.out.rs

@@ -44,20 +44,26 @@ mod generated_tests {
     // Test that the value of the constant is the same in both Rust and C.
     // This performs a byte by byte comparision of the constant value.
     pub fn ctest_const_ON() {
+        type T = bool;
         extern "C" {
-            fn __ctest_const_ON() -> *const bool;
+            fn ctest_const__ON() -> *const T;
         }
-        let val = ON;
-        unsafe {
-            let ptr1 = ptr::from_ref(&val).cast::<u8>();
-            let ptr2 = __ctest_const_ON().cast::<u8>();
-            let ptr1_bytes = slice::from_raw_parts(ptr1, mem::size_of::<bool>());
-            let ptr2_bytes = slice::from_raw_parts(ptr2, mem::size_of::<bool>());
-            for (i, (&b1, &b2)) in ptr1_bytes.iter().zip(ptr2_bytes.iter()).enumerate() {
-                // HACK: This may read uninitialized data! We do this because
-                // there isn't a good way to recursively iterate all fields.
-                check_same_hex(b1, b2, &format!("ON value at byte {}", i));
-            }
+
+        /* HACK: The slices may contian uninitialized data! We do this because
+         * there isn't a good way to recursively iterate all fields. */
+
+        let r_val: T = ON;
+        let r_bytes = unsafe {
+            slice::from_raw_parts(ptr::from_ref(&r_val).cast::<u8>(), size_of::<T>())
+        };
+
+        let c_bytes = unsafe {
+            let c_ptr: *const T = unsafe { ctest_const__ON() };
+            slice::from_raw_parts(c_ptr.cast::<u8>(), size_of::<T>())
+        };
+
+        for (i, (&b1, &b2)) in r_bytes.iter().zip(c_bytes.iter()).enumerate() {
+            check_same_hex(b1, b2, &format!("ON value at byte {}", i));
         }
     }
 }

ctest-next/tests/input/simple.out.with-renames.c

@@ -7,18 +7,18 @@
 
 #include <simple.h>
 
-static char const* ctest_const_A_val_static = A;
+static char *ctest_const_A_val_static = A;
 
 // Define a function that returns a pointer to the value of the constant to test.
 // This will later be called on the Rust side via FFI.
-char const** __ctest_const_cstr_A(void) {
-    return &ctest_const_A_val_static;
+char *ctest_const_cstr__A(void) {
+    return ctest_const_A_val_static;
 }
 
-static char const* ctest_const_B_val_static = C_B;
+static char *ctest_const_B_val_static = C_B;
 
 // Define a function that returns a pointer to the value of the constant to test.
 // This will later be called on the Rust side via FFI.
-char const** __ctest_const_cstr_B(void) {
-    return &ctest_const_B_val_static;
+char *ctest_const_cstr__B(void) {
+    return ctest_const_B_val_static;
 }

ctest-next/tests/input/simple.out.with-renames.rs

@@ -45,34 +45,46 @@ mod generated_tests {
     // While fat pointers can't be translated, we instead use * const c_char.
     pub fn ctest_const_cstr_A() {
         extern "C" {
-            fn __ctest_const_cstr_A() -> *const *const u8;
-        }
-        let val = A;
-        unsafe {
-            let ptr = *__ctest_const_cstr_A();
-            let val = CStr::from_ptr(ptr.cast::<c_char>());
-            let val = val.to_str().expect("const A not utf8");
-            let c = ::std::ffi::CStr::from_ptr(ptr as *const _);
-            let c = c.to_str().expect("const A not utf8");
-            check_same(val, c, "A string");
+            fn ctest_const_cstr__A() -> *const c_char;
         }
+
+        // SAFETY: we assume that `c_char` pointer consts are for C strings.
+        let r_val = unsafe {
+            let r_ptr: *const c_char = A;
+            assert!(!r_ptr.is_null(), "const A is null");
+            CStr::from_ptr(r_ptr)
+        };
+
+        // SAFETY: FFI call returns a valid C string.
+        let c_val = unsafe {
+            let c_ptr: *const c_char = unsafe { ctest_const_cstr__A()  };
+            CStr::from_ptr(c_ptr)
+        };
+
+        check_same(r_val, c_val, "const A string");
     }
 
     // Test that the string constant is the same in both Rust and C.
     // While fat pointers can't be translated, we instead use * const c_char.
     pub fn ctest_const_cstr_B() {
         extern "C" {
-            fn __ctest_const_cstr_B() -> *const *const u8;
-        }
-        let val = B;
-        unsafe {
-            let ptr = *__ctest_const_cstr_B();
-            let val = CStr::from_ptr(ptr.cast::<c_char>());
-            let val = val.to_str().expect("const B not utf8");
-            let c = ::std::ffi::CStr::from_ptr(ptr as *const _);
-            let c = c.to_str().expect("const B not utf8");
-            check_same(val, c, "B string");
+            fn ctest_const_cstr__B() -> *const c_char;
         }
+
+        // SAFETY: we assume that `c_char` pointer consts are for C strings.
+        let r_val = unsafe {
+            let r_ptr: *const c_char = B;
+            assert!(!r_ptr.is_null(), "const B is null");
+            CStr::from_ptr(r_ptr)
+        };
+
+        // SAFETY: FFI call returns a valid C string.
+        let c_val = unsafe {
+            let c_ptr: *const c_char = unsafe { ctest_const_cstr__B()  };
+            CStr::from_ptr(c_ptr)
+        };
+
+        check_same(r_val, c_val, "const B string");
     }
 }
 

ctest-next/tests/input/simple.out.with-skips.c

@@ -7,10 +7,10 @@
 
 #include <simple.h>
 
-static char const* ctest_const_A_val_static = A;
+static char *ctest_const_A_val_static = A;
 
 // Define a function that returns a pointer to the value of the constant to test.
 // This will later be called on the Rust side via FFI.
-char const** __ctest_const_cstr_A(void) {
-    return &ctest_const_A_val_static;
+char *ctest_const_cstr__A(void) {
+    return ctest_const_A_val_static;
 }

ctest-next/tests/input/simple.out.with-skips.rs

@@ -45,17 +45,23 @@ mod generated_tests {
     // While fat pointers can't be translated, we instead use * const c_char.
     pub fn ctest_const_cstr_A() {
         extern "C" {
-            fn __ctest_const_cstr_A() -> *const *const u8;
-        }
-        let val = A;
-        unsafe {
-            let ptr = *__ctest_const_cstr_A();
-            let val = CStr::from_ptr(ptr.cast::<c_char>());
-            let val = val.to_str().expect("const A not utf8");
-            let c = ::std::ffi::CStr::from_ptr(ptr as *const _);
-            let c = c.to_str().expect("const A not utf8");
-            check_same(val, c, "A string");
+            fn ctest_const_cstr__A() -> *const c_char;
         }
+
+        // SAFETY: we assume that `c_char` pointer consts are for C strings.
+        let r_val = unsafe {
+            let r_ptr: *const c_char = A;
+            assert!(!r_ptr.is_null(), "const A is null");
+            CStr::from_ptr(r_ptr)
+        };
+
+        // SAFETY: FFI call returns a valid C string.
+        let c_val = unsafe {
+            let c_ptr: *const c_char = unsafe { ctest_const_cstr__A()  };
+            CStr::from_ptr(c_ptr)
+        };
+
+        check_same(r_val, c_val, "const A string");
     }
 }