feat(test2): Provide a #[test] macro

Author: epage

Cargo.lock

@@ -8,4 +8,4 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 ## [Unreleased] - ReleaseDate
 
 <!-- next-url -->
-[Unreleased]: https://github.com/epage/pytest-rs/compare/9d9263a628ea7d17e39cf5bfa22ee190fb6e3cc7...HEAD
+[Unreleased]: https://github.com/epage/pytest-rs/compare/106268b63bedd252fc285778e3bd99b6e16c8608...HEAD

crates/libtest2-proc-macro/CHANGELOG.md

@@ -29,7 +29,9 @@ color = ["libtest2-harness/color"]
 threads = ["libtest2-harness/threads"]
 
 [dependencies]
+distributed-list = { version = "0.0.2", path = "../distributed_list" }
 libtest2-harness = { version = "0.0.3", path = "../libtest2-harness" }
+libtest2-proc-macro = { version = "0.0.3", path = "../libtest2-proc-macro" }
 
 [dev-dependencies]
 dunce = "1.0.4"

crates/libtest2/Cargo.toml

@@ -2,31 +2,31 @@ use libtest2::RunError;
 use libtest2::RunResult;
 use libtest2::TestContext;
 
-libtest2::main!(
-    check_toph,
-    check_katara,
-    check_sokka,
-    long_computation,
-    compile_fail_dummy
-);
+#[libtest2::main]
+fn main() {}
 
 // Tests
 
+#[libtest2::test]
 fn check_toph(_context: &TestContext) -> RunResult {
     Ok(())
 }
+#[libtest2::test]
 fn check_katara(_context: &TestContext) -> RunResult {
     Ok(())
 }
+#[libtest2::test]
 fn check_sokka(_context: &TestContext) -> RunResult {
     Err(RunError::fail("Sokka tripped and fell :("))
 }
+#[libtest2::test]
 fn long_computation(context: &TestContext) -> RunResult {
     context.ignore_for("slow")?;
 
     std::thread::sleep(std::time::Duration::from_secs(1));
     Ok(())
 }
+#[libtest2::test]
 fn compile_fail_dummy(_context: &TestContext) -> RunResult {
     Ok(())
 }

crates/libtest2/examples/simple.rs

@@ -5,6 +5,28 @@ use libtest2_harness::TestKind;
 use crate::RunResult;
 use crate::TestContext;
 
