Convert test helper into assert_hash_works

Author: webmaster128

packages/std/src/addresses.rs

@@ -399,7 +399,7 @@ fn hash(ty: &str, key: &[u8]) -> Vec<u8> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::HexBinary;
+    use crate::{assert_hash_works, HexBinary};
     use hex_literal::hex;
     use std::collections::HashSet;
 
@@ -651,7 +651,7 @@ mod tests {
     fn canonical_addr_implements_hash() {
         let alice = CanonicalAddr::from([0, 187, 61, 11, 250, 0]);
         let bob = CanonicalAddr::from([16, 21, 33, 0, 255, 9]);
-        crate::test_utils::check_hash_impl(alice, bob)
+        assert_hash_works!(alice, bob);
     }
 
     /// This requires Hash and Eq to be implemented

packages/std/src/binary.rs

@@ -238,6 +238,7 @@ impl<'de> de::Visitor<'de> for Base64Visitor {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::assert_hash_works;
     use crate::errors::StdError;
     use crate::serde::{from_slice, to_vec};
     use std::collections::HashSet;
@@ -513,7 +514,7 @@ mod tests {
     fn binary_implements_hash() {
         let a = Binary::from([0, 187, 61, 11, 250, 0]);
         let b = Binary::from([16, 21, 33, 0, 255, 9]);
-        crate::test_utils::check_hash_impl(a, b)
+        assert_hash_works!(a, b);
     }
 
     /// This requires Hash and Eq to be implemented

packages/std/src/hex_binary.rs

@@ -247,7 +247,7 @@ impl<'de> de::Visitor<'de> for HexVisitor {
 mod tests {
     use super::*;
 
-    use crate::{from_slice, to_vec, StdError};
+    use crate::{assert_hash_works, from_slice, to_vec, StdError};
     use std::collections::HashSet;
 
     #[test]
@@ -577,7 +577,7 @@ mod tests {
     fn hex_binary_implements_hash() {
         let a = HexBinary::from([0, 187, 61, 11, 250, 0]);
         let b = HexBinary::from([16, 21, 33, 0, 255, 9]);
-        crate::test_utils::check_hash_impl(a, b)
+        assert_hash_works!(a, b);
     }
 
     /// This requires Hash and Eq to be implemented

packages/std/src/lib.rs

@@ -121,10 +121,6 @@ pub use crate::imports::{ExternalApi, ExternalQuerier, ExternalStorage};
 #[cfg(not(target_arch = "wasm32"))]
 pub mod testing;
 
-// Internal testing utilities
-#[cfg(test)]
-mod test_utils;
-
 // Re-exports
 
 pub use cosmwasm_derive::entry_point;

packages/std/src/test_utils.rs

@@ -1,4 +1,6 @@
 use crate::{Decimal, Uint128};
+#[cfg(test)]
+use core::hash::{Hash, Hasher};
 use std::str::FromStr as _;
 
 /// Asserts that two expressions are approximately equal to each other.
@@ -21,6 +23,25 @@ macro_rules! assert_approx_eq {
     }};
 }
 
+/// Asserts that type `T` implements `Hash` trait correctly.
+///
+/// `left` and `right` must be unequal objects.
+///
+/// Some object pairs may produce the same hash causing test failure.
+/// In those cases try different objects. The test uses stable hasher
+/// so once working pair is identified, the test’s going to continue
+/// passing.
+#[macro_export]
+#[cfg(test)]
+macro_rules! assert_hash_works {
+    ($left:expr, $right:expr $(,)?) => {{
+        $crate::testing::assert_hash_works_impl($left, $right, None);
+    }};
+    ($left:expr, $right:expr, $($args:tt)+) => {{
+        $crate::testing::assert_hash_works_impl($left, $right, Some(format!($($args)*)));
+    }};
+}
+
 /// Implementation for the [`cosmwasm_std::assert_approx_eq`] macro. This does not provide any
 /// stability guarantees and may change any time.
 #[track_caller]
@@ -50,6 +71,45 @@ pub fn assert_approx_eq_impl<U: Into<Uint128>>(
     }
 }
 
+/// Tests that type `T` implements `Hash` trait correctly.
+///
+/// `left` and `right` must be unequal objects.
+///
+/// Some object pairs may produce the same hash causing test failure.
+/// In those cases try different objects. The test uses stable hasher
+/// so once working pair is identified, the test’s going to continue
+/// passing.
+#[track_caller]
+#[doc(hidden)]
+#[cfg(test)]
+pub fn assert_hash_works_impl<T: Clone + Hash>(left: T, right: T, panic_msg: Option<String>) {
+    fn hash(value: &impl Hash) -> u64 {
+        let mut hasher = crc32fast::Hasher::default();
+        value.hash(&mut hasher);
+        hasher.finish()
+    }
+
+    // Check clone
+    if hash(&left) != hash(&left.clone()) {
+        match panic_msg {
+            Some(panic_msg) => {
+                panic!("assertion failed: `hash(left) == hash(left.clone())`\n: {panic_msg}")
+            }
+            None => panic!("assertion failed: `hash(left) == hash(left.clone())`"),
+        }
+    }
+
+    // Check different object
+    if hash(&left) == hash(&right) {
+        match panic_msg {
+            Some(panic_msg) => {
+                panic!("assertion failed: `hash(left) != hash(right)`\n: {panic_msg}")
+            }
+            None => panic!("assertion failed: `hash(left) != hash(right)`"),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     #[test]

packages/std/src/testing/assertions.rs

@@ -8,6 +8,8 @@ mod mock;
 mod shuffle;
 
 pub use assertions::assert_approx_eq_impl;
+#[cfg(test)]
+pub use assertions::assert_hash_works_impl;
 
 #[cfg(feature = "cosmwasm_1_3")]
 pub use mock::DistributionQuerier;