difftest: switch to mimic-libtest from tester

Author: Firestar99

Cargo.lock

@@ -27,6 +27,7 @@ members = [
 
     "tests/compiletests",
     "tests/compiletests/deps-helper",
+    "tests/difftests/bin",
     "tests/difftests/runner",
     "tests/difftests/lib",
 ]

Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "difftests"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+
+# See rustc_codegen_spirv/Cargo.toml for details on these features
+[features]
+default = ["use-compiled-tools"]
+use-installed-tools = ["difftest-runner/use-installed-tools"]
+use-compiled-tools = ["difftest-runner/use-compiled-tools"]
+
+[dependencies]
+anyhow = "1.0"
+difftest-runner.workspace = true
+
+[lints]
+workspace = true
+
+[[test]]
+name = "difftests"
+path = "src/test.rs"
+harness = false

tests/difftests/bin/Cargo.toml

@@ -0,0 +1,6 @@
+use anyhow::Result;
+use std::process::ExitCode;
+
+pub fn main() -> Result<ExitCode> {
+    difftest_runner::run()
+}

tests/difftests/bin/src/test.rs

@@ -16,7 +16,7 @@ use-compiled-tools = []
 anyhow = "1.0"
 tracing = "0.1"
 tracing-subscriber = { version = "0.3.20", features = ["fmt", "env-filter"] }
-tester = "0.9.1"
+libtest-mimic = "0.8.1"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 thiserror = "2.0.12"

tests/difftests/runner/Cargo.toml

@@ -2,61 +2,38 @@
 
 use crate::testcase::collect_test_dirs;
 use anyhow::Result;
+use libtest_mimic::{Arguments, Trial};
 use runner::Runner;
+use std::process::ExitCode;
+use std::sync::Arc;
 use std::{
     env, fs,
-    process::{self, Command},
-};
-use tester::{
-    ColorConfig, DynTestName, OutputFormat, RunIgnored, ShouldPanic, TestDesc, TestDescAndFn,
-    TestFn, TestType, run_tests_console,
-    test::{TestOpts, parse_opts},
+    process::{self},
 };
 use tracing_subscriber::FmtSubscriber;
 
 mod differ;
 mod runner;
 mod testcase;
 
-fn run() -> Result<()> {
+pub fn run() -> Result<ExitCode> {
     let subscriber = FmtSubscriber::builder()
         .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
         .finish();
     tracing::subscriber::set_global_default(subscriber).expect("Failed to set global subscriber");
 
-    let args: Vec<String> = env::args().collect();
-    let opts: TestOpts = match parse_opts(&args) {
-        Some(Ok(o)) => TestOpts {
-            test_threads: Some(1),
-            ..o
-        },
-        Some(Err(e)) => {
-            eprintln!("Error parsing test options: {e}");
-            process::exit(1);
-        }
-        None => TestOpts {
-            list: false,
-            filters: vec![],
-            filter_exact: false,
-            force_run_in_process: false,
-            exclude_should_panic: false,
-            run_ignored: RunIgnored::No,
-            run_tests: true,
-            bench_benchmarks: false,
-            logfile: None,
-            nocapture: false,
-            color: ColorConfig::AutoColor,
-            format: OutputFormat::Pretty,
-            test_threads: Some(1),
-            skip: vec![],
-            time_options: None,
-            options: tester::Options {
-                display_output: true,
-                panic_abort: true,
-            },
-        },
-    };
+    let mut args = Arguments::from_args();
+
+    // If filters are provided that look like paths (contain '/'), convert them to test names
+    if let Some(filter) = &mut args.filter {
+        *filter = filter.replace('/', "::");
+    }
 
+    let tests = collect_tests()?;
+    Ok(libtest_mimic::run(&args, tests).exit_code())
+}
+
+fn collect_tests() -> Result<Vec<Trial>> {
     // Find the manifest directory at compile time and locate tests in ../tests.
     let manifest_dir = env!("CARGO_MANIFEST_DIR");
     let base = std::path::Path::new(manifest_dir)
@@ -72,77 +49,23 @@ fn run() -> Result<()> {
         .expect("Failed to canonicalize tests directory");
     tracing::debug!("Using output directory: {}", output_dir.display());
 
-    let runner = Runner {
+    let runner = Arc::new(Runner {
         base_dir: base.clone(),
         output_dir,
-    };
+    });
 
     let test_cases = collect_test_dirs(&base).expect("Failed to collect test case directories");
     if test_cases.is_empty() {
         eprintln!("No valid tests found in {}", base.display());
         process::exit(1);
     }
 
-    // We build first to ensure that the tests are compiled before running them and to
-    // passthrough stdout and stderr from cargo to help debugging.
-    let mut cmd = Command::new("cargo");
-    let cmd = cmd.arg("build").arg("--release");
-    runner::forward_features(cmd);
-    cmd.current_dir(&base)
-        .stderr(process::Stdio::inherit())
-        .stdout(process::Stdio::inherit());
-    tracing::debug!("Running cargo command: {:?}", cmd);
-
-    let output = cmd.output().expect("build output");
-    let exit_code = output.status.code().unwrap_or(-1);
-    tracing::debug!("Cargo build exited with code {}", exit_code);
-    if !output.status.success() {
-        tracing::error!("Cargo build failed");
-        process::exit(exit_code);
-    }
-
-    let tests: Vec<TestDescAndFn> = test_cases
+    let trails = test_cases
         .into_iter()
-        .map(|case| TestDescAndFn {
-            desc: TestDesc {
-                name: DynTestName(case.to_string()),
-                ignore: false,
-                should_panic: ShouldPanic::No,
-                allow_fail: false,
-                test_type: TestType::IntegrationTest,
-            },
-            testfn: TestFn::DynTestFn(Box::new({
-                let runner = runner.clone();
-                move || {
-                    runner
-                        .run_test_case(&case)
-                        .unwrap_or_else(|e| panic!("{}", e));
-                }
-            })),
+        .map(|case| {
+            let runner = runner.clone();
+            Trial::test(case.to_string(), move || Ok(runner.run_test_case(&case)?))
         })
         .collect();
-
-    // If filters are provided that look like paths (contain '/'), convert them to test names
-    let opts = if opts.filters.iter().any(|f| f.contains('/')) {
-        let mut new_opts = opts;
-        new_opts.filters = new_opts
-            .filters
-            .into_iter()
-            .map(|filter| {
-                if filter.contains('/') {
-                    // Convert path-like filter to test name format
-                    filter.replace('/', "::")
-                } else {
-                    filter
-                }
-            })
-            .collect();
-        new_opts
-    } else {
-        opts
-    };
-
-    let passed = run_tests_console(&opts, tests).expect("Failed to run tests");
-
-    process::exit(if passed { 0 } else { 1 });
+    Ok(trails)
 }