mii/merkle.rs
1
0
Fork 0
mirror of https://github.com/mii443/merkle.rs.git synced 2025-09-01 14:49:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix clippy warnings and disable benchmarks temporarily

Browse Source
This commit is contained in:
Romain Ruetschi
2019-07-23 10:44:41 +02:00
parent 3b374e5a43
commit c65560d9f4
4 changed files with 106 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.toml
View File

@ -16,7 +16,6 @@ readme = "README.md"
keywords = ["merkle", "merkle-tree"] keywords = ["merkle", "merkle-tree"]
categories = ["data-structures", "cryptography"] categories = ["data-structures", "cryptography"]
[dependencies] [dependencies]
ring = "^0.16.1" ring = "^0.16.1"
protobuf = { version = "^2.8.0", optional = true } protobuf = { version = "^2.8.0", optional = true }

202
benches/lib.rs
View File

@ -1,128 +1,128 @@
#![feature(test)] // #![feature(test)]
#![feature(rand)] // #![feature(rand)]
extern crate rand; // extern crate rand;
extern crate test; // extern crate test;
extern crate merkle; // extern crate merkle;
extern crate ring; // extern crate ring;
use rand::Rng; // use rand::Rng;
use test::Bencher; // use test::Bencher;
use ring::digest::{Algorithm, SHA512}; // use ring::digest::{Algorithm, SHA512};
use merkle::MerkleTree; // use merkle::MerkleTree;
#[allow(non_upper_case_globals)] // #[allow(non_upper_case_globals)]
static digest: &'static Algorithm = &SHA512; // static digest: &'static Algorithm = &SHA512;
#[bench] // #[bench]
fn bench_small_str_tree(b: &mut Bencher) { // fn bench_small_str_tree(b: &mut Bencher) {
let values = vec!["one", "two", "three", "four"]; // let values = vec!["one", "two", "three", "four"];
b.iter(|| MerkleTree::from_vec(digest, values.clone())); // b.iter(|| MerkleTree::from_vec(digest, values.clone()));
} // }
#[bench] // #[bench]
fn bench_small_str_proof_gen(b: &mut Bencher) { // fn bench_small_str_proof_gen(b: &mut Bencher) {
let values = vec!["one", "two", "three", "four"]; // let values = vec!["one", "two", "three", "four"];
let tree = MerkleTree::from_vec(digest, values.clone()); // let tree = MerkleTree::from_vec(digest, values.clone());
b.iter(|| { // b.iter(|| {
for value in &values { // for value in &values {
let proof = tree.gen_proof(value); // let proof = tree.gen_proof(value);
test::black_box(proof); // test::black_box(proof);
} // }
}); // });
} // }
#[bench] // #[bench]
fn bench_small_str_proof_check(b: &mut Bencher) { // fn bench_small_str_proof_check(b: &mut Bencher) {
let values = vec!["one", "two", "three", "four"]; // let values = vec!["one", "two", "three", "four"];
let tree = MerkleTree::from_vec(digest, values.clone()); // let tree = MerkleTree::from_vec(digest, values.clone());
let proofs = values // let proofs = values
.iter() // .iter()
.map(|v| tree.gen_proof(v).unwrap()) // .map(|v| tree.gen_proof(v).unwrap())
.collect::<Vec<_>>(); // .collect::<Vec<_>>();
b.iter(|| { // b.iter(|| {
for proof in &proofs { // for proof in &proofs {
test::black_box(proof.validate(tree.root_hash())); // test::black_box(proof.validate(tree.root_hash()));
} // }
}); // });
} // }
#[bench] // #[bench]
fn bench_big_rnd_tree(b: &mut Bencher) { // fn bench_big_rnd_tree(b: &mut Bencher) {
let mut values = vec![vec![0u8; 256]; 160]; // let mut values = vec![vec![0u8; 256]; 160];
let mut rng = rand::IsaacRng::new_unseeded(); // let mut rng = rand::IsaacRng::new_unseeded();
for mut v in &mut values { // for mut v in &mut values {
rng.fill_bytes(&mut v); // rng.fill_bytes(&mut v);
} // }
b.iter(|| { // b.iter(|| {
let tree = MerkleTree::from_vec(digest, values.clone()); // let tree = MerkleTree::from_vec(digest, values.clone());
test::black_box(tree) // test::black_box(tree)
}); // });
} // }
#[bench] // #[bench]
fn bench_big_rnd_proof_gen(b: &mut Bencher) { // fn bench_big_rnd_proof_gen(b: &mut Bencher) {
let mut values = vec![vec![0u8; 256]; 160]; // let mut values = vec![vec![0u8; 256]; 160];
let mut rng = rand::IsaacRng::new_unseeded(); // let mut rng = rand::IsaacRng::new_unseeded();
for mut v in &mut values { // for mut v in &mut values {
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.clone());
b.iter(|| { // b.iter(|| {
for value in &values { // for value in &values {
let proof = tree.gen_proof(value.clone()); // let proof = tree.gen_proof(value.clone());
test::black_box(proof); // test::black_box(proof);
} // }
}); // });
} // }
#[bench] // #[bench]
fn bench_big_rnd_proof_check(b: &mut Bencher) { // fn bench_big_rnd_proof_check(b: &mut Bencher) {
let mut values = vec![vec![0u8; 256]; 160]; // let mut values = vec![vec![0u8; 256]; 160];
let mut rng = rand::IsaacRng::new_unseeded(); // let mut rng = rand::IsaacRng::new_unseeded();
for mut v in &mut values { // for mut v in &mut values {
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.clone());
let proofs = values // let proofs = values
.into_iter() // .into_iter()
.map(|v| tree.gen_proof(v).unwrap()) // .map(|v| tree.gen_proof(v).unwrap())
.collect::<Vec<_>>(); // .collect::<Vec<_>>();
b.iter(|| { // b.iter(|| {
for proof in &proofs { // for proof in &proofs {
test::black_box(proof.validate(tree.root_hash())); // test::black_box(proof.validate(tree.root_hash()));
} // }
}); // });
} // }
#[bench] // #[bench]
fn bench_big_rnd_iter(b: &mut Bencher) { // fn bench_big_rnd_iter(b: &mut Bencher) {
let mut values = vec![vec![0u8; 256]; 160]; // let mut values = vec![vec![0u8; 256]; 160];
let mut rng = rand::IsaacRng::new_unseeded(); // let mut rng = rand::IsaacRng::new_unseeded();
for mut v in &mut values { // for mut v in &mut values {
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.clone());
b.iter(|| { // b.iter(|| {
for value in &tree { // for value in &tree {
test::black_box(value); // test::black_box(value);
} // }
}); // });
} // }

