ctest: add foreign static test

Author: mbyx

ctest-next/src/ast/static_variable.rs

@@ -12,6 +12,7 @@ pub struct Static {
     pub(crate) ident: BoxStr,
     pub(crate) link_name: Option<BoxStr>,
     pub(crate) ty: syn::Type,
+    pub(crate) mutable: bool,
 }
 
 impl Static {

ctest-next/src/ffi_items.rs

@@ -63,7 +63,6 @@ impl FfiItems {
     }
 
     /// Return a list of all foreign statics found mapped by their ABI.
-    #[cfg_attr(not(test), expect(unused))]
     pub(crate) fn foreign_statics(&self) -> &Vec<Static> {
         &self.foreign_statics
     }
@@ -159,13 +158,15 @@ fn visit_foreign_item_static(table: &mut FfiItems, i: &syn::ForeignItemStatic, a
     let ident = i.ident.to_string().into_boxed_str();
     let ty = i.ty.deref().clone();
     let link_name = extract_single_link_name(&i.attrs);
+    let mutable = matches!(i.mutability, syn::StaticMutability::Mut(_));
 
     table.foreign_statics.push(Static {
         public,
         abi,
         ident,
         link_name,
         ty,
+        mutable,
     });
 }
 

ctest-next/src/template.rs

@@ -4,7 +4,7 @@ use quote::ToTokens;
 use syn::spanned::Spanned;
 
 use crate::ffi_items::FfiItems;
-use crate::translator::Translator;
+use crate::translator::{TranslationErrorKind, Translator};
 use crate::{
     BoxStr, Field, MapInput, Result, TestGenerator, TranslationError, VolatileItemKind, cdecl,
 };
@@ -50,6 +50,7 @@ impl CTestTemplate {
 /// Stores all information necessary for generation of tests for all items.
 #[derive(Clone, Debug, Default)]
 pub(crate) struct TestTemplate {
+    pub foreign_static_tests: Vec<TestForeignStatic>,
     pub field_ptr_tests: Vec<TestFieldPtr>,
     pub field_size_offset_tests: Vec<TestFieldSizeOffset>,
     pub roundtrip_tests: Vec<TestRoundtrip>,
@@ -75,6 +76,7 @@ impl TestTemplate {
         template.populate_field_size_offset_tests(&helper)?;
         template.populate_field_ptr_tests(&helper)?;
         template.populate_roundtrip_tests(&helper)?;
+        template.populate_foreign_static_tests(&helper)?;
 
         Ok(template)
     }
@@ -380,6 +382,64 @@ impl TestTemplate {
 
         Ok(())
     }
+
+    /// Populates tests for foreign statics, keeping track of the names of each test.
+    fn populate_foreign_static_tests(
+        &mut self,
+        helper: &TranslateHelper,
+    ) -> Result<(), TranslationError> {
+        for static_ in helper.ffi_items.foreign_statics() {
+            let is_volatile = helper
+                .generator
+                .volatile_items
+                .iter()
+                .any(|is_volatile| is_volatile(VolatileItemKind::Static(static_.clone())));
+
+            let c_ty = helper.c_type(static_)?.into_boxed_str();
+            let rust_ty = static_.ty.to_token_stream().to_string().into_boxed_str();
+
+            let return_type = if rust_ty.contains("extern") {
+                helper.translator.translate_type(&static_.ty)?
+            } else {
+                cdecl::ptr(
+                    helper.translator.translate_type(&static_.ty)?,
+                    cdecl::Constness::Mut,
+                )
+            };
+            let return_type = cdecl::cdecl(
+                &return_type,
+                format!("ctest_static_ty__{}", static_.ident()),
+            )
+            .map_err(|_| {
+                TranslationError::new(
+                    TranslationErrorKind::InvalidReturn,
+                    &static_.ty.to_token_stream().to_string(),
+                    static_.ty.span(),
+                )
+            })?;
+
+            let item = TestForeignStatic {
+                test_name: static_test_ident(static_.ident()),
+                id: static_.ident().into(),
+                c_val: helper.c_ident(static_).into_boxed_str(),
+                rust_ty: rust_ty.into(),
+                mutable: if static_.mutable { "mut" } else { "const" }.into(),
+                volatile_keyword: { if is_volatile { "volatile " } else { "" }.into() },
+                c_mutable: if c_ty.contains("const") || static_.mutable {
+                    ""
+                } else {
+                    "const "
+                }
+                .into(),
+                return_type: return_type.into(),
+            };
+
+            self.foreign_static_tests.push(item.clone());
+            self.test_idents.push(item.test_name);
+        }
+
+        Ok(())
+    }
 }
 
 /* Many test structures have the following fields:
@@ -457,6 +517,18 @@ pub(crate) struct TestRoundtrip {
     pub is_alias: bool,
 }
 
+#[derive(Clone, Debug)]
+pub(crate) struct TestForeignStatic {
+    pub test_name: BoxStr,
+    pub id: BoxStr,
+    pub c_val: BoxStr,
+    pub rust_ty: BoxStr,
+    pub mutable: BoxStr,
+    pub c_mutable: BoxStr,
+    pub return_type: BoxStr,
+    pub volatile_keyword: BoxStr,
+}
+
 fn signededness_test_ident(ident: &str) -> BoxStr {
     format!("ctest_signededness_{ident}").into()
 }
@@ -485,6 +557,10 @@ fn roundtrip_test_ident(ident: &str) -> BoxStr {
     format!("ctest_roundtrip_{ident}").into()
 }
 
+fn static_test_ident(ident: &str) -> BoxStr {
+    format!("ctest_static_{ident}").into()
+}
+
 /// Wrap methods that depend on both ffi items and the generator.
 pub(crate) struct TranslateHelper<'a> {
     ffi_items: &'a FfiItems,

ctest-next/templates/test.c

@@ -118,3 +118,19 @@ ctest_field_ptr__{{ item.id }}__{{ item.field.ident() }}({{ item.c_ty }} *b) {
 #ifdef _MSC_VER
 #  pragma warning(default:4365)
 #endif
+
+{%- for static_ in ctx.foreign_static_tests +%}
+
+// Return a pointer to the static variable content.
+{%- if static_.rust_ty.contains("extern") +%}
+typedef {{ static_.return_type }};
+ctest_static_ty__{{ static_.id }} ctest_static__{{ static_.id }}(void) {
+    return {{ static_.c_val }};
+}
+{%- else +%}
+typedef {{ static_.volatile_keyword }}{{ static_.c_mutable }}{{ static_.return_type }};
+ctest_static_ty__{{ static_.id }} ctest_static__{{ static_.id }}(void) {
+    return &{{ static_.c_val }};
+}
+{%- endif +%}
+{%- endfor +%}

ctest-next/templates/test.rs

@@ -10,7 +10,7 @@ mod generated_tests {
     #![allow(non_snake_case)]
     #![deny(improper_ctypes_definitions)]
     #[allow(unused_imports)]
-    use std::ffi::{CStr, c_int, c_char};
+    use std::ffi::{CStr, c_int, c_char, c_uint};
     use std::fmt::{Debug, LowerHex};
     use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
     #[allow(unused_imports)]
@@ -314,6 +314,37 @@ mod generated_tests {
         }
     }
 {%- endfor +%}
+
+{%- for static_ in ctx.foreign_static_tests +%}
+
+    // Tests if the pointer to the static variable matches in both Rust and C.
+    pub fn {{ static_.test_name }}() {
+    {%- if static_.rust_ty.contains("extern") +%}
+        extern "C" {
+            fn ctest_static__{{ static_.id }}() -> {{ static_.rust_ty }};
+        }
+        unsafe {
+            // We must use addr_of! here because of https://github.com/rust-lang/rust/issues/114447
+            let actual = std::mem::transmute_copy::<_, usize>(&*std::ptr::addr_of!({{ static_.id }}));
+            let expected = {
+                let val = ctest_static__{{ static_.id }}();
+                std::mem::transmute_copy::<_, usize>(&val)
+            };
+            check_same(actual, expected, "{{ static_.id }} static");
+        }
+    {%- else +%}
+        extern "C" {
+            fn ctest_static__{{ static_.id }}() -> *{{ static_.mutable }} {{ static_.rust_ty }};
+        }
+        unsafe {
+            // We must use addr_of! here because of https://github.com/rust-lang/rust/issues/114447
+            check_same(std::ptr::addr_of!({{ static_.id }}) as usize,
+                    ctest_static__{{ static_.id }}() as usize,
+                    "{{ static_.id }} static");
+        }
+    {%- endif +%}
+    }
+{%- endfor +%}
 }
 
 use generated_tests::*;

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

@@ -64,3 +64,9 @@ in6_addr ctest_roundtrip__in6_addr(
 #ifdef _MSC_VER
 #  pragma warning(default:4365)
 #endif
+
+// Return a pointer to the static variable content.
+typedef const in6_addr *ctest_static_ty__in6addr_any;
+ctest_static_ty__in6addr_any ctest_static__in6addr_any(void) {
+    return &in6addr_any;
+}

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

@@ -7,7 +7,7 @@ mod generated_tests {
     #![allow(non_snake_case)]
     #![deny(improper_ctypes_definitions)]
     #[allow(unused_imports)]
-    use std::ffi::{CStr, c_int, c_char};
+    use std::ffi::{CStr, c_char};
     use std::fmt::{Debug, LowerHex};
     use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
     #[allow(unused_imports)]
@@ -213,6 +213,19 @@ mod generated_tests {
             }
         }
     }
+
+    // Tests if the pointer to the static variable matches in both Rust and C.
+    pub fn ctest_static_in6addr_any() {
+        extern "C" {
+            fn ctest_static__in6addr_any() -> *const in6_addr;
+        }
+        unsafe {
+            // We must use addr_of! here because of https://github.com/rust-lang/rust/issues/114447
+            check_same(std::ptr::addr_of!(in6addr_any) as usize,
+                    ctest_static__in6addr_any() as usize,
+                    "in6addr_any static");
+        }
+    }
 }
 
 use generated_tests::*;
@@ -236,4 +249,5 @@ fn run_all() {
     ctest_size_align_in6_addr();
     ctest_signededness_in6_addr();
     ctest_roundtrip_in6_addr();
+    ctest_static_in6addr_any();
 }

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

@@ -6,5 +6,5 @@ pub const ON: bool = true;
 unsafe extern "C" {
     fn malloc(size: usize) -> *mut c_void;
 
-    static in6addr_any: in6_addr;
+    pub static in6addr_any: in6_addr;
 }

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

@@ -7,7 +7,7 @@ mod generated_tests {
     #![allow(non_snake_case)]
     #![deny(improper_ctypes_definitions)]
     #[allow(unused_imports)]
-    use std::ffi::{CStr, c_int, c_char};
+    use std::ffi::{CStr, c_char};
     use std::fmt::{Debug, LowerHex};
     use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
     #[allow(unused_imports)]

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

@@ -7,7 +7,7 @@ mod generated_tests {
     #![allow(non_snake_case)]
     #![deny(improper_ctypes_definitions)]
     #[allow(unused_imports)]
-    use std::ffi::{CStr, c_int, c_char};
+    use std::ffi::{CStr, c_char};
     use std::fmt::{Debug, LowerHex};
     use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
     #[allow(unused_imports)]