libc-test: port windows to use ctest-next

Author: mbyx

.github/workflows/ci.yaml

@@ -89,7 +89,7 @@ jobs:
               # Remove `-Dwarnings` at the MSRV since lints may be different
               export RUSTFLAGS=""
               # Remove `ctest-next` which uses the 2024 edition
-              perl -i -ne 'print unless /"ctest-(next|test)",/' Cargo.toml
+              perl -i -ne 'print unless /"ctest-(next|test)",/ || /"libc-test",/' Cargo.toml
           fi
 
           ./ci/verify-build.sh
@@ -320,7 +320,7 @@ jobs:
     - name: Install Rust
       run: rustup update "$MSRV" --no-self-update && rustup default "$MSRV"
     - name: Remove edition 2024 crates
-      run: perl -i -ne 'print unless /"ctest-(next|test)",/' Cargo.toml
+      run: perl -i -ne 'print unless /"ctest-(next|test)",/ || /"libc-test",/' Cargo.toml
     - uses: Swatinem/rust-cache@v2
     - run: cargo build -p ctest
 

Cargo.lock

@@ -1,6 +1,7 @@
 use std::ops::Deref;
 
 use askama::Template;
+use proc_macro2::Span;
 use quote::ToTokens;
 use syn::spanned::Spanned;
 
