Fix Clippy warnings in test code.

And use the same Rust nightly version for Clippy and Rustfmt.

.travis.yml

@@ -63,7 +63,7 @@ matrix:
       before_script:
         - rustup component add clippy-preview
       script:
-        - cargo clippy --all -- -D clippy
+        - cargo clippy --all --tests --all-features -- -D clippy
 
 env:
   global:

src/merkletree.rs

@@ -163,7 +163,7 @@ impl<T> MerkleTree<T> {
     /// Generate an inclusion proof for the `n`-th leaf value.
     pub fn gen_nth_proof(&self, n: usize) -> Option<Proof<T>>
     where
-        T: Hashable + Clone
+        T: Hashable + Clone,
     {
         let root_hash = self.root_hash().clone();
         let value = if let Some(value) = self.root.nth_leaf(n, self.count) {

src/proof.rs

@@ -57,6 +57,7 @@ mod algorithm_serde {
         }
     }
 
+    #[cfg(test)]
     mod test {
         use super::*;
         use ring::digest::{
@@ -74,13 +75,13 @@ mod algorithm_serde {
         fn test_serialize_known_algorithms() {
             extern crate serde_json;
 
-            for alg in [SHA1, SHA256, SHA384, SHA512, SHA512_256].iter() {
+            for alg in &[SHA1, SHA256, SHA384, SHA512, SHA512_256] {
                 let mut serializer = serde_json::Serializer::with_formatter(
                     vec![],
                     serde_json::ser::PrettyFormatter::new(),
                 );
 
-                let _ = serialize(alg, &mut serializer).expect(&format!("{:?}", alg));
+                serialize(alg, &mut serializer).expect(&format!("{:?}", alg));
                 let alg_ = deserialize(&mut serde_json::Deserializer::from_slice(
                     &serializer.into_inner()[..],
                 )).expect(&format!("{:?}", alg));

src/tests.rs

@@ -153,7 +153,7 @@ fn test_wrong_proof() {
 #[test]
 fn test_nth_proof() {
     // 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].iter() {
+    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 tree = MerkleTree::from_vec(digest, values.clone());
         let root_hash = tree.root_hash();
@@ -206,7 +206,7 @@ fn test_tree_iter() {
 fn test_tree_into_iter() {
     let values = (1..10).map(|x| vec![x]).collect::<Vec<_>>();
     let tree = MerkleTree::from_vec(digest, values.clone());
-    let iter = tree.iter().cloned().collect::<Vec<_>>();
+    let iter = tree.into_iter().collect::<Vec<_>>();
 
     assert_eq!(values, iter);
 }

src/tree.rs

@@ -77,7 +77,11 @@ impl<T> Tree<T> {
                     None
                 }
             }
-            Tree::Node { ref left, ref right, .. } => {
+            Tree::Node {
+                ref left,
+                ref right,
+                ..
+            } => {
                 if n < left_count {
                     left.nth_leaf(n, left_count)
                 } else {

tests/proto.rs

@@ -39,8 +39,8 @@ pub struct PublicKey {
 impl PublicKey {
     pub fn new(zero_values: Vec<u8>, one_values: Vec<u8>) -> Self {
         PublicKey {
-            zero_values: zero_values,
+            zero_values,
-            one_values: one_values,
+            one_values,
         }
     }