test: Use automatic test detection

Move from `test/` to `tests/`, which is the directory for autodetection.
This means that we can drop `[[test]]` entries in `libc-test/Cargo.toml`
that don't require nondefault configuration like `harness = false`.

As part of this, `style` and its selftests are moved to the `libc-test`
source directory.

Author: tgross35

libc-test/Cargo.toml

@@ -9,14 +9,14 @@ license = "MIT OR Apache-2.0"
 repository = "https://github.com/rust-lang/libc"
 
 [dependencies]
+annotate-snippets = { version = "0.11.5", features = ["testing-colors"] }
 cfg-if = "1.0.1"
 libc = { path = "..", version = "1.0.0-alpha.1", default-features = false }
+proc-macro2 = { version = "1.0.95", features = ["span-locations"] }
+syn = { version = "2.0.104", features = ["full", "visit"] }
 
 [dev-dependencies]
-syn = { version = "2.0.104", features = ["full", "visit"] }
-proc-macro2 = { version = "1.0.95", features = ["span-locations"] }
 glob = "0.3.2"
-annotate-snippets = { version = "0.11.5", features = ["testing-colors"] }
 
 [build-dependencies]
 cc = "1.2.29"
@@ -30,79 +30,44 @@ extra_traits = ["libc/extra_traits"]
 
 [[test]]
 name = "main"
-path = "test/main.rs"
+path = "tests/main.rs"
 harness = false
 
 [[test]]
 name = "linux-fcntl"
-path = "test/linux_fcntl.rs"
+path = "tests/linux_fcntl.rs"
 harness = false
 
 [[test]]
 name = "linux-if-arp"
-path = "test/linux_if_arp.rs"
+path = "tests/linux_if_arp.rs"
 harness = false
 
 [[test]]
 name = "linux-ipv6"
-path = "test/linux_ipv6.rs"
+path = "tests/linux_ipv6.rs"
 harness = false
 
 [[test]]
 name = "linux-elf"
-path = "test/linux_elf.rs"
+path = "tests/linux_elf.rs"
 harness = false
 
 [[test]]
 name = "linux-strerror_r"
-path = "test/linux_strerror_r.rs"
+path = "tests/linux_strerror_r.rs"
 harness = false
 
 [[test]]
 name = "linux-termios"
-path = "test/linux_termios.rs"
+path = "tests/linux_termios.rs"
 harness = false
 
-[[test]]
-name = "cmsg"
-path = "test/cmsg.rs"
-harness = true
-
-[[test]]
-name = "makedev"
-path = "test/makedev.rs"
-harness = true
-
-[[test]]
-name = "errqueue"
-path = "test/errqueue.rs"
-harness = true
-
-[[test]]
-name = "sigrt"
-path = "test/sigrt.rs"
-harness = true
-
 [[test]]
 name = "semver"
-path = "test/semver.rs"
+path = "tests/semver.rs"
 harness = false
 
-[[test]]
-name = "primitive_types"
-path = "test/primitive_types.rs"
-harness = true
-
-[[test]]
-name = "style"
-path = "test/check_style.rs"
-harness = true
-
-[[test]]
-name = "style_tests"
-path = "test/style_tests.rs"
-harness = true
-
 # FIXME(msrv): These should be moved to the root Cargo.toml as `[workspace.lints.*]`
 #              once MSRV is above 1.64 and replaced with `[lints] workspace=true`
 

libc-test/src/lib.rs

@@ -0,0 +1 @@
+pub mod style;

libc-test/test/style/mod.rs renamed to libc-test/src/style.rs

@@ -37,6 +37,9 @@ use syn::spanned::Spanned;
 use syn::visit::{self, Visit};
 use syn::Token;
 
+#[cfg(test)]
+mod tests;
+
 const ALLOWED_REPEATED_MACROS: &[&str] = &["s", "s_no_extra_traits", "s_paren"];
 
 pub type Error = Box<dyn std::error::Error>;

libc-test/src/style/tests.rs

