cosmwasm_std: remove dependency on DefaultHasher in tests

DefaultHasher is part of std module and is not available on no_std
builds.  Remove dependency on that type to pave the path for no_std
support.

This is done by adding test_utils::check_hash_impl helper function
which tests whether type implements Hash trait.  That function uses
crc32fast::Hasher instead of DefaultHasher thus eliminating need
for std.

Furthermore, Binary and HexBinary tests checking AsRef implementation
call AsRef::as_ref directly and explicitly check the result rather
than unnecessarily hashing the data.

As an added bonus, this diff has negative delta. \o/

Author: mina86

Cargo.lock

@@ -63,5 +63,6 @@ cosmwasm-crypto = { path = "../crypto", version = "1.3.0-rc.0" }
 cosmwasm-schema = { path = "../schema" }
 # The chrono dependency is only used in an example, which Rust compiles for us. If this causes trouble, remove it.
 chrono = { version = "0.4", default-features = false, features = ["alloc", "std"] }
+crc32fast = "1.3.2"
 hex-literal = "0.3.1"
 serde_json = "1.0.81"

packages/std/Cargo.toml

@@ -401,9 +401,7 @@ mod tests {
     use super::*;
     use crate::HexBinary;
     use hex_literal::hex;
-    use std::collections::hash_map::DefaultHasher;
     use std::collections::HashSet;
-    use std::hash::{Hash, Hasher};
 
     #[test]
     fn addr_unchecked_works() {
@@ -651,23 +649,9 @@ mod tests {
 
     #[test]
     fn canonical_addr_implements_hash() {
-        let alice1 = CanonicalAddr::from([0, 187, 61, 11, 250, 0]);
-        let mut hasher = DefaultHasher::new();
-        alice1.hash(&mut hasher);
-        let alice1_hash = hasher.finish();
-
-        let alice2 = CanonicalAddr::from([0, 187, 61, 11, 250, 0]);
-        let mut hasher = DefaultHasher::new();
-        alice2.hash(&mut hasher);
-        let alice2_hash = hasher.finish();
-
+        let alice = CanonicalAddr::from([0, 187, 61, 11, 250, 0]);
         let bob = CanonicalAddr::from([16, 21, 33, 0, 255, 9]);
-        let mut hasher = DefaultHasher::new();
-        bob.hash(&mut hasher);
-        let bob_hash = hasher.finish();
-
-        assert_eq!(alice1_hash, alice2_hash);
-        assert_ne!(alice1_hash, bob_hash);
+        crate::test_utils::check_hash_impl(alice, bob)
     }
 
     /// This requires Hash and Eq to be implemented

packages/std/src/addresses.rs

@@ -240,9 +240,7 @@ mod tests {
     use super::*;
     use crate::errors::StdError;
     use crate::serde::{from_slice, to_vec};
-    use std::collections::hash_map::DefaultHasher;
     use std::collections::HashSet;
-    use std::hash::{Hash, Hasher};
 
     #[test]
     fn encode_decode() {
@@ -505,51 +503,17 @@ mod tests {
 
     #[test]
     fn binary_implements_as_ref() {
-        // Can use as_ref (this we already get via the Deref implementation)
-        let data = Binary(vec![7u8, 35, 49, 101, 0, 255]);
-        assert_eq!(data.as_ref(), &[7u8, 35, 49, 101, 0, 255]);
-
-        let data = Binary(vec![7u8, 35, 49, 101, 0, 255]);
-        let data_ref = &data;
-        assert_eq!(data_ref.as_ref(), &[7u8, 35, 49, 101, 0, 255]);
-
-        // Implements as ref
-
-        // This is a dummy function to mimic the signature of
-        // https://docs.rs/sha2/0.10.6/sha2/trait.Digest.html#tymethod.digest
-        fn hash(data: impl AsRef<[u8]>) -> u64 {
-            let mut hasher = DefaultHasher::new();
-            data.as_ref().hash(&mut hasher);
-            hasher.finish()
-        }
-
-        let data = Binary(vec![7u8, 35, 49, 101, 0, 255]);
-        hash(data);
-
-        let data = Binary(vec![7u8, 35, 49, 101, 0, 255]);
-        let data_ref = &data;
-        hash(data_ref);
+        let want = &[7u8, 35, 49, 101, 0, 255];
+        let data = Binary(want.to_vec());
+        assert_eq!(want, AsRef::<[u8]>::as_ref(&data));
+        assert_eq!(want, AsRef::<[u8]>::as_ref(&&data));
     }
 
     #[test]
     fn binary_implements_hash() {
-        let a1 = Binary::from([0, 187, 61, 11, 250, 0]);
-        let mut hasher = DefaultHasher::new();
-        a1.hash(&mut hasher);
-        let a1_hash = hasher.finish();
-
-        let a2 = Binary::from([0, 187, 61, 11, 250, 0]);
-        let mut hasher = DefaultHasher::new();
-        a2.hash(&mut hasher);
-        let a2_hash = hasher.finish();
-
+        let a = Binary::from([0, 187, 61, 11, 250, 0]);
         let b = Binary::from([16, 21, 33, 0, 255, 9]);
-        let mut hasher = DefaultHasher::new();
-        b.hash(&mut hasher);
-        let b_hash = hasher.finish();
-
-        assert_eq!(a1_hash, a2_hash);
-        assert_ne!(a1_hash, b_hash);
+        crate::test_utils::check_hash_impl(a, b)
     }
 
     /// This requires Hash and Eq to be implemented

packages/std/src/binary.rs

@@ -248,9 +248,7 @@ mod tests {
     use super::*;
 
     use crate::{from_slice, to_vec, StdError};
-    use std::collections::hash_map::DefaultHasher;
     use std::collections::HashSet;
-    use std::hash::{Hash, Hasher};
 
     #[test]
     fn from_hex_works() {
@@ -569,51 +567,17 @@ mod tests {
 
     #[test]
     fn hex_binary_implements_as_ref() {
-        // Can use as_ref (this we already get via the Deref implementation)
-        let data = HexBinary(vec![7u8, 35, 49, 101, 0, 255]);
-        assert_eq!(data.as_ref(), &[7u8, 35, 49, 101, 0, 255]);
-
-        let data = HexBinary(vec![7u8, 35, 49, 101, 0, 255]);
-        let data_ref = &data;
-        assert_eq!(data_ref.as_ref(), &[7u8, 35, 49, 101, 0, 255]);
-
-        // Implements as ref
-
-        // This is a dummy function to mimic the signature of
-        // https://docs.rs/sha2/0.10.6/sha2/trait.Digest.html#tymethod.digest
-        fn hash(data: impl AsRef<[u8]>) -> u64 {
-            let mut hasher = DefaultHasher::new();
-            data.as_ref().hash(&mut hasher);
-            hasher.finish()
-        }
-
-        let data = HexBinary(vec![7u8, 35, 49, 101, 0, 255]);
-        hash(data);
-
-        let data = HexBinary(vec![7u8, 35, 49, 101, 0, 255]);
-        let data_ref = &data;
-        hash(data_ref);
+        let want = &[7u8, 35, 49, 101, 0, 255];
+        let data = HexBinary(want.to_vec());
+        assert_eq!(want, AsRef::<[u8]>::as_ref(&data));
+        assert_eq!(want, AsRef::<[u8]>::as_ref(&&data));
     }
 
     #[test]
     fn hex_binary_implements_hash() {
-        let a1 = HexBinary::from([0, 187, 61, 11, 250, 0]);
-        let mut hasher = DefaultHasher::new();
-        a1.hash(&mut hasher);
-        let a1_hash = hasher.finish();
-
-        let a2 = HexBinary::from([0, 187, 61, 11, 250, 0]);
-        let mut hasher = DefaultHasher::new();
-        a2.hash(&mut hasher);
-        let a2_hash = hasher.finish();
-
+        let a = HexBinary::from([0, 187, 61, 11, 250, 0]);
         let b = HexBinary::from([16, 21, 33, 0, 255, 9]);
-        let mut hasher = DefaultHasher::new();
-        b.hash(&mut hasher);
-        let b_hash = hasher.finish();
-
-        assert_eq!(a1_hash, a2_hash);
-        assert_ne!(a1_hash, b_hash);
+        crate::test_utils::check_hash_impl(a, b)
     }
 
     /// This requires Hash and Eq to be implemented

packages/std/src/hex_binary.rs

@@ -121,6 +121,10 @@ 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/lib.rs

@@ -0,0 +1,24 @@
+//! Module with common routines used internally by the library in unit tests.
+
+use core::hash::{Hash, Hasher};
+
+/// Tests that type `T` implements `Hash` trait correctly.
+///
+/// `foo` and `bar` must be different 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.
+pub(crate) fn check_hash_impl<T: Clone + Hash>(foo: T, bar: T) {
+    let foo_copy = foo.clone();
+
+    fn hash<T: Hash>(value: &T) -> u64 {
+        let mut hasher = crc32fast::Hasher::default();
+        value.hash(&mut hasher);
+        hasher.finish()
+    }
+
+    let foo_hash = hash(&foo);
+    assert_eq!(foo_hash, hash(&foo_copy));
+    assert_ne!(foo_hash, hash(&bar));
+}