Run clippy on all tests

Author: webmaster128

.circleci/config.yml

@@ -694,34 +694,38 @@ jobs:
       #
       # Workspace packages
       #
+      - run:
+          name: Clippy linting on crypto
+          working_directory: ~/project/packages/crypto
+          command: cargo clippy --tests -- -D warnings
       - run:
           name: Clippy linting on schema
           working_directory: ~/project/packages/schema
-          command: cargo clippy -- -D warnings
+          command: cargo clippy --tests -- -D warnings
       - run:
           name: Clippy linting on std (no feature flags)
           working_directory: ~/project/packages/std
-          command: cargo clippy -- -D warnings
+          command: cargo clippy --tests -- -D warnings
       - run:
           name: Clippy linting on std (all feature flags)
           working_directory: ~/project/packages/std
-          command: cargo clippy --features iterator,staking -- -D warnings
+          command: cargo clippy --tests --features iterator,staking -- -D warnings
       - run:
           name: Clippy linting on storage (no feature flags)
           working_directory: ~/project/packages/storage
-          command: cargo clippy -- -D warnings
+          command: cargo clippy --tests -- -D warnings
       - run:
           name: Clippy linting on storage (all feature flags)
           working_directory: ~/project/packages/storage
-          command: cargo clippy --features iterator -- -D warnings
+          command: cargo clippy --tests --features iterator -- -D warnings
       - run:
           name: Clippy linting on vm (no feature flags)
           working_directory: ~/project/packages/vm
-          command: cargo clippy --no-default-features -- -D warnings
+          command: cargo clippy --tests --no-default-features -- -D warnings
       - run:
           name: Clippy linting on vm (all feature flags)
           working_directory: ~/project/packages/vm
-          command: cargo clippy --features iterator,staking,stargate -- -D warnings
+          command: cargo clippy --tests --features iterator,staking,stargate -- -D warnings
       #
       # Contracts
       #

packages/std/src/addresses.rs

@@ -251,7 +251,7 @@ mod tests {
         assert_eq!(set.len(), 2);
 
         let set1 = HashSet::<HumanAddr>::from_iter(vec![bob.clone(), alice1.clone()]);
-        let set2 = HashSet::from_iter(vec![alice1.clone(), alice2.clone(), bob.clone()]);
+        let set2 = HashSet::from_iter(vec![alice1, alice2, bob]);
         assert_eq!(set1, set2);
     }
 
@@ -399,7 +399,7 @@ mod tests {
         assert_eq!(set.len(), 2);
 
         let set1 = HashSet::<CanonicalAddr>::from_iter(vec![bob.clone(), alice1.clone()]);
-        let set2 = HashSet::from_iter(vec![alice1.clone(), alice2.clone(), bob.clone()]);
+        let set2 = HashSet::from_iter(vec![alice1, alice2, bob]);
         assert_eq!(set1, set2);
     }
 }

packages/std/src/binary.rs

@@ -541,7 +541,7 @@ mod tests {
         assert_eq!(set.len(), 2);
 
         let set1 = HashSet::<Binary>::from_iter(vec![b.clone(), a1.clone()]);
-        let set2 = HashSet::from_iter(vec![a1.clone(), a2.clone(), b.clone()]);
+        let set2 = HashSet::from_iter(vec![a1, a2, b]);
         assert_eq!(set1, set2);
     }
 

packages/std/src/deps.rs

