Run clippy on tests and other new parts of the codebase

spacejam · spacejam · commit e7df1fbdce88 · 2020-10-24T10:54:16.000+02:00
diff --git a/examples/playground.rs b/examples/playground.rs
@@ -13,10 +13,10 @@ fn basic() -> Result<()> {
 
     // set and get
     db.insert(k.clone(), v1.clone())?;
-    assert_eq!(db.get(&k).unwrap().unwrap(), (v1.clone()));
+    assert_eq!(db.get(&k).unwrap().unwrap(), (v1));
 
     // compare and swap
-    match db.compare_and_swap(k.clone(), Some(&v1.clone()), Some(v2.clone()))? {
+    match db.compare_and_swap(k.clone(), Some(&v1), Some(v2.clone()))? {
         Ok(()) => println!("it worked!"),
         Err(sled::CompareAndSwapError { current: cur, proposed: _ }) => {
             println!("the actual current value is {:?}", cur)
@@ -26,8 +26,8 @@ fn basic() -> Result<()> {
     // scan forward
     let mut iter = db.range(k.as_slice()..);
     let (k1, v1) = iter.next().unwrap().unwrap();
-    assert_eq!(v1, v2.clone());
-    assert_eq!(k1, k.clone());
+    assert_eq!(v1, v2);
+    assert_eq!(k1, k);
     assert_eq!(iter.next(), None);
 
     // deletion
@@ -43,7 +43,7 @@ fn merge_operator() -> Result<()> {
         merged_bytes: &[u8],      // the new bytes being merged in
     ) -> Option<Vec<u8>> {
         // set the new value, return None to delete
-        let mut ret = old_value.map_or_else(|| vec![], |ov| ov.to_vec());
+        let mut ret = old_value.map_or_else(Vec::new, |ov| ov.to_vec());
 
         ret.extend_from_slice(merged_bytes);
 
diff --git a/src/ivec.rs b/src/ivec.rs
@@ -376,20 +376,20 @@ fn ivec_as_mut_identity() {
 mod qc {
     use super::IVec;
 
-    fn prop_identity(ivec: IVec) -> bool {
+    fn prop_identity(ivec: &IVec) -> bool {
         let mut iv2 = ivec.clone();
 
         if iv2 != ivec {
             println!("expected clone to equal original");
             return false;
         }
 
-        if &*ivec != &mut *iv2 {
+        if *ivec != *iv2 {
             println!("expected AsMut to equal original");
             return false;
         }
 
-        if &*ivec != iv2.as_mut() {
+        if *ivec != iv2.as_mut() {
             println!("expected AsMut to equal original");
             return false;
         }
@@ -400,7 +400,7 @@ mod qc {
     quickcheck::quickcheck! {
         #[cfg_attr(miri, ignore)]
         fn bool(item: IVec) -> bool {
-            prop_identity(item)
+            prop_identity(&item)
         }
     }
 }
diff --git a/src/pagecache/iterator.rs b/src/pagecache/iterator.rs
@@ -334,9 +334,7 @@ fn scan_segment_headers_and_tail(
     );
 
     // scatter
-    let header_promises_res: Result<
-        Vec<OneShot<Option<(LogOffset, SegmentHeader)>>>,
-    > = (0..segments)
+    let header_promises_res: Result<Vec<_>> = (0..segments)
         .map({
             // let config = config.clone();
             move |idx| {
diff --git a/src/serialization.rs b/src/serialization.rs
@@ -1020,91 +1020,91 @@ mod qc {
         }
     }
 
-    fn prop_serialize<T>(item: T) -> bool
+    fn prop_serialize<T>(item: &T) -> bool
     where
         T: Serialize + PartialEq + Clone + std::fmt::Debug,
     {
-        let mut buf = vec![0; item.serialized_size() as usize];
+        let mut buf = vec![0; usize::try_from(item.serialized_size()).unwrap()];
         let buf_ref = &mut buf.as_mut_slice();
         item.serialize_into(buf_ref);
         assert_eq!(
             buf_ref.len(),
             0,
             "round-trip failed to consume produced bytes"
         );
-        assert_eq!(buf.len(), item.serialized_size() as usize,);
+        assert_eq!(buf.len() as u64, item.serialized_size());
         let deserialized = T::deserialize(&mut buf.as_slice()).unwrap();
-        if item != deserialized {
+        if *item == deserialized {
+            true
+        } else {
             eprintln!(
                 "round-trip serialization failed. original:\n\n{:?}\n\n \
                  deserialized(serialized(original)):\n\n{:?}",
                 item, deserialized
             );
             false
-        } else {
-            true
         }
     }
 
     quickcheck::quickcheck! {
         #[cfg_attr(miri, ignore)]
         fn bool(item: bool) -> bool {
-            prop_serialize(item)
+            prop_serialize(&item)
         }
 
         #[cfg_attr(miri, ignore)]
         fn u8(item: u8) -> bool {
-            prop_serialize(item)
+            prop_serialize(&item)
         }
 
         #[cfg_attr(miri, ignore)]
         fn i64(item: SpreadI64) -> bool {
-            prop_serialize(item.0)
+            prop_serialize(&item.0)
         }
 
         #[cfg_attr(miri, ignore)]
         fn u64(item: SpreadU64) -> bool {
-            prop_serialize(item.0)
+            prop_serialize(&item.0)
         }
 
         #[cfg_attr(miri, ignore)]
         fn disk_ptr(item: DiskPtr) -> bool {
-            prop_serialize(item)
+            prop_serialize(&item)
         }
 
         #[cfg_attr(miri, ignore)]
         fn page_state(item: PageState) -> bool {
-            prop_serialize(item)
+            prop_serialize(&item)
         }
 
         #[cfg_attr(miri, ignore)]
         fn meta(item: Meta) -> bool {
-            prop_serialize(item)
+            prop_serialize(&item)
         }
 
         #[cfg_attr(miri, ignore)]
         fn snapshot(item: Snapshot) -> bool {
-            prop_serialize(item)
+            prop_serialize(&item)
         }
 
         #[cfg_attr(miri, ignore)]
         fn node(item: Node) -> bool {
-            prop_serialize(item)
+            prop_serialize(&item)
         }
 
         #[cfg_attr(miri, ignore)]
         fn data(item: Data) -> bool {
-            prop_serialize(item)
+            prop_serialize(&item)
         }
 
         #[cfg_attr(miri, ignore)]
         fn link(item: Link) -> bool {
-            prop_serialize(item)
+            prop_serialize(&item)
         }
 
         #[cfg_attr(miri, ignore)]
         fn msg_header(item: MessageHeader) -> bool {
-            prop_serialize(item)
+            prop_serialize(&item)
         }
     }
 
@@ -1122,6 +1122,6 @@ mod qc {
             data: Data::Index(Index::default()),
         };
 
-        prop_serialize(node);
+        prop_serialize(&node);
     }
 }
diff --git a/src/subscriber.rs b/src/subscriber.rs
@@ -305,28 +305,19 @@ fn basic_subscriber() {
 
     let k2: IVec = vec![].into();
     let r2 = subs.reserve(&k2).unwrap();
-    r2.complete(&Event::Insert {
-        key: k2.clone(),
-        value: IVec::from(k2.clone()),
-    });
+    r2.complete(&Event::Insert { key: k2.clone(), value: k2.clone() });
 
     let k3: IVec = vec![0].into();
     let r3 = subs.reserve(&k3).unwrap();
-    r3.complete(&Event::Insert {
-        key: k3.clone(),
-        value: IVec::from(k3.clone()),
-    });
+    r3.complete(&Event::Insert { key: k3.clone(), value: k3.clone() });
 
     let k4: IVec = vec![0, 1].into();
     let r4 = subs.reserve(&k4).unwrap();
     r4.complete(&Event::Remove { key: k4.clone() });
 
     let k5: IVec = vec![0, 1, 2].into();
     let r5 = subs.reserve(&k5).unwrap();
-    r5.complete(&Event::Insert {
-        key: k5.clone(),
-        value: IVec::from(k5.clone()),
-    });
+    r5.complete(&Event::Insert { key: k5.clone(), value: k5.clone() });
 
     let k6: IVec = vec![1, 1, 2].into();
     let r6 = subs.reserve(&k6).unwrap();
@@ -338,10 +329,7 @@ fn basic_subscriber() {
 
     let k8: IVec = vec![1, 2, 2].into();
     let r8 = subs.reserve(&k8).unwrap();
-    r8.complete(&Event::Insert {
-        key: k8.clone(),
-        value: IVec::from(k8.clone()),
-    });
+    r8.complete(&Event::Insert { key: k8.clone(), value: k8.clone() });
 
     assert_eq!(s1.next().unwrap().key(), &*k2);
     assert_eq!(s1.next().unwrap().key(), &*k3);
diff --git a/tests/test_crash_recovery.rs b/tests/test_crash_recovery.rs
@@ -75,7 +75,7 @@ fn verify(tree: &sled::Tree) -> (u32, u32) {
     let mut lowest = 0;
     for res in iter {
         let (_k, v) = res.unwrap();
-        if &v[..4] == &highest_vec[..4] {
+        if v[..4] == highest_vec[..4] {
             contiguous += 1;
         } else {
             let expected = if highest == 0 {
@@ -238,12 +238,9 @@ fn run() {
         .path(RECOVERY_DIR.to_string())
         .segment_size(SEGMENT_SIZE);
 
-    match thread::spawn(|| run_inner(config)).join() {
-        Err(e) => {
-            println!("worker thread failed: {:?}", e);
-            std::process::exit(15);
-        }
-        _ => {}
+    if let Err(e) = thread::spawn(|| run_inner(config)).join() {
+        println!("worker thread failed: {:?}", e);
+        std::process::exit(15);
     }
 }
 
@@ -270,12 +267,9 @@ fn run_batches() {
         spawn_killah();
     }
 
-    match t1.join().and_then(|_| t2.join()) {
-        Err(e) => {
-            println!("worker thread failed: {:?}", e);
-            std::process::exit(15);
-        }
-        _ => {}
+    if let Err(e) = t1.join().and_then(|_| t2.join()) {
+        println!("worker thread failed: {:?}", e);
+        std::process::exit(15);
     }
 }
 
@@ -288,10 +282,9 @@ fn run_child_process(test_name: &str) -> Child {
         .env(TEST_ENV_VAR, test_name)
         .env("SLED_CRASH_CHANCE", CRASH_CHANCE.to_string())
         .spawn()
-        .expect(&format!(
-            "could not spawn child process for {} test",
-            test_name
-        ))
+        .unwrap_or_else(|_| {
+            panic!("could not spawn child process for {} test", test_name)
+        })
 }
 
 fn handle_child_exit_status(dir: &str, status: ExitStatus) {
@@ -516,8 +509,6 @@ fn run_iter() {
     let deleter = thread::Builder::new()
         .name("deleter".into())
         .spawn({
-            let t = t.clone();
-            let barrier = barrier.clone();
             move || {
                 barrier.wait();
 
diff --git a/tests/test_log.rs b/tests/test_log.rs
@@ -319,7 +319,7 @@ fn log_chunky_iterator() {
         }
     }
 
-    for (_, pid, lsn, ptr) in reference.clone().into_iter() {
+    for (_, pid, lsn, ptr) in reference.into_iter() {
         assert!(log.read(pid, lsn, ptr).is_ok());
     }
 }
diff --git a/tests/test_tree.rs b/tests/test_tree.rs
@@ -214,7 +214,7 @@ fn concurrent_tree_ops() {
         debug!("========== CAS test in test {} ==========", i);
         par! {t, |tree: &Tree, k: Vec<u8>| {
             let k1 = k.clone();
-            let mut k2 = k.clone();
+            let mut k2 = k;
             k2.reverse();
             tree.compare_and_swap(&k1, Some(&*k1), Some(k2)).unwrap().unwrap();
         }};
@@ -225,7 +225,7 @@ fn concurrent_tree_ops() {
 
         par! {t, |tree: &Tree, k: Vec<u8>| {
             let k1 = k.clone();
-            let mut k2 = k.clone();
+            let mut k2 = k;
             k2.reverse();
             assert_eq!(tree.get(&*k1).unwrap().unwrap().to_vec(), k2);
         }};
@@ -397,8 +397,6 @@ fn concurrent_tree_iter() -> Result<()> {
     let deleter = thread::Builder::new()
         .name("deleter".into())
         .spawn({
-            let t = t.clone();
-            let barrier = barrier.clone();
             move || {
                 barrier.wait();
 
@@ -502,7 +500,7 @@ fn concurrent_tree_transactions() -> TransactionResult<()> {
             let sub = db.watch_prefix(b"k1");
             drop(db);
 
-            while let Ok(_) = sub.next_timeout(Duration::from_millis(100)) {}
+            while sub.next_timeout(Duration::from_millis(100)).is_ok() {}
             drop(sub);
 
             Ok(())
diff --git a/tests/test_tree_failpoints.rs b/tests/test_tree_failpoints.rs
@@ -476,16 +476,16 @@ fn run_tree_crashes_nicely(ops: Vec<Op>, flusher: bool) -> bool {
                 // the last crash, keep the value for that key corresponding to
                 // the most recent operation, and toss the rest.
                 for (_key, reference_entry) in reference.iter_mut() {
-                    if reference_entry.versions.len() > 1 {
-                        if reference_entry.crash_epoch == crash_counter {
-                            let last = std::mem::replace(
-                                &mut reference_entry.versions,
-                                Vec::new(),
-                            )
-                            .pop()
-                            .unwrap();
-                            reference_entry.versions.push(last);
-                        }
+                    if reference_entry.versions.len() > 1
+                        && reference_entry.crash_epoch == crash_counter
+                    {
+                        let last = std::mem::replace(
+                            &mut reference_entry.versions,
+                            Vec::new(),
+                        )
+                        .pop()
+                        .unwrap();
+                        reference_entry.versions.push(last);
                     }
                 }
             }
diff --git a/tests/tree/mod.rs b/tests/tree/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -376,20 +376,20 @@ fn ivec_as_mut_identity() {`
`376`	`376`	`mod qc {`
`377`	`377`	`use super::IVec;`
`378`	`378`
`379`		`- fn prop_identity(ivec: IVec) -> bool {`
	`379`	`+ fn prop_identity(ivec: &IVec) -> bool {`
`380`	`380`	`let mut iv2 = ivec.clone();`
`381`	`381`
`382`	`382`	`if iv2 != ivec {`
`383`	`383`	`println!("expected clone to equal original");`
`384`	`384`	`return false;`
`385`	`385`	`}`
`386`	`386`
`387`		`- if &ivec != &mut iv2 {`
	`387`	`+ if ivec != iv2 {`
`388`	`388`	`println!("expected AsMut to equal original");`
`389`	`389`	`return false;`
`390`	`390`	`}`
`391`	`391`
`392`		`- if &*ivec != iv2.as_mut() {`
	`392`	`+ if *ivec != iv2.as_mut() {`
`393`	`393`	`println!("expected AsMut to equal original");`
`394`	`394`	`return false;`
`395`	`395`	`}`
`@@ -400,7 +400,7 @@ mod qc {`
`400`	`400`	`quickcheck::quickcheck! {`
`401`	`401`	`#[cfg_attr(miri, ignore)]`
`402`	`402`	`fn bool(item: IVec) -> bool {`
`403`		`- prop_identity(item)`
	`403`	`+ prop_identity(&item)`
`404`	`404`	`}`
`405`	`405`	`}`
`406`	`406`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1020,91 +1020,91 @@ mod qc {`
`1020`	`1020`	`}`
`1021`	`1021`	`}`
`1022`	`1022`
`1023`		`- fn prop_serialize<T>(item: T) -> bool`
	`1023`	`+ fn prop_serialize<T>(item: &T) -> bool`
`1024`	`1024`	`where`
`1025`	`1025`	`T: Serialize + PartialEq + Clone + std::fmt::Debug,`
`1026`	`1026`	`{`
`1027`		`- let mut buf = vec![0; item.serialized_size() as usize];`
	`1027`	`+ let mut buf = vec![0; usize::try_from(item.serialized_size()).unwrap()];`
`1028`	`1028`	`let buf_ref = &mut buf.as_mut_slice();`
`1029`	`1029`	`item.serialize_into(buf_ref);`
`1030`	`1030`	`assert_eq!(`
`1031`	`1031`	`buf_ref.len(),`
`1032`	`1032`	`0,`
`1033`	`1033`	`"round-trip failed to consume produced bytes"`
`1034`	`1034`	`);`
`1035`		`- assert_eq!(buf.len(), item.serialized_size() as usize,);`
	`1035`	`+ assert_eq!(buf.len() as u64, item.serialized_size());`
`1036`	`1036`	`let deserialized = T::deserialize(&mut buf.as_slice()).unwrap();`
`1037`		`- if item != deserialized {`
	`1037`	`+ if *item == deserialized {`
	`1038`	`+ true`
	`1039`	`+ } else {`
`1038`	`1040`	`eprintln!(`
`1039`	`1041`	`"round-trip serialization failed. original:\n\n{:?}\n\n \`
`1040`	`1042`	`deserialized(serialized(original)):\n\n{:?}",`
`1041`	`1043`	`item, deserialized`
`1042`	`1044`	`);`
`1043`	`1045`	`false`
`1044`		`- } else {`
`1045`		`- true`
`1046`	`1046`	`}`
`1047`	`1047`	`}`
`1048`	`1048`
`1049`	`1049`	`quickcheck::quickcheck! {`
`1050`	`1050`	`#[cfg_attr(miri, ignore)]`
`1051`	`1051`	`fn bool(item: bool) -> bool {`
`1052`		`- prop_serialize(item)`
	`1052`	`+ prop_serialize(&item)`
`1053`	`1053`	`}`
`1054`	`1054`
`1055`	`1055`	`#[cfg_attr(miri, ignore)]`
`1056`	`1056`	`fn u8(item: u8) -> bool {`
`1057`		`- prop_serialize(item)`
	`1057`	`+ prop_serialize(&item)`
`1058`	`1058`	`}`
`1059`	`1059`
`1060`	`1060`	`#[cfg_attr(miri, ignore)]`
`1061`	`1061`	`fn i64(item: SpreadI64) -> bool {`
`1062`		`- prop_serialize(item.0)`
	`1062`	`+ prop_serialize(&item.0)`
`1063`	`1063`	`}`
`1064`	`1064`
`1065`	`1065`	`#[cfg_attr(miri, ignore)]`
`1066`	`1066`	`fn u64(item: SpreadU64) -> bool {`
`1067`		`- prop_serialize(item.0)`
	`1067`	`+ prop_serialize(&item.0)`
`1068`	`1068`	`}`
`1069`	`1069`
`1070`	`1070`	`#[cfg_attr(miri, ignore)]`
`1071`	`1071`	`fn disk_ptr(item: DiskPtr) -> bool {`
`1072`		`- prop_serialize(item)`
	`1072`	`+ prop_serialize(&item)`
`1073`	`1073`	`}`
`1074`	`1074`
`1075`	`1075`	`#[cfg_attr(miri, ignore)]`
`1076`	`1076`	`fn page_state(item: PageState) -> bool {`
`1077`		`- prop_serialize(item)`
	`1077`	`+ prop_serialize(&item)`
`1078`	`1078`	`}`
`1079`	`1079`
`1080`	`1080`	`#[cfg_attr(miri, ignore)]`
`1081`	`1081`	`fn meta(item: Meta) -> bool {`
`1082`		`- prop_serialize(item)`
	`1082`	`+ prop_serialize(&item)`
`1083`	`1083`	`}`
`1084`	`1084`
`1085`	`1085`	`#[cfg_attr(miri, ignore)]`
`1086`	`1086`	`fn snapshot(item: Snapshot) -> bool {`
`1087`		`- prop_serialize(item)`
	`1087`	`+ prop_serialize(&item)`
`1088`	`1088`	`}`
`1089`	`1089`
`1090`	`1090`	`#[cfg_attr(miri, ignore)]`
`1091`	`1091`	`fn node(item: Node) -> bool {`
`1092`		`- prop_serialize(item)`
	`1092`	`+ prop_serialize(&item)`
`1093`	`1093`	`}`
`1094`	`1094`
`1095`	`1095`	`#[cfg_attr(miri, ignore)]`
`1096`	`1096`	`fn data(item: Data) -> bool {`
`1097`		`- prop_serialize(item)`
	`1097`	`+ prop_serialize(&item)`
`1098`	`1098`	`}`
`1099`	`1099`
`1100`	`1100`	`#[cfg_attr(miri, ignore)]`
`1101`	`1101`	`fn link(item: Link) -> bool {`
`1102`		`- prop_serialize(item)`
	`1102`	`+ prop_serialize(&item)`
`1103`	`1103`	`}`
`1104`	`1104`
`1105`	`1105`	`#[cfg_attr(miri, ignore)]`
`1106`	`1106`	`fn msg_header(item: MessageHeader) -> bool {`
`1107`		`- prop_serialize(item)`
	`1107`	`+ prop_serialize(&item)`
`1108`	`1108`	`}`
`1109`	`1109`	`}`
`1110`	`1110`
`@@ -1122,6 +1122,6 @@ mod qc {`
`1122`	`1122`	`data: Data::Index(Index::default()),`
`1123`	`1123`	`};`
`1124`	`1124`
`1125`		`- prop_serialize(node);`
	`1125`	`+ prop_serialize(&node);`
`1126`	`1126`	`}`
`1127`	`1127`	`}`
Original file line number	Diff line number	Diff line change
`@@ -319,7 +319,7 @@ fn log_chunky_iterator() {`
`319`	`319`	`}`
`320`	`320`	`}`
`321`	`321`
`322`		`- for (_, pid, lsn, ptr) in reference.clone().into_iter() {`
	`322`	`+ for (_, pid, lsn, ptr) in reference.into_iter() {`
`323`	`323`	`assert!(log.read(pid, lsn, ptr).is_ok());`
`324`	`324`	`}`
`325`	`325`	`}`