ctest: add defines for specific headers and language selection

Author: mbyx

Cargo.lock

@@ -1,5 +1,6 @@
 //! Configuration of the test generator.
 
+use std::collections::BTreeMap;
 use std::env;
 use std::fs::File;
 use std::io::Write;
@@ -13,8 +14,8 @@ use crate::ffi_items::FfiItems;
 use crate::template::{CTestTemplate, RustTestTemplate};
 use crate::translator::translate_primitive_type;
 use crate::{
-    Const, Field, MapInput, Parameter, Result, Static, Struct, TranslationError, Type, Union,
-    VolatileItemKind, expand,
+    Const, Field, Language, MapInput, Parameter, Result, Static, Struct, TranslationError, Type,
+    Union, VolatileItemKind, expand,
 };
 
 /// A function that takes a mappable input and returns its mapping as `Some`, otherwise
@@ -35,14 +36,16 @@ type CEnum = Box<dyn Fn(&str) -> bool>;
 #[derive(Default)]
 #[expect(missing_debug_implementations)]
 pub struct TestGenerator {
-    pub(crate) headers: Vec<String>,
+    pub(crate) headers: BTreeMap<String, Vec<String>>,
     pub(crate) target: Option<String>,
     pub(crate) includes: Vec<PathBuf>,
     out_dir: Option<PathBuf>,
     pub(crate) flags: Vec<String>,
     pub(crate) defines: Vec<(String, Option<String>)>,
     cfg: Vec<(String, Option<String>)>,
     mapped_names: Vec<MappedName>,
+    /// The programming language to generate tests in.
+    pub(crate) language: Language,
     pub(crate) skips: Vec<Skip>,
     pub(crate) verbose_skip: bool,
     pub(crate) volatile_items: Vec<VolatileItem>,
@@ -100,7 +103,46 @@ impl TestGenerator {
     ///    .header("bar.h");
     /// ```
     pub fn header(&mut self, header: &str) -> &mut Self {
-        self.headers.push(header.to_string());
+        self.headers.entry(header.to_string()).or_default();
+        self
+    }
+
+    /// Add a header to be included as part of the generated C file, as well as defines for it.
+    ///
+    /// The generated C test will be compiled by a C compiler, and this can be
+    /// used to ensure that all the necessary header files are included to test
+    /// all FFI definitions. The defines are only set for the inclusion of that header file, and are
+    /// undefined immediately after.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use ctest::TestGenerator;
+    ///
+    /// let mut cfg = TestGenerator::new();
+    /// cfg.header_with_defines("foo.h", vec![])
+    ///    .header_with_defines("bar.h", vec!["DEBUG", "DEPRECATED"]);
+    /// ```
+    pub fn header_with_defines(&mut self, header: &str, defines: Vec<&str>) -> &mut Self {
+        self.headers
+            .entry(header.to_string())
+            .or_default()
+            .extend(defines.iter().map(|d| d.to_string()));
+        self
+    }
+
+    /// Sets the programming language, by default it is C.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use ctest::{TestGenerator, Language};
+    ///
+    /// let mut cfg = TestGenerator::new();
+    /// cfg.language(Language::CXX);
+    /// ```
+    pub fn language(&mut self, language: Language) -> &mut Self {
+        self.language = language;
         self
     }
 
@@ -999,7 +1041,7 @@ impl TestGenerator {
         ensure_trailing_newline(&mut c_file);
 
         // Generate the C/Cxx side of the tests.
-        let c_output_path = output_file_path.with_extension("c");
+        let c_output_path = output_file_path.with_extension(self.language.extension());
         File::create(&c_output_path)
             .map_err(GenerationError::OsError)?
             .write_all(c_file.as_bytes())

ctest/src/generator.rs

@@ -74,6 +74,35 @@ pub(crate) enum MapInput<'a> {
     UnionFieldType(&'a Union, &'a Field),
 }
 
+/// The language used to generate the tests.
+#[derive(Debug, Default, Clone)]
+#[non_exhaustive]
+pub enum Language {
+    /// The C Programming Language.
+    #[default]
+    C,
+    /// The C++ Programming Language.
+    CXX,
+}
+
+impl Language {
+    /// Return the file extension of the programming language.
+    pub fn extension(&self) -> &str {
+        match self {
+            Self::C => "c",
+            Self::CXX => "cpp",
+        }
+    }
+
+    /// Return the linkage to use for each language.
+    pub fn linkage(&self) -> &str {
+        match self {
+            Self::C => "",
+            Self::CXX => r#"extern "C" "#,
+        }
+    }
+}
+
 /* The From impls make it easier to write code in the test templates. */
 
 impl<'a> From<&'a Const> for MapInput<'a> {

ctest/src/lib.rs

@@ -7,7 +7,7 @@ use std::path::{Path, PathBuf};
 use std::process::Command;
 
 use crate::generator::GenerationError;
-use crate::{EDITION, Result, TestGenerator};
+use crate::{EDITION, Language, Result, TestGenerator};
 
 /// Generate all tests for the given crate and output the Rust side to a file.
 #[doc(hidden)]
@@ -34,7 +34,7 @@ pub fn generate_test(
         .map_err(|_| GenerationError::EnvVarNotFound("HOST, HOST_PLATFORM".to_string()))?;
 
     let mut cfg = cc::Build::new();
-    cfg.file(output_file_path.with_extension("c"));
+    cfg.file(output_file_path.with_extension(generator.language.extension()));
     cfg.host(&host);
 
     if target.contains("msvc") {
@@ -78,6 +78,8 @@ pub fn generate_test(
         cfg.define(k, v.as_ref().map(|s| &s[..]));
     }
 
+    cfg.cpp(matches!(generator.language, Language::CXX));
+
     let stem: &str = output_file_path.file_stem().unwrap().to_str().unwrap();
     cfg.target(&target)
         .out_dir(output_file_path.parent().unwrap())

ctest/src/runner.rs

@@ -1,5 +1,7 @@
 //! Generation of tests from templates for both Rust and C.
 
+use std::collections::BTreeMap;
+
 use askama::Template;
 use proc_macro2::Span;
 use quote::ToTokens;
@@ -35,7 +37,9 @@ impl RustTestTemplate {
 #[template(path = "test.c")]
 pub(crate) struct CTestTemplate {
     pub template: TestTemplate,
-    pub headers: Vec<String>,
+    // Use a `BTreeMap` instead of a `HashMap` because order matters.
+    pub headers: BTreeMap<String, Vec<String>>,
+    pub linkage: String,
 }
 
 impl CTestTemplate {
@@ -46,6 +50,7 @@ impl CTestTemplate {
         Ok(Self {
             template: TestTemplate::new(ffi_items, generator)?,
             headers: generator.headers.clone(),
+            linkage: generator.language.linkage().to_string(),
         })
     }
 }

ctest/src/template.rs

@@ -8,11 +8,23 @@
 #include <stdint.h>
 #include <stdio.h>
 
-{%- for header in self.headers +%}
+{%- for header in self.headers.keys() +%}
+{%- for define in self.headers[header] +%}
 
+#define {{ define }}
+{%- endfor +%}
 #include <{{ header }}>
+{%- for define in self.headers[header] +%}
+#undef {{ define }}
+{%- endfor +%}
 {%- endfor +%}
 
+#if defined(__cplusplus)
+    #define CTEST_ALIGNOF(T) alignof(T)
+#else
+    #define CTEST_ALIGNOF(T) _Alignof(T)
+#endif
+
 typedef void (*ctest_void_func)(void);
 
 {%- for const_cstr in ctx.const_cstr_tests +%}
@@ -21,7 +33,7 @@ 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.
-char *ctest_const_cstr__{{ const_cstr.id }}(void) {
+{{ self.linkage }}char *ctest_const_cstr__{{ const_cstr.id }}(void) {
     return ctest_const_{{ const_cstr.id }}_val_static;
 }
 {%- endfor +%}
@@ -32,25 +44,25 @@ static {{ constant.c_ty }} ctest_const_{{ constant.id }}_val_static = {{ constan
 
 // 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_ty }} *ctest_const__{{ constant.id }}(void) {
+{{ self.linkage }}{{ constant.c_ty }} *ctest_const__{{ constant.id }}(void) {
     return &ctest_const_{{ constant.id }}_val_static;
 }
 {%- endfor +%}
 
 {%- for item in ctx.size_align_tests +%}
 
 // Return the size of a type.
-uint64_t ctest_size_of__{{ item.id }}(void) { return sizeof({{ item.c_ty }}); }
+{{ self.linkage }}uint64_t ctest_size_of__{{ item.id }}(void) { return sizeof({{ item.c_ty }}); }
 
 // Return the alignment of a type.
-uint64_t ctest_align_of__{{ item.id }}(void) { return _Alignof({{ item.c_ty }}); }
+{{ self.linkage }}uint64_t ctest_align_of__{{ item.id }}(void) { return CTEST_ALIGNOF({{ item.c_ty }}); }
 {%- endfor +%}
 
 {%- for alias in ctx.signededness_tests +%}
 
 // 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__{{ alias.id }}(void) {
+{{ self.linkage }}uint32_t ctest_signededness_of__{{ alias.id }}(void) {
     {{ alias.c_ty }} all_ones = ({{ alias.c_ty }}) -1;
     return all_ones < 0;
 }
@@ -59,12 +71,12 @@ uint32_t ctest_signededness_of__{{ alias.id }}(void) {
 {%- for item in ctx.field_size_offset_tests +%}
 
 // Return the offset of a struct/union field.
-uint64_t ctest_offset_of__{{ item.id }}__{{ item.field.ident() }}(void) {
+{{ self.linkage }}uint64_t ctest_offset_of__{{ item.id }}__{{ item.field.ident() }}(void) {
     return offsetof({{ item.c_ty }}, {{ item.c_field }});
 }
 
 // Return the size of a struct/union field.
-uint64_t ctest_size_of__{{ item.id }}__{{ item.field.ident() }}(void) {
+{{ self.linkage }}uint64_t ctest_size_of__{{ item.id }}__{{ item.field.ident() }}(void) {
     return sizeof((({{ item.c_ty }}){}).{{ item.c_field }});
 }
 {%- endfor +%}
@@ -75,7 +87,7 @@ uint64_t ctest_size_of__{{ item.id }}__{{ item.field.ident() }}(void) {
 // 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 {{ item.volatile_keyword }}{{ item.field_return_type }};
-ctest_field_ty__{{ item.id }}__{{ item.field.ident() }}
+{{ self.linkage }}ctest_field_ty__{{ item.id }}__{{ item.field.ident() }}
 ctest_field_ptr__{{ item.id }}__{{ item.field.ident() }}({{ item.c_ty }} *b) {
     return &b->{{ item.c_field }};
 }
@@ -92,7 +104,7 @@ ctest_field_ptr__{{ item.id }}__{{ item.field.ident() }}({{ item.c_ty }} *b) {
 // 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.
-{{ item.c_ty }} ctest_roundtrip__{{ item.id }}(
+{{ self.linkage }}{{ item.c_ty }} ctest_roundtrip__{{ item.id }}(
     {{ item.c_ty }} value,
     const uint8_t is_padding_byte[sizeof({{ item.c_ty }})],
     uint8_t value_bytes[sizeof({{ item.c_ty }})]
@@ -130,7 +142,8 @@ ctest_field_ptr__{{ item.id }}__{{ item.field.ident() }}({{ item.c_ty }} *b) {
 
 {%- for item in ctx.foreign_fn_tests +%}
 
-ctest_void_func ctest_foreign_fn__{{ item.id }}(void) {
+// Return a function pointer.
+{{ self.linkage }}ctest_void_func ctest_foreign_fn__{{ item.id }}(void) {
     return (ctest_void_func){{ item.c_val }};
 }
 {%- endfor +%}
@@ -142,7 +155,7 @@ ctest_void_func ctest_foreign_fn__{{ item.id }}(void) {
 {%- for static_ in ctx.foreign_static_tests +%}
 
 // Return a pointer to the static variable content.
-void *ctest_static__{{ static_.id }}(void) {
+{{ self.linkage }}void *ctest_static__{{ static_.id }}(void) {
     // FIXME(ctest): Not correct due to casting the function to a data pointer.
     return (void *)&{{ static_.c_val }};
 }

ctest/templates/test.c

@@ -130,6 +130,8 @@ fn test_entrypoint_macro() {
     let library_path = "macro.out.a";
 
     let (mut gen_, out_dir) = default_generator(1, "macro.h").unwrap();
+    gen_.header_with_defines("macro.h", vec!["UNSIGNED"]);
+
     check_entrypoint(&mut gen_, out_dir, crate_path, library_path, include_path);
 }
 

ctest/tests/basic.rs

@@ -4,9 +4,14 @@
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
-
 #include <hierarchy.h>
 
+#if defined(__cplusplus)
+    #define CTEST_ALIGNOF(T) alignof(T)
+#else
+    #define CTEST_ALIGNOF(T) _Alignof(T)
+#endif
+
 typedef void (*ctest_void_func)(void);
 
 static bool ctest_const_ON_val_static = ON;
@@ -21,7 +26,7 @@ bool *ctest_const__ON(void) {
 uint64_t ctest_size_of__in6_addr(void) { return sizeof(in6_addr); }
 
 // Return the alignment of a type.
-uint64_t ctest_align_of__in6_addr(void) { return _Alignof(in6_addr); }
+uint64_t ctest_align_of__in6_addr(void) { return CTEST_ALIGNOF(in6_addr); }
 
 // 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`
@@ -73,6 +78,7 @@ in6_addr ctest_roundtrip__in6_addr(
 #  pragma warning(disable:4191)
 #endif
 
+// Return a function pointer.
 ctest_void_func ctest_foreign_fn__malloc(void) {
     return (ctest_void_func)malloc;
 }

ctest/tests/input/hierarchy.out.c

@@ -1,5 +1,6 @@
 #include <stdint.h>
 
+#ifdef UNSIGNED
 struct VecU8
 {
     uint8_t x;
@@ -11,3 +12,16 @@ struct VecU16
     uint16_t x;
     uint16_t y;
 };
+#else
+struct VecI8
+{
+    int8_t x;
+    int8_t y;
+};
+
+struct VecI16
+{
+    int16_t x;
+    int16_t y;
+};
+#endif