Merge rust-bitcoin/rust-bitcoin#3204: Do many cleanups (and bug fix)

dae42bef9d do not enable bitcoin-io by default (Antoni Spaanderman)
a14cdaf859 don't enable std by default when testing (Antoni Spaanderman)
e83830dcfc use slice instead of array to not have to hardcode the length (Antoni Spaanderman)
55749d6f61 use `hash.to_byte_array` to check equality with `test.output` (Antoni Spaanderman)
969864e3b0 use fixed size array if possible, otherwise `&'static [u8]` (Antoni Spaanderman)
28ccf70fa6 remove unnecesarry borrow operator (`&`) (Antoni Spaanderman)
fa3a3afd02 remove unnecessary slicing (Antoni Spaanderman)
22e42ab86c fix test code being unnecessarily feature gated (Antoni Spaanderman)

Pull request description:

  - remove 2 unnecessary cfg attributes from tests left over from  #3167 (it made them not dependent on `alloc` anymore)
  - simplify assertion logic by removing unnecessary conversions before comparing
  - make tests `no_std` compatible by adding imports to alloc or std
  - feature gate tests behind the `alloc` feature if they use anything from the alloc crate (like the `format!` macro)
  - `schemars` feature enables `alloc` because (for example) its trait wants implementations to return `String`
  - fix `bitcoin-io` always enabling when `std` is enabled (only useful if people depend on `hashes` only, `bitcoin` depends on `bitcoin-io` already)

ACKs for top commit:
  tcharding:
    ACK dae42bef9d
  Kixunil:
    ACK dae42bef9d
  apoelstra:
    ACK dae42bef9d successfully ran local tests

Tree-SHA512: 622fd4963ef21530a98af89bcfc71abe8723aac12d363ab88d9bd30dcf2f75392711bec10e2901fab5f1a30e11897d1aae36e22892738aa1e5670166f91fddd4

bitcoin/src/pow.rs