@@ -74,8 +74,8 @@ mod tests {
     fn execute2(_deps: DepsMut) {}
 
     fn query(deps: Deps) {
-        query2(deps.clone());
-        query2(deps.clone());
+        query2(deps);
+        query2(deps);
     }
     fn query2(_deps: Deps) {}
 

packages/std/src/math.rs

@@ -432,13 +432,13 @@ mod tests {
         // 1/3 (result floored)
         assert_eq!(
             Decimal::from_ratio(1u64, 3u64),
-            Decimal(0_333_333_333_333_333_333)
+            Decimal(333_333_333_333_333_333)
         );
 
         // 2/3 (result floored)
         assert_eq!(
             Decimal::from_ratio(2u64, 3u64),
-            Decimal(0_666_666_666_666_666_666)
+            Decimal(666_666_666_666_666_666)
         );
     }
 
@@ -467,9 +467,9 @@ mod tests {
         assert_eq!(Decimal::from_str("0.123").unwrap(), Decimal::permille(123));
 
         assert_eq!(Decimal::from_str("40.00").unwrap(), Decimal::percent(4000));
-        assert_eq!(Decimal::from_str("04.00").unwrap(), Decimal::percent(0400));
-        assert_eq!(Decimal::from_str("00.40").unwrap(), Decimal::percent(0040));
-        assert_eq!(Decimal::from_str("00.04").unwrap(), Decimal::percent(0004));
+        assert_eq!(Decimal::from_str("04.00").unwrap(), Decimal::percent(400));
+        assert_eq!(Decimal::from_str("00.40").unwrap(), Decimal::percent(40));
+        assert_eq!(Decimal::from_str("00.04").unwrap(), Decimal::percent(4));
 
         // Can handle 18 fractional digits
         assert_eq!(
@@ -738,6 +738,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(clippy::op_ref)]
     fn uint128_math() {
         let a = Uint128(12345);
         let b = Uint128(23456);

packages/std/src/mock.rs

@@ -664,7 +664,7 @@ mod tests {
         let expected = hex!("044a071e8a6e10aada2b8cf39fa3b5fb3400b04e99ea8ae64ceea1a977dbeaf5d5f8c8fbd10b71ab14cd561f7df8eb6da50f8a8d81ba564342244d26d1d4211595");
 
         // Wrong hash
-        let mut corrupted_hash = hash.clone();
+        let mut corrupted_hash = hash;
         corrupted_hash[0] ^= 0x01;
         let pubkey = api
             .secp256k1_recover_pubkey(&corrupted_hash, &signature, recovery_param)
@@ -784,9 +784,7 @@ mod tests {
 
         // all
         let all = bank
-            .query(&BankQuery::AllBalances {
-                address: addr.clone(),
-            })
+            .query(&BankQuery::AllBalances { address: addr })
             .unwrap()
             .unwrap();
         let res: AllBalanceResponse = from_binary(&all).unwrap();
@@ -813,7 +811,7 @@ mod tests {
         // missing denom
         let miss = bank
             .query(&BankQuery::Balance {
-                address: addr.clone(),
+                address: addr,
                 denom: "MISS".to_string(),
             })
             .unwrap()
@@ -970,21 +968,21 @@ mod tests {
 
         // filter a by validator (1 and 1)
         let dels = get_delegator(&staking, user_a.clone(), val1.clone());
-        assert_eq!(dels, Some(del1a.clone()));
-        let dels = get_delegator(&staking, user_a.clone(), val2.clone());
-        assert_eq!(dels, Some(del2a.clone()));
+        assert_eq!(dels, Some(del1a));
+        let dels = get_delegator(&staking, user_a, val2.clone());
+        assert_eq!(dels, Some(del2a));
 
         // filter b by validator (2 and 0)
         let dels = get_delegator(&staking, user_b.clone(), val1.clone());
-        assert_eq!(dels, Some(del1b.clone()));
-        let dels = get_delegator(&staking, user_b.clone(), val2.clone());
+        assert_eq!(dels, Some(del1b));
+        let dels = get_delegator(&staking, user_b, val2.clone());
         assert_eq!(dels, None);
 
         // filter c by validator (0 and 1)
-        let dels = get_delegator(&staking, user_c.clone(), val1.clone());
+        let dels = get_delegator(&staking, user_c.clone(), val1);
         assert_eq!(dels, None);
-        let dels = get_delegator(&staking, user_c.clone(), val2.clone());
-        assert_eq!(dels, Some(del2c.clone()));
+        let dels = get_delegator(&staking, user_c, val2);
+        assert_eq!(dels, Some(del2c));
     }
 
     #[test]

packages/std/src/results/context.rs

@@ -80,7 +80,7 @@ mod tests {
     fn empty_context() {
         let ctx = Context::new();
 
-        let init: Response = ctx.clone().into();
+        let init: Response = ctx.into();
         assert_eq!(init, Response::default());
     }
 
@@ -105,7 +105,7 @@ mod tests {
         let expected_attributes = vec![attr("sender", "john"), attr("action", "test")];
         let expected_data = Some(Binary::from(b"banana"));
 
-        let response: Response = ctx.clone().into();
+        let response: Response = ctx.into();
         assert_eq!(&response.messages, &expected_msgs);
         assert_eq!(&response.attributes, &expected_attributes);
         assert_eq!(&response.data, &expected_data);

packages/storage/src/bucket.rs

@@ -230,7 +230,7 @@ mod tests {
         };
         bucket.save(b"maria", &data).unwrap();
 
-        let reader = bucket_read::<Data>(&mut store, b"data");
+        let reader = bucket_read::<Data>(&store, b"data");
 
         // check empty data handling
         assert!(reader.load(b"john").is_err());
@@ -291,7 +291,7 @@ mod tests {
 
         // it's my birthday
         let birthday = |mayd: Option<Data>| -> StdResult<Data> {
-            let mut d = mayd.ok_or(StdError::not_found("Data"))?;
+            let mut d = mayd.ok_or_else(|| StdError::not_found("Data"))?;
             d.age += 1;
             Ok(d)
         };
@@ -321,7 +321,7 @@ mod tests {
         let mut old_age = 0i32;
         bucket
             .update(b"maria", |mayd: Option<Data>| -> StdResult<_> {
-                let mut d = mayd.ok_or(StdError::not_found("Data"))?;
+                let mut d = mayd.ok_or_else(|| StdError::not_found("Data"))?;
                 old_age = d.age;
                 d.age += 1;
                 Ok(d)
@@ -390,7 +390,7 @@ mod tests {
                 data.age += 1;
                 Ok(data)
             } else {
-                return Err(MyError::NotFound);
+                Err(MyError::NotFound)
             }
         });
         match res.unwrap_err() {

packages/storage/src/prefixed_storage.rs

@@ -115,14 +115,14 @@ mod tests {
         let mut storage = MockStorage::new();
 
         // set
-        let mut foo = PrefixedStorage::new(&mut storage, b"foo");
-        foo.set(b"bar", b"gotcha");
+        let mut s1 = PrefixedStorage::new(&mut storage, b"foo");
+        s1.set(b"bar", b"gotcha");
         assert_eq!(storage.get(b"\x00\x03foobar").unwrap(), b"gotcha".to_vec());
 
         // get
-        let foo = PrefixedStorage::new(&mut storage, b"foo");
-        assert_eq!(foo.get(b"bar"), Some(b"gotcha".to_vec()));
-        assert_eq!(foo.get(b"elsewhere"), None);
+        let s2 = PrefixedStorage::new(&mut storage, b"foo");
+        assert_eq!(s2.get(b"bar"), Some(b"gotcha".to_vec()));
+        assert_eq!(s2.get(b"elsewhere"), None);
     }
 
     #[test]
@@ -149,13 +149,13 @@ mod tests {
         storage.set(b"\x00\x03foobar", b"gotcha");
 
         // try readonly correctly
-        let foo = ReadonlyPrefixedStorage::new(&storage, b"foo");
-        assert_eq!(foo.get(b"bar"), Some(b"gotcha".to_vec()));
-        assert_eq!(foo.get(b"elsewhere"), None);
+        let s1 = ReadonlyPrefixedStorage::new(&storage, b"foo");
+        assert_eq!(s1.get(b"bar"), Some(b"gotcha".to_vec()));
+        assert_eq!(s1.get(b"elsewhere"), None);
 
         // no collisions with other prefixes
-        let fo = ReadonlyPrefixedStorage::new(&storage, b"fo");
-        assert_eq!(fo.get(b"obar"), None);
+        let s2 = ReadonlyPrefixedStorage::new(&storage, b"fo");
+        assert_eq!(s2.get(b"obar"), None);
     }
 
     #[test]

packages/vm/src/checksum.rs

@@ -106,7 +106,7 @@ mod tests {
 
     #[test]
     fn into_vec_works() {
-        let checksum = Checksum::generate(&vec![12u8; 17]);
+        let checksum = Checksum::generate(&[12u8; 17]);
         let as_vec: Vec<u8> = checksum.into();
         assert_eq!(as_vec, checksum.0);
     }