libtest: print the type of test being run

Author: lolbinarycat

library/test/src/console.rs

@@ -257,9 +257,9 @@ fn on_test_event(
     out: &mut dyn OutputFormatter,
 ) -> io::Result<()> {
     match (*event).clone() {
-        TestEvent::TeFiltered(filtered_tests, shuffle_seed) => {
+        TestEvent::TeFiltered(filtered_tests, shuffle_seed, group_kind) => {
             st.total = filtered_tests;
-            out.write_run_start(filtered_tests, shuffle_seed)?;
+            out.write_run_start(filtered_tests, shuffle_seed, group_kind)?;
         }
         TestEvent::TeFilteredOut(filtered_out) => {
             st.filtered_out = filtered_out;

library/test/src/event.rs

@@ -4,6 +4,7 @@
 use super::test_result::TestResult;
 use super::time::TestExecTime;
 use super::types::{TestDesc, TestId};
+use crate::TestGroupKind;
 
 #[derive(Debug, Clone)]
 pub struct CompletedTest {
@@ -28,7 +29,7 @@ impl CompletedTest {
 
 #[derive(Debug, Clone)]
 pub enum TestEvent {
-    TeFiltered(usize, Option<u64>),
+    TeFiltered(usize, Option<u64>, TestGroupKind),
     TeWait(TestDesc),
     TeResult(CompletedTest),
     TeTimeout(TestDesc),

library/test/src/formatters/json.rs

@@ -94,7 +94,12 @@ impl<T: Write> OutputFormatter for JsonFormatter<T> {
             ))
     }
 
-    fn write_run_start(&mut self, test_count: usize, shuffle_seed: Option<u64>) -> io::Result<()> {
+    fn write_run_start(
+        &mut self,
+        test_count: usize,
+        shuffle_seed: Option<u64>,
+        _kind: super::TestGroupKind,
+    ) -> io::Result<()> {
         let shuffle_seed_json = if let Some(shuffle_seed) = shuffle_seed {
             format!(r#", "shuffle_seed": {shuffle_seed}"#)
         } else {

library/test/src/formatters/junit.rs

@@ -54,6 +54,7 @@ impl<T: Write> OutputFormatter for JunitFormatter<T> {
         &mut self,
         _test_count: usize,
         _shuffle_seed: Option<u64>,
+        _group_kind: super::TestGroupKind,
     ) -> io::Result<()> {
         // We write xml header on run start
         self.write_message("<?xml version=\"1.0\" encoding=\"UTF-8\"?>")
@@ -187,7 +188,7 @@ impl<T: Write> OutputFormatter for JunitFormatter<T> {
 fn parse_class_name(desc: &TestDesc) -> (String, String) {
     match desc.test_type {
         TestType::UnitTest => parse_class_name_unit(desc),
-        TestType::DocTest => parse_class_name_doc(desc),
+        TestType::DocTest { merged: _ } => parse_class_name_doc(desc),
         TestType::IntegrationTest => parse_class_name_integration(desc),
         TestType::Unknown => (String::from("unknown"), String::from(desc.name.as_slice())),
     }

library/test/src/formatters/mod.rs

@@ -21,7 +21,12 @@ pub(crate) trait OutputFormatter {
     fn write_test_discovered(&mut self, desc: &TestDesc, test_type: &str) -> io::Result<()>;
     fn write_discovery_finish(&mut self, state: &ConsoleTestDiscoveryState) -> io::Result<()>;
 
-    fn write_run_start(&mut self, test_count: usize, shuffle_seed: Option<u64>) -> io::Result<()>;
+    fn write_run_start(
+        &mut self,
+        test_count: usize,
+        shuffle_seed: Option<u64>,
+        kind: TestGroupKind,
+    ) -> io::Result<()>;
     fn write_test_start(&mut self, desc: &TestDesc) -> io::Result<()>;
     fn write_timeout(&mut self, desc: &TestDesc) -> io::Result<()>;
     fn write_result(
@@ -43,3 +48,22 @@ pub(crate) fn write_stderr_delimiter(test_output: &mut Vec<u8>, test_name: &Test
     }
     writeln!(test_output, "---- {test_name} stderr ----").unwrap();
 }
+
+/// Controls what type of message is printed when running tests.
+#[non_exhaustive]
+#[derive(Copy, Clone, Debug)]
+pub enum TestGroupKind {
+    Regular,
+    DocTestMerged,
+    DocTestStandalone,
+}
+
+impl TestGroupKind {
+    fn qualifier(&self) -> &str {
+        match self {
+            TestGroupKind::Regular => "",
+            TestGroupKind::DocTestMerged => "merged doc",
+            TestGroupKind::DocTestStandalone => "standalone doc",
+        }
+    }
+}

library/test/src/formatters/pretty.rs

@@ -206,14 +206,20 @@ impl<T: Write> OutputFormatter for PrettyFormatter<T> {
         ))
     }
 
-    fn write_run_start(&mut self, test_count: usize, shuffle_seed: Option<u64>) -> io::Result<()> {
+    fn write_run_start(
+        &mut self,
+        test_count: usize,
+        shuffle_seed: Option<u64>,
+        kind: super::TestGroupKind,
+    ) -> io::Result<()> {
         let noun = if test_count != 1 { "tests" } else { "test" };
         let shuffle_seed_msg = if let Some(shuffle_seed) = shuffle_seed {
             format!(" (shuffle seed: {shuffle_seed})")
         } else {
             String::new()
         };
-        self.write_plain(format!("\nrunning {test_count} {noun}{shuffle_seed_msg}\n"))
+        let qual = kind.qualifier();
+        self.write_plain(format!("\nrunning {test_count} {qual}{noun}{shuffle_seed_msg}\n"))
     }
 
     fn write_test_start(&mut self, desc: &TestDesc) -> io::Result<()> {

library/test/src/formatters/terse.rs

@@ -197,15 +197,21 @@ impl<T: Write> OutputFormatter for TerseFormatter<T> {
         Ok(())
     }
 
-    fn write_run_start(&mut self, test_count: usize, shuffle_seed: Option<u64>) -> io::Result<()> {
+    fn write_run_start(
+        &mut self,
+        test_count: usize,
+        shuffle_seed: Option<u64>,
+        kind: super::TestGroupKind,
+    ) -> io::Result<()> {
         self.total_test_count = test_count;
         let noun = if test_count != 1 { "tests" } else { "test" };
         let shuffle_seed_msg = if let Some(shuffle_seed) = shuffle_seed {
             format!(" (shuffle seed: {shuffle_seed})")
         } else {
             String::new()
         };
-        self.write_plain(format!("\nrunning {test_count} {noun}{shuffle_seed_msg}\n"))
+        let qual = kind.qualifier();
+        self.write_plain(format!("\nrunning {test_count} {qual}{noun}{shuffle_seed_msg}\n"))
     }
 
     fn write_test_start(&mut self, desc: &TestDesc) -> io::Result<()> {

library/test/src/lib.rs

@@ -35,6 +35,7 @@ pub use cli::TestOpts;
 pub use self::ColorConfig::*;
 pub use self::bench::{Bencher, black_box};
 pub use self::console::run_tests_console;
+pub use self::formatters::TestGroupKind;
 pub use self::options::{ColorConfig, Options, OutputFormat, RunIgnored, ShouldPanic};
 pub use self::types::TestName::*;
 pub use self::types::*;
@@ -327,6 +328,19 @@ where
     if !opts.bench_benchmarks {
         filtered_tests = convert_benchmarks_to_tests(filtered_tests);
     }
+    let group_kind = match filtered_tests.get(0).map(|x| x.desc.test_type) {
+        // if all remaining tests are the same kind of doctest, we will print a different message.
+        Some(ty @ TestType::DocTest { merged })
+            if filtered_tests.iter().all(|t| t.desc.test_type == ty) =>
+        {
+            if merged {
+                TestGroupKind::DocTestMerged
+            } else {
+                TestGroupKind::DocTestStandalone
+            }
+        }
+        _ => TestGroupKind::Regular,
+    };
 
     for test in filtered_tests {
         let mut desc = test.desc;
@@ -348,7 +362,7 @@ where
 
     let shuffle_seed = get_shuffle_seed(opts);
 
-    let event = TestEvent::TeFiltered(filtered.total_len(), shuffle_seed);
+    let event = TestEvent::TeFiltered(filtered.total_len(), shuffle_seed, group_kind);
     notify_about_test_event(event)?;
 
     let concurrency = opts.test_threads.unwrap_or_else(get_concurrency);

library/test/src/time.rs

@@ -167,7 +167,7 @@ impl TestTimeOptions {
         match test.test_type {
             TestType::UnitTest => self.unit_threshold.warn,
             TestType::IntegrationTest => self.integration_threshold.warn,
-            TestType::DocTest => self.doctest_threshold.warn,
+            TestType::DocTest { merged: _ } => self.doctest_threshold.warn,
             TestType::Unknown => time_constants::UNKNOWN_WARN,
         }
     }
@@ -176,7 +176,7 @@ impl TestTimeOptions {
         match test.test_type {
             TestType::UnitTest => self.unit_threshold.critical,
             TestType::IntegrationTest => self.integration_threshold.critical,
-            TestType::DocTest => self.doctest_threshold.critical,
+            TestType::DocTest { merged: _ } => self.doctest_threshold.critical,
             TestType::Unknown => time_constants::UNKNOWN_CRITICAL,
         }
     }

library/test/src/types.rs

@@ -21,7 +21,7 @@ pub enum TestType {
     /// Integration-style tests are expected to be in the `tests` folder of the crate.
     IntegrationTest,
     /// Doctests are created by the `librustdoc` manually, so it's a different type of test.
-    DocTest,
+    DocTest { merged: bool },
     /// Tests for the sources that don't follow the project layout convention
     /// (e.g. tests in raw `main.rs` compiled by calling `rustc --test` directly).
     Unknown,
@@ -251,7 +251,7 @@ pub struct TestDescAndFn {
     pub testfn: TestFn,
 }
 
-impl TestDescAndFn {
+/*impl TestDescAndFn {
     pub const fn new_doctest(
         test_name: &'static str,
         ignore: bool,
@@ -260,6 +260,7 @@ impl TestDescAndFn {
         no_run: bool,
         should_panic: bool,
         testfn: TestFn,
+        merged: bool,
     ) -> Self {
         Self {
             desc: TestDesc {
@@ -278,9 +279,9 @@ impl TestDescAndFn {
                 } else {
                     options::ShouldPanic::No
                 },
-                test_type: TestType::DocTest,
+                test_type: TestType::DocTest{ merged },
             },
             testfn,
         }
     }
-}
+}*/