Work around a handful of issues in ctest-test

tgross35 · sanstzu · commit e8d90daf19da · 2025-05-17T04:46:43.000+08:00
* Tests for C++ can only be run when g++ or another C++ compiler is available. We don't need to test this on all platforms, so make the tests check whether a compiler is available and only run these tests if so. * Statics seem to produce duplicate symbol errors [1]. Comment out the relevant parts of tests for now. * Tests don't work when cross compiling. Gate the `all.rs` test to only run on x86_64. Most of this needs to be removed, but the workarounds get us able to run something in CI. [1]: rust-lang#4365
diff --git a/ci/docker/x86_64-unknown-linux-gnu/Dockerfile b/ci/docker/x86_64-unknown-linux-gnu/Dockerfile
@@ -2,7 +2,7 @@ FROM ubuntu:24.10
 
 RUN apt-get update
 RUN apt-get install -y --no-install-recommends \
-  gcc libc6-dev ca-certificates linux-headers-generic
+  gcc g++ libc6-dev ca-certificates linux-headers-generic
 
 RUN apt search linux-headers
 RUN ls /usr/src
diff --git a/ctest-test/Cargo.toml b/ctest-test/Cargo.toml
@@ -11,6 +11,7 @@ ctest = { path = "../ctest" }
 cc = "1.0"
 
 [dependencies]
+cfg-if = "1.0.0"
 libc = "0.2"
 
 [lib]
