Add support for googletest matchers.

Author: mgautierfr

rustest-testing/Cargo.toml

@@ -13,7 +13,8 @@ categories.workspace = true
 [dependencies]
 
 [dev-dependencies]
-rustest = { path = "../rustest" }
+googletest = "0.14.0"
+rustest = { path = "../rustest", features = ["googletest"] }
 
 
 [lib]

rustest-testing/src/lib.rs

@@ -9,13 +9,20 @@ pub fn add(left: u64, right: u64) -> u64 {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use googletest::prelude::*;
     use rustest::test;
 
     #[test]
     fn it_works() {
         let result = add(2, 2);
         assert!(result == 4);
     }
+
+    #[test]
+    fn it_works_with_gtest() {
+        let result = add(2, 2);
+        assert_that!(result, eq(4));
+    }
 }
 
 #[cfg(test)]

rustest-testing/src/other_mod.rs

@@ -5,6 +5,7 @@ pub fn addition(a: u32, b: u32) -> u32 {
 #[cfg(test)]
 pub(crate) mod tests {
     use super::*;
+    use googletest::prelude::*;
     use rustest::test;
 
     #[test(params:(u32, u32, u32)=[
@@ -13,7 +14,8 @@ pub(crate) mod tests {
         (598318, 54876521, 55474839)
     ])]
     fn test_addition_ok(Param((a, b, expected)): Param) {
-        assert_eq!(addition(a, b), expected);
+        expect_that!(addition(a, b), eq(expected));
+        expect_that!(addition(b, a), eq(expected));
     }
 
     #[test(params:(u32, u32, u32)=[
@@ -23,6 +25,6 @@ pub(crate) mod tests {
     ])]
     #[xfail]
     fn test_addition_fail(Param((a, b, expected)): Param) {
-        assert_eq!(addition(a, b), expected);
+        assert_that!(addition(a, b), eq(expected));
     }
 }

rustest/Cargo.toml

@@ -12,9 +12,13 @@ keywords.workspace = true
 
 [dependencies]
 ctor = { version = "0.4.1", features = ["__no_warn_on_missing_unsafe"] }
+googletest = { version = "0.14.0", optional = true }
 libtest-mimic = "0.8.1"
 rustest-macro = { version = "0.1.0", path = "../rustest-macro" }
 
+[features]
+googletest = ["dep:googletest"]
+
 [[test]]
 name = "test"
 harness = false

rustest/src/test.rs

@@ -1,10 +1,12 @@
+use core::fmt::Display;
 use libtest_mimic::Failed;
 use std::error::Error;
 
 /// Result of a test.
 pub type Result = std::result::Result<(), Box<dyn Error>>;
 
 #[doc(hidden)]
+
 pub struct InnerTestError {
     msg: String,
 }
@@ -21,6 +23,13 @@ impl Display for InnerTestError {
     }
 }
 
+#[cfg(feature = "googletest")]
+impl From<googletest::internal::test_outcome::TestFailure> for InnerTestError {
+    fn from(e: googletest::internal::test_outcome::TestFailure) -> Self {
+        Self { msg: e.to_string() }
+    }
+}
+
 /// The result of test runned by rustest.
 ///
 /// InnerTestResult is necessary as we are somehow between user (`Result`) and libtest_mimic (`LibTestResult`).
@@ -58,13 +67,42 @@ impl IntoError for Result {
     }
 }
 
+#[cfg(feature = "googletest")]
+impl<T> IntoError for googletest::Result<T> {
+    fn into_error(self) -> InnerTestResult {
+        self.map(|_v| ())
+            .map_err(|e| InnerTestError::new(e.to_string()))
+    }
+}
+
 /// An actual test run by rustest
 pub struct Test {
     name: String,
     runner: Box<dyn FnOnce() -> InnerTestResult + Send + std::panic::UnwindSafe>,
     xfail: bool,
 }
 
+fn setup_gtest() {
+    #[cfg(feature = "googletest")]
+    {
+        use googletest::internal::test_outcome::TestOutcome;
+        TestOutcome::init_current_test_outcome();
+    }
+}
+
+fn collect_gtest(test_result: InnerTestResult) -> InnerTestResult {
+    #[cfg(not(feature = "googletest"))]
+    {
+        test_result
+    }
+
+    #[cfg(feature = "googletest")]
+    {
+        use googletest::internal::test_outcome::TestOutcome;
+        TestOutcome::close_current_test_outcome(test_result).map_err(|e| e.into())
+    }
+}
+
 impl Test {
     /// Build a new test.
     pub fn new<F>(name: impl Into<String>, xfail: bool, runner: F) -> Self
@@ -78,6 +116,7 @@ impl Test {
         }
     }
     fn run(self) -> LibTestResult {
+        setup_gtest();
         let unwind_result = std::panic::catch_unwind(self.runner);
         let test_result = match unwind_result {
             Ok(Ok(())) => Ok(()),
@@ -92,6 +131,7 @@ impl Test {
                 Err(InnerTestError::new(payload))
             }
         };
+        let test_result = collect_gtest(test_result);
         if self.xfail {
             match test_result {
                 Ok(_) => Err("Test should fail".into()),