milksad
/
rust-bitcoin-unsafe-fast
14
0
Fork 0
Code Issues Pull Requests Activity

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
This commit is contained in:
merge-script 2024-08-29 21:20:10 +00:00
parent cfb53c7866 dae42bef9d
commit 0d9e8f8c99
No known key found for this signature in database
GPG Key ID: C588D63CE41B97C1
18 changed files with 131 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
bitcoin/src/pow.rs
View File

@ -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)

3
hashes/Cargo.toml
View File

@ -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

9
hashes/src/hash160.rs
View File

@ -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.to_string(), &test.output_str);
assert_eq!(hash[..], test.output);
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);
}
}

4
hashes/src/hkdf.rs
View File

@ -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;

29
hashes/src/hmac.rs
View File

@ -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> {
key: &'a [u8],
input: &'a [u8],
output: &'a [u8],
struct Test {
key: &'static [u8],
input: &'static [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],
input: &[0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65],
output: &[
key: &[ 0x0b; 20 ],
input: &[ 0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65 ],
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);
}
}

4
hashes/src/impls.rs
View File

@ -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::{

10
hashes/src/internal_macros.rs
View File

@ -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 {

25
hashes/src/lib.rs
View File

@ -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");

8
hashes/src/ripemd160.rs
View File

@ -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.to_string(), &test.output_str);
assert_eq!(hash[..], test.output);
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);
}
}

8
hashes/src/sha1.rs
View File

@ -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.to_string(), &test.output_str);
assert_eq!(hash[..], test.output);
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);
}
}

27
hashes/src/sha256.rs
View File

@ -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.to_string(), &test.output_str);
assert_eq!(hash[..], test.output);
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 {
bytes.push(i as u8);
for i in 0..=256 {
let bytes = &bytes[0..i];
assert_eq!(
Hash::hash(&bytes),
Hash::hash_unoptimized(&bytes),
Hash::hash(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);

12
hashes/src/sha256d.rs
View File

@ -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.to_string(), &test.output_str);
assert_eq!(hash[..], test.output);
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");

16
hashes/src/sha256t.rs
View File

@ -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);

8
hashes/src/sha384.rs
View File

@ -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.to_string(), &test.output_str);
assert_eq!(hash[..], test.output);
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);
}
}
}

8
hashes/src/sha512.rs
View File

@ -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.to_string(), &test.output_str);
assert_eq!(hash[..], test.output);
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);
}
}

8
hashes/src/sha512_256.rs
View File

@ -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.to_string(), &test.output_str);
assert_eq!(hash[..], test.output);
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);
}
}
}

2
hashes/src/siphash24.rs
View File

@ -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);

12
hashes/src/util.rs
View File

@ -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)