PUBLIC: expect less or equal family of assertions.

Rust flavours for:[]

* `verify_lt`: verify if `actual` is **less than or equal to** `expected` and return `Result`.
* `assert_lt`: exists in rust: https://docs.rs/all_asserts/latest/all_asserts/macro.assert_le.html
* `expect_lt`: **logs failure** and **continue execution** if `actual` is **greater** than `expected`.

PiperOrigin-RevId: 647676022

Author: satylogin

googletest/src/assertions.rs

@@ -334,7 +334,7 @@ macro_rules! succeed {
 ///
 /// This can only be invoked inside tests with the
 /// [`googletest::test`][crate::test] attribute. The failure must be generated
-/// in the same thread as that running the thread itself.
+/// in the same thread as that running the test itself.
 ///
 /// ```ignore
 /// use googletest::prelude::*;
@@ -377,7 +377,7 @@ macro_rules! add_failure {
 ///
 /// This can only be invoked inside tests with the
 /// [`googletest::test`][crate::test] attribute. The failure must be generated
-/// in the same thread as that running the thread itself.
+/// in the same thread as that running the test itself.
 ///
 /// ```ignore
 /// use googletest::prelude::*;
@@ -456,7 +456,7 @@ macro_rules! verify_true {
 ///
 /// This can only be invoked inside tests with the
 /// [`googletest::test`][crate::test] attribute. The failure must be generated
-/// in the same thread as that running the thread itself.
+/// in the same thread as that running the test itself.
 ///
 /// Example:
 /// ```ignore
@@ -482,7 +482,7 @@ macro_rules! assert_true {
 ///
 /// This can only be invoked inside tests with the
 /// [`googletest::test`][crate::test] attribute. The failure must be generated
-/// in the same thread as that running the thread itself.
+/// in the same thread as that running the test itself.
 ///
 /// Example:
 /// ```ignore
@@ -541,7 +541,7 @@ macro_rules! verify_false {
 ///
 /// This can only be invoked inside tests with the
 /// [`googletest::test`][crate::test] attribute. The failure must be generated
-/// in the same thread as that running the thread itself.
+/// in the same thread as that running the test itself.
 ///
 /// Example:
 /// ```ignore
@@ -567,7 +567,7 @@ macro_rules! assert_false {
 ///
 /// This can only be invoked inside tests with the
 /// [`googletest::test`][crate::test] attribute. The failure must be generated
-/// in the same thread as that running the thread itself.
+/// in the same thread as that running the test itself.
 ///
 /// Example:
 /// ```ignore
@@ -637,7 +637,7 @@ macro_rules! verify_eq {
 ///
 /// This can only be invoked inside tests with the
 /// [`googletest::test`][crate::test] attribute. The failure must be generated
-/// in the same thread as that running the thread itself.
+/// in the same thread as that running the test itself.
 ///
 /// Example:
 /// ```ignore
@@ -701,7 +701,7 @@ macro_rules! assert_eq {
 ///
 /// This can only be invoked inside tests with the
 /// [`googletest::test`][crate::test] attribute. The failure must be generated
-/// in the same thread as that running the thread itself.
+/// in the same thread as that running the test itself.
 ///
 /// Example:
 /// ```ignore
@@ -805,7 +805,7 @@ macro_rules! verify_ne {
 ///
 /// This can only be invoked inside tests with the
 /// [`googletest::test`][crate::test] attribute. The failure must be generated
-/// in the same thread as that running the thread itself.
+/// in the same thread as that running the test itself.
 ///
 /// Example:
 /// ```ignore
@@ -883,7 +883,7 @@ macro_rules! verify_lt {
 ///
 /// This can only be invoked inside tests with the
 /// [`googletest::test`][crate::test] attribute. The failure must be generated
-/// in the same thread as that running the thread itself.
+/// in the same thread as that running the test itself.
 ///
 /// Example:
 /// ```ignore
@@ -921,6 +921,85 @@ macro_rules! expect_lt {
     };
 }
 
+/// Checks whether the first argument is less than or equal to the second
+/// argument.
+///
+/// Evaluates to `Result::Ok(())` if the first argument is less than or equal to
+/// the second and `Result::Err(TestAssertionFailure)` if it is greater. The
+/// caller must then decide how to handle the `Err` variant. It has a few
+/// options:
+///  * Abort the current function with the `?` operator. This requires that the
+///    function return a suitable `Result`.
+///  * Log the test failure and continue by calling the method
+///    `and_log_failure`.
+///
+/// Of course, one can also use all other standard methods on `Result`.
+///
+/// **Invoking this macro by itself does not cause a test failure to be recorded
+/// or output.** The resulting `Result` must be handled as described above to
+/// cause the test to be recorded as a failure.
+///
+/// Example:
+/// ```ignore
+/// use googletest::prelude::*;
+///
+/// #[test]
+/// fn should_fail() -> Result<()> {
+///     verify_le!(2, 1)
+/// }
+#[macro_export]
+macro_rules! verify_le {
+    ($actual:expr, $expected:expr $(,)?) => {
+        verify_that!($actual, $crate::matchers::le($expected))
+    };
+}
+
+/// Marks test as failed and continues execution if the first argument is
+/// greater than the second argument.
+///
+/// This is a **not-fatal** failure. The test continues execution even after the
+/// macro execution.
+///
+/// This can only be invoked inside tests with the
+/// [`googletest::test`][crate::test] attribute. The failure must be generated
+/// in the same thread as that running the test itself.
+///
+/// Example:
+/// ```ignore
+/// use googletest::prelude::*;
+///
+/// #[googletest::test]
+/// fn should_fail() {
+///     expect_le!(2, 1);
+///     println!("This will print!");
+/// }
+/// ```
+///
+/// One may include formatted arguments in the failure message:
+///```ignore
+/// use googletest::prelude::*;
+///
+/// #[googletest::test]
+/// fn should_fail() {
+///     let argument = "argument"
+///     expect_le!(2, 1, "custom failure message: {argument}");
+///     println!("This will print!");
+/// }
+/// ```
+#[macro_export]
+macro_rules! expect_le {
+    ($actual:expr, $expected:expr, $($format_args:expr),+ $(,)?) => {
+        use $crate::GoogleTestSupport;
+        verify_le!($actual, $expected)
+            .with_failure_message(|| format!($($format_args),*))
+            .and_log_failure();
+    };
+    ($actual:expr, $expected:expr $(,)?) => {
+        use $crate::GoogleTestSupport;
+        verify_le!($actual, $expected).and_log_failure();
+    };
+}
+
 /// Matches the given value against the given matcher, panicking if it does not
 /// match.
 ///

googletest/src/lib.rs

@@ -51,8 +51,9 @@ pub mod prelude {
     // Assert macros
     pub use super::{
         add_failure, add_failure_at, assert_false, assert_that, assert_true, expect_eq,
-        expect_false, expect_lt, expect_ne, expect_pred, expect_that, expect_true, fail, succeed,
-        verify_eq, verify_false, verify_lt, verify_ne, verify_pred, verify_that, verify_true,
+        expect_false, expect_le, expect_lt, expect_ne, expect_pred, expect_that, expect_true, fail,
+        succeed, verify_eq, verify_false, verify_le, verify_lt, verify_ne, verify_pred,
+        verify_that, verify_true,
     };
 }
 

integration_tests/Cargo.toml

@@ -285,6 +285,21 @@ name = "failure_due_to_returned_error"
 path = "src/failure_due_to_returned_error.rs"
 test = false
 
+[[bin]]
+name = "verify_le_when_greater_returns_error"
+path = "src/verify_le_when_greater_returns_error.rs"
+test = false
+
+[[bin]]
+name = "expect_le_when_greater_marks_failed"
+path = "src/expect_le_when_greater_marks_failed.rs"
+test = false
+
+[[bin]]
+name = "expect_le_supports_custom_message"
+path = "src/expect_le_supports_custom_message.rs"
+test = false
+
 [[bin]]
 name = "failure_due_to_returned_error_with_line_numbers"
 path = "src/failure_due_to_returned_error_with_line_numbers.rs"

integration_tests/src/expect_le_supports_custom_message.rs

@@ -0,0 +1,24 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+fn main() {}
+#[cfg(test)]
+mod tests {
+    use googletest::prelude::*;
+    #[googletest::test]
+    fn should_fail() {
+        let arg = "argument";
+        expect_le!(2, 1, "Failure message with argument: {arg}");
+        println!("This will print");
+    }
+}

integration_tests/src/expect_le_when_greater_marks_failed.rs

@@ -0,0 +1,26 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+fn main() {}
+
+#[cfg(test)]
+mod tests {
+    use googletest::prelude::*;
+
+    #[googletest::test]
+    fn should_fail() {
+        expect_le!(2, 1);
+        println!("This will print");
+    }
+}

integration_tests/src/integration_tests.rs

@@ -1414,6 +1414,76 @@ mod tests {
         verify_that!(output, contains_regex("This will print"))
     }
 
+    #[test]
+    fn verify_le_should_pass() -> Result<()> {
+        verify_le!(1, 1)
+    }
+
+    #[test]
+    fn verify_le_supports_trailing_comma() -> Result<()> {
+        verify_le!(1, 2,)
+    }
+
+    #[test]
+    fn verify_le_when_greater_returns_error() -> Result<()> {
+        let output =
+            run_external_process_in_tests_directory("verify_le_when_greater_returns_error")?;
+
+        verify_that!(
+            output,
+            contains_regex(indoc! {"
+                Expected: is less than or equal to 1
+                Actual: 2,
+                  which is greater than 1
+                  at .*verify_le_when_greater_returns_error.rs:[0-9]+:[0-9]
+            "})
+        )
+    }
+
+    #[googletest::test]
+    fn expect_le_should_pass() {
+        expect_le!(1, 1);
+    }
+
+    #[googletest::test]
+    fn expect_le_supports_trailing_comma() {
+        expect_le!(1, 2,);
+    }
+
+    #[googletest::test]
+    fn expect_le_when_greater_marks_failed() -> Result<()> {
+        let output =
+            run_external_process_in_tests_directory("expect_le_when_greater_marks_failed")?;
+
+        expect_that!(
+            output,
+            contains_regex(indoc! {"
+                Expected: is less than or equal to 1
+                Actual: 2,
+                  which is greater than 1
+                  at .*expect_le_when_greater_marks_failed.rs:[0-9]+:[0-9]
+            "})
+        );
+        verify_that!(output, contains_regex("This will print"))
+    }
+
+    #[googletest::test]
+    fn expect_le_supports_custom_message() -> Result<()> {
+        let output = run_external_process_in_tests_directory("expect_le_supports_custom_message")?;
+
+        expect_that!(
+            output,
+            contains_regex(indoc! {"
+                Expected: is less than or equal to 1
+                Actual: 2,
+                  which is greater than 1
+                Failure message with argument: argument
+                  at .*expect_le_supports_custom_message.rs:[0-9]+:[0-9]
+            "})
+        );
+        verify_that!(output, contains_regex("This will print"))
+    }
+
     #[test]
     fn test_using_normal_test_attribute_macro_formats_failure_message_correctly() -> Result<()> {
         let result = should_display_error_correctly_without_google_test_macro();

integration_tests/src/verify_le_when_greater_returns_error.rs

@@ -0,0 +1,25 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+fn main() {}
+
+#[cfg(test)]
+mod tests {
+    use googletest::prelude::*;
+
+    #[test]
+    fn should_fail() -> Result<()> {
+        verify_le!(2, 1)
+    }
+}

run_integration_tests.sh

@@ -74,6 +74,9 @@ INTEGRATION_TEST_BINARIES=(
   "verify_lt_when_not_less_returns_error"
   "expect_lt_when_not_less_marks_failed"
   "expect_lt_supports_custom_message"
+  "verify_le_when_greater_returns_error"
+  "expect_le_when_greater_marks_failed"
+  "expect_le_supports_custom_message"
   "fatal_and_non_fatal_failure"
   "first_failure_aborts"
   "google_test_with_rstest"