Fix Clippy warings (#468)

Author: qsantos

src/big_integer/poly1305.rs

@@ -91,7 +91,7 @@ mod tests {
         mac.add_msg(&tmp_buffer, 2);
         let result = mac.get_tag();
         assert_eq!(
-            get_tag_hex(&result.as_slice()),
+            get_tag_hex(result.as_slice()),
             "a8061dc1305136c6c22b8baf0c0127a9"
         );
     }

src/ciphers/aes.rs

@@ -538,7 +538,7 @@ mod tests {
         let decrypted = aes_decrypt(&encrypted, AesKey::AesKey128(key));
         assert_eq!(
             str,
-            String::from_utf8(decrypted).unwrap().trim_end_matches("\0")
+            String::from_utf8(decrypted).unwrap().trim_end_matches('\0')
         );
     }
 }

src/ciphers/diffie_hellman.rs

@@ -296,24 +296,20 @@ mod tests {
     #[test]
     fn verify_invalid_pub_key() {
         let diffie = DiffieHellman::new(Some(14));
-        assert_eq!(diffie.is_valid_public_key("0000"), false);
+        assert!(!diffie.is_valid_public_key("0000"));
     }
 
     #[test]
     fn verify_valid_pub_key() {
         let diffie = DiffieHellman::new(Some(14));
-        assert_eq!(
-            diffie.is_valid_public_key("EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"),
-            true
-        );
+        assert!(diffie.is_valid_public_key("EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"));
     }
 
     #[test]
     fn verify_invalid_pub_key_same_as_prime() {
         let diffie = DiffieHellman::new(Some(14));
-        assert_eq!(
-            diffie.is_valid_public_key(
-                "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1\
+        assert!(!diffie.is_valid_public_key(
+            "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1\
         29024E088A67CC74020BBEA63B139B22514A08798E3404DD\
         EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245\
         E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED\
@@ -324,9 +320,7 @@ mod tests {
         E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9\
         DE2BCBF6955817183995497CEA956AE515D2261898FA0510\
         15728E5A8AACAA68FFFFFFFFFFFFFFFF"
-            ),
-            false
-        );
+        ));
     }
 
     #[test]

src/ciphers/hashing_traits.rs

