ctest: fix bug where functions and statics aren't skipped

Author: mbyx

ctest-next/src/generator.rs

@@ -647,6 +647,29 @@ impl TestGenerator {
         self
     }
 
+    /// Configures how Rust type alias names are translated to C.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use ctest_next::TestGenerator;
+    ///
+    /// let mut cfg = TestGenerator::new();
+    /// cfg.rename_alias(|c| {
+    ///     (c.ident() == "sighandler_t").then_some("sig_t".to_string())
+    /// });
+    /// ```
+    pub fn rename_alias(&mut self, f: impl Fn(&Type) -> Option<String> + 'static) -> &mut Self {
+        self.mapped_names.push(Box::new(move |item| {
+            if let MapInput::Alias(t) = item {
+                f(t)
+            } else {
+                None
+            }
+        }));
+        self
+    }
+
     /// Configures how a Rust struct field is translated to a C struct field.
     ///
     /// # Examples

ctest-next/src/template.rs

@@ -400,7 +400,7 @@ impl TestTemplate {
                 .as_ref()
                 .is_some_and(|skip| skip(ident))
         };
-        for func in helper.ffi_items.foreign_functions() {
+        for func in helper.filtered_ffi_items.foreign_functions() {
             if should_skip_fn_test(func.ident()) {
                 continue;
             }
@@ -423,7 +423,7 @@ impl TestTemplate {
         &mut self,
         helper: &TranslateHelper,
     ) -> Result<(), TranslationError> {
-        for static_ in helper.ffi_items.foreign_statics() {
+        for static_ in helper.filtered_ffi_items.foreign_statics() {
             let rust_ty = static_.ty.to_token_stream().to_string().into_boxed_str();
 
             let item = TestForeignStatic {

ctest-next/tests/basic.rs

@@ -91,7 +91,12 @@ fn test_skip_simple() {
     let library_path = "simple.out.with-skips.a";
 
     let (mut gen_, out_dir) = default_generator(1, "simple.h").unwrap();
-    gen_.skip_const(|c| c.ident() == "B");
+    gen_.skip_const(|c| c.ident() == "B" || c.ident() == "A")
+        .skip_alias(|a| a.ident() == "Byte")
+        .skip_struct(|s| s.ident() == "Person")
+        .skip_union(|u| u.ident() == "Word")
+        .skip_fn(|f| f.ident() == "calloc")
+        .skip_static(|s| s.ident() == "byte");
 
     check_entrypoint(&mut gen_, out_dir, crate_path, library_path, include_path);
 }

ctest-next/tests/input/simple.h

@@ -2,6 +2,8 @@
 
 typedef uint8_t Byte;
 
+Byte byte = 0x42;
+
 struct Person
 {
     const char *name;
@@ -17,3 +19,6 @@ union Word
 
 #define A "abc"
 #define C_B "bac"
+
+extern void *calloc(size_t num, size_t size);
+extern Byte byte;

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

@@ -242,6 +242,16 @@ union Word ctest_roundtrip__Word(
 #  pragma warning(disable:4191)
 #endif
 
+ctest_void_func ctest_foreign_fn__calloc(void) {
+    return (ctest_void_func)calloc;
+}
+
 #ifdef _MSC_VER
 #  pragma warning(default:4191)
 #endif
+
+// Return a pointer to the static variable content.
+void *ctest_static__byte(void) {
+    // FIXME(ctest): Not correct due to casting the function to a data pointer.
+    return (void *)&byte;
+}

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

@@ -742,6 +742,28 @@ mod generated_tests {
             }
         }
     }
+
+    /// Check if the Rust and C side function pointers point to the same underlying function.
+    pub fn ctest_foreign_fn_calloc() {
+        extern "C" {
+            fn ctest_foreign_fn__calloc() -> unsafe extern "C" fn();
+        }
+        let actual = unsafe { ctest_foreign_fn__calloc() } as u64;
+        let expected = calloc as u64;
+        check_same(actual, expected, "calloc function pointer");
+    }
+
+    // Tests if the pointer to the static variable matches in both Rust and C.
+    pub fn ctest_static_byte() {
+        extern "C" {
+            fn ctest_static__byte() -> *const Byte;
+        }
+        let actual = (&raw const byte).addr();
+        let expected = unsafe {
+            ctest_static__byte().addr()
+        };
+        check_same(actual, expected, "byte static");
+    }
 }
 
 use generated_tests::*;
@@ -780,4 +802,6 @@ fn run_all() {
     ctest_roundtrip_Byte();
     ctest_roundtrip_Person();
     ctest_roundtrip_Word();
+    ctest_foreign_fn_calloc();
+    ctest_static_byte();
 }

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

@@ -9,221 +9,12 @@
 
 typedef void (*ctest_void_func)(void);
 
-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 *ctest_const_cstr__A(void) {
-    return ctest_const_A_val_static;
-}
-
-// Return the size of a type.
-uint64_t ctest_size_of__Byte(void) { return sizeof(Byte); }
-
-// Return the alignment of a type.
-uint64_t ctest_align_of__Byte(void) { return _Alignof(Byte); }
-
-// Return the size of a type.
-uint64_t ctest_size_of__Person(void) { return sizeof(struct Person); }
-
-// Return the alignment of a type.
-uint64_t ctest_align_of__Person(void) { return _Alignof(struct Person); }
-
-// Return the size of a type.
-uint64_t ctest_size_of__Word(void) { return sizeof(union Word); }
-
-// Return the alignment of a type.
-uint64_t ctest_align_of__Word(void) { return _Alignof(union Word); }
-
-// Return `1` if the type is signed, otherwise return `0`.
-// Casting -1 to the aliased type if signed evaluates to `-1 < 0`, if unsigned to `MAX_VALUE < 0`
-uint32_t ctest_signededness_of__Byte(void) {
-    Byte all_ones = (Byte) -1;
-    return all_ones < 0;
-}
-
-// Return the offset of a struct/union field.
-uint64_t ctest_offset_of__Person__name(void) {
-    return offsetof(struct Person, name);
-}
-
-// Return the size of a struct/union field.
-uint64_t ctest_size_of__Person__name(void) {
-    return sizeof(((struct Person){}).name);
-}
-
-// Return the offset of a struct/union field.
-uint64_t ctest_offset_of__Person__age(void) {
-    return offsetof(struct Person, age);
-}
-
-// Return the size of a struct/union field.
-uint64_t ctest_size_of__Person__age(void) {
-    return sizeof(((struct Person){}).age);
-}
-
-// Return the offset of a struct/union field.
-uint64_t ctest_offset_of__Person__job(void) {
-    return offsetof(struct Person, job);
-}
-
-// Return the size of a struct/union field.
-uint64_t ctest_size_of__Person__job(void) {
-    return sizeof(((struct Person){}).job);
-}
-
-// Return the offset of a struct/union field.
-uint64_t ctest_offset_of__Word__word(void) {
-    return offsetof(union Word, word);
-}
-
-// Return the size of a struct/union field.
-uint64_t ctest_size_of__Word__word(void) {
-    return sizeof(((union Word){}).word);
-}
-
-// Return the offset of a struct/union field.
-uint64_t ctest_offset_of__Word__byte(void) {
-    return offsetof(union Word, byte);
-}
-
-// Return the size of a struct/union field.
-uint64_t ctest_size_of__Word__byte(void) {
-    return sizeof(((union Word){}).byte);
-}
-
-// Return a pointer to a struct/union field.
-// This field can have a normal data type, or it could be a function pointer or an array, which
-// have different syntax. A typedef is used for convenience, but the syntax must be precomputed.
-typedef const char **ctest_field_ty__Person__name;
-ctest_field_ty__Person__name
-ctest_field_ptr__Person__name(struct Person *b) {
-    return &b->name;
-}
-
-// Return a pointer to a struct/union field.
-// This field can have a normal data type, or it could be a function pointer or an array, which
-// have different syntax. A typedef is used for convenience, but the syntax must be precomputed.
-typedef uint8_t *ctest_field_ty__Person__age;
-ctest_field_ty__Person__age
-ctest_field_ptr__Person__age(struct Person *b) {
-    return &b->age;
-}
-
-// Return a pointer to a struct/union field.
-// This field can have a normal data type, or it could be a function pointer or an array, which
-// have different syntax. A typedef is used for convenience, but the syntax must be precomputed.
-typedef void (**ctest_field_ty__Person__job)(uint8_t, const char *);
-ctest_field_ty__Person__job
-ctest_field_ptr__Person__job(struct Person *b) {
-    return &b->job;
-}
-
-// Return a pointer to a struct/union field.
-// This field can have a normal data type, or it could be a function pointer or an array, which
-// have different syntax. A typedef is used for convenience, but the syntax must be precomputed.
-typedef uint16_t *ctest_field_ty__Word__word;
-ctest_field_ty__Word__word
-ctest_field_ptr__Word__word(union Word *b) {
-    return &b->word;
-}
-
-// Return a pointer to a struct/union field.
-// This field can have a normal data type, or it could be a function pointer or an array, which
-// have different syntax. A typedef is used for convenience, but the syntax must be precomputed.
-typedef Byte (*ctest_field_ty__Word__byte)[2];
-ctest_field_ty__Word__byte
-ctest_field_ptr__Word__byte(union Word *b) {
-    return &b->byte;
-}
-
 #ifdef _MSC_VER
 // Disable signed/unsigned conversion warnings on MSVC.
 // These trigger even if the conversion is explicit.
 #  pragma warning(disable:4365)
 #endif
 
-// Tests whether the struct/union/alias `x` when passed by value to C and back to Rust
-// remains unchanged.
-// It checks if the size is the same as well as if the padding bytes are all in the correct place.
-Byte ctest_roundtrip__Byte(
-    Byte value,
-    const uint8_t is_padding_byte[sizeof(Byte)],
-    uint8_t value_bytes[sizeof(Byte)]
-) {
-    int size = (int)sizeof(Byte);
-    // Mark `p` as volatile so that the C compiler does not optimize away the pattern we create.
-    // Otherwise the Rust side would not be able to see it.
-    volatile uint8_t* p = (volatile uint8_t*)&value;
-    int i = 0;
-    for (i = 0; i < size; ++i) {
-        // We skip padding bytes in both Rust and C because writing to it is undefined.
-        // Instead we just make sure the the placement of the padding bytes remains the same.
-        if (is_padding_byte[i]) { continue; }
-        value_bytes[i] = p[i];
-        // After we check that the pattern remained unchanged from Rust to C, we invert the pattern
-        // and send it back to Rust to make sure that it remains unchanged from C to Rust.
-        uint8_t d = (uint8_t)(255) - (uint8_t)(i % 256);
-        d = d == 0 ? 42: d;
-        p[i] = d;
-    }
-    return value;
-}
-
-// Tests whether the struct/union/alias `x` when passed by value to C and back to Rust
-// remains unchanged.
-// It checks if the size is the same as well as if the padding bytes are all in the correct place.
-struct Person ctest_roundtrip__Person(
-    struct Person value,
-    const uint8_t is_padding_byte[sizeof(struct Person)],
-    uint8_t value_bytes[sizeof(struct Person)]
-) {
-    int size = (int)sizeof(struct Person);
-    // Mark `p` as volatile so that the C compiler does not optimize away the pattern we create.
-    // Otherwise the Rust side would not be able to see it.
-    volatile uint8_t* p = (volatile uint8_t*)&value;
-    int i = 0;
-    for (i = 0; i < size; ++i) {
-        // We skip padding bytes in both Rust and C because writing to it is undefined.
-        // Instead we just make sure the the placement of the padding bytes remains the same.
-        if (is_padding_byte[i]) { continue; }
-        value_bytes[i] = p[i];
-        // After we check that the pattern remained unchanged from Rust to C, we invert the pattern
-        // and send it back to Rust to make sure that it remains unchanged from C to Rust.
-        uint8_t d = (uint8_t)(255) - (uint8_t)(i % 256);
-        d = d == 0 ? 42: d;
-        p[i] = d;
-    }
-    return value;
-}
-
-// Tests whether the struct/union/alias `x` when passed by value to C and back to Rust
-// remains unchanged.
-// It checks if the size is the same as well as if the padding bytes are all in the correct place.
-union Word ctest_roundtrip__Word(
-    union Word value,
-    const uint8_t is_padding_byte[sizeof(union Word)],
-    uint8_t value_bytes[sizeof(union Word)]
-) {
-    int size = (int)sizeof(union Word);
-    // Mark `p` as volatile so that the C compiler does not optimize away the pattern we create.
-    // Otherwise the Rust side would not be able to see it.
-    volatile uint8_t* p = (volatile uint8_t*)&value;
-    int i = 0;
-    for (i = 0; i < size; ++i) {
-        // We skip padding bytes in both Rust and C because writing to it is undefined.
-        // Instead we just make sure the the placement of the padding bytes remains the same.
-        if (is_padding_byte[i]) { continue; }
-        value_bytes[i] = p[i];
-        // After we check that the pattern remained unchanged from Rust to C, we invert the pattern
-        // and send it back to Rust to make sure that it remains unchanged from C to Rust.
-        uint8_t d = (uint8_t)(255) - (uint8_t)(i % 256);
-        d = d == 0 ? 42: d;
-        p[i] = d;
-    }
-    return value;
-}
-
 #ifdef _MSC_VER
 #  pragma warning(default:4365)
 #endif