diff --git a/.travis.yml b/.travis.yml index 3b9bbf6e6..bf3a27276 100644 --- a/.travis.yml +++ b/.travis.yml @@ -36,6 +36,7 @@ script: cargo fmt -- --check; fi - cargo check --all --tests + - cargo check --all --benches - cargo build --all - cargo test --all --exclude uint --exclude fixed-hash - if [ "$TRAVIS_RUST_VERSION" == "nightly" ]; then diff --git a/ethbloom/src/lib.rs b/ethbloom/src/lib.rs index 9ef11e3ee..49a18214f 100644 --- a/ethbloom/src/lib.rs +++ b/ethbloom/src/lib.rs @@ -1,45 +1,42 @@ //! -//! ```rust -//! extern crate ethbloom; -//! #[macro_use] extern crate hex_literal; +//! ``` +//! use hex_literal::hex; //! use ethbloom::{Bloom, Input}; //! -//! fn main() { -//! use std::str::FromStr; -//! let bloom = Bloom::from_str( -//! "00000000000000000000000000000000\ -//! 00000000100000000000000000000000\ -//! 00000000000000000000000000000000\ -//! 00000000000000000000000000000000\ -//! 00000000000000000000000000000000\ -//! 00000000000000000000000000000000\ -//! 00000002020000000000000000000000\ -//! 00000000000000000000000800000000\ -//! 10000000000000000000000000000000\ -//! 00000000000000000000001000000000\ -//! 00000000000000000000000000000000\ -//! 00000000000000000000000000000000\ -//! 00000000000000000000000000000000\ -//! 00000000000000000000000000000000\ -//! 00000000000000000000000000000000\ -//! 00000000000000000000000000000000" -//! ).unwrap(); -//! let address = hex!("ef2d6d194084c2de36e0dabfce45d046b37d1106"); -//! let topic = hex!("02c69be41d0b7e40352fc85be1cd65eb03d40ef8427a0ca4596b1ead9a00e9fc"); +//! use std::str::FromStr; +//! let bloom = Bloom::from_str( +//! "00000000000000000000000000000000\ +//! 00000000100000000000000000000000\ +//! 00000000000000000000000000000000\ +//! 00000000000000000000000000000000\ +//! 00000000000000000000000000000000\ +//! 00000000000000000000000000000000\ +//! 00000002020000000000000000000000\ +//! 00000000000000000000000800000000\ +//! 10000000000000000000000000000000\ +//! 00000000000000000000001000000000\ +//! 00000000000000000000000000000000\ +//! 00000000000000000000000000000000\ +//! 00000000000000000000000000000000\ +//! 00000000000000000000000000000000\ +//! 00000000000000000000000000000000\ +//! 00000000000000000000000000000000" +//! ).unwrap(); +//! let address = hex!("ef2d6d194084c2de36e0dabfce45d046b37d1106"); +//! let topic = hex!("02c69be41d0b7e40352fc85be1cd65eb03d40ef8427a0ca4596b1ead9a00e9fc"); //! -//! let mut my_bloom = Bloom::default(); -//! assert!(!my_bloom.contains_input(Input::Raw(&address))); -//! assert!(!my_bloom.contains_input(Input::Raw(&topic))); +//! let mut my_bloom = Bloom::default(); +//! assert!(!my_bloom.contains_input(Input::Raw(&address))); +//! assert!(!my_bloom.contains_input(Input::Raw(&topic))); //! -//! my_bloom.accrue(Input::Raw(&address)); -//! assert!(my_bloom.contains_input(Input::Raw(&address))); -//! assert!(!my_bloom.contains_input(Input::Raw(&topic))); +//! my_bloom.accrue(Input::Raw(&address)); +//! assert!(my_bloom.contains_input(Input::Raw(&address))); +//! assert!(!my_bloom.contains_input(Input::Raw(&topic))); //! -//! my_bloom.accrue(Input::Raw(&topic)); -//! assert!(my_bloom.contains_input(Input::Raw(&address))); -//! assert!(my_bloom.contains_input(Input::Raw(&topic))); -//! assert_eq!(my_bloom, bloom); -//! } +//! my_bloom.accrue(Input::Raw(&topic)); +//! assert!(my_bloom.contains_input(Input::Raw(&address))); +//! assert!(my_bloom.contains_input(Input::Raw(&topic))); +//! assert_eq!(my_bloom, bloom); //! ``` //! diff --git a/fixed-hash/README.md b/fixed-hash/README.md index 19f4c79f9..c07db2f23 100644 --- a/fixed-hash/README.md +++ b/fixed-hash/README.md @@ -7,7 +7,7 @@ Provides macros to construct custom fixed-size hash types. Simple 256 bit (32 bytes) hash type. ```rust -#[macro_use] extern crate fixed_hash; +use fixed_hash::construct_fixed_hash; construct_fixed_hash! { /// My 256 bit hash type. @@ -30,9 +30,6 @@ assert_eq!(H160::from(H256::zero()), H160::zero()); It is possible to add attributes to your types, for example to make them serializable. ```rust -extern crate serde; -#[macro_use] extern crate serde_derive; - construct_fixed_hash!{ /// My serializable hash type. #[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))] diff --git a/fixed-hash/src/hash.rs b/fixed-hash/src/hash.rs index 25098b5ad..ea2210076 100644 --- a/fixed-hash/src/hash.rs +++ b/fixed-hash/src/hash.rs @@ -13,38 +13,30 @@ /// Create a public unformatted hash type with 32 bytes size. /// /// ``` -/// # #[macro_use] extern crate fixed_hash; +/// use fixed_hash::construct_fixed_hash; +/// /// construct_fixed_hash!{ pub struct H256(32); } -/// # fn main() { -/// # assert_eq!(std::mem::size_of::(), 32); -/// # } +/// assert_eq!(std::mem::size_of::(), 32); /// ``` /// /// With additional attributes and doc comments. /// /// ``` -/// # #[macro_use] extern crate fixed_hash; -/// // Add the below two lines to import serde and its derive -/// // extern crate serde; -/// // #[macro_use] extern crate serde_derive; +/// use fixed_hash::construct_fixed_hash; /// construct_fixed_hash!{ /// /// My unformatted 160 bytes sized hash type. /// #[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))] /// pub struct H160(20); /// } -/// # fn main() { -/// # assert_eq!(std::mem::size_of::(), 20); -/// # } +/// assert_eq!(std::mem::size_of::(), 20); /// ``` /// /// The visibility modifier is optional and you can create a private hash type. /// /// ``` -/// # #[macro_use] extern crate fixed_hash; +/// use fixed_hash::construct_fixed_hash; /// construct_fixed_hash!{ struct H512(64); } -/// # fn main() { -/// # assert_eq!(std::mem::size_of::(), 64); -/// # } +/// assert_eq!(std::mem::size_of::(), 64); /// ``` #[macro_export(local_inner_macros)] macro_rules! construct_fixed_hash { @@ -761,15 +753,13 @@ macro_rules! impl_ops_for_hash { /// # Example /// /// ``` -/// #[macro_use] extern crate fixed_hash; +/// use fixed_hash::{construct_fixed_hash, impl_fixed_hash_conversions}; /// construct_fixed_hash!{ struct H160(20); } /// construct_fixed_hash!{ struct H256(32); } /// impl_fixed_hash_conversions!(H256, H160); /// // now use it! -/// # fn main() { /// assert_eq!(H256::from(H160::zero()), H256::zero()); /// assert_eq!(H160::from(H256::zero()), H160::zero()); -/// # } /// ``` #[macro_export(local_inner_macros)] macro_rules! impl_fixed_hash_conversions { diff --git a/fixed-hash/src/lib.rs b/fixed-hash/src/lib.rs index bfc210a84..a3e7af6f7 100644 --- a/fixed-hash/src/lib.rs +++ b/fixed-hash/src/lib.rs @@ -54,9 +54,6 @@ pub use rand; #[doc(hidden)] pub use quickcheck; -#[cfg(test)] -extern crate rand_xorshift; - #[macro_use] mod hash; diff --git a/keccak-hash/Cargo.toml b/keccak-hash/Cargo.toml index 14b6b19ba..3d7d88943 100644 --- a/keccak-hash/Cargo.toml +++ b/keccak-hash/Cargo.toml @@ -14,6 +14,7 @@ primitive-types = { path = "../primitive-types", version = "0.6", default-featur [dev-dependencies] tempdir = "0.3.7" +criterion = "0.3.0" [features] default = ["std"] diff --git a/keccak-hash/benches/keccak_256.rs b/keccak-hash/benches/keccak_256.rs index 5cf5f2526..5c5794bf5 100644 --- a/keccak-hash/benches/keccak_256.rs +++ b/keccak-hash/benches/keccak_256.rs @@ -14,37 +14,36 @@ // You should have received a copy of the GNU General Public License // along with Parity. If not, see . -#![feature(test)] - -extern crate test; - +use criterion::{black_box, criterion_group, criterion_main, Criterion}; use keccak_hash::keccak; -use test::Bencher; -#[bench] -fn bench_keccak_256_with_empty_input(b: &mut Bencher) { +criterion_group!(keccak_256, keccak_256_with_empty_input, keccak_256_with_typical_input, keccak_256_with_large_input,); +criterion_main!(keccak_256); + +pub fn keccak_256_with_empty_input(c: &mut Criterion) { let empty = [0u8; 0]; - b.bytes = empty.len() as u64; - b.iter(|| { - let _out = keccak(empty); - }) + c.bench_function("keccak_256_with_empty_input", |b| { + b.iter(|| { + let _out = keccak(black_box(empty)); + }) + }); } -#[bench] -fn bench_keccak_256_with_typical_input(b: &mut Bencher) { - let data: Vec = From::from("some medum length string with important information"); - b.bytes = data.len() as u64; - b.iter(|| { - let _out = keccak(&data); - }) +pub fn keccak_256_with_typical_input(c: &mut Criterion) { + let data: Vec = From::from("some medium length string with important information"); + c.bench_function("keccak_256_with_typical_input", |b| { + b.iter(|| { + let _out = keccak(black_box(&data)); + }) + }); } -#[bench] -fn bench_keccak_256_with_large_input(b: &mut Bencher) { +pub fn keccak_256_with_large_input(c: &mut Criterion) { // 4096 chars let data: Vec = From::from("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"); - b.bytes = data.len() as u64; - b.iter(|| { - let _out = keccak(&data); - }) + c.bench_function("keccak_256_with_large_input", |b| { + b.iter(|| { + let _out = keccak(black_box(&data)); + }) + }); } diff --git a/kvdb-rocksdb/Cargo.toml b/kvdb-rocksdb/Cargo.toml index 657c0392c..d7cef5999 100644 --- a/kvdb-rocksdb/Cargo.toml +++ b/kvdb-rocksdb/Cargo.toml @@ -27,6 +27,7 @@ parity-util-mem = { path = "../parity-util-mem", version = "0.4", default-featur [dev-dependencies] alloc_counter = "0.0.4" criterion = "0.3" +ethereum-types = { path = "../ethereum-types" } kvdb-shared-tests = { path = "../kvdb-shared-tests", version = "0.1" } rand = "0.7.2" tempdir = "0.3.7" diff --git a/parity-crypto/benches/bench.rs b/parity-crypto/benches/bench.rs index e0830bb98..6c13aa369 100644 --- a/parity-crypto/benches/bench.rs +++ b/parity-crypto/benches/bench.rs @@ -14,11 +14,8 @@ // You should have received a copy of the GNU General Public License // along with Parity. If not, see . -#[macro_use] -extern crate criterion; - use crate::parity_crypto::publickey::Generator; -use criterion::{Bencher, Criterion}; +use criterion::{criterion_group, criterion_main, Bencher, Criterion}; criterion_group!(benches, input_len, ecdh_agree,); diff --git a/primitive-types/impls/serde/src/serialize.rs b/primitive-types/impls/serde/src/serialize.rs index 01e85c036..431a56ec7 100644 --- a/primitive-types/impls/serde/src/serialize.rs +++ b/primitive-types/impls/serde/src/serialize.rs @@ -272,9 +272,7 @@ where #[cfg(test)] mod tests { use super::*; - extern crate serde_derive; - - use self::serde_derive::{Deserialize, Serialize}; + use serde_derive::{Deserialize, Serialize}; #[derive(Serialize, Deserialize)] struct Bytes(#[serde(with = "super")] Vec); diff --git a/rlp/src/lib.rs b/rlp/src/lib.rs index ab386e689..a4c66e2ac 100644 --- a/rlp/src/lib.rs +++ b/rlp/src/lib.rs @@ -59,14 +59,10 @@ pub const EMPTY_LIST_RLP: [u8; 1] = [0xC0; 1]; /// Shortcut function to decode trusted rlp /// -/// ```rust -/// extern crate rlp; -/// -/// fn main () { -/// let data = vec![0x83, b'c', b'a', b't']; -/// let animal: String = rlp::decode(&data).expect("could not decode"); -/// assert_eq!(animal, "cat".to_owned()); -/// } +/// ``` +/// let data = vec![0x83, b'c', b'a', b't']; +/// let animal: String = rlp::decode(&data).expect("could not decode"); +/// assert_eq!(animal, "cat".to_owned()); /// ``` pub fn decode(bytes: &[u8]) -> Result where @@ -86,14 +82,10 @@ where /// Shortcut function to encode structure into rlp. /// -/// ```rust -/// extern crate rlp; -/// -/// fn main () { -/// let animal = "cat"; -/// let out = rlp::encode(&animal); -/// assert_eq!(out, vec![0x83, b'c', b'a', b't']); -/// } +/// ``` +/// let animal = "cat"; +/// let out = rlp::encode(&animal); +/// assert_eq!(out, vec![0x83, b'c', b'a', b't']); /// ``` pub fn encode(object: &E) -> Vec where diff --git a/rlp/src/stream.rs b/rlp/src/stream.rs index 6dcf1500e..851b845b9 100644 --- a/rlp/src/stream.rs +++ b/rlp/src/stream.rs @@ -53,16 +53,12 @@ impl RlpStream { /// Apends null to the end of stream, chainable. /// - /// ```rust - /// extern crate rlp; - /// use rlp::*; - /// - /// fn main () { - /// let mut stream = RlpStream::new_list(2); - /// stream.append_empty_data().append_empty_data(); - /// let out = stream.out(); - /// assert_eq!(out, vec![0xc2, 0x80, 0x80]); - /// } + /// ``` + /// use rlp::RlpStream; + /// let mut stream = RlpStream::new_list(2); + /// stream.append_empty_data().append_empty_data(); + /// let out = stream.out(); + /// assert_eq!(out, vec![0xc2, 0x80, 0x80]); /// ``` pub fn append_empty_data(&mut self) -> &mut Self { // self push raw item @@ -94,16 +90,12 @@ impl RlpStream { /// Appends value to the end of stream, chainable. /// - /// ```rust - /// extern crate rlp; - /// use rlp::*; - /// - /// fn main () { - /// let mut stream = RlpStream::new_list(2); - /// stream.append(&"cat").append(&"dog"); - /// let out = stream.out(); - /// assert_eq!(out, vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']); - /// } + /// ``` + /// use rlp::RlpStream; + /// let mut stream = RlpStream::new_list(2); + /// stream.append(&"cat").append(&"dog"); + /// let out = stream.out(); + /// assert_eq!(out, vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']); /// ``` pub fn append(&mut self, value: &E) -> &mut Self where @@ -119,16 +111,12 @@ impl RlpStream { /// Appends iterator to the end of stream, chainable. /// - /// ```rust - /// extern crate rlp; - /// use rlp::*; - /// - /// fn main () { - /// let mut stream = RlpStream::new_list(2); - /// stream.append(&"cat").append_iter("dog".as_bytes().iter().cloned()); - /// let out = stream.out(); - /// assert_eq!(out, vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']); - /// } + /// ``` + /// use rlp::RlpStream; + /// let mut stream = RlpStream::new_list(2); + /// stream.append(&"cat").append_iter("dog".as_bytes().iter().cloned()); + /// let out = stream.out(); + /// assert_eq!(out, vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']); /// ``` pub fn append_iter(&mut self, value: I) -> &mut Self where @@ -167,17 +155,13 @@ impl RlpStream { /// Declare appending the list of given size, chainable. /// - /// ```rust - /// extern crate rlp; - /// use rlp::*; - /// - /// fn main () { - /// let mut stream = RlpStream::new_list(2); - /// stream.begin_list(2).append(&"cat").append(&"dog"); - /// stream.append(&""); - /// let out = stream.out(); - /// assert_eq!(out, vec![0xca, 0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g', 0x80]); - /// } + /// ``` + /// use rlp::RlpStream; + /// let mut stream = RlpStream::new_list(2); + /// stream.begin_list(2).append(&"cat").append(&"dog"); + /// stream.append(&""); + /// let out = stream.out(); + /// assert_eq!(out, vec![0xca, 0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g', 0x80]); /// ``` pub fn begin_list(&mut self, len: usize) -> &mut RlpStream { self.finished_list = false; @@ -249,18 +233,15 @@ impl RlpStream { /// Clear the output stream so far. /// - /// ```rust - /// extern crate rlp; - /// use rlp::*; - /// - /// fn main () { - /// let mut stream = RlpStream::new_list(3); - /// stream.append(&"cat"); - /// stream.clear(); - /// stream.append(&"dog"); - /// let out = stream.out(); - /// assert_eq!(out, vec![0x83, b'd', b'o', b'g']); - /// } + /// ``` + /// use rlp::RlpStream; + /// let mut stream = RlpStream::new_list(3); + /// stream.append(&"cat"); + /// stream.clear(); + /// stream.append(&"dog"); + /// let out = stream.out(); + /// assert_eq!(out, vec![0x83, b'd', b'o', b'g']); + /// ``` pub fn clear(&mut self) { // clear bytes self.buffer.clear(); @@ -271,19 +252,16 @@ impl RlpStream { /// Returns true if stream doesnt expect any more items. /// - /// ```rust - /// extern crate rlp; - /// use rlp::*; - /// - /// fn main () { - /// let mut stream = RlpStream::new_list(2); - /// stream.append(&"cat"); - /// assert_eq!(stream.is_finished(), false); - /// stream.append(&"dog"); - /// assert_eq!(stream.is_finished(), true); - /// let out = stream.out(); - /// assert_eq!(out, vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']); - /// } + /// ``` + /// use rlp::RlpStream; + /// let mut stream = RlpStream::new_list(2); + /// stream.append(&"cat"); + /// assert_eq!(stream.is_finished(), false); + /// stream.append(&"dog"); + /// assert_eq!(stream.is_finished(), true); + /// let out = stream.out(); + /// assert_eq!(out, vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']); + /// ``` pub fn is_finished(&self) -> bool { self.unfinished_lists.is_empty() } diff --git a/triehash/src/lib.rs b/triehash/src/lib.rs index 964e7e14f..81a005826 100644 --- a/triehash/src/lib.rs +++ b/triehash/src/lib.rs @@ -47,20 +47,15 @@ fn shared_prefix_len(first: &[T], second: &[T]) -> usize { /// Generates a trie root hash for a vector of values /// -/// ```rust -/// extern crate triehash; -/// extern crate keccak_hasher; -/// extern crate ethereum_types; -/// #[macro_use] extern crate hex_literal; +/// ``` +/// use hex_literal::hex; /// use ethereum_types::H256; /// use triehash::ordered_trie_root; /// use keccak_hasher::KeccakHasher; /// -/// fn main() { -/// let v = &["doe", "reindeer"]; -/// let root = H256::from(hex!("e766d5d51b89dc39d981b41bda63248d7abce4f0225eefd023792a540bcffee3")); -/// assert_eq!(ordered_trie_root::(v), root.as_ref()); -/// } +/// let v = &["doe", "reindeer"]; +/// let root = H256::from(hex!("e766d5d51b89dc39d981b41bda63248d7abce4f0225eefd023792a540bcffee3")); +/// assert_eq!(ordered_trie_root::(v), root.as_ref()); /// ``` pub fn ordered_trie_root(input: I) -> H::Out where @@ -74,25 +69,20 @@ where /// Generates a trie root hash for a vector of key-value tuples /// -/// ```rust -/// extern crate triehash; -/// extern crate ethereum_types; -/// extern crate keccak_hasher; -/// #[macro_use] extern crate hex_literal; +/// ``` +/// use hex_literal::hex; /// use triehash::trie_root; /// use ethereum_types::H256; /// use keccak_hasher::KeccakHasher; /// -/// fn main() { -/// let v = vec![ -/// ("doe", "reindeer"), -/// ("dog", "puppy"), -/// ("dogglesworth", "cat"), -/// ]; +/// let v = vec![ +/// ("doe", "reindeer"), +/// ("dog", "puppy"), +/// ("dogglesworth", "cat"), +/// ]; /// -/// let root = H256::from(hex!("8aad789dff2f538bca5d8ea56e8abe10f4c7ba3a5dea95fea4cd6e7c3a1168d3")); -/// assert_eq!(trie_root::(v), root.as_ref()); -/// } +/// let root = H256::from(hex!("8aad789dff2f538bca5d8ea56e8abe10f4c7ba3a5dea95fea4cd6e7c3a1168d3")); +/// assert_eq!(trie_root::(v), root.as_ref()); /// ``` pub fn trie_root(input: I) -> H::Out where @@ -126,25 +116,20 @@ where /// Generates a key-hashed (secure) trie root hash for a vector of key-value tuples. /// -/// ```rust -/// extern crate triehash; -/// extern crate keccak_hasher; -/// extern crate ethereum_types; -/// #[macro_use] extern crate hex_literal; +/// ``` +/// use hex_literal::hex; /// use ethereum_types::H256; /// use triehash::sec_trie_root; /// use keccak_hasher::KeccakHasher; /// -/// fn main() { -/// let v = vec![ -/// ("doe", "reindeer"), -/// ("dog", "puppy"), -/// ("dogglesworth", "cat"), -/// ]; +/// let v = vec![ +/// ("doe", "reindeer"), +/// ("dog", "puppy"), +/// ("dogglesworth", "cat"), +/// ]; /// -/// let root = H256::from(hex!("d4cd937e4a4368d7931a9cf51686b7e10abb3dce38a39000fd7902a092b64585")); -/// assert_eq!(sec_trie_root::(v), root.as_ref()); -/// } +/// let root = H256::from(hex!("d4cd937e4a4368d7931a9cf51686b7e10abb3dce38a39000fd7902a092b64585")); +/// assert_eq!(sec_trie_root::(v), root.as_ref()); /// ``` pub fn sec_trie_root(input: I) -> H::Out where