@@ -79,7 +79,7 @@ mod tests {
         // echo -n "Hello World" | openssl sha256 -hex -mac HMAC -macopt hexkey:"deadbeef"
         let mut hmac: HMAC<64, 32, SHA256> = HMAC::new_default();
         hmac.add_key(&[0xde, 0xad, 0xbe, 0xef]).unwrap();
-        hmac.update(&b"Hello World".to_vec());
+        hmac.update(b"Hello World");
         let hash = hmac.finalize();
         assert_eq!(
             get_hash_string(&hash),

src/ciphers/morse_code.rs

@@ -8,15 +8,14 @@ pub fn encode(message: &str) -> String {
     let dictionary = _morse_dictionary();
     message
         .chars()
-        .into_iter()
         .map(|char| char.to_uppercase().to_string())
         .map(|letter| dictionary.get(letter.as_str()))
         .map(|option| option.unwrap_or(&UNKNOWN_CHARACTER).to_string())
         .collect::<Vec<String>>()
         .join(" ")
 }
 
-// Declaritive macro for creating readable map declarations, for more info see https://doc.rust-lang.org/book/ch19-06-macros.html
+// Declarative macro for creating readable map declarations, for more info see https://doc.rust-lang.org/book/ch19-06-macros.html
 macro_rules! map {
     ($($key:expr => $value:expr),* $(,)?) => {
         std::iter::Iterator::collect(IntoIterator::into_iter([$(($key, $value),)*]))

src/ciphers/sha256.rs

@@ -270,7 +270,7 @@ pub mod tests {
     #[test]
     fn ascii() {
         let mut res = SHA256::new_default();
-        res.update(&b"The quick brown fox jumps over the lazy dog".to_vec());
+        res.update(b"The quick brown fox jumps over the lazy dog");
         assert_eq!(
             res.get_hash(),
             [
@@ -284,7 +284,7 @@ pub mod tests {
     #[test]
     fn ascii_avalanche() {
         let mut res = SHA256::new_default();
-        res.update(&b"The quick brown fox jumps over the lazy dog.".to_vec());
+        res.update(b"The quick brown fox jumps over the lazy dog.");
         assert_eq!(
             res.get_hash(),
             [
@@ -306,7 +306,7 @@ pub mod tests {
     #[test]
     fn long_ascii() {
         let mut res = SHA256::new_default();
-        let val = &b"The quick brown fox jumps over the lazy dog.".to_vec();
+        let val = b"The quick brown fox jumps over the lazy dog.";
         for _ in 0..1000 {
             res.update(val);
         }
@@ -316,7 +316,7 @@ pub mod tests {
             "c264fca077807d391df72fadf39dd63be21f1823f65ca530c9637760eabfc18c"
         );
         let mut res = SHA256::new_default();
-        let val = &b"a".to_vec();
+        let val = b"a";
         for _ in 0..999 {
             res.update(val);
         }
@@ -329,7 +329,7 @@ pub mod tests {
     #[test]
     fn short_ascii() {
         let mut res = SHA256::new_default();
-        let val = &b"a".to_vec();
+        let val = b"a";
         res.update(val);
         let hash = res.get_hash();
         assert_eq!(

src/ciphers/xor.rs

@@ -35,15 +35,15 @@ mod tests {
     #[test]
     fn test_zero_byte() {
         let test_string = "The quick brown fox jumps over the lazy dog";
-        let key = ' ' as u8;
+        let key = b' ';
         let ciphered_text = xor(test_string, key);
         assert_eq!(test_string.as_bytes(), xor_bytes(&ciphered_text, key));
     }
 
     #[test]
     fn test_invalid_byte() {
         let test_string = "The quick brown fox jumps over the lazy dog";
-        let key = !0 as u8;
+        let key = !0;
         let ciphered_text = xor(test_string, key);
         assert_eq!(test_string.as_bytes(), xor_bytes(&ciphered_text, key));
     }

src/data_structures/avl_tree.rs

@@ -365,7 +365,7 @@ mod tests {
     #[test]
     fn sorted() {
         let tree: AVLTree<_> = (1..8).rev().collect();
-        assert!((1..8).eq(tree.iter().map(|&x| x)));
+        assert!((1..8).eq(tree.iter().copied()));
     }
 
     #[test]

src/data_structures/b_tree.rs

@@ -182,6 +182,6 @@ mod test {
         tree.insert(12);
         tree.insert(15);
         assert!(tree.search(15));
-        assert_eq!(tree.search(16), false);
+        assert!(!tree.search(16));
     }
 }

src/data_structures/graph.rs

@@ -135,7 +135,7 @@ mod test_undirected_graph {
             (&String::from("c"), &String::from("b"), 10),
         ];
         for edge in expected_edges.iter() {
-            assert_eq!(graph.edges().contains(edge), true);
+            assert!(graph.edges().contains(edge));
         }
     }
 
@@ -188,7 +188,7 @@ mod test_directed_graph {
             (&String::from("b"), &String::from("c"), 10),
         ];
         for edge in expected_edges.iter() {
-            assert_eq!(graph.edges().contains(edge), true);
+            assert!(graph.edges().contains(edge));
         }
     }
 
@@ -212,9 +212,9 @@ mod test_directed_graph {
         graph.add_node("a");
         graph.add_node("b");
         graph.add_node("c");
-        assert_eq!(graph.contains("a"), true);
-        assert_eq!(graph.contains("b"), true);
-        assert_eq!(graph.contains("c"), true);
-        assert_eq!(graph.contains("d"), false);
+        assert!(graph.contains("a"));
+        assert!(graph.contains("b"));
+        assert!(graph.contains("c"));
+        assert!(!graph.contains("d"));
     }
 }

src/data_structures/heap.rs

@@ -169,12 +169,8 @@ mod tests {
         assert_eq!(heap.next(), Some(2));
     }
 
+    #[derive(Default)]
     struct Point(/* x */ i32, /* y */ i32);
-    impl Default for Point {
-        fn default() -> Self {
-            Self(0, 0)
-        }
-    }
 
     #[test]
     fn test_key_heap() {

src/data_structures/linked_list.rs

@@ -481,7 +481,7 @@ mod tests {
         println!("Linked List is {}", list);
         let retrived_item = list.get(1);
         assert!(retrived_item.is_some());
-        assert_eq!(2 as i32, *retrived_item.unwrap());
+        assert_eq!(2, *retrived_item.unwrap());
     }
 
     #[test]

src/data_structures/queue.rs

@@ -47,7 +47,7 @@ mod tests {
     fn test_enqueue() {
         let mut queue: Queue<u8> = Queue::new();
         queue.enqueue(64);
-        assert_eq!(queue.is_empty(), false);
+        assert!(!queue.is_empty());
     }
 
     #[test]

src/data_structures/stack_using_singly_linked_list.rs

@@ -181,15 +181,15 @@ mod test_stack {
         list.push(4);
         list.push(5);
 
-        assert_eq!(list.is_empty(), false);
+        assert!(!list.is_empty());
 
         assert_eq!(list.pop(), Ok(5));
         assert_eq!(list.pop(), Ok(4));
 
         assert_eq!(list.pop(), Ok(1));
         assert_eq!(list.pop(), Err("Stack is empty"));
 
-        assert_eq!(list.is_empty(), true);
+        assert!(list.is_empty());
     }
 
     #[test]
@@ -204,8 +204,8 @@ mod test_stack {
         assert_eq!(list.peek_mut(), Some(&mut 3));
 
         match list.peek_mut() {
-            None => None,
-            Some(value) => Some(*value = 42),
+            None => (),
+            Some(value) => *value = 42,
         };
 
         assert_eq!(list.peek(), Some(&42));

src/data_structures/treap.rs

@@ -337,7 +337,7 @@ mod tests {
     #[test]
     fn sorted() {
         let tree: Treap<_> = (1..8).rev().collect();
-        assert!((1..8).eq(tree.iter().map(|&x| x)));
+        assert!((1..8).eq(tree.iter().copied()));
     }
 
     #[test]

src/data_structures/union_find.rs

@@ -74,16 +74,16 @@ mod tests {
         assert_eq!(uf.find(8), 8);
         assert_eq!(uf.find(9), 9);
 
-        assert_eq!(uf.union(0, 1), true);
-        assert_eq!(uf.union(1, 2), true);
-        assert_eq!(uf.union(2, 3), true);
-        assert_eq!(uf.union(3, 4), true);
-        assert_eq!(uf.union(4, 5), true);
-        assert_eq!(uf.union(5, 6), true);
-        assert_eq!(uf.union(6, 7), true);
-        assert_eq!(uf.union(7, 8), true);
-        assert_eq!(uf.union(8, 9), true);
-        assert_eq!(uf.union(9, 0), false);
+        assert!(uf.union(0, 1));
+        assert!(uf.union(1, 2));
+        assert!(uf.union(2, 3));
+        assert!(uf.union(3, 4));
+        assert!(uf.union(4, 5));
+        assert!(uf.union(5, 6));
+        assert!(uf.union(6, 7));
+        assert!(uf.union(7, 8));
+        assert!(uf.union(8, 9));
+        assert!(!uf.union(9, 0));
 
         assert_eq!(1, uf.count());
     }

src/dynamic_programming/fractional_knapsack.rs

@@ -91,7 +91,7 @@ mod tests {
     fn test_nan() {
         let capacity = 36.0;
         // 2nd element is NaN
-        let values = vec![25.0, 0.0 / 0.0, 25.0, 6.0, 2.0];
+        let values = vec![25.0, f64::NAN, 25.0, 6.0, 2.0];
         let weights = vec![10.0, 10.0, 10.0, 4.0, 2.0];
         assert_eq!(fractional_knapsack(capacity, weights, values), 83.0);
     }

src/dynamic_programming/is_subsequence.rs

@@ -27,13 +27,7 @@ mod tests {
 
     #[test]
     fn test() {
-        assert_eq!(
-            is_subsequence(String::from("abc"), String::from("ahbgdc")),
-            true
-        );
-        assert_eq!(
-            is_subsequence(String::from("axc"), String::from("ahbgdc")),
-            false
-        );
+        assert!(is_subsequence(String::from("abc"), String::from("ahbgdc")));
+        assert!(!is_subsequence(String::from("axc"), String::from("ahbgdc")));
     }
 }

src/dynamic_programming/longest_increasing_subsequence.rs

@@ -52,29 +52,29 @@ mod tests {
     #[test]
     /// Need to specify generic type T in order to function
     fn test_empty_vec() {
-        assert_eq!(longest_increasing_subsequence::<i32>(&vec![]), vec![]);
+        assert_eq!(longest_increasing_subsequence::<i32>(&[]), vec![]);
     }
 
     #[test]
     fn test_example_1() {
         assert_eq!(
-            longest_increasing_subsequence(&vec![10, 9, 2, 5, 3, 7, 101, 18]),
+            longest_increasing_subsequence(&[10, 9, 2, 5, 3, 7, 101, 18]),
             vec![2, 3, 7, 18]
         );
     }
 
     #[test]
     fn test_example_2() {
         assert_eq!(
-            longest_increasing_subsequence(&vec![0, 1, 0, 3, 2, 3]),
+            longest_increasing_subsequence(&[0, 1, 0, 3, 2, 3]),
             vec![0, 1, 2, 3]
         );
     }
 
     #[test]
     fn test_example_3() {
         assert_eq!(
-            longest_increasing_subsequence(&vec![7, 7, 7, 7, 7, 7, 7]),
+            longest_increasing_subsequence(&[7, 7, 7, 7, 7, 7, 7]),
             vec![7]
         );
     }
@@ -104,6 +104,6 @@ mod tests {
 
     #[test]
     fn test_negative_elements() {
-        assert_eq!(longest_increasing_subsequence(&vec![-2, -1]), vec![-2, -1]);
+        assert_eq!(longest_increasing_subsequence(&[-2, -1]), vec![-2, -1]);
     }
 }

src/dynamic_programming/maximal_square.rs

@@ -45,7 +45,7 @@ mod tests {
 
     #[test]
     fn test() {
-        assert_eq!(maximal_square(&mut vec![]), 0);
+        assert_eq!(maximal_square(&mut []), 0);
 
         let mut matrix = vec![vec![0, 1], vec![1, 0]];
         assert_eq!(maximal_square(&mut matrix), 1);

src/dynamic_programming/snail.rs

@@ -111,7 +111,7 @@ mod test {
     #[test]
     fn test_empty() {
         let empty: &[Vec<i32>] = &[vec![]];
-        assert_eq!(snail(&empty), vec![]);
+        assert_eq!(snail(empty), vec![]);
     }
 
     #[test]

src/general/convex_hull.rs

@@ -70,7 +70,7 @@ mod tests {
 
     #[test]
     fn empty() {
-        assert_eq!(convex_hull_graham(&vec![]), vec![]);
+        assert_eq!(convex_hull_graham(&[]), vec![]);
     }
 
     #[test]