Add a recursion base-case to verify_pred to avoid stack overflow, allow printing of arbitrary function arguments, and add tests for its current functionality to catch regressions as more changes are added to implement other features.

PiperOrigin-RevId: 684434719

Author: Googler

googletest/src/assertions.rs

@@ -168,24 +168,23 @@ macro_rules! verify_that {
 /// # */
 /// fn test() -> Result<()> {
 ///     let a = 1;
-///     let b = 7;
-///     let n = 5;
-///     verify_pred!(equals_modulo(a, b, n))?;
+///     fn b(_x: i32) -> i32 { 7 }
+///     verify_pred!(equals_modulo(a, b(b(2)), 2 + 3))?;
 ///     Ok(())
 /// }
 /// # verify_that!(
 /// #     test(),
-/// #     err(displays_as(contains_substring("equals_modulo(a, b, n) was false with")))
+/// #     err(displays_as(contains_substring("equals_modulo(a, b(b(2)), 2 + 3) was false with")))
 /// # ).unwrap();
 /// ```
 ///
 /// This results in the following message:
 ///
 /// ```text
-/// equals_modulo(a, b, n) was false with
+/// equals_modulo(a, b(b(2)), 2 + 3) was false with
 ///   a = 1,
-///   b = 7,
-///   n = 5
+///   b(v) = 7,
+///   2 + 3 = 5
 /// ```
 ///
 /// The function passed to this macro must return `bool`. Each of the arguments
@@ -205,20 +204,30 @@ macro_rules! verify_that {
 /// ```
 ///
 /// **Warning:** This macro assumes that the arguments passed to the predicate
-/// are either *variables* or *calls to pure functions*. If two subsequent
-/// invocations to any of the expresssions passed as arguments result in
-/// different values, then the output message of a test failure will deviate
-/// from the values actually passed to the predicate. For this reason, *always
-/// assign the outputs of non-pure functions to variables before using them in
-/// this macro. For example:
+/// are pure so that two subsequent invocations to any of the expresssions
+/// passed as arguments result in different values, then the output message of a
+/// test failure will deviate from the values actually passed to the predicate.
+/// For this reason, *always assign the outputs of non-pure functions to
+/// variables before using them in this macro. For example:
 ///
 /// ```ignore
 /// let output = generate_random_number();  // Assigned outside of verify_pred.
 /// verify_pred!(is_sufficiently_random(output))?;
 /// ```
 #[macro_export]
 macro_rules! verify_pred {
-    ([$($predicate:tt)*]($($arg:tt),* $(,)?)) => {
+    (@internal [$($predicate:tt)+] $(,)?) => {
+        if !$($predicate)* {
+            $crate::assertions::internal::report_failed_predicate(
+                stringify!($($predicate)*),
+                vec![],
+            )
+        } else {
+            Ok(())
+        }
+    };
+
+    (@internal [$($predicate:tt)+]($($arg:expr),* $(,)?)) => {
         if !$($predicate)*($($arg),*) {
             $crate::assertions::internal::report_failed_predicate(
                 concat!(stringify!($($predicate)*), stringify!(($($arg),*))),
@@ -229,12 +238,12 @@ macro_rules! verify_pred {
         }
     };
 
-    ([$($predicate:tt)*] $first:tt $($rest:tt)*) => {
-        $crate::verify_pred!([$($predicate)* $first] $($rest)*)
+    (@internal [$($predicate:tt)+] $first:tt $($rest:tt)*) => {
+        $crate::verify_pred!(@internal [$($predicate)* $first] $($rest)*)
     };
 
     ($first:tt $($rest:tt)*) => {
-        $crate::verify_pred!([$first] $($rest)*)
+        $crate::verify_pred!(@internal [$first] $($rest)*)
     };
 }
 

googletest/tests/assertions_test.rs

@@ -0,0 +1,80 @@
+mod verify_pred {
+    use googletest::prelude::*;
+    use indoc::indoc;
+
+    #[test]
+    fn supports_function_call() -> Result<()> {
+        fn f(_a: u32, _b: u32, _c: u32) -> bool {
+            false
+        }
+        fn g(_a: u32) -> u32 {
+            5
+        }
+
+        let a = 1;
+        let res = verify_pred!(f(a, g(g(3)), 1 + 2));
+        verify_that!(
+            res,
+            err(displays_as(contains_substring(indoc! {
+                "
+                f(a, g(g(3)), 1 + 2) was false with
+                  a = 1,
+                  g(g(3)) = 5,
+                  1 + 2 = 3
+                "
+            })))
+        )?;
+
+        Ok(())
+    }
+
+    #[test]
+    fn supports_trailing_comma() -> Result<()> {
+        verify_that!(verify_pred!(false,), err(anything()))
+    }
+
+    #[test]
+    fn supports_non_function() -> Result<()> {
+        verify_pred!(true)?;
+        verify_that!(verify_pred!(false), err(anything()))
+    }
+
+    #[test]
+    fn supports_method_calls() -> Result<()> {
+        struct Foo {
+            b: Bar,
+        }
+        struct Bar;
+        impl Bar {
+            fn c(&self) -> bool {
+                false
+            }
+        }
+
+        let a = Foo { b: Bar };
+        let res = verify_pred!(a.b.c());
+        verify_that!(res, err(displays_as(contains_substring("a.b.c() was false"))))
+    }
+
+    #[test]
+    fn supports_chained_method_calls() -> Result<()> {
+        struct Foo;
+        impl Foo {
+            fn b(self) -> Bar {
+                Bar
+            }
+        }
+        struct Bar;
+        impl Bar {
+            fn c(self) -> bool {
+                false
+            }
+        }
+
+        let a = Foo;
+        let res = verify_pred!(a.b().c());
+        verify_that!(res, err(displays_as(contains_substring("a.b().c() was false"))))?;
+
+        Ok(())
+    }
+}

googletest/tests/lib.rs

@@ -14,6 +14,7 @@
 
 mod all_matcher_test;
 mod any_matcher_test;
+mod assertions_test;
 mod colorized_diff_test;
 mod composition_test;
 mod elements_are_matcher_test;