@@ -453,7 +454,11 @@ impl<'a> TranslateHelper<'a> {
             // inside of `Fn` when parsed.
             MapInput::Fn(_) => unimplemented!(),
             // For structs/unions/aliases, their type is the same as their identifier.
-            MapInput::Alias(a) => (a.ident(), a.ident().to_string()),
+            // FIXME(ctest): For some specific primitives such as c_uint, they don't exist on the
+            // C side and have to be manually translated. If they are removed to use `std::ffi`,
+            // then this becomes unneeded (although it won't break).
+            MapInput::Alias(a) => (a.ident(), self.translator
+                    .translate_primitive_type(&syn::Ident::new(a.ident(), Span::call_site()))),
             MapInput::Struct(s) => (s.ident(), s.ident().to_string()),
             MapInput::Union(u) => (u.ident(), u.ident().to_string()),
 

ctest-next/src/template.rs

@@ -228,7 +228,7 @@ impl Translator {
     }
 
     /// Translate a Rust primitive type into its C equivalent.
-    fn translate_primitive_type(&self, ty: &syn::Ident) -> String {
+    pub(crate) fn translate_primitive_type(&self, ty: &syn::Ident) -> String {
         match ty.to_string().as_str() {
             "usize" => "size_t".to_string(),
             "isize" => "ssize_t".to_string(),

ctest-next/src/translator.rs

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

ctest-next/templates/test.rs

@@ -21,6 +21,7 @@ annotate-snippets = { version = "0.11.5", features = ["testing-colors"] }
 [build-dependencies]
 cc = "1.2.29"
 ctest = { path = "../ctest" }
+ctest-next = { path = "../ctest-next" }
 regex = "1.11.1"
 
 [features]

libc-test/Cargo.toml

@@ -65,7 +65,10 @@ fn do_ctest() {
         t if t.contains("solaris") => test_solarish(t),
         t if t.contains("illumos") => test_solarish(t),
         t if t.contains("wasi") => test_wasi(t),
-        t if t.contains("windows") => test_windows(t),
+        t if t.contains("windows") => {
+            test_windows_next(t);
+            test_windows(t);
+        }
         t if t.contains("vxworks") => test_vxworks(t),
         t if t.contains("nto-qnx") => test_neutrino(t),
         t if t.contains("aix") => return test_aix(t),
@@ -77,6 +80,10 @@ fn ctest_cfg() -> ctest::TestGenerator {
     ctest::TestGenerator::new()
 }
 
+fn ctest_next_cfg() -> ctest_next::TestGenerator {
+    ctest_next::TestGenerator::new()
+}
+
 fn do_semver() {
     let mut out = PathBuf::from(env::var("OUT_DIR").unwrap());
     out.push("semver.rs");
@@ -945,6 +952,123 @@ fn test_windows(target: &str) {
     cfg.generate(src_hotfix_dir().join("lib.rs"), "main.rs");
 }
 
+fn test_windows_next(target: &str) {
+    assert!(target.contains("windows"));
+    let gnu = target.contains("gnu");
+    let i686 = target.contains("i686");
+
+    let mut cfg = ctest_next_cfg();
+    if target.contains("msvc") {
+        cfg.flag("/wd4324");
+    }
+    cfg.define("_WIN32_WINNT", Some("0x8000"));
+
+    headers! { cfg:
+        "direct.h",
+        "errno.h",
+        "fcntl.h",
+        "io.h",
+        "limits.h",
+        "locale.h",
+        "process.h",
+        "signal.h",
+        "stddef.h",
+        "stdint.h",
+        "stdio.h",
+        "stdlib.h",
+        "sys/stat.h",
+        "sys/types.h",
+        "sys/utime.h",
+        "time.h",
+        "wchar.h",
+        [gnu]: "ws2tcpip.h",
+        [!gnu]: "Winsock2.h",
+    }
+
+    cfg.rename_struct_ty(|ty| {
+        match ty {
+            // Just pass all these through, no need for a "struct" prefix
+            "FILE" | "DIR" | "Dl_info" => ty.to_string().into(),
+            t if t.ends_with("_t") => t.to_string().into(),
+            // Windows uppercase structs don't have `struct` in fr.into()ont:
+            t if ty.chars().next().unwrap().is_uppercase() => t.to_string().into(),
+            "stat" => "struct __stat64".to_string().into(),
+            "utimbuf" => "struct __utimbuf64".to_string().into(),
+            _ => None,
+        }
+    });
+    cfg.rename_type(move |ty| {
+        match ty {
+            // FIXME(windows): these don't exist:
+            "time64_t" => "__time64_t".to_string().into(),
+            "ssize_t" => "SSIZE_T".to_string().into(),
+
+            "sighandler_t" if !gnu => "_crt_signal_t".to_string().into(),
+            "sighandler_t" if gnu => "__p_sig_fn_t".to_string().into(),
+            _ => None,
+        }
+    });
+
+    cfg.rename_fn(move |func| {
+        func.link_name()
+            .map(|l| l.to_string())
+            .or(func.ident().to_string().into())
+    });
+
+    cfg.skip_alias(move |alias| match alias.ident() {
+        "SSIZE_T" if !gnu => true,
+        "ssize_t" if !gnu => true,
+        // FIXME(windows): The size and alignment of this type are incorrect
+        "time_t" if gnu && i686 => true,
+        _ => false,
+    });
+
+    cfg.skip_struct(move |struct_| {
+        let ty = struct_.ident();
+        if ty.starts_with("__c_anonymous_") {
+            return true;
+        }
+        match ty {
+            // FIXME(windows): The size and alignment of this struct are incorrect
+            "timespec" if gnu && i686 => true,
+            _ => false,
+        }
+    });
+    cfg.skip_union(move |union_| union_.ident().starts_with("__c_anonymous_"));
+
+    cfg.skip_const(move |constant| {
+        match constant.ident() {
+            // FIXME(windows): API error:
+            // SIG_ERR type is "void (*)(int)", not "int"
+            "SIG_ERR" |
+            // Similar for SIG_DFL/IGN/GET/SGE/ACK
+            "SIG_DFL" | "SIG_IGN" | "SIG_GET" | "SIG_SGE" | "SIG_ACK" => true,
+            // FIXME(windows): newer windows-gnu environment on CI?
+            "_O_OBTAIN_DIR" if gnu => true,
+            _ => false,
+        }
+    });
+
+    cfg.skip_struct_field(move |s, field| s.ident() == "CONTEXT" && field.ident() == "Fp");
+    // FIXME(windows): All functions point to the wrong addresses?
+    // cfg.skip_fn_ptr_check(|_| true);
+
+    cfg.skip_signededness(move |c| {
+        match c {
+            // windows-isms
+            n if n.starts_with("P") => true,
+            n if n.starts_with("H") => true,
+            n if n.starts_with("LP") => true,
+            "sighandler_t" if gnu => true,
+            _ => false,
+        }
+    });
+
+    cfg.skip_fn(|_| false);
+
+    ctest_next::generate_test(&mut cfg, "../src/lib.rs", "main.rs").unwrap();
+}
+
 fn test_redox(target: &str) {
     assert!(target.contains("redox"));