mii/merkle.rs
1
0
Fork 0
mirror of https://github.com/mii443/merkle.rs.git synced 2025-08-22 16:05:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix warnings and deprecation notices

Browse Source
This commit is contained in:
Romain Ruetschi
2020-07-09 23:10:10 +02:00
parent 5d7629fc63
commit 90f31ef641
3 changed files with 48 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
benches/proof.rs
View File

@ -12,7 +12,7 @@ use merkle::MerkleTree;
use rand::RngCore; use rand::RngCore;
use ring::digest::{Algorithm, SHA512}; use ring::digest::{Algorithm, SHA512};
static DIGEST: &'static Algorithm = &SHA512; static DIGEST: &Algorithm = &SHA512;
fn bench_small_str_tree(c: &mut Criterion) { fn bench_small_str_tree(c: &mut Criterion) {
c.bench_function("MerkleTree::from_bec - small", |b| { c.bench_function("MerkleTree::from_bec - small", |b| {
@ -115,7 +115,7 @@ fn bench_big_rnd_iter(c: &mut Criterion) {
rng.fill_bytes(&mut v); rng.fill_bytes(&mut v);
} }
let tree = MerkleTree::from_vec(DIGEST, values.clone()); let tree = MerkleTree::from_vec(DIGEST, values);
b.iter(|| { b.iter(|| {
for value in &tree { for value in &tree {
black_box(value); black_box(value);

14
build.rs
View File

@ -21,14 +21,12 @@ fn has_right_protoc_version(version: &str) -> bool {
#[cfg(feature = "serialization-protobuf")] #[cfg(feature = "serialization-protobuf")]
fn build_protobuf(out_dir: &str, input: &[&str], includes: &[&str]) { fn build_protobuf(out_dir: &str, input: &[&str], includes: &[&str]) {
use self::protoc_rust::{run, Args}; protoc_rust::Codegen::new()
run(Args { .out_dir(out_dir)
out_dir, .inputs(input)
input, .includes(includes)
includes, .run()
customize: Default::default(), .expect("Running protoc failed");
})
.expect("protoc");
} }
#[cfg(feature = "serialization-protobuf")] #[cfg(feature = "serialization-protobuf")]

81
src/tests.rs
View File

@ -9,27 +9,26 @@ use crate::hashutils::{HashUtils, Hashable};
use crate::merkletree::MerkleTree; use crate::merkletree::MerkleTree;
use crate::proof::Positioned; use crate::proof::Positioned;
#[allow(non_upper_case_globals)] static DIGEST: &Algorithm = &SHA512;
static digest: &'static Algorithm = &SHA512;
#[test] #[test]
fn test_from_str_vec() { fn test_from_str_vec() {
let values = vec!["one", "two", "three", "four"]; let values = vec!["one", "two", "three", "four"];
let hashes = vec![ let hashes = vec![
digest.hash_leaf(&values[0].as_bytes()), DIGEST.hash_leaf(&values[0].as_bytes()),
digest.hash_leaf(&values[1].as_bytes()), DIGEST.hash_leaf(&values[1].as_bytes()),
digest.hash_leaf(&values[2].as_bytes()), DIGEST.hash_leaf(&values[2].as_bytes()),
digest.hash_leaf(&values[3].as_bytes()), DIGEST.hash_leaf(&values[3].as_bytes()),
]; ];
let count = values.len(); let count = values.len();
let tree = MerkleTree::from_vec(digest, values); let tree = MerkleTree::from_vec(DIGEST, values);
let h01 = digest.hash_nodes(&hashes[0], &hashes[1]); let h01 = DIGEST.hash_nodes(&hashes[0], &hashes[1]);
let h23 = digest.hash_nodes(&hashes[2], &hashes[3]); let h23 = DIGEST.hash_nodes(&hashes[2], &hashes[3]);
let root_hash = digest.hash_nodes(&h01, &h23); let root_hash = DIGEST.hash_nodes(&h01, &h23);
assert_eq!(tree.count(), count); assert_eq!(tree.count(), count);
assert_eq!(tree.height(), 2); assert_eq!(tree.height(), 2);
@ -39,8 +38,8 @@ fn test_from_str_vec() {
#[test] #[test]
fn test_from_vec_empty() { fn test_from_vec_empty() {
let values: Vec<Vec<u8>> = vec![]; let values: Vec<Vec<u8>> = vec![];
let tree = MerkleTree::from_vec(digest, values); let tree = MerkleTree::from_vec(DIGEST, values);
let empty_hash: Vec<u8> = digest.hash_empty().as_ref().into(); let empty_hash: Vec<u8> = DIGEST.hash_empty().as_ref().into();
let root_hash = tree.root_hash().clone(); let root_hash = tree.root_hash().clone();
assert_eq!(root_hash, empty_hash); assert_eq!(root_hash, empty_hash);
@ -49,9 +48,9 @@ fn test_from_vec_empty() {
#[test] #[test]
fn test_from_vec1() { fn test_from_vec1() {
let values = vec!["hello, world".to_string()]; let values = vec!["hello, world".to_string()];
let tree = MerkleTree::from_vec(digest, values); let tree = MerkleTree::from_vec(DIGEST, values);
let root_hash = &digest.hash_leaf(b"hello, world"); let root_hash = &DIGEST.hash_leaf(b"hello, world");
assert_eq!(tree.count(), 1); assert_eq!(tree.count(), 1);
assert_eq!(tree.height(), 0); assert_eq!(tree.height(), 0);
@ -61,17 +60,17 @@ fn test_from_vec1() {
#[test] #[test]
fn test_from_vec3() { fn test_from_vec3() {
let values = vec![vec![1], vec![2], vec![3]]; let values = vec![vec![1], vec![2], vec![3]];
let tree = MerkleTree::from_vec(digest, values); let tree = MerkleTree::from_vec(DIGEST, values);
let hashes = vec![ let hashes = vec![
digest.hash_leaf(&vec![1]), DIGEST.hash_leaf(&vec![1]),
digest.hash_leaf(&vec![2]), DIGEST.hash_leaf(&vec![2]),
digest.hash_leaf(&vec![3]), DIGEST.hash_leaf(&vec![3]),
]; ];
let h01 = digest.hash_nodes(&hashes[0], &hashes[1]); let h01 = DIGEST.hash_nodes(&hashes[0], &hashes[1]);
let h2 = &hashes[2]; let h2 = &hashes[2];
let root_hash = &digest.hash_nodes(&h01, h2); let root_hash = &DIGEST.hash_nodes(&h01, h2);
assert_eq!(tree.count(), 3); assert_eq!(tree.count(), 3);
assert_eq!(tree.height(), 2); assert_eq!(tree.height(), 2);
@ -81,23 +80,23 @@ fn test_from_vec3() {
#[test] #[test]
fn test_from_vec9() { fn test_from_vec9() {
let values = (1..10).map(|x| vec![x]).collect::<Vec<_>>(); let values = (1..10).map(|x| vec![x]).collect::<Vec<_>>();
let tree = MerkleTree::from_vec(digest, values.clone()); let tree = MerkleTree::from_vec(DIGEST, values.clone());
let hashes = values let hashes = values
.iter() .iter()
.map(|v| digest.hash_leaf(v)) .map(|v| DIGEST.hash_leaf(v))
.collect::<Vec<_>>(); .collect::<Vec<_>>();
let h01 = digest.hash_nodes(&hashes[0], &hashes[1]); let h01 = DIGEST.hash_nodes(&hashes[0], &hashes[1]);
let h23 = digest.hash_nodes(&hashes[2], &hashes[3]); let h23 = DIGEST.hash_nodes(&hashes[2], &hashes[3]);
let h45 = digest.hash_nodes(&hashes[4], &hashes[5]); let h45 = DIGEST.hash_nodes(&hashes[4], &hashes[5]);
let h67 = digest.hash_nodes(&hashes[6], &hashes[7]); let h67 = DIGEST.hash_nodes(&hashes[6], &hashes[7]);
let h8 = &hashes[8]; let h8 = &hashes[8];
let h0123 = digest.hash_nodes(&h01, &h23); let h0123 = DIGEST.hash_nodes(&h01, &h23);
let h4567 = digest.hash_nodes(&h45, &h67); let h4567 = DIGEST.hash_nodes(&h45, &h67);
let h1to7 = digest.hash_nodes(&h0123, &h4567); let h1to7 = DIGEST.hash_nodes(&h0123, &h4567);
let root_hash = &digest.hash_nodes(&h1to7, h8); let root_hash = &DIGEST.hash_nodes(&h1to7, h8);
assert_eq!(tree.count(), 9); assert_eq!(tree.count(), 9);
assert_eq!(tree.height(), 4); assert_eq!(tree.height(), 4);
@ -107,7 +106,7 @@ fn test_from_vec9() {
#[test] #[test]
fn test_valid_proof() { fn test_valid_proof() {
let values = (1..10).map(|x| vec![x]).collect::<Vec<_>>(); let values = (1..10).map(|x| vec![x]).collect::<Vec<_>>();
let tree = MerkleTree::from_vec(digest, values.clone()); let tree = MerkleTree::from_vec(DIGEST, values.clone());
let root_hash = tree.root_hash(); let root_hash = tree.root_hash();
for value in values { for value in values {
@ -121,7 +120,7 @@ fn test_valid_proof() {
#[test] #[test]
fn test_valid_proof_str() { fn test_valid_proof_str() {
let values = vec!["Hello", "my", "name", "is", "Rusty"]; let values = vec!["Hello", "my", "name", "is", "Rusty"];
let tree = MerkleTree::from_vec(digest, values); let tree = MerkleTree::from_vec(DIGEST, values);
let root_hash = tree.root_hash(); let root_hash = tree.root_hash();
let value = "Rusty"; let value = "Rusty";
@ -135,10 +134,10 @@ fn test_valid_proof_str() {
#[test] #[test]
fn test_wrong_proof() { fn test_wrong_proof() {
let values1 = vec![vec![1], vec![2], vec![3], vec![4]]; let values1 = vec![vec![1], vec![2], vec![3], vec![4]];
let tree1 = MerkleTree::from_vec(digest, values1.clone()); let tree1 = MerkleTree::from_vec(DIGEST, values1.clone());
let values2 = vec![vec![4], vec![5], vec![6], vec![7]]; let values2 = vec![vec![4], vec![5], vec![6], vec![7]];
let tree2 = MerkleTree::from_vec(digest, values2.clone()); let tree2 = MerkleTree::from_vec(DIGEST, values2);
let root_hash = tree2.root_hash(); let root_hash = tree2.root_hash();
@ -155,7 +154,7 @@ fn test_nth_proof() {
// Calculation depends on the total count. Try a few numbers: odd, even, powers of two... // Calculation depends on the total count. Try a few numbers: odd, even, powers of two...
for &count in &[1, 2, 3, 10, 15, 16, 17, 22] { for &count in &[1, 2, 3, 10, 15, 16, 17, 22] {
let values = (1..=count).map(|x| vec![x as u8]).collect::<Vec<_>>(); let values = (1..=count).map(|x| vec![x as u8]).collect::<Vec<_>>();
let tree = MerkleTree::from_vec(digest, values.clone()); let tree = MerkleTree::from_vec(DIGEST, values.clone());
let root_hash = tree.root_hash(); let root_hash = tree.root_hash();
for i in 0..count { for i in 0..count {
@ -173,7 +172,7 @@ fn test_nth_proof() {
#[test] #[test]
fn test_mutate_proof_first_lemma() { fn test_mutate_proof_first_lemma() {
let values = (1..10).map(|x| vec![x]).collect::<Vec<_>>(); let values = (1..10).map(|x| vec![x]).collect::<Vec<_>>();
let tree = MerkleTree::from_vec(digest, values.clone()); let tree = MerkleTree::from_vec(DIGEST, values.clone());
let root_hash = tree.root_hash(); let root_hash = tree.root_hash();
for (i, value) in values.into_iter().enumerate() { for (i, value) in values.into_iter().enumerate() {
@ -199,7 +198,7 @@ fn test_mutate_proof_first_lemma() {
#[test] #[test]
fn test_tree_iter() { fn test_tree_iter() {
let values = (1..10).map(|x| vec![x]).collect::<Vec<_>>(); let values = (1..10).map(|x| vec![x]).collect::<Vec<_>>();
let tree = MerkleTree::from_vec(digest, values.clone()); let tree = MerkleTree::from_vec(DIGEST, values.clone());
let iter = tree.iter().cloned().collect::<Vec<_>>(); let iter = tree.iter().cloned().collect::<Vec<_>>();
assert_eq!(values, iter); assert_eq!(values, iter);
@ -208,7 +207,7 @@ fn test_tree_iter() {
#[test] #[test]
fn test_tree_into_iter() { fn test_tree_into_iter() {
let values = (1..10).map(|x| vec![x]).collect::<Vec<_>>(); let values = (1..10).map(|x| vec![x]).collect::<Vec<_>>();
let tree = MerkleTree::from_vec(digest, values.clone()); let tree = MerkleTree::from_vec(DIGEST, values.clone());
let iter = tree.into_iter().collect::<Vec<_>>(); let iter = tree.into_iter().collect::<Vec<_>>();
assert_eq!(values, iter); assert_eq!(values, iter);
@ -217,7 +216,7 @@ fn test_tree_into_iter() {
#[test] #[test]
fn test_tree_into_iter_loop() { fn test_tree_into_iter_loop() {
let values = (1..10).map(|x| vec![x]).collect::<Vec<_>>(); let values = (1..10).map(|x| vec![x]).collect::<Vec<_>>();
let tree = MerkleTree::from_vec(digest, values.clone()); let tree = MerkleTree::from_vec(DIGEST, values.clone());
let mut collected = Vec::new(); let mut collected = Vec::new();
@ -231,7 +230,7 @@ fn test_tree_into_iter_loop() {
#[test] #[test]
fn test_tree_into_iter_loop_borrow() { fn test_tree_into_iter_loop_borrow() {
let values = (1..10).map(|x| vec![x]).collect::<Vec<_>>(); let values = (1..10).map(|x| vec![x]).collect::<Vec<_>>();
let tree = MerkleTree::from_vec(digest, values.clone()); let tree = MerkleTree::from_vec(DIGEST, values.clone());
let mut collected = Vec::new(); let mut collected = Vec::new();
@ -285,7 +284,7 @@ fn test_custom_hashable_impl() {
}) })
.collect::<Vec<_>>(); .collect::<Vec<_>>();
let tree = MerkleTree::from_vec(digest, keys); let tree = MerkleTree::from_vec(DIGEST, keys);
assert_eq!(tree.count(), 10); assert_eq!(tree.count(), 10);
assert_eq!(tree.height(), 4); assert_eq!(tree.height(), 4);