diff --git a/ctest-test/build.rs b/ctest-test/build.rs
@@ -1,3 +1,5 @@
+use std::process::Command;
+
 fn main() {
     use std::env;
     let opt_level = env::var("OPT_LEVEL")
@@ -48,34 +50,43 @@ fn main() {
         .skip_roundtrip(|_| true)
         .generate("src/t2.rs", "t2gen.rs");
 
-    ctest::TestGenerator::new()
-        .header("t1.h")
-        .language(ctest::Lang::CXX)
-        .include("src")
-        .fn_cname(|a, b| b.unwrap_or(a).to_string())
-        .type_name(move |ty, is_struct, is_union| match ty {
-            "T1Union" => ty.to_string(),
-            "Transparent" => ty.to_string(),
-            t if is_struct => format!("struct {}", t),
-            t if is_union => format!("union {}", t),
-            t => t.to_string(),
-        })
-        .volatile_item(t1_volatile)
-        .array_arg(t1_arrays)
-        .skip_roundtrip(|n| n == "Arr")
-        .generate("src/t1.rs", "t1gen_cxx.rs");
-    ctest::TestGenerator::new()
-        .header("t2.h")
-        .language(ctest::Lang::CXX)
-        .include("src")
-        .type_name(move |ty, is_struct, is_union| match ty {
-            "T2Union" => ty.to_string(),
-            t if is_struct => format!("struct {}", t),
-            t if is_union => format!("union {}", t),
-            t => t.to_string(),
-        })
-        .skip_roundtrip(|_| true)
-        .generate("src/t2.rs", "t2gen_cxx.rs");
+    println!("cargo::rustc-check-cfg=cfg(has_cxx)");
+    if !cfg!(unix) || Command::new("c++").arg("v").output().is_ok() {
+        // A C compiler is always available, but these are only run if a C++ compiler is
+        // also available.
+        println!("cargo::rustc-cfg=has_cxx");
+
+        ctest::TestGenerator::new()
+            .header("t1.h")
+            .language(ctest::Lang::CXX)
+            .include("src")
+            .fn_cname(|a, b| b.unwrap_or(a).to_string())
+            .type_name(move |ty, is_struct, is_union| match ty {
+                "T1Union" => ty.to_string(),
+                "Transparent" => ty.to_string(),
+                t if is_struct => format!("struct {}", t),
+                t if is_union => format!("union {}", t),
+                t => t.to_string(),
+            })
+            .volatile_item(t1_volatile)
+            .array_arg(t1_arrays)
+            .skip_roundtrip(|n| n == "Arr")
+            .generate("src/t1.rs", "t1gen_cxx.rs");
+        ctest::TestGenerator::new()
+            .header("t2.h")
+            .language(ctest::Lang::CXX)
+            .include("src")
+            .type_name(move |ty, is_struct, is_union| match ty {
+                "T2Union" => ty.to_string(),
+                t if is_struct => format!("struct {}", t),
+                t if is_union => format!("union {}", t),
+                t => t.to_string(),
+            })
+            .skip_roundtrip(|_| true)
+            .generate("src/t2.rs", "t2gen_cxx.rs");
+    } else {
+        println!("cargo::warning=skipping C++ tests");
+    }
 }
 
 fn t1_volatile(i: ctest::VolatileItemKind) -> bool {
diff --git a/ctest-test/src/bin/t1_cxx.rs b/ctest-test/src/bin/t1_cxx.rs
@@ -1,7 +1,12 @@
 #![cfg(not(test))]
-#![deny(warnings)]
 
-use ctest_test::t1::*;
-use libc::*;
+cfg_if::cfg_if! {
+    if #[cfg(has_cxx)] {
+        use ctest_test::t1::*;
+        use libc::*;
 
-include!(concat!(env!("OUT_DIR"), "/t1gen_cxx.rs"));
+        include!(concat!(env!("OUT_DIR"), "/t1gen_cxx.rs"));
+    } else {
+        fn main() {}
+    }
+}
diff --git a/ctest-test/src/bin/t2_cxx.rs b/ctest-test/src/bin/t2_cxx.rs
@@ -1,6 +1,11 @@
 #![cfg(not(test))]
-#![deny(warnings)]
 
-use ctest_test::t2::*;
+cfg_if::cfg_if! {
+    if #[cfg(has_cxx)] {
+        use ctest_test::t2::*;
 
-include!(concat!(env!("OUT_DIR"), "/t2gen_cxx.rs"));
+        include!(concat!(env!("OUT_DIR"), "/t2gen_cxx.rs"));
+    } else {
+        fn main() {}
+    }
+}
diff --git a/ctest-test/src/t1.c b/ctest-test/src/t1.c
@@ -72,4 +72,6 @@ void* T1_vol0(volatile void* x, void* a) { return a? a: (void*)x; }
 volatile void* T1_vol1(void* x, void*  b) { return b? (volatile void*)x : (volatile void*)x; }
 volatile void* T1_vol2(void*  c, volatile void* x) { return c? x : x; }
 
+/* FIXME(#4365): duplicate symbol errors when enabled
 uint8_t (* volatile T1_fn_ptr_vol)(uint8_t, uint8_t) = foo;
+*/
diff --git a/ctest-test/src/t1.h b/ctest-test/src/t1.h
@@ -62,14 +62,17 @@ void T1v(const Arr* a);
 
 extern uint32_t T1static;
 extern const uint8_t T1_static_u8;
-uint8_t T1_static_mut_u8;
-uint8_t (*T1_static_mut_fn_ptr)(uint8_t, uint8_t);
+/* FIXME(#4365): duplicate symbol errors when enabled
+// uint8_t T1_static_mut_u8;
+// uint8_t (*T1_static_mut_fn_ptr)(uint8_t, uint8_t);
 extern uint8_t (*const T1_static_const_fn_ptr_unsafe)(uint8_t, uint8_t);
+*/
 extern void (*const T1_static_const_fn_ptr_unsafe2)(uint8_t);
 extern void (*const T1_static_const_fn_ptr_unsafe3)(void);
 
 extern const uint8_t T1_static_right;