@@ -1928,7 +1928,7 @@ mod tests {
     #[test]
     fn work_log2() {
         // Compare work log2 to historical Bitcoin Core values found in Core logs.
-        let tests: [(u128, f64); 5] = [
+        let tests: &[(u128, f64)] = &[
             // (chainwork, core log2)                // height
             (0x200020002, 33.000022),                // 1
             (0xa97d67041c5e51596ee7, 79.405055),     // 308004
@@ -1937,7 +1937,7 @@ mod tests {
             (0x2ef447e01d1642c40a184ada, 93.553183), // 738965
         ];
 
-        for (chainwork, core_log2) in tests {
+        for &(chainwork, core_log2) in tests {
             // Core log2 in the logs is rounded to 6 decimal places.
             let log2 = (Work::from(chainwork).log2() * 1e6).round() / 1e6;
             assert_eq!(log2, core_log2)

hashes/Cargo.toml

@@ -15,8 +15,9 @@ exclude = ["tests", "contrib"]
 
 [features]
 default = ["std"]
-std = ["alloc", "hex/std", "bitcoin-io/std"]
+std = ["alloc", "hex/std", "bitcoin-io?/std"]
 alloc = ["hex/alloc"]
+schemars = ["dep:schemars", "alloc"]
 # If you want I/O you must enable either "std" or "io".
 io = ["bitcoin-io"]
 # Smaller (but slower) implementation of sha256, sha512 and ripemd160

hashes/src/hash160.rs

@@ -51,11 +51,12 @@ mod tests {
     #[test]
     #[cfg(feature = "alloc")]
     fn test() {
+        use alloc::string::ToString;
+
         use super::Hash;
         use crate::{hash160, HashEngine};
 
         #[derive(Clone)]
-        #[cfg(feature = "alloc")]
         struct Test {
             input: [u8; 65],
             output: [u8; 20],
@@ -89,8 +90,8 @@ mod tests {
             // Hash through high-level API, check hex encoding/decoding
             let hash = hash160::Hash::hash(&test.input[..]);
             assert_eq!(hash, test.output_str.parse::<hash160::Hash>().expect("parse hex"));
-            assert_eq!(&hash[..], &test.output[..]);
+            assert_eq!(hash[..], test.output);
-            assert_eq!(&hash.to_string(), &test.output_str);
+            assert_eq!(hash.to_string(), test.output_str);
 
             // Hash through engine, checking that we can input byte by byte
             let mut engine = hash160::Hash::engine();
@@ -99,7 +100,7 @@ mod tests {
             }
             let manual_hash = Hash::from_engine(engine);
             assert_eq!(hash, manual_hash);
-            assert_eq!(hash.to_byte_array()[..].as_ref(), test.output.as_slice());
+            assert_eq!(hash.to_byte_array(), test.output);
         }
     }
 

hashes/src/hkdf.rs

@@ -5,9 +5,9 @@
 //! Implementation based on RFC5869, but the interface is scoped
 //! to BIP324's requirements.
 
-#[cfg(all(feature = "alloc", not(feature = "std")))]
+#[cfg(feature = "alloc")]
 use alloc::vec;
-#[cfg(all(feature = "alloc", not(feature = "std")))]
+#[cfg(feature = "alloc")]
 use alloc::vec::Vec;
 use core::fmt;
 

hashes/src/hmac.rs

@@ -23,7 +23,7 @@ pub struct Hmac<T: GeneralHash>(T);
 impl<T: GeneralHash + schemars::JsonSchema> schemars::JsonSchema for Hmac<T> {
     fn is_referenceable() -> bool { <T as schemars::JsonSchema>::is_referenceable() }
 
-    fn schema_name() -> std::string::String { <T as schemars::JsonSchema>::schema_name() }
+    fn schema_name() -> alloc::string::String { <T as schemars::JsonSchema>::schema_name() }
 
     fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
         <T as schemars::JsonSchema>::json_schema(gen)
@@ -164,15 +164,14 @@ impl<'de, T: GeneralHash + Deserialize<'de>> Deserialize<'de> for Hmac<T> {
 #[cfg(test)]
 mod tests {
     #[test]
-    #[cfg(feature = "alloc")]
     fn test() {
         use crate::{sha256, GeneralHash as _, Hash as _, HashEngine, Hmac, HmacEngine};
 
         #[derive(Clone)]
-        struct Test<'a> {
+        struct Test {
-            key: &'a [u8],
+            key: &'static [u8],
-            input: &'a [u8],
+            input: &'static [u8],
-            output: &'a [u8],
+            output: [u8; 32],
         }
 
         #[rustfmt::skip]
@@ -181,9 +180,9 @@ mod tests {
             // Sadly the RFC2104 test vectors all use MD5 as their underlying hash function,
             // which of course this library does not support.
             Test {
-                key: &[ 0x0b; 20],
+                key: &[ 0x0b; 20 ],
-                input: &[0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65],
+                input: &[ 0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65 ],
-                output: &[
+                output: [
                     0xb0, 0x34, 0x4c, 0x61, 0xd8, 0xdb, 0x38, 0x53,
                     0x5c, 0xa8, 0xaf, 0xce, 0xaf, 0x0b, 0xf1, 0x2b,
                     0x88, 0x1d, 0xc2, 0x00, 0xc9, 0x83, 0x3d, 0xa7,
@@ -198,7 +197,7 @@ mod tests {
                     0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68,
                     0x69, 0x6e, 0x67, 0x3f,
                 ],
-                output: &[
+                output: [
                     0x5b, 0xdc, 0xc1, 0x46, 0xbf, 0x60, 0x75, 0x4e,
                     0x6a, 0x04, 0x24, 0x26, 0x08, 0x95, 0x75, 0xc7,
                     0x5a, 0x00, 0x3f, 0x08, 0x9d, 0x27, 0x39, 0x83,
@@ -208,7 +207,7 @@ mod tests {
             Test {
                 key: &[ 0xaa; 20 ],
                 input: &[ 0xdd; 50 ],
-                output: &[
+                output: [
                     0x77, 0x3e, 0xa9, 0x1e, 0x36, 0x80, 0x0e, 0x46,
                     0x85, 0x4d, 0xb8, 0xeb, 0xd0, 0x91, 0x81, 0xa7,
                     0x29, 0x59, 0x09, 0x8b, 0x3e, 0xf8, 0xc1, 0x22,
@@ -223,7 +222,7 @@ mod tests {
                     0x19
                 ],
                 input: &[ 0xcd; 50 ],
-                output: &[
+                output: [
                     0x82, 0x55, 0x8a, 0x38, 0x9a, 0x44, 0x3c, 0x0e,
                     0xa4, 0xcc, 0x81, 0x98, 0x99, 0xf2, 0x08, 0x3a,
                     0x85, 0xf0, 0xfa, 0xa3, 0xe5, 0x78, 0xf8, 0x07,
@@ -241,7 +240,7 @@ mod tests {
                     0x48, 0x61, 0x73, 0x68, 0x20, 0x4b, 0x65, 0x79,
                     0x20, 0x46, 0x69, 0x72, 0x73, 0x74,
                 ],
-                output: &[
+                output: [
                     0x60, 0xe4, 0x31, 0x59, 0x1e, 0xe0, 0xb6, 0x7f,
                     0x0d, 0x8a, 0x26, 0xaa, 0xcb, 0xf5, 0xb7, 0x7f,
                     0x8e, 0x0b, 0xc6, 0x21, 0x37, 0x28, 0xc5, 0x14,
@@ -271,7 +270,7 @@ mod tests {
                     0x20, 0x48, 0x4d, 0x41, 0x43, 0x20, 0x61, 0x6c,
                     0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x2e,
                 ],
-                output: &[
+                output: [
                     0x9b, 0x09, 0xff, 0xa7, 0x1b, 0x94, 0x2f, 0xcb,
                     0x27, 0x63, 0x5f, 0xbc, 0xd5, 0xb0, 0xe9, 0x44,
                     0xbf, 0xdc, 0x63, 0x64, 0x4f, 0x07, 0x13, 0x93,
@@ -285,7 +284,7 @@ mod tests {
             engine.input(test.input);
             let hash = Hmac::<sha256::Hash>::from_engine(engine);
             assert_eq!(hash.as_ref(), test.output);
-            assert_eq!(hash.as_byte_array(), test.output);
+            assert_eq!(hash.to_byte_array(), test.output);
         }
     }
 

hashes/src/impls.rs

@@ -81,8 +81,10 @@ impl_write!(
     T: crate::GeneralHash
 );
 
-#[cfg(test)]
+#[cfg(all(test, feature = "alloc"))] // right now every test here depends on `alloc`
 mod tests {
+    use alloc::format;
+
     use bitcoin_io::Write;
 
     use crate::{

hashes/src/internal_macros.rs

@@ -224,9 +224,17 @@ macro_rules! hash_type_no_default {
 
         #[cfg(feature = "schemars")]
         impl schemars::JsonSchema for Hash {
-            fn schema_name() -> String { "Hash".to_owned() }
+            fn schema_name() -> alloc::string::String {
+                use alloc::borrow::ToOwned;
+
+                "Hash".to_owned()
+            }
 
             fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
+                use alloc::borrow::ToOwned;
+                use alloc::boxed::Box;
+                use alloc::string::String;
+
                 let len = $bits / 8;
                 let mut schema: schemars::schema::SchemaObject = <String>::json_schema(gen).into();
                 schema.string = Some(Box::new(schemars::schema::StringValidation {

hashes/src/lib.rs

@@ -62,7 +62,7 @@
 //! # fn main() {}
 //! ```
 
-#![cfg_attr(all(not(test), not(feature = "std")), no_std)]
+#![cfg_attr(not(feature = "std"), no_std)]
 // Experimental features we need.
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
 #![cfg_attr(bench, feature(test))]
@@ -75,9 +75,9 @@
 #![allow(clippy::manual_range_contains)] // More readable than clippy's format.
 #![allow(clippy::needless_borrows_for_generic_args)] // https://github.com/rust-lang/rust-clippy/issues/12454
 
-#[cfg(all(feature = "alloc", not(feature = "std")))]
+#[cfg(feature = "alloc")]
 extern crate alloc;
-#[cfg(any(test, feature = "std"))]
+
 extern crate core;
 
 #[cfg(feature = "bitcoin-io")]
@@ -334,16 +334,19 @@ mod tests {
         struct TestNewtype2(sha256d::Hash);
     }
 
-    #[rustfmt::skip]
-    const DUMMY: TestNewtype = TestNewtype::from_byte_array([
-        0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x78, 0x89,
-        0x13, 0x24, 0x35, 0x46, 0x57, 0x68, 0x79, 0x8a,
-        0x14, 0x25, 0x36, 0x47, 0x58, 0x69, 0x7a, 0x8b,
-        0x15, 0x26, 0x37, 0x48, 0x59, 0x6a, 0x7b, 0x8c,
-    ]);
-
     #[test]
+    #[cfg(feature = "alloc")]
     fn newtype_fmt_roundtrip() {
+        use alloc::format;
+
+        #[rustfmt::skip]
+        const DUMMY: TestNewtype = TestNewtype::from_byte_array([
+            0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x78, 0x89,
+            0x13, 0x24, 0x35, 0x46, 0x57, 0x68, 0x79, 0x8a,
+            0x14, 0x25, 0x36, 0x47, 0x58, 0x69, 0x7a, 0x8b,
+            0x15, 0x26, 0x37, 0x48, 0x59, 0x6a, 0x7b, 0x8c,
+        ]);
+
         let orig = DUMMY;
         let hex = format!("{}", orig);
         let rinsed = hex.parse::<TestNewtype>().expect("failed to parse hex");

hashes/src/ripemd160.rs

@@ -413,6 +413,8 @@ mod tests {
     #[test]
     #[cfg(feature = "alloc")]
     fn test() {
+        use alloc::string::ToString;
+
         use crate::{ripemd160, HashEngine};
 
         #[derive(Clone)]
@@ -477,8 +479,8 @@ mod tests {
             // Hash through high-level API, check hex encoding/decoding
             let hash = ripemd160::Hash::hash(test.input.as_bytes());
             assert_eq!(hash, test.output_str.parse::<ripemd160::Hash>().expect("parse hex"));
-            assert_eq!(&hash[..], &test.output[..]);
+            assert_eq!(hash[..], test.output);
-            assert_eq!(&hash.to_string(), &test.output_str);
+            assert_eq!(hash.to_string(), test.output_str);
             assert_eq!(ripemd160::Hash::from_bytes_ref(&test.output), &hash);
             assert_eq!(ripemd160::Hash::from_bytes_mut(&mut test.output), &hash);
 
@@ -489,7 +491,7 @@ mod tests {
             }
             let manual_hash = ripemd160::Hash::from_engine(engine);
             assert_eq!(hash, manual_hash);
-            assert_eq!(hash.as_byte_array(), test.output.as_slice());
+            assert_eq!(hash.to_byte_array(), test.output);
         }
     }
 

hashes/src/sha1.rs

@@ -132,6 +132,8 @@ mod tests {
     #[test]
     #[cfg(feature = "alloc")]
     fn test() {
+        use alloc::string::ToString;
+
         use crate::{sha1, HashEngine};
 
         #[derive(Clone)]
@@ -183,8 +185,8 @@ mod tests {
             // Hash through high-level API, check hex encoding/decoding
             let hash = sha1::Hash::hash(test.input.as_bytes());
             assert_eq!(hash, test.output_str.parse::<sha1::Hash>().expect("parse hex"));
-            assert_eq!(&hash[..], &test.output[..]);
+            assert_eq!(hash[..], test.output);
-            assert_eq!(&hash.to_string(), &test.output_str);
+            assert_eq!(hash.to_string(), test.output_str);
 
             // Hash through engine, checking that we can input byte by byte
             let mut engine = sha1::Hash::engine();
@@ -193,7 +195,7 @@ mod tests {
             }
             let manual_hash = sha1::Hash::from_engine(engine);
             assert_eq!(hash, manual_hash);
-            assert_eq!(hash.as_byte_array(), test.output.as_slice());
+            assert_eq!(hash.to_byte_array(), test.output);
         }
     }
 

hashes/src/sha256.rs

@@ -864,12 +864,16 @@ impl HashEngine {
 
 #[cfg(test)]
 mod tests {
+    use core::array;
+
     use super::*;
     use crate::{sha256, HashEngine};
 
     #[test]
     #[cfg(feature = "alloc")]
     fn test() {
+        use alloc::string::ToString;
+
         #[derive(Clone)]
         struct Test {
             input: &'static str,
@@ -916,8 +920,8 @@ mod tests {
             // Hash through high-level API, check hex encoding/decoding
             let hash = sha256::Hash::hash(test.input.as_bytes());
             assert_eq!(hash, test.output_str.parse::<sha256::Hash>().expect("parse hex"));
-            assert_eq!(&hash[..], &test.output[..]);
+            assert_eq!(hash[..], test.output);
-            assert_eq!(&hash.to_string(), &test.output_str);
+            assert_eq!(hash.to_string(), test.output_str);
 
             // Hash through engine, checking that we can input byte by byte
             let mut engine = sha256::Hash::engine();
@@ -926,12 +930,15 @@ mod tests {
             }
             let manual_hash = sha256::Hash::from_engine(engine);
             assert_eq!(hash, manual_hash);
-            assert_eq!(hash.to_byte_array()[..].as_ref(), test.output.as_slice());
+            assert_eq!(hash.to_byte_array(), test.output);
         }
     }
 
     #[test]
+    #[cfg(feature = "alloc")]
     fn fmt_roundtrips() {
+        use alloc::format;
+
         let hash = sha256::Hash::hash(b"some arbitrary bytes");
         let hex = format!("{}", hash);
         let rinsed = hex.parse::<sha256::Hash>().expect("failed to parse hex");
@@ -1023,14 +1030,13 @@ mod tests {
 
     #[test]
     fn hash_unoptimized() {
-        assert_eq!(Hash::hash(&[]), Hash::hash_unoptimized(&[]));
+        let bytes: [u8; 256] = array::from_fn(|i| i as u8);
 
-        let mut bytes = Vec::new();
+        for i in 0..=256 {
-        for i in 0..256 {
+            let bytes = &bytes[0..i];
-            bytes.push(i as u8);
             assert_eq!(
-                Hash::hash(&bytes),
+                Hash::hash(bytes),
-                Hash::hash_unoptimized(&bytes),
+                Hash::hash_unoptimized(bytes),
                 "hashes don't match for length {}",
                 i + 1
             );
@@ -1050,7 +1056,10 @@ mod tests {
     fn const_midstate() { assert_eq!(Midstate::hash_tag(b"TapLeaf"), TAP_LEAF_MIDSTATE,) }
 
     #[test]
+    #[cfg(feature = "alloc")]
     fn regression_midstate_debug_format() {
+        use alloc::format;
+
         let want = "Midstate { bytes: 9ce0e4e67c116c3938b3caf2c30f5089d3f3936c47636e607db33eeaddc6f0c9, length: 64 }";
         let got = format!("{:?}", TAP_LEAF_MIDSTATE);
         assert_eq!(got, want);

hashes/src/sha256d.rs

@@ -43,11 +43,14 @@ fn from_engine(e: HashEngine) -> Hash {
 
 #[cfg(test)]
 mod tests {
+    #[allow(unused_imports)] // whether this is used depends on features
     use crate::sha256d;
 
     #[test]
     #[cfg(feature = "alloc")]
     fn test() {
+        use alloc::string::ToString;
+
         use crate::{sha256, HashEngine};
 
         #[derive(Clone)]
@@ -76,8 +79,8 @@ mod tests {
             // Hash through high-level API, check hex encoding/decoding
             let hash = sha256d::Hash::hash(test.input.as_bytes());
             assert_eq!(hash, test.output_str.parse::<sha256d::Hash>().expect("parse hex"));
-            assert_eq!(&hash[..], &test.output[..]);
+            assert_eq!(hash[..], test.output);
-            assert_eq!(&hash.to_string(), &test.output_str);
+            assert_eq!(hash.to_string(), test.output_str);
 
             // Hash through engine, checking that we can input byte by byte
             let mut engine = sha256d::Hash::engine();
@@ -92,12 +95,15 @@ mod tests {
             let sha2d_hash = sha2_hash.hash_again();
             assert_eq!(hash, sha2d_hash);
 
-            assert_eq!(hash.to_byte_array()[..].as_ref(), test.output.as_slice());
+            assert_eq!(hash.to_byte_array(), test.output);
         }
     }
 
     #[test]
+    #[cfg(feature = "alloc")]
     fn fmt_roundtrips() {
+        use alloc::format;
+
         let hash = sha256d::Hash::hash(b"some arbitrary bytes");
         let hex = format!("{}", hash);
         let rinsed = hex.parse::<sha256d::Hash>().expect("failed to parse hex");

hashes/src/sha256t.rs

@@ -23,9 +23,17 @@ pub struct Hash<T>([u8; 32], PhantomData<T>);
 
 #[cfg(feature = "schemars")]
 impl<T: Tag> schemars::JsonSchema for Hash<T> {
-    fn schema_name() -> String { "Hash".to_owned() }
+    fn schema_name() -> alloc::string::String {
+        use alloc::borrow::ToOwned;
+
+        "Hash".to_owned()
+    }
 
     fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
+        use alloc::borrow::ToOwned;
+        use alloc::boxed::Box;
+        use alloc::string::String;
+
         let mut schema: schemars::schema::SchemaObject = <String>::json_schema(gen).into();
         schema.string = Some(Box::new(schemars::schema::StringValidation {
             max_length: Some(32 * 2),
@@ -353,6 +361,8 @@ mod tests {
     #[test]
     #[cfg(feature = "alloc")]
     fn manually_created_sha256t_hash_type() {
+        use alloc::string::ToString;
+
         assert_eq!(TestHash::hash(&[0]).to_string(), HASH_ZERO_FORWARD);
     }
 
@@ -370,6 +380,8 @@ mod tests {
     #[test]
     #[cfg(feature = "alloc")]
     fn macro_created_sha256t_hash_type_backward() {
+        use alloc::string::ToString;
+
         let inner = sha256t::Hash::<NewTypeTagBackward>::hash(&[0]);
         let hash = NewTypeHashBackward::from_byte_array(inner.to_byte_array());
         assert_eq!(hash.to_string(), HASH_ZERO_BACKWARD);
@@ -391,6 +403,8 @@ mod tests {
     #[test]
     #[cfg(feature = "alloc")]
     fn macro_created_sha256t_hash_type_prints_forward() {
+        use alloc::string::ToString;
+
         let inner = sha256t::Hash::<NewTypeTagForward>::hash(&[0]);
         let hash = NewTypeHashForward::from_byte_array(inner.to_byte_array());
         assert_eq!(hash.to_string(), HASH_ZERO_FORWARD);

hashes/src/sha384.rs

@@ -45,6 +45,8 @@ mod tests {
     #[test]
     #[cfg(feature = "alloc")]
     fn test() {
+        use alloc::string::ToString;
+
         use crate::{sha384, HashEngine};
 
         #[derive(Clone)]
@@ -123,8 +125,8 @@ mod tests {
             // Hash through high-level API, check hex encoding/decoding
             let hash = sha384::Hash::hash(test.input.as_bytes());
             assert_eq!(hash, test.output_str.parse::<sha384::Hash>().expect("parse hex"));
-            assert_eq!(&hash[..], &test.output[..]);
+            assert_eq!(hash[..], test.output);
-            assert_eq!(&hash.to_string(), &test.output_str);
+            assert_eq!(hash.to_string(), test.output_str);
 
             // Hash through engine, checking that we can input byte by byte
             let mut engine = sha384::Hash::engine();
@@ -133,7 +135,7 @@ mod tests {
             }
             let manual_hash = sha384::Hash::from_engine(engine);
             assert_eq!(hash, manual_hash);
-            assert_eq!(hash.to_byte_array()[..].as_ref(), test.output.as_slice());
+            assert_eq!(hash.to_byte_array(), test.output);
         }
     }
 }

hashes/src/sha512.rs

@@ -310,6 +310,8 @@ mod tests {
     #[test]
     #[cfg(feature = "alloc")]
     fn test() {
+        use alloc::string::ToString;
+
         use crate::{sha512, HashEngine};
 
         #[derive(Clone)]
@@ -370,8 +372,8 @@ mod tests {
             // Hash through high-level API, check hex encoding/decoding
             let hash = sha512::Hash::hash(test.input.as_bytes());
             assert_eq!(hash, test.output_str.parse::<sha512::Hash>().expect("parse hex"));
-            assert_eq!(&hash[..], &test.output[..]);
+            assert_eq!(hash[..], test.output);
-            assert_eq!(&hash.to_string(), &test.output_str);
+            assert_eq!(hash.to_string(), test.output_str);
 
             // Hash through engine, checking that we can input byte by byte
             let mut engine = sha512::Hash::engine();
@@ -380,7 +382,7 @@ mod tests {
             }
             let manual_hash = sha512::Hash::from_engine(engine);
             assert_eq!(hash, manual_hash);
-            assert_eq!(hash.to_byte_array()[..].as_ref(), test.output.as_slice());
+            assert_eq!(hash.to_byte_array(), test.output);
         }
     }
 

hashes/src/sha512_256.rs

@@ -55,6 +55,8 @@ mod tests {
     #[test]
     #[cfg(feature = "alloc")]
     fn test() {
+        use alloc::string::ToString;
+
         use crate::{sha512_256, HashEngine};
 
         #[derive(Clone)]
@@ -123,8 +125,8 @@ mod tests {
             // Hash through high-level API, check hex encoding/decoding
             let hash = sha512_256::Hash::hash(test.input.as_bytes());
             assert_eq!(hash, test.output_str.parse::<sha512_256::Hash>().expect("parse hex"));
-            assert_eq!(&hash[..], &test.output[..]);
+            assert_eq!(hash[..], test.output);
-            assert_eq!(&hash.to_string(), &test.output_str);
+            assert_eq!(hash.to_string(), test.output_str);
 
             // Hash through engine, checking that we can input byte by byte
             let mut engine = sha512_256::Hash::engine();
@@ -133,7 +135,7 @@ mod tests {
             }
             let manual_hash = sha512_256::Hash::from_engine(engine);
             assert_eq!(hash, manual_hash);
-            assert_eq!(hash.to_byte_array()[..].as_ref(), test.output.as_slice());
+            assert_eq!(hash.to_byte_array(), test.output);
         }
     }
 }

hashes/src/siphash24.rs

@@ -318,7 +318,7 @@ mod tests {
 
         for i in 0..64 {
             vin[i] = i as u8;
-            let vec = Hash::from_slice(&vecs[i][..]).unwrap();
+            let vec = Hash::from_slice(&vecs[i]).unwrap();
             let out = Hash::hash_with_keys(k0, k1, &vin[0..i]);
             assert_eq!(vec, out, "vec #{}", i);
 

hashes/src/util.rs

@@ -400,28 +400,40 @@ mod test {
     }
 
     #[test]
+    #[cfg(feature = "alloc")]
     fn display() {
+        use alloc::format;
+
         let want = "0000000000000000000000000000000000000000000000000000000000000000";
         let got = format!("{}", TestHash::all_zeros());
         assert_eq!(got, want)
     }
 
     #[test]
+    #[cfg(feature = "alloc")]
     fn display_alternate() {
+        use alloc::format;
+
         let want = "0x0000000000000000000000000000000000000000000000000000000000000000";
         let got = format!("{:#}", TestHash::all_zeros());
         assert_eq!(got, want)
     }
 
     #[test]
+    #[cfg(feature = "alloc")]
     fn lower_hex() {
+        use alloc::format;
+
         let want = "0000000000000000000000000000000000000000000000000000000000000000";
         let got = format!("{:x}", TestHash::all_zeros());
         assert_eq!(got, want)
     }
 
     #[test]
+    #[cfg(feature = "alloc")]
     fn lower_hex_alternate() {
+        use alloc::format;
+
         let want = "0x0000000000000000000000000000000000000000000000000000000000000000";
         let got = format!("{:#x}", TestHash::all_zeros());
         assert_eq!(got, want)