@@ -0,0 +1,258 @@
+//! Verifies the implementation of the style checker in [style].
+
+use super::StyleChecker;
+
+#[test]
+fn check_style_accept_correct_module_layout() {
+    let contents = r#"
+use core::mem::size_of;
+pub type foo_t = u32;
+struct Foo {}
+pub const FOO: u32 = 0x20000;
+f! {}
+extern "C" {}
+mod foolib;
+pub use self::foolib::*;
+"#
+    .to_string();
+
+    let mut checker = StyleChecker::new();
+    checker.check_string(contents).unwrap();
+    checker.finalize().unwrap();
+}
+
+#[test]
+fn check_style_reject_incorrect_module_layout() {
+    let contents = r#"
+use core::mem::size_of;
+pub type foo_t = u32;
+struct Foo {}
+pub const FOO: u32 = 0x20000;
+extern "C" {}
+f! {}
+mod foolib;
+pub use self::foolib::*;
+"#
+    .to_string();
+
+    let mut checker = StyleChecker::new();
+    checker.check_string(contents).unwrap();
+    assert!(checker.finalize().is_err());
+}
+
+#[test]
+fn check_style_reject_incorrect_cfg_if_layout() {
+    let contents = r#"
+cfg_if! {
+    if #[cfg(foo)] {
+        pub type foo_t = u32;
+        use core::mem::size_of;
+    }
+}
+"#
+    .to_string();
+
+    let mut checker = StyleChecker::new();
+    checker.check_string(contents).unwrap();
+    assert!(checker.finalize().is_err());
+}
+
+#[test]
+fn check_style_accept_cfg_if_branch_resets_state() {
+    let contents = r#"
+cfg_if! {
+    if #[cfg(foo)] {
+        use core::mem::size_of;
+        pub type foo_t = u32;
+    } else {
+        use core::mem::align_of;
+    }
+}
+"#
+    .to_string();
+
+    let mut checker = StyleChecker::new();
+    checker.check_string(contents).unwrap();
+    checker.finalize().unwrap();
+}
+
+#[test]
+fn check_style_reject_multiple_f_macros() {
+    let contents = r#"
+f! {}
+f! {}
+"#
+    .to_string();
+
+    let mut checker = StyleChecker::new();
+    checker.check_string(contents).unwrap();
+    assert!(checker.finalize().is_err());
+}
+
+#[test]
+fn check_style_accept_cfg_ignore_target_endian_nested() {
+    let contents = r#"
+pub struct Foo {
+    #[cfg(target_endian = "little")]
+    pub id: __u16,
+}
+"#
+    .to_string();
+
+    let mut checker = StyleChecker::new();
+    checker.check_string(contents).unwrap();
+    checker.finalize().unwrap();
+}
+
+#[test]
+fn check_style_reject_manual_copy() {
+    let contents = r#"
+#[derive(Copy)]
+pub struct Foo {}
+"#
+    .to_string();
+
+    let mut checker = StyleChecker::new();
+    checker.check_string(contents).unwrap();
+    assert!(checker.finalize().is_err());
+}
+
+#[test]
+fn check_style_reject_manual_clone() {
+    let contents = r#"
+#[derive(Clone)]
+pub struct Foo {}
+"#
+    .to_string();
+
+    let mut checker = StyleChecker::new();
+    checker.check_string(contents).unwrap();
+    assert!(checker.finalize().is_err());
+}
+
+#[test]
+fn check_style_accept_multiple_s_macros_with_disjoint_cfg() {
+    let contents = r#"
+// Main `s!`
+s! {}
+
+// These are not supported on a single arch. It doesn't make sense to
+// duplicate `foo` into every single file except one, so allow this here.
+#[cfg(not(target_arch = "foo"))]
+s! { pub struct foo { /* ... */ } }
+
+// Similar to the above, no problems here
+#[cfg(not(target_os = "illumos"))]
+s! { pub struct bar { /* ... */ } }
+"#
+    .to_string();
+
+    let mut checker = StyleChecker::new();
+    checker.check_string(contents).unwrap();
+    checker.finalize().unwrap();
+}
+
+#[test]
+fn check_style_reject_duplicated_s_macro() {
+    let contents = r#"
+s! {}
+s! {}
+"#
+    .to_string();
+
+    let mut checker = StyleChecker::new();
+    checker.check_string(contents).unwrap();
+    assert!(checker.finalize().is_err());
+}
+
+#[test]
+fn check_style_reject_duplicated_s_macro_cfg() {
+    let contents = r#"
+#[cfg(not(target_arch = "foo"))]
+s! {}
+
+#[cfg(not(target_arch = "foo"))]
+s! {}
+"#
+    .to_string();
+
+    let mut checker = StyleChecker::new();
+    checker.check_string(contents).unwrap();
+    assert!(checker.finalize().is_err());
+}
+
+#[test]
+fn check_style_reject_single_positive_s_macro_cfg() {
+    let contents = r#"
+// A positive (no `not`) config: reject because this should go into
+// the relevant file.
+#[cfg(target_arch = "foo")]
+s! { pub struct foo { /* ... */ } }
+"#
+    .to_string();
+
+    let mut checker = StyleChecker::new();
+    checker.check_string(contents).unwrap();
+    assert!(checker.finalize().is_err());
+}
+
+#[test]
+fn check_style_reject_single_positive_s_macro_cfg_target_os() {
+    let contents = r#"
+// A positive (no `not`) config: reject because this should go into
+// the relevant file.
+#[cfg(target_os = "foo")]
+s! { pub struct foo { /* ... */ } }
+"#
+    .to_string();
+
+    let mut checker = StyleChecker::new();
+    checker.check_string(contents).unwrap();
+    assert!(checker.finalize().is_err());
+}
+
+#[test]
+fn check_style_accept_positive_s_macro_any() {
+    let contents = r#"
+// It's nicer to accept this so that we don't have to duplicate the same struct 3 times.
+#[cfg(any(target_arch = "foo", target_arch = "bar", target_arch = "baz"))]
+s! { pub struct foo { /* ... */ } }
+"#
+    .to_string();
+
+    let mut checker = StyleChecker::new();
+    checker.check_string(contents).unwrap();
+    checker.finalize().unwrap();
+}
+
+#[test]
+fn check_style_accept_positive_s_macro_all() {
+    let contents = r#"
+#[cfg(all(target_arch = "foo", target_arch = "bar", target_arch = "baz"))]
+s! { pub struct foo { /* ... */ } }
+"#
+    .to_string();
+
+    let mut checker = StyleChecker::new();
+    checker.check_string(contents).unwrap();
+    checker.finalize().unwrap();
+}
+
+#[test]
+fn check_style_reject_duplicated_cfg_and_cfg_if() {
+    let contents = r#"
+#[cfg(not(target_arch = "foo"))]
+s! { pub struct foo { /* ... */ } }
+
+cfg_if! {
+    if #[cfg(not(target_arch = "foo"))] {
+        s!{ pub struct bar {} }
+    }
+}
+"#
+    .to_string();
+
+    let mut checker = StyleChecker::new();
+    checker.check_string(contents).unwrap();
+    assert!(checker.finalize().is_err());
+}