[nextest-runner] track test kind in RustTestCaseSummary

We're going to use this to run benchmarks in the future.

Author: sunshowers

nextest-metadata/src/test_list.rs

@@ -737,6 +737,9 @@ impl RustTestSuiteStatusSummary {
 #[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
 #[serde(rename_all = "kebab-case")]
 pub struct RustTestCaseSummary {
+    /// The kind of Rust test this is.
+    pub kind: RustTestKind,
+
     /// Returns true if this test is marked ignored.
     ///
     /// Ignored tests, if run, are executed with the `--ignored` argument.
@@ -748,6 +751,38 @@ pub struct RustTestCaseSummary {
     pub filter_match: FilterMatch,
 }
 
+/// The kind of Rust test something is.
+///
+/// Part of a [`RustTestCaseSummary`].
+#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Deserialize, Serialize)]
+#[serde(transparent)]
+pub struct RustTestKind(pub Cow<'static, str>);
+
+impl RustTestKind {
+    /// Creates a new `RustTestKind` from a string.
+    #[inline]
+    pub fn new(kind: impl Into<Cow<'static, str>>) -> Self {
+        Self(kind.into())
+    }
+
+    /// Creates a new `RustTestKind` from a static string.
+    #[inline]
+    pub const fn new_const(kind: &'static str) -> Self {
+        Self(Cow::Borrowed(kind))
+    }
+
+    /// Returns the kind as a string.
+    pub fn as_str(&self) -> &str {
+        &self.0
+    }
+
+    /// The "test" kind, used for functions annotated with `#[test]`.
+    pub const TEST: Self = Self::new_const("test");
+
+    /// The "bench" kind, used for functions annotated with `#[bench]`.
+    pub const BENCH: Self = Self::new_const("bench");
+}
+
 /// An enum describing whether a test matches a filter.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
 #[serde(rename_all = "kebab-case", tag = "status")]

nextest-runner/src/list/test_list.rs

@@ -29,8 +29,8 @@ use guppy::{
 use nextest_filtering::{BinaryQuery, EvalContext, TestQuery};
 use nextest_metadata::{
     BuildPlatform, FilterMatch, MismatchReason, RustBinaryId, RustNonTestBinaryKind,
-    RustTestBinaryKind, RustTestBinarySummary, RustTestCaseSummary, RustTestSuiteStatusSummary,
-    RustTestSuiteSummary, TestListSummary,
+    RustTestBinaryKind, RustTestBinarySummary, RustTestCaseSummary, RustTestKind,
+    RustTestSuiteStatusSummary, RustTestSuiteSummary, TestListSummary,
 };
 use owo_colors::OwoColorize;
 use std::{
@@ -604,10 +604,11 @@ impl<'g> TestList<'g> {
         // Treat ignored and non-ignored as separate sets of single filters, so that partitioning
         // based on one doesn't affect the other.
         let mut non_ignored_filter = filter.build();
-        for test_name in Self::parse(&test_binary.binary_id, non_ignored.as_ref())? {
+        for (test_name, kind) in Self::parse(&test_binary.binary_id, non_ignored.as_ref())? {
             test_cases.insert(
                 test_name.into(),
                 RustTestCaseSummary {
+                    kind,
                     ignored: false,
                     filter_match: non_ignored_filter.filter_match(
                         &test_binary,
@@ -621,14 +622,15 @@ impl<'g> TestList<'g> {
         }
 
         let mut ignored_filter = filter.build();
-        for test_name in Self::parse(&test_binary.binary_id, ignored.as_ref())? {
+        for (test_name, kind) in Self::parse(&test_binary.binary_id, ignored.as_ref())? {
             // Note that libtest prints out:
             // * just ignored tests if --ignored is passed in
             // * all tests, both ignored and non-ignored, if --ignored is not passed in
             // Adding ignored tests after non-ignored ones makes everything resolve correctly.
             test_cases.insert(
                 test_name.into(),
                 RustTestCaseSummary {
+                    kind,
                     ignored: true,
                     filter_match: ignored_filter.filter_match(
                         &test_binary,
@@ -657,7 +659,7 @@ impl<'g> TestList<'g> {
     fn parse<'a>(
         binary_id: &'a RustBinaryId,
         list_output: &'a str,
-    ) -> Result<Vec<&'a str>, CreateTestListError> {
+    ) -> Result<Vec<(&'a str, RustTestKind)>, CreateTestListError> {
         let mut list = Self::parse_impl(binary_id, list_output).collect::<Result<Vec<_>, _>>()?;
         list.sort_unstable();
         Ok(list)
@@ -666,25 +668,31 @@ impl<'g> TestList<'g> {
     fn parse_impl<'a>(
         binary_id: &'a RustBinaryId,
         list_output: &'a str,
-    ) -> impl Iterator<Item = Result<&'a str, CreateTestListError>> + 'a + use<'a> {
+    ) -> impl Iterator<Item = Result<(&'a str, RustTestKind), CreateTestListError>> + 'a + use<'a>
+    {
         // The output is in the form:
         // <test name>: test
         // <test name>: test
         // ...
 
-        list_output.lines().map(move |line| {
-            line.strip_suffix(": test")
-                .or_else(|| line.strip_suffix(": benchmark"))
-                .ok_or_else(|| {
-                    CreateTestListError::parse_line(
-                        binary_id.clone(),
-                        format!(
-                            "line '{line}' did not end with the string ': test' or ': benchmark'"
-                        ),
-                        list_output,
-                    )
-                })
-        })
+        list_output
+            .lines()
+            .map(move |line| match line.strip_suffix(": test") {
+                Some(test_name) => Ok((test_name, RustTestKind::TEST)),
+                None => match line.strip_suffix(": benchmark") {
+                    Some(test_name) => Ok((test_name, RustTestKind::BENCH)),
+                    None => {
+                        return Err(CreateTestListError::parse_line(
+                            binary_id.clone(),
+                            format!(
+                                "line '{line}' did not end with the string \
+                                 ': test' or ': benchmark'"
+                            ),
+                            list_output,
+                        ));
+                    }
+                },
+            })
     }
 
     /// Writes this test list out in a human-friendly format.
@@ -1384,26 +1392,32 @@ mod tests {
                     status: RustTestSuiteStatus::Listed {
                         test_cases: btreemap! {
                             "tests::foo::test_bar".to_owned() => RustTestCaseSummary {
+                                kind: RustTestKind::TEST,
                                 ignored: false,
                                 filter_match: FilterMatch::Matches,
                             },
                             "tests::baz::test_quux".to_owned() => RustTestCaseSummary {
+                                kind: RustTestKind::TEST,
                                 ignored: false,
                                 filter_match: FilterMatch::Matches,
                             },
                             "benches::bench_foo".to_owned() => RustTestCaseSummary {
+                                kind: RustTestKind::BENCH,
                                 ignored: false,
                                 filter_match: FilterMatch::Matches,
                             },
                             "tests::ignored::test_bar".to_owned() => RustTestCaseSummary {
+                                kind: RustTestKind::TEST,
                                 ignored: true,
                                 filter_match: FilterMatch::Mismatch { reason: MismatchReason::Ignored },
                             },
                             "tests::baz::test_ignored".to_owned() => RustTestCaseSummary {
+                                kind: RustTestKind::TEST,
                                 ignored: true,
                                 filter_match: FilterMatch::Mismatch { reason: MismatchReason::Ignored },
                             },
                             "benches::ignored_bench_foo".to_owned() => RustTestCaseSummary {
+                                kind: RustTestKind::BENCH,
                                 ignored: true,
                                 filter_match: FilterMatch::Mismatch { reason: MismatchReason::Ignored },
                             },
@@ -1512,38 +1526,44 @@ mod tests {
                   "status": "listed",
                   "testcases": {
                     "benches::bench_foo": {
+                      "kind": "bench",
                       "ignored": false,
                       "filter-match": {
                         "status": "matches"
                       }
                     },
                     "benches::ignored_bench_foo": {
+                      "kind": "bench",
                       "ignored": true,
                       "filter-match": {
                         "status": "mismatch",
                         "reason": "ignored"
                       }
                     },
                     "tests::baz::test_ignored": {
+                      "kind": "test",
                       "ignored": true,
                       "filter-match": {
                         "status": "mismatch",
                         "reason": "ignored"
                       }
                     },
                     "tests::baz::test_quux": {
+                      "kind": "test",
                       "ignored": false,
                       "filter-match": {
                         "status": "matches"
                       }
                     },
                     "tests::foo::test_bar": {
+                      "kind": "test",
                       "ignored": false,
                       "filter-match": {
                         "status": "matches"
                       }
                     },
                     "tests::ignored::test_bar": {
+                      "kind": "test",
                       "ignored": true,
                       "filter-match": {
                         "status": "mismatch",