-uint8_t (*T1_static_right2)(uint8_t, uint8_t);
+/* FIXME(#4365): duplicate symbol errors when enabled
+// uint8_t (*T1_static_right2)(uint8_t, uint8_t);
 
 // T1_fn_ptr_nested: function pointer to a function, taking a uint8_t, and
 // returning a function pointer to a function taking a uint16_t and returning a
@@ -80,6 +83,7 @@ uint32_t (*(*T1_fn_ptr_s)(uint8_t))(uint16_t);
 // uint8_t -> uint8_t, and returning a function pointer to a function taking a
 // uint16_t and returning a uint32_t
 uint32_t (*(*T1_fn_ptr_s2)(uint8_t(*)(uint8_t), uint16_t(*)(uint16_t)))(uint16_t);
+*/
 
 extern const int32_t T1_arr0[2];
 extern const int32_t T1_arr1[2][3];
@@ -98,8 +102,10 @@ extern int32_t* T1_mut_opt_mut_ref;
 extern const int32_t* T1_const_opt_const_ref;
 
 extern void (*const T1_opt_fn1)(void);
-uint32_t (*(*T1_opt_fn2)(uint8_t))(uint16_t);
-uint32_t (*(*T1_opt_fn3)(uint8_t(*)(uint8_t), uint16_t(*)(uint16_t)))(uint16_t);
+/* FIXME(#4365): duplicate symbol errors when enabled
+// uint32_t (*(*T1_opt_fn2)(uint8_t))(uint16_t);
+// uint32_t (*(*T1_opt_fn3)(uint8_t(*)(uint8_t), uint16_t(*)(uint16_t)))(uint16_t);
+*/
 
 
 struct Q {
@@ -153,8 +159,10 @@ void* T1_vol0(volatile void*, void*);
 volatile void* T1_vol1(void*, void*);
 volatile void* T1_vol2(void*, volatile void*);
 
+/* FIXME(#4365): duplicate symbol errors when enabled
 // volatile function pointers:
 uint8_t (*volatile T1_fn_ptr_vol)(uint8_t, uint8_t);
+*/
 
 #define LOG_MAX_LINE_LENGTH (1400)
 
diff --git a/ctest-test/src/t1.rs b/ctest-test/src/t1.rs
@@ -93,22 +93,26 @@ pub fn foo() {
 
 extern "C" {
     pub static T1_static_u8: u8;
-    pub static mut T1_static_mut_u8: u8;
-    pub static mut T1_static_mut_fn_ptr: extern "C" fn(u8, u8) -> u8;
+    /* FIXME(#4365): duplicate symbol errors when enabled
+    // pub static mut T1_static_mut_u8: u8;
+    // pub static mut T1_static_mut_fn_ptr: extern "C" fn(u8, u8) -> u8;
     pub static T1_static_const_fn_ptr_unsafe: unsafe extern "C" fn(u8, u8) -> u8;
+     */
     pub static T1_static_const_fn_ptr_unsafe2: unsafe extern "C" fn(u8) -> ();
     pub static T1_static_const_fn_ptr_unsafe3: unsafe extern "C" fn() -> ();
 
     #[link_name = "T1_static_right"]
     pub static T1_static_wrong: u8;
-    #[link_name = "T1_static_right2"]
-    pub static mut T1_static_wrong2: extern "C" fn(u8, u8) -> u8;
+    /* FIXME(#4365): duplicate symbol errors when enabled
+    // #[link_name = "T1_static_right2"]
+    // pub static mut T1_static_wrong2: extern "C" fn(u8, u8) -> u8;
 
     pub static T1_fn_ptr_s: unsafe extern "C" fn(u8) -> extern "C" fn(u16) -> u32;
     pub static T1_fn_ptr_s2: unsafe extern "C" fn(
         extern "C" fn(u8) -> u8,
         extern "C" fn(u16) -> u16,
     ) -> extern "C" fn(u16) -> u32;
+    */
 
     pub static T1_arr0: [i32; 2];
     pub static T1_arr1: [[i32; 3]; 2];
@@ -128,13 +132,15 @@ extern "C" {
     pub static T1_const_opt_const_ref: Option<&'static i32>;
 
     pub static T1_opt_fn1: Option<unsafe extern "C" fn() -> ()>;
+    /* FIXME(#4365): duplicate symbol errors when enabled
     pub static T1_opt_fn2: Option<unsafe extern "C" fn(u8) -> extern "C" fn(u16) -> u32>;
     pub static T1_opt_fn3: Option<
         unsafe extern "C" fn(
             extern "C" fn(u8) -> u8,
             extern "C" fn(u16) -> u16,
         ) -> extern "C" fn(u16) -> u32,
     >;
+    */
 }
 
 #[repr(C)]
@@ -176,7 +182,9 @@ extern "C" {
     pub fn T1_vol0(arg0: *mut c_void, arg1: *mut c_void) -> *mut c_void;
     pub fn T1_vol1(arg0: *mut c_void, arg1: *mut c_void) -> *mut c_void;
     pub fn T1_vol2(arg0: *mut c_void, arg1: *mut c_void) -> *mut c_void;
+    /* FIXME(#4365): duplicate symbol errors when enabled
     pub static T1_fn_ptr_vol: Option<unsafe extern "C" fn(u8, u8) -> u8>;
+    */
 }
 
 pub const LOG_MAX_LINE_LENGTH: usize = 1400;
diff --git a/ctest-test/tests/all.rs b/ctest-test/tests/all.rs
@@ -1,3 +1,6 @@
+// FIXME(ctest): this test doesn't work when cross compiling.
+#![cfg(target_arch = "x86_64")]
+
 use std::collections::HashSet;
 use std::env;
 use std::process::{Command, ExitStatus};
@@ -12,25 +15,35 @@ fn cmd(name: &str) -> Command {
     Command::new(p)
 }
 
+fn output(cmd: &mut Command) -> (String, ExitStatus) {
+    eprintln!("command: {cmd:?}");
+    let output = cmd.output().unwrap();
+    let stdout = String::from_utf8(output.stdout).unwrap();
+    let stderr = String::from_utf8(output.stderr).unwrap();
+
+    (stdout + &stderr, output.status)
+}
+
 #[test]
 fn t1() {
     let (o, status) = output(&mut cmd("t1"));
-    assert!(status.success(), "{}", o);
+    assert!(status.success(), "output: {o}");
     assert!(!o.contains("bad "), "{}", o);
     eprintln!("o: {}", o);
 }
 
 #[test]
+#[cfg(has_cxx)]
 fn t1_cxx() {
     let (o, status) = output(&mut cmd("t1_cxx"));
-    assert!(status.success(), "{}", o);
+    assert!(status.success(), "output: {o}");
     assert!(!o.contains("bad "), "{}", o);
 }
 
 #[test]
 fn t2() {
     let (o, status) = output(&mut cmd("t2"));
-    assert!(!status.success(), "{}", o);
+    assert!(!status.success(), "output: {o}");
     let errors = [
         "bad T2Foo signed",
         "bad T2TypedefFoo signed",
@@ -72,9 +85,10 @@ fn t2() {
 }
 
 #[test]
+#[cfg(has_cxx)]
 fn t2_cxx() {
     let (o, status) = output(&mut cmd("t2_cxx"));
-    assert!(!status.success(), "{}", o);
+    assert!(!status.success(), "output: {o}");
     let errors = [
         "bad T2Foo signed",
         "bad T2TypedefFoo signed",
@@ -114,11 +128,3 @@ fn t2_cxx() {
         panic!();
     }
 }
-
-fn output(cmd: &mut Command) -> (String, ExitStatus) {
-    let output = cmd.output().unwrap();
-    let stdout = String::from_utf8(output.stdout).unwrap();
-    let stderr = String::from_utf8(output.stderr).unwrap();
-
-    (stdout + &stderr, output.status)
-}