+#[derive(Copy, Clone)]
+pub struct DynCase(pub &'static dyn Case);
+
+impl Case for DynCase {
+    fn name(&self) -> &str {
+        self.0.name()
+    }
+    fn kind(&self) -> TestKind {
+        self.0.kind()
+    }
+    fn source(&self) -> Option<&Source> {
+        self.0.source()
+    }
+    fn exclusive(&self, context: &TestContext) -> bool {
+        self.0.exclusive(context)
+    }
+
+    fn run(&self, context: &TestContext) -> RunResult {
+        self.0.run(context)
+    }
+}
+
 pub struct FnCase {
     name: String,
     #[allow(clippy::type_complexity)]
@@ -58,6 +80,8 @@ pub fn main(cases: impl IntoIterator<Item = impl Case + 'static>) {
             ::std::process::exit(1);
         }
     };
+    let mut cases = cases.into_iter().collect::<Vec<_>>();
+    cases.sort_by_key(|c| c.name().to_owned());
     let harness = match harness.discover(cases) {
         Ok(harness) => harness,
         Err(err) => {

crates/libtest2/src/case.rs

@@ -12,19 +12,21 @@
 //! harness = false
 //! ```
 //!
-//! And in `tests/mytest.rs` you would call [`main!`], passing it each of your tests:
+//! And in `tests/mytest.rs` you would wrap `main` with [`#[main]`]:
 //!
 //! ```no_run
 //! # use libtest2::RunError;
 //! # use libtest2::RunResult;
 //! # use libtest2::TestContext;
+//! #[libtest2::test]
 //! fn check_toph(_context: &TestContext) -> RunResult {
 //!     Ok(())
 //! }
 //!
-//! libtest2::main!(check_toph);
+//! #[libtest2::main]
+//! fn main() {
+//! }
 //! ```
-//!
 
 #![cfg_attr(docsrs, feature(doc_cfg))]
 //#![warn(clippy::print_stderr)]
@@ -35,15 +37,24 @@ mod macros;
 
 #[doc(hidden)]
 pub mod _private {
-    pub use crate::_main as main;
+    pub use distributed_list::push;
+    pub use distributed_list::DistributedList;
+    pub use libtest2_harness::Case;
+    pub use libtest2_harness::Source;
+    pub use libtest2_harness::TestKind;
+
+    pub use crate::_main_parse as main_parse;
+    pub use crate::_test_parse as test_parse;
+    pub use crate::case::DynCase;
 }
 
-pub use _private::main;
 pub use case::main;
 pub use case::FnCase;
 pub use libtest2_harness::RunError;
 pub use libtest2_harness::RunResult;
 pub use libtest2_harness::TestContext;
+pub use libtest2_proc_macro::main;
+pub use libtest2_proc_macro::test;
 
 #[doc = include_str!("../README.md")]
 #[cfg(doctest)]

crates/libtest2/src/lib.rs

@@ -1,11 +1,45 @@
-/// Expands to the test harness
 #[macro_export]
-macro_rules! _main {
-    ( $( $test:path ),* $(,)*) => {
+macro_rules! _main_parse {
+    (#[main] fn main $($item:tt)*) => {
+        static TESTS: $crate::_private::DistributedList<$crate::_private::DynCase> = $crate::_private::DistributedList::root();
+
         fn main() {
-            $crate::main([
-                $($crate::FnCase::test(::std::stringify!($test), $test)),*
-        ]);
+            fn inner $($item)*
+
+            inner();
+            $crate::main(TESTS.iter().copied());
         }
-    }
+    };
+}
+
+#[macro_export]
+#[allow(clippy::crate_in_macro_def)] // accessing item defined by `_main_parse`
+macro_rules! _test_parse {
+    (#[test] fn $name:ident $($item:tt)*) => {
+        #[allow(non_camel_case_types)]
+        struct $name;
+
+        impl $crate::_private::Case for $name {
+            fn name(&self) -> &str {
+                $crate::_private::push!(crate::TESTS, _: $crate::_private::DynCase = $crate::_private::DynCase(&$name));
+
+                stringify!($name)
+            }
+            fn kind(&self) -> $crate::_private::TestKind {
+                Default::default()
+            }
+            fn source(&self) -> Option<&$crate::_private::Source> {
+                None
+            }
+            fn exclusive(&self, _: &$crate::TestContext) -> bool {
+                false
+            }
+
+            fn run(&self, context: &$crate::TestContext) -> $crate::RunResult {
+                fn run $($item)*
+
+                run(context)
+            }
+        }
+    };
 }

crates/libtest2/src/macros.rs

@@ -7,16 +7,20 @@ fn test_cmd() -> snapbox::cmd::Command {
     let (bin, current_dir) = BIN.get_or_init(|| {
         let package_root = crate::util::new_test(
             r#"
-libtest2::main!(foo, bar, barro);
+#[libtest2::main]
+fn main() {}
 
+#[libtest2::test]
 fn foo(_context: &libtest2::TestContext) -> libtest2::RunResult {
     Ok(())
 }
 
+#[libtest2::test]
 fn bar(_context: &libtest2::TestContext) -> libtest2::RunResult {
     Ok(())
 }
 
+#[libtest2::test]
 fn barro(_context: &libtest2::TestContext) -> libtest2::RunResult {
     Ok(())
 }

crates/libtest2/tests/testsuite/all_passing.rs

@@ -7,20 +7,25 @@ fn test_cmd() -> snapbox::cmd::Command {
     let (bin, current_dir) = BIN.get_or_init(|| {
         let package_root = crate::util::new_test(
             r#"
-libtest2::main!(one, two, three, one_two);
+#[libtest2::main]
+fn main() {}
 
+#[libtest2::test]
 fn one(_context: &libtest2::TestContext) -> libtest2::RunResult {
     Ok(())
 }
 
+#[libtest2::test]
 fn two(_context: &libtest2::TestContext) -> libtest2::RunResult {
     Ok(())
 }
 
+#[libtest2::test]
 fn three(_context: &libtest2::TestContext) -> libtest2::RunResult {
     Ok(())
 }
 
+#[libtest2::test]
 fn one_two(_context: &libtest2::TestContext) -> libtest2::RunResult {
     Ok(())
 }
@@ -95,17 +100,17 @@ fn list() {
         0,
         str![[r#"
 one: test
-two: test
-three: test
 one_two: test
+three: test
+two: test
 
 4 tests
 
 
 "#]],
         str![[r#"
 one: test
-two: test
+one_two: test
 ...
 
 4 tests