Add a skip-huge option

Author: tgross35

src/etc/test-float-parse/src/lib.rs

@@ -48,6 +48,7 @@ pub struct Config {
     /// Failures per test
     pub max_failures: Option<u64>,
     pub fuzz_count: Option<u64>,
+    pub skip_huge: bool,
 }
 
 /// Collect, filter, and launch all tests.
@@ -60,26 +61,34 @@ pub fn run(cfg: Config, include: &[String], exclude: &[String]) -> ExitCode {
     rayon::ThreadPoolBuilder::new().num_threads(threads).build_global().unwrap();
 
     let mut tests = register_tests();
+    let initial_tests: Vec<_> = tests.iter().map(|t| t.name.clone()).collect();
 
     let unmatched: Vec<_> = include
         .iter()
         .chain(exclude.iter())
         .filter(|filt| !tests.iter().any(|t| t.matches(filt)))
         .collect();
+
     assert!(
         unmatched.is_empty(),
         "filters were provided that have no matching tests: {unmatched:#?}"
     );
+
     tests.retain(|test| !exclude.iter().any(|exc| test.matches(exc)));
 
+    if cfg.skip_huge {
+        tests.retain(|test| !test.is_huge_test());
+    }
+
     if !include.is_empty() {
         tests.retain(|test| include.iter().any(|inc| test.matches(inc)));
     }
 
     let (logfile, logfile_name) = create_log_file();
     let mut out = Tee { f: &logfile };
 
-    for exc in exclude {
+    for exc in initial_tests.iter().filter(|orig_name| !tests.iter().any(|t| t.name == **orig_name))
+    {
         out.write_sout(format!("Skipping test '{exc}'"));
     }
 

src/etc/test-float-parse/src/main.rs

@@ -5,7 +5,9 @@ use test_float_parse as tfp;
 
 static HELP: &str = r#"Usage:
 
-  ./test-float-parse [--timeout x] [--exclude x] [INCLUDE ...]
+  ./test-float-parse [--timeout x] [--exclude x] [--max-failures x] [INCLUDE ...]
+  ./test-float-parse [--fuzz-count x] [INCLUDE ...]
+  ./test-float-parse [--skip-huge] [INCLUDE ...]
   ./test-float-parse --list
 
 Args:
@@ -22,6 +24,7 @@ Args:
   --fuzz-count N           Run the fuzzer with N iterations. Only has an effect
                            if fuzz tests are enabled. Pass `--fuzz-count none`
                            to remove this limit.
+  --skip-huge              Skip tests that run for a long time.
 "#;
 
 enum ArgMode {
@@ -67,6 +70,7 @@ fn parse_args(args: Vec<String>) -> (tfp::Config, Vec<String>, Vec<String>) {
         timeout: Duration::from_secs(60 * 60 * 3),
         max_failures: Some(20),
         fuzz_count: Some(tfp::DEFAULT_FUZZ_COUNT),
+        skip_huge: false,
     };
 
     let mut mode = ArgMode::Any;
@@ -79,6 +83,10 @@ fn parse_args(args: Vec<String>) -> (tfp::Config, Vec<String>, Vec<String>) {
             ArgMode::Any if arg == "--exclude" => ArgMode::Exclude,
             ArgMode::Any if arg == "--max-failures" => ArgMode::MaxFailures,
             ArgMode::Any if arg == "--fuzz-count" => ArgMode::FuzzCount,
+            ArgMode::Any if arg == "--skip-huge" => {
+                cfg.skip_huge = true;
+                ArgMode::Any
+            }
             ArgMode::Any if arg.starts_with('-') => {
                 panic!("Unknown argument {arg}. Usage:\n{HELP}")
             }