7
src/proof.rs
View File

@ -75,11 +75,12 @@ mod algorithm_serde {
serde_json::ser::PrettyFormatter::new(), serde_json::ser::PrettyFormatter::new(),
); );
serialize(alg, &mut serializer).expect(&format!("{:?}", alg)); serialize(alg, &mut serializer).unwrap_or_else(|_| panic!("{:?}", alg));
let alg_ = deserialize(&mut serde_json::Deserializer::from_slice( let alg_ = deserialize(&mut serde_json::Deserializer::from_slice(
&serializer.into_inner()[..], &serializer.into_inner()[..],
)) ))
.expect(&format!("{:?}", alg)); .unwrap_or_else(|_| panic!("{:?}", alg));
assert_eq!(*alg, alg_); assert_eq!(*alg, alg_);
} }
@ -92,7 +93,7 @@ mod algorithm_serde {
{ {
let alg_str = "\"BLAKE2b\""; let alg_str = "\"BLAKE2b\"";
let mut deserializer = serde_json::Deserializer::from_str(alg_str); let mut deserializer = serde_json::Deserializer::from_str(alg_str);
let _ = deserialize(&mut deserializer).expect(&format!("{:?}", alg_str)); let _ = deserialize(&mut deserializer).unwrap_or_else(|_| panic!("{:?}", alg_str));
} }
} }
} }

2
src/tests.rs
View File

@ -154,7 +154,7 @@ fn test_wrong_proof() {
fn test_nth_proof() { 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 + 1)).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();