build(rust): vendor googletest crate

third_party/crates/googletest-0.14.3/src/matchers/has_entry_matcher.rs

@@ -0,0 +1,178 @@
+// Copyright 2022 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.
+
+use crate::description::Description;
+use crate::matcher::{Matcher, MatcherBase, MatcherResult};
+use std::collections::HashMap;
+use std::fmt::Debug;
+use std::hash::Hash;
+
+/// Matches a `&HashMap` containing the given `key` whose value is matched by
+/// the matcher `inner`.
+///
+/// ```
+/// # use googletest::prelude::*;
+/// # use std::collections::HashMap;
+/// # fn should_pass() -> Result<()> {
+/// let value = HashMap::from([(0, 1), (1, -1)]);
+/// verify_that!(value, has_entry(0, eq(&1)))?;  // Passes
+/// #     Ok(())
+/// # }
+/// # fn should_fail_1() -> Result<()> {
+/// # let value = HashMap::from([(0, 1), (1, -1)]);
+/// verify_that!(value, has_entry(1, gt(&0)))?;  // Fails: value not matched
+/// #     Ok(())
+/// # }
+/// # fn should_fail_2() -> Result<()> {
+/// # let value = HashMap::from([(0, 1), (1, -1)]);
+/// verify_that!(value, has_entry(2, eq(&0)))?;  // Fails: key not present
+/// #     Ok(())
+/// # }
+/// # should_pass().unwrap();
+/// # should_fail_1().unwrap_err();
+/// # should_fail_2().unwrap_err();
+/// ```
+///
+/// Note: One could obtain the same effect by using `contains` and a
+/// `Matcher<(&Key, &Value)>`:
+///
+/// ```
+/// # use googletest::prelude::*;
+/// # use std::collections::HashMap;
+/// # fn should_pass() -> Result<()> {
+/// let value = HashMap::from([(0, 1), (1, -1)]);
+/// verify_that!(value, contains(eq((&0, &1))))?;
+/// #     Ok(())
+/// # }
+/// # should_pass().unwrap();
+/// ```
+pub fn has_entry<KeyT, MatcherT>(key: KeyT, inner: MatcherT) -> HasEntryMatcher<KeyT, MatcherT> {
+    HasEntryMatcher { key, inner }
+}
+
+#[derive(MatcherBase)]
+pub struct HasEntryMatcher<KeyT, MatcherT> {
+    key: KeyT,
+    inner: MatcherT,
+}
+
+impl<'a, KeyT: Debug + Eq + Hash, ValueT: Debug, MatcherT: Matcher<&'a ValueT>>
+    Matcher<&'a HashMap<KeyT, ValueT>> for HasEntryMatcher<KeyT, MatcherT>
+{
+    fn matches(&self, actual: &'a HashMap<KeyT, ValueT>) -> MatcherResult {
+        if let Some(value) = actual.get(&self.key) {
+            self.inner.matches(value)
+        } else {
+            MatcherResult::NoMatch
+        }
+    }
+
+    fn explain_match(&self, actual: &'a HashMap<KeyT, ValueT>) -> Description {
+        if let Some(value) = actual.get(&self.key) {
+            format!(
+                "which contains key {:?}, but is mapped to value {:#?}, {}",
+                self.key,
+                value,
+                self.inner.explain_match(value)
+            )
+            .into()
+        } else {
+            format!("which doesn't contain key {:?}", self.key).into()
+        }
+    }
+
+    fn describe(&self, matcher_result: MatcherResult) -> Description {
+        match matcher_result {
+            MatcherResult::Match => format!(
+                "contains key {:?}, which value {}",
+                self.key,
+                self.inner.describe(MatcherResult::Match)
+            )
+            .into(),
+            MatcherResult::NoMatch => format!(
+                "doesn't contain key {:?} or contains key {:?}, which value {}",
+                self.key,
+                self.key,
+                self.inner.describe(MatcherResult::NoMatch)
+            )
+            .into(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::prelude::*;
+    use crate::Result;
+    use indoc::indoc;
+    use std::collections::HashMap;
+
+    #[test]
+    fn has_entry_does_not_match_empty_hash_map() -> Result<()> {
+        let value: HashMap<i32, i32> = HashMap::new();
+        verify_that!(&value, not(has_entry(0, eq(&0))))
+    }
+
+    #[test]
+    fn has_entry_matches_hash_map_with_value() -> Result<()> {
+        let value: HashMap<i32, i32> = HashMap::from([(0, 0)]);
+        verify_that!(&value, has_entry(0, eq(&0)))
+    }
+
+    #[test]
+    fn has_entry_does_not_match_hash_map_with_wrong_value() -> Result<()> {
+        let value: HashMap<i32, i32> = HashMap::from([(0, 1)]);
+        verify_that!(&value, not(has_entry(0, eq(&0))))
+    }
+
+    #[test]
+    fn has_entry_does_not_match_hash_map_with_wrong_key() -> Result<()> {
+        let value: HashMap<i32, i32> = HashMap::from([(1, 0)]);
+        verify_that!(&value, not(has_entry(0, eq(&0))))
+    }
+
+    #[test]
+    fn has_entry_shows_correct_message_when_key_is_not_present() -> Result<()> {
+        let result = verify_that!(HashMap::from([(0, 0)]), has_entry(1, eq(&0)));
+
+        verify_that!(
+            result,
+            err(displays_as(contains_substring(indoc!(
+                "
+                Value of: HashMap::from([(0, 0)])
+                Expected: contains key 1, which value is equal to 0
+                Actual: {0: 0},
+                  which doesn't contain key 1
+                "
+            ))))
+        )
+    }
+
+    #[test]
+    fn has_entry_shows_correct_message_when_key_has_non_matching_value() -> Result<()> {
+        let result = verify_that!(HashMap::from([(0, 0)]), has_entry(0, eq(&1)));
+
+        verify_that!(
+            result,
+            err(displays_as(contains_substring(indoc!(
+                "
+                Value of: HashMap::from([(0, 0)])
+                Expected: contains key 0, which value is equal to 1
+                Actual: {0: 0},
+                  which contains key 0, but is mapped to value 0, which isn't equal to 1
+                "
+            ))))
+        )
+    }
+}