Merge pull request #88 from google:move-declarative-macro-tests

PiperOrigin-RevId: 517346494

Author: copybara-github

googletest/src/matchers/all_matcher.rs

@@ -157,40 +157,7 @@ mod tests {
         verify_that, Result,
     };
     use indoc::indoc;
-    use matchers::{contains_substring, displays_as, ends_with, eq, err, not, starts_with};
-
-    #[google_test]
-    fn matches_any_value_when_list_is_empty() -> Result<()> {
-        verify_that!((), all!())
-    }
-
-    #[google_test]
-    fn matches_value_with_single_matching_component() -> Result<()> {
-        verify_that!(123, all!(eq(123)))
-    }
-
-    #[google_test]
-    fn does_not_match_value_with_single_non_matching_component() -> Result<()> {
-        verify_that!(123, not(all!(eq(456))))
-    }
-
-    #[google_test]
-    fn matches_value_with_two_matching_components() -> Result<()> {
-        verify_that!("A string", all!(starts_with("A"), ends_with("string")))
-    }
-
-    #[google_test]
-    fn does_not_match_value_with_one_non_matching_component_among_two_components() -> Result<()> {
-        verify_that!(123, not(all!(eq(123), eq(456))))
-    }
-
-    #[google_test]
-    fn supports_trailing_comma() -> Result<()> {
-        verify_that!(
-            "An important string",
-            all!(starts_with("An"), contains_substring("important"), ends_with("string"),)
-        )
-    }
+    use matchers::{displays_as, ends_with, eq, starts_with};
 
     #[google_test]
     fn description_shows_more_than_one_matcher() -> Result<()> {
@@ -240,39 +207,4 @@ mod tests {
             displays_as(eq("which does not start with \"Another\""))
         )
     }
-
-    #[google_test]
-    fn mismatch_description_two_failed_matchers() -> Result<()> {
-        verify_that!(
-            all!(starts_with("One"), starts_with("Two")).explain_match("Three"),
-            displays_as(eq(
-                "\n  * which does not start with \"One\"\n  * which does not start with \"Two\""
-            ))
-        )
-    }
-
-    #[google_test]
-    fn mismatch_description_empty_matcher() -> Result<()> {
-        verify_that!(all!().explain_match("Three"), displays_as(eq("which is anything")))
-    }
-
-    #[google_test]
-    fn all_multiple_failed_assertions() -> Result<()> {
-        let result = verify_that!(4, all![eq(1), eq(2), eq(3)]);
-        verify_that!(
-            result,
-            err(displays_as(contains_substring(indoc!(
-                "
-                Value of: 4
-                Expected: has all the following properties:
-                  * is equal to 1
-                  * is equal to 2
-                  * is equal to 3
-                Actual: 4, 
-                  * which isn't equal to 1
-                  * which isn't equal to 2
-                  * which isn't equal to 3"
-            ))))
-        )
-    }
 }

googletest/src/matchers/elements_are_matcher.rs

@@ -153,112 +153,3 @@ pub mod internal {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    #[cfg(not(google3))]
-    use crate as googletest;
-    use googletest::matcher::Matcher;
-    #[cfg(not(google3))]
-    use googletest::matchers;
-    use googletest::{google_test, verify_that, Result};
-    use indoc::indoc;
-    use matchers::{contains_substring, displays_as, eq, err, not};
-
-    #[google_test]
-    fn elements_are_matches_vector() -> Result<()> {
-        let value = vec![1, 2, 3];
-        verify_that!(value, elements_are![eq(1), eq(2), eq(3)])
-    }
-
-    #[google_test]
-    fn elements_are_matches_slice() -> Result<()> {
-        let value = vec![1, 2, 3];
-        let slice = value.as_slice();
-        verify_that!(*slice, elements_are![eq(1), eq(2), eq(3)])
-    }
-
-    #[google_test]
-    fn elements_are_matches_array() -> Result<()> {
-        verify_that!([1, 2, 3], elements_are![eq(1), eq(2), eq(3)])
-    }
-
-    #[google_test]
-    fn elements_are_supports_trailing_comma() -> Result<()> {
-        let value = vec![1, 2, 3];
-        verify_that!(value, elements_are![eq(1), eq(2), eq(3),])
-    }
-
-    #[google_test]
-    fn elements_are_returns_no_match_when_expected_and_actual_sizes_differ() -> Result<()> {
-        let value = vec![1, 2];
-        verify_that!(value, not(elements_are![eq(1), eq(2), eq(3)]))
-    }
-
-    #[google_test]
-    fn elements_are_produces_correct_failure_message() -> Result<()> {
-        let result = verify_that!(vec![1, 4, 3], elements_are![eq(1), eq(2), eq(3)]);
-        verify_that!(
-            result,
-            err(displays_as(contains_substring(indoc!(
-                "
-                Value of: vec![1, 4, 3]
-                Expected: has elements:
-                  0. is equal to 1
-                  1. is equal to 2
-                  2. is equal to 3
-                Actual: [
-                    1,
-                    4,
-                    3,
-                ], where element #1 is 4, which isn't equal to 2"
-            ))))
-        )
-    }
-
-    #[google_test]
-    fn elements_are_produces_correct_failure_message_nested() -> Result<()> {
-        let result = verify_that!(
-            vec![vec![0, 1], vec![1, 2]],
-            elements_are![elements_are![eq(1), eq(2)], elements_are![eq(2), eq(3)]]
-        );
-        verify_that!(
-            result,
-            err(displays_as(contains_substring(indoc!(
-                "
-                Value of: vec![vec! [0, 1], vec! [1, 2]]
-                Expected: has elements:
-                  0. has elements:
-                       0. is equal to 1
-                       1. is equal to 2
-                  1. has elements:
-                       0. is equal to 2
-                       1. is equal to 3
-                Actual: [
-                    [
-                        0,
-                        1,
-                    ],
-                    [
-                        1,
-                        2,
-                    ],
-                ], where:
-                  * element #0 is [0, 1], where:
-                      * element #0 is 0, which isn't equal to 1
-                      * element #1 is 1, which isn't equal to 2
-                  * element #1 is [1, 2], where:
-                      * element #0 is 1, which isn't equal to 2
-                      * element #1 is 2, which isn't equal to 3"
-            ))))
-        )
-    }
-
-    #[google_test]
-    fn elements_are_explain_match_wrong_size() -> Result<()> {
-        verify_that!(
-            elements_are![eq(1)].explain_match(&vec![1, 2]),
-            displays_as(eq("whose size is 2"))
-        )
-    }
-}

googletest/src/matchers/field_matcher.rs

@@ -165,137 +165,3 @@ pub mod internal {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    #[cfg(not(google3))]
-    use crate as googletest;
-    use googletest::matcher::{Matcher, MatcherResult};
-    #[cfg(not(google3))]
-    use googletest::matchers;
-    use googletest::{google_test, verify_that, Result};
-    use matchers::{container_eq, contains_substring, displays_as, eq, err, not};
-
-    #[derive(Debug)]
-    struct IntField {
-        int: i32,
-    }
-
-    #[google_test]
-    fn field_matches_integer_field() -> Result<()> {
-        verify_that!(IntField { int: 32 }, field!(IntField.int, eq(32)))
-    }
-
-    #[derive(Debug)]
-    struct StringField {
-        strink: String,
-    }
-
-    #[google_test]
-    fn field_matches_string_field() -> Result<()> {
-        verify_that!(
-            StringField { strink: "yes".to_string() },
-            field!(StringField.strink, eq("yes"))
-        )
-    }
-
-    #[google_test]
-    fn field_error_message_shows_field_name_and_inner_matcher() -> Result<()> {
-        let matcher = field!(IntField.int, eq(31));
-
-        verify_that!(
-            matcher.describe(MatcherResult::Matches),
-            eq("has field `int`, which is equal to 31")
-        )
-    }
-
-    mod sub {
-        #[derive(Debug)]
-        pub struct SubStruct {
-            pub field: i32,
-        }
-    }
-
-    #[google_test]
-    fn struct_in_other_module_matches() -> Result<()> {
-        verify_that!(sub::SubStruct { field: 32 }, field!(sub::SubStruct.field, eq(32)))
-    }
-
-    #[derive(Debug)]
-    struct Tuple(i32, String);
-
-    #[google_test]
-    fn tuple_matches_with_index() -> Result<()> {
-        verify_that!(Tuple(32, "yes".to_string()), field!(Tuple.0, eq(32)))
-    }
-
-    #[google_test]
-    fn matches_enum_value() -> Result<()> {
-        #[derive(Debug)]
-        enum AnEnum {
-            AValue(u32),
-        }
-        let value = AnEnum::AValue(123);
-
-        verify_that!(value, field!(AnEnum::AValue.0, eq(123)))
-    }
-
-    #[google_test]
-    fn shows_correct_failure_message_for_wrong_struct_entry() -> Result<()> {
-        #[derive(Debug)]
-        struct AStruct {
-            a: Vec<u32>,
-        }
-        let value = AStruct { a: vec![1] };
-
-        let result = verify_that!(value, field!(AStruct.a, container_eq([])));
-
-        verify_that!(
-            result,
-            err(displays_as(contains_substring(
-                "which has field `a`, which contains the unexpected element 1"
-            )))
-        )
-    }
-
-    #[google_test]
-    fn does_not_match_enum_value_with_wrong_enum_variant() -> Result<()> {
-        #[derive(Debug)]
-        enum AnEnum {
-            #[allow(dead_code)] // This variant is intentionally unused.
-            AValue(u32),
-            AnotherValue,
-        }
-        let value = AnEnum::AnotherValue;
-
-        verify_that!(value, not(field!(AnEnum::AValue.0, eq(123))))
-    }
-
-    #[google_test]
-    fn shows_correct_failure_message_for_wrong_enum_value() -> Result<()> {
-        #[derive(Debug)]
-        enum AnEnum {
-            #[allow(dead_code)] // This variant is intentionally unused.
-            AValue {
-                a: u32,
-            },
-            AnotherValue,
-        }
-        let value = AnEnum::AnotherValue;
-
-        let result = verify_that!(value, field!(AnEnum::AValue.a, eq(123)));
-
-        verify_that!(result, err(displays_as(contains_substring("which has no field `a`"))))
-    }
-
-    #[google_test]
-    fn matches_struct_like_enum_value() -> Result<()> {
-        #[derive(Debug)]
-        enum AnEnum {
-            AValue { a_field: u32 },
-        }
-        let value = AnEnum::AValue { a_field: 123 };
-
-        verify_that!(value, field!(AnEnum::AValue.a_field, eq(123)))
-    }
-}

googletest/src/matchers/mod.rs

@@ -134,4 +134,4 @@ pub use superset_of_matcher::superset_of;
 #[cfg(google3)]
 pub use tuple_matcher::tuple;
 #[cfg(google3)]
-pub use unordered_elements_are_matcher::{contains_each, unordered_elements_are};
+pub use unordered_elements_are_matcher::{contains_each, is_contained_in, unordered_elements_are};