Support negated patterns with - and change from : to , for pattern separation.

We adjust the supported pattern syntax to include negated patterns, improving alignment with [GTest C++](https://google.github.io/googletest/advanced.html#running-a-subset-of-the-tests).

Unfortunately, we have to deviate from GTest C++ with respect to the pattern separator `:` for ergonomic reasons.  The colon character `:` doesn't work well to separate the patterns because `::` is Rust's namespace separator.  This clash makes it much too easy to make unintentional mistakes when trying to write filter patterns with module paths.

To avoid this conflict, we switch to `,` as the pattern separator.

PiperOrigin-RevId: 734611957

Author: Googler

googletest/src/internal/test_filter.rs

@@ -5,8 +5,17 @@
 //!
 //! * TESTBRIDGE_TEST_ONLY: string passed from --test_filter
 //!
-//! We interpret it as a colon-separated list of glob patterns.  If
-//! any pattern in the list succeeds, the filter passes.
+//! The format of a filter is a ‘,‘-separated list of wildcard
+//! patterns (called the positive patterns) optionally followed by a
+//! ‘-’ and another ‘,‘-separated pattern list (called the negative
+//! patterns). A test matches the filter if and only if it matches any
+//! of the positive patterns but does not match any of the negative
+//! patterns.  (Note that this is a deliberate devation from GTest
+//! C++, which uses colons to separate the patterns, as colons will
+//! unfortunately clash with Rust's "::" namespacing operator.)
+//!
+//! As an example: "*mount*-*doom*" will accept any string that contains the
+//! substring "mount", as long as it also doesn't contain "doom"
 use crate::internal::glob::{is_glob_pattern, Pattern};
 use std::sync::OnceLock;
 
@@ -51,23 +60,56 @@ impl TestFilter for Matches {
 }
 
 struct Collection {
-    equals: Box<[Equals]>,
-    matches: Box<[Matches]>,
+    // The positive portion:
+    positive_equals: Box<[Equals]>,
+    positive_matches: Box<[Matches]>,
+
+    // The negative portion:
+    negative_equals: Box<[Equals]>,
+    negative_matches: Box<[Matches]>,
 }
 
 impl TestFilter for Collection {
     fn filter(&self, test_name: &str) -> bool {
-        self.equals.iter().any(|f| f.filter(test_name))
-            || self.matches.iter().any(|f| f.filter(test_name))
+        (self.positive_equals.iter().any(|f| f.filter(test_name))
+            || self.positive_matches.iter().any(|f| f.filter(test_name)))
+            && (!self.negative_equals.iter().any(|f| f.filter(test_name)))
+            && (!self.negative_matches.iter().any(|f| f.filter(test_name)))
     }
 }
 
 fn get_test_filter(testbridge_test_only: &str) -> Collection {
-    let (with_globs, literals): (Vec<_>, Vec<_>) =
-        testbridge_test_only.split(':').partition(|s| is_glob_pattern(s));
+    let positive_negative: Vec<&str> = testbridge_test_only.splitn(2, '-').collect();
+
+    let (positive_with_globs, positive_literals): (Vec<_>, Vec<_>) = {
+        let positive = positive_negative[0];
+        if positive.is_empty() {
+            // Forces the empty positive filter to accept everything:
+            (vec!["*"], vec![])
+        } else {
+            positive.split(',').partition(|s| is_glob_pattern(s))
+        }
+    };
+
+    let (negative_with_globs, negative_literals): (Vec<_>, Vec<_>) = match positive_negative.get(1)
+    {
+        Some(negative) if !negative.is_empty() => {
+            negative.split(',').partition(|s| is_glob_pattern(s))
+        }
+        _ => (vec![], vec![]),
+    };
+
     Collection {
-        equals: literals.into_iter().map(|s| Equals(s.to_string())).collect(),
-        matches: with_globs.into_iter().map(|s| Matches(Pattern::new(s.to_string()))).collect(),
+        positive_equals: positive_literals.into_iter().map(|s| Equals(s.to_string())).collect(),
+        positive_matches: positive_with_globs
+            .into_iter()
+            .map(|s| Matches(Pattern::new(s.to_string())))
+            .collect(),
+        negative_equals: negative_literals.into_iter().map(|s| Equals(s.to_string())).collect(),
+        negative_matches: negative_with_globs
+            .into_iter()
+            .map(|s| Matches(Pattern::new(s.to_string())))
+            .collect(),
     }
 }
 
@@ -86,11 +128,20 @@ mod tests {
     }
 
     #[test]
-    fn empty_filter_accepts_only_empty() -> Result<()> {
+    fn empty_filter_accepts_all() -> Result<()> {
         let filter = get_test_filter("");
 
         verify_that!(filter.filter(""), is_true())?;
-        verify_that!(filter.filter("abcdefg"), is_false())?;
+        verify_that!(filter.filter("abcdefg"), is_true())?;
+        Ok(())
+    }
+
+    #[test]
+    fn empty_negation_filter_accepts_all() -> Result<()> {
+        let filter = get_test_filter("-");
+
+        verify_that!(filter.filter(""), is_true())?;
+        verify_that!(filter.filter("abcdefg"), is_true())?;
         Ok(())
     }
 
@@ -134,7 +185,7 @@ mod tests {
 
     #[test]
     fn collection() -> Result<()> {
-        let filter = get_test_filter("a:b");
+        let filter = get_test_filter("a,b");
 
         verify_that!(filter.filter(""), is_false())?;
         verify_that!(filter.filter("a"), is_true())?;
@@ -148,12 +199,63 @@ mod tests {
 
     #[test]
     fn collection_with_globs() -> Result<()> {
-        let filter = get_test_filter("*test1*:*test2*");
+        let filter = get_test_filter("*test1*,*test2*");
 
         verify_that!(filter.filter(""), is_false())?;
         verify_that!(filter.filter("this is test1"), is_true())?;
         verify_that!(filter.filter("and test2 is it"), is_true())?;
         verify_that!(filter.filter("but test3 is not"), is_false())?;
         Ok(())
     }
+
+    #[test]
+    fn collection_with_globs_negation() -> Result<()> {
+        let filter = get_test_filter("*test*-*testbad");
+
+        verify_that!(filter.filter(""), is_false())?;
+        verify_that!(filter.filter("module"), is_false())?;
+        verify_that!(filter.filter("module::my_test1"), is_true())?;
+        verify_that!(filter.filter("module::my_test2"), is_true())?;
+        verify_that!(filter.filter("module::my_testbad"), is_false())?;
+        Ok(())
+    }
+
+    #[test]
+    fn mount_doom() -> Result<()> {
+        let filter = get_test_filter("*mount*-*doom*");
+
+        verify_that!(filter.filter(""), is_false())?;
+        verify_that!(filter.filter("mount rushmore"), is_true())?;
+        verify_that!(filter.filter("doom mount"), is_false())?;
+        verify_that!(filter.filter("dismount"), is_true())?;
+        verify_that!(filter.filter("mountains of moria"), is_true())?;
+        verify_that!(filter.filter("frodo and sam went to mount doom"), is_false())?;
+        Ok(())
+    }
+
+    #[test]
+    fn collection_with_only_negation() -> Result<()> {
+        let filter = get_test_filter("-testbad1,testbad2");
+
+        verify_that!(filter.filter(""), is_true())?;
+        verify_that!(filter.filter("test"), is_true())?;
+        verify_that!(filter.filter("testbad1"), is_false())?;
+        verify_that!(filter.filter("testbad2"), is_false())?;
+        verify_that!(filter.filter("testbad3"), is_true())?;
+        Ok(())
+    }
+
+    #[test]
+    fn magic_words_a_and_e() -> Result<()> {
+        let filter = get_test_filter("a*,e*-abracadabra,elbereth,avada kedavra");
+
+        verify_that!(filter.filter("alakazam"), is_true())?;
+        verify_that!(filter.filter("abracadabra"), is_false())?;
+        verify_that!(filter.filter("avada kedavra"), is_false())?;
+        verify_that!(filter.filter("enchantment"), is_true())?;
+        verify_that!(filter.filter("elbereth"), is_false())?;
+        verify_that!(filter.filter("expecto patronum"), is_true())?;
+        verify_that!(filter.filter("fuego"), is_false())?;
+        Ok(())
+    }
 }

integration_tests/src/always_fails.rs

@@ -19,7 +19,7 @@ mod tests {
     use googletest::prelude::*;
 
     #[gtest]
-    fn always_fails() -> Result<()> {
+    fn this_always_fails() -> Result<()> {
         verify_that!(2, eq(3))
     }
 }

integration_tests/src/integration_tests.rs

@@ -1940,15 +1940,38 @@ mod tests {
     }
 
     #[gtest]
-    fn should_fail_when_failing_test_matches() -> Result<()> {
+    fn should_fail_on_always_fails_when_filter_is_empty() -> Result<()> {
+        verify_that!(execute_filtered_test("always_fails", "")?, is_false())
+    }
+
+    #[gtest]
+    fn should_fail_when_failing_test_matches_exactly() -> Result<()> {
+        verify_that!(
+            execute_filtered_test("always_fails", "always_fails::tests::this_always_fails")?,
+            is_false()
+        )
+    }
+
+    #[gtest]
+    fn should_fail_when_failing_test_matches_with_globs() -> Result<()> {
         verify_that!(execute_filtered_test("always_fails", "*fails*")?, is_false())
     }
 
     #[gtest]
-    fn should_pass_when_failing_test_mismatch() -> Result<()> {
+    fn should_pass_when_failing_test_mismatches_no_implicit_contains() -> Result<()> {
+        verify_that!(execute_filtered_test("always_fails", "fails")?, is_true())
+    }
+
+    #[gtest]
+    fn should_pass_when_failing_test_mismatches_obviously() -> Result<()> {
         verify_that!(execute_filtered_test("always_fails", "filter_should_mismatch")?, is_true())
     }
 
+    #[gtest]
+    fn should_pass_when_failing_test_excluded() -> Result<()> {
+        verify_that!(execute_filtered_test("always_fails", "-*::this_always_fails")?, is_true())
+    }
+
     #[::core::prelude::v1::test]
     #[should_panic]
     fn should_panic_when_expect_that_runs_without_attribute_macro_after_another_test() {