Apply all the suggestions

Author: AbeZbm

src/map/slice.rs

@@ -633,20 +633,19 @@ mod tests {
     fn slice_new() {
         let slice: &Slice<i32, i32> = Slice::new();
         assert!(slice.is_empty());
-        assert!(slice.len() == 0);
+        assert_eq!(slice.len(), 0);
     }
 
     #[test]
     fn slice_new_mut() {
         let slice: &mut Slice<i32, i32> = Slice::new_mut();
         assert!(slice.is_empty());
-        assert!(slice.len() == 0);
+        assert_eq!(slice.len(), 0);
     }
 
     #[test]
     fn slice_get_index_mut() {
-        let vec: Vec<(i32, i32)> = (0..10).map(|i| (i, i * i)).collect();
-        let mut map: IndexMap<i32, i32> = vec.iter().cloned().collect();
+        let mut map: IndexMap<i32, i32> = (0..10).map(|i| (i, i * i)).collect();
         let slice: &mut Slice<i32, i32> = map.as_mut_slice();
 
         {
@@ -656,8 +655,8 @@ mod tests {
 
             *value = 11;
         }
-        
-        assert_eq!(slice.get_index(0).unwrap().1, &11);
+
+        assert_eq!(slice[0], 11);
 
         {
             let result = slice.get_index_mut(11);
@@ -671,14 +670,12 @@ mod tests {
         let result = slice.split_first();
         assert!(result.is_none());
 
-        let vec: Vec<(i32, i32)> = (0..10).map(|i| (i, i * i)).collect();
-        let mut map: IndexMap<i32, i32> = vec.iter().cloned().collect();
+        let mut map: IndexMap<i32, i32> = (0..10).map(|i| (i, i * i)).collect();
         let slice: &mut Slice<i32, i32> = map.as_mut_slice();
 
         {
             let (first, rest) = slice.split_first().unwrap();
-            assert_eq!(*first.0, 0);
-            assert_eq!(*first.1, 0);
+            assert_eq!(first, (&0, &0));
             assert_eq!(rest.len(), 9);
         }
         assert_eq!(slice.len(), 10);
@@ -690,20 +687,18 @@ mod tests {
         let result = slice.split_first_mut();
         assert!(result.is_none());
 
-        let vec: Vec<(i32, i32)> = (0..10).map(|i| (i, i * i)).collect();
-        let mut map: IndexMap<i32, i32> = vec.iter().cloned().collect();
+        let mut map: IndexMap<i32, i32> = (0..10).map(|i| (i, i * i)).collect();
         let slice: &mut Slice<i32, i32> = map.as_mut_slice();
 
         {
             let (first, rest) = slice.split_first_mut().unwrap();
-            assert_eq!(*first.0, 0);
-            assert_eq!(*first.1, 0);
+            assert_eq!(first, (&0, &mut 0));
             assert_eq!(rest.len(), 9);
 
             *first.1 = 11;
         }
         assert_eq!(slice.len(), 10);
-        assert_eq!(slice.first().unwrap().1, &11);
+        assert_eq!(slice[0], 11);
     }
 
     #[test]
@@ -712,14 +707,12 @@ mod tests {
         let result = slice.split_last();
         assert!(result.is_none());
 
-        let vec: Vec<(i32, i32)> = (0..10).map(|i| (i, i * i)).collect();
-        let mut map: IndexMap<i32, i32> = vec.iter().cloned().collect();
+        let mut map: IndexMap<i32, i32> = (0..10).map(|i| (i, i * i)).collect();
         let slice: &mut Slice<i32, i32> = map.as_mut_slice();
 
         {
             let (last, rest) = slice.split_last().unwrap();
-            assert_eq!(*last.0, 9);
-            assert_eq!(*last.1, 81);
+            assert_eq!(last, (&9, &81));
             assert_eq!(rest.len(), 9);
         }
         assert_eq!(slice.len(), 10);
@@ -731,35 +724,27 @@ mod tests {
         let result = slice.split_last_mut();
         assert!(result.is_none());
 
-        let vec: Vec<(i32, i32)> = (0..10).map(|i| (i, i * i)).collect();
-        let mut map: IndexMap<i32, i32> = vec.iter().cloned().collect();
+        let mut map: IndexMap<i32, i32> = (0..10).map(|i| (i, i * i)).collect();
         let slice: &mut Slice<i32, i32> = map.as_mut_slice();
 
         {
             let (last, rest) = slice.split_last_mut().unwrap();
-            assert_eq!(*last.0, 9);
-            assert_eq!(*last.1, 81);
+            assert_eq!(last, (&9, &mut 81));
             assert_eq!(rest.len(), 9);
 
             *last.1 = 100;
         }
+
         assert_eq!(slice.len(), 10);
-        assert_eq!(slice.last().unwrap().1, &100);
+        assert_eq!(slice[slice.len() - 1], 100);
     }
 
     #[test]
     fn slice_get_range() {
-        let vec: Vec<(i32, i32)> = (0..10).map(|i| (i, i * i)).collect();
-        let mut map: IndexMap<i32, i32> = vec.iter().cloned().collect();
+        let mut map: IndexMap<i32, i32> = (0..10).map(|i| (i, i * i)).collect();
         let slice: &mut Slice<i32, i32> = map.as_mut_slice();
-        let result = slice.get_range(3..6);
-        assert_eq!(result.unwrap().len(), 3);
-        for i in 0..3 {
-            assert_eq!(result.unwrap().get_index(i).unwrap().0, &(i as i32 + 3));
-            assert_eq!(
-                *result.unwrap().get_index(i).unwrap().1,
-                ((i + 3) * (i + 3)) as i32
-            );
-        }
+        let subslice = slice.get_range(3..6).unwrap();
+        assert_eq!(subslice.len(), 3);
+        assert_eq!(subslice, &[(3, 9), (4, 16), (5, 25)]);
     }
 }

src/map/tests.rs

@@ -607,7 +607,7 @@ fn get_index_mut2() {
 
         *value = 7;
     }
-    assert_eq!(map.get_index(0).unwrap().1, &7);
+    assert_eq!(map[0], 7);
 
     {
         let (key, _) = map.get_index_mut2(0).unwrap();
@@ -623,13 +623,16 @@ fn shift_shift_remove_index() {
     map.insert(3, 4);
     map.insert(5, 6);
     map.insert(7, 8);
-
-    let result = map.shift_remove_index(2);
-    assert_eq!(result, Some((5, 6)));
-    assert_eq!(map.len(), 3);
+    map.insert(9, 10);
 
     let result = map.shift_remove_index(1);
     assert_eq!(result, Some((3, 4)));
+    assert_eq!(map.len(), 4);
+
+    map.swap_remove(&5);
+
+    let result = map.shift_remove_index(1);
+    assert_eq!(result, Some((9, 10)));
     assert_eq!(map.len(), 2);
 
     let result = map.shift_remove_index(2);
@@ -644,13 +647,17 @@ fn shift_remove_entry() {
     map.insert(3, 4);
     map.insert(5, 6);
     map.insert(7, 8);
-
-    let result = map.shift_remove_entry(&5);
-    assert_eq!(result, Some((5, 6)));
-    assert_eq!(map.len(), 3);
+    map.insert(9, 10);
 
     let result = map.shift_remove_entry(&3);
     assert_eq!(result, Some((3, 4)));
+    assert_eq!(map.len(), 4);
+
+    map.swap_remove(&5);
+    assert_eq!(map.as_slice(), &[(1, 2), (9, 10), (7, 8)]);
+
+    let result = map.shift_remove_entry(&9);
+    assert_eq!(result, Some((9, 10)));
     assert_eq!(map.len(), 2);
 
     let result = map.shift_remove_entry(&9);
@@ -665,13 +672,16 @@ fn shift_remove_full() {
     map.insert(3, 4);
     map.insert(5, 6);
     map.insert(7, 8);
-
-    let result = map.shift_remove_full(&5);
-    assert_eq!(result, Some((2, 5, 6)));
-    assert_eq!(map.len(), 3);
+    map.insert(9, 10);
 
     let result = map.shift_remove_full(&3);
     assert_eq!(result, Some((1, 3, 4)));
+    assert_eq!(map.len(), 4);
+
+    map.swap_remove(&5);
+
+    let result = map.shift_remove_full(&9);
+    assert_eq!(result, Some((1, 9, 10)));
     assert_eq!(map.len(), 2);
 
     let result = map.shift_remove_full(&9);
@@ -683,24 +693,26 @@ fn shift_remove_full() {
 fn sorted_unstable_by() {
     let mut map: IndexMap<i32, i32> = IndexMap::new();
     map.extend(vec![(1, 10), (2, 20), (3, 30), (4, 40), (5, 50)]);
-    let sorted = map.sorted_unstable_by(|a, b, c, d| d.cmp(&b));
+    let sorted = map.sorted_unstable_by(|_a, b, _c, d| d.cmp(&b));
 
-    let expected: Vec<(i32, i32)> = vec![(5, 50), (4, 40), (3, 30), (2, 20), (1, 10)];
-    let result: Vec<(i32, i32)> = sorted.map(|(k, v)| (k, v)).collect();
-    assert_eq!(result, expected);
+    assert_eq!(
+        sorted.as_slice(),
+        &[(5, 50), (4, 40), (3, 30), (2, 20), (1, 10)]
+    );
 }
 
 #[test]
 fn into_boxed_slice() {
     let mut map: IndexMap<i32, i32> = IndexMap::new();
-    for i in 0..100 {
+    for i in 0..5 {
         map.insert(i, i * 10);
     }
     let boxed_slice: Box<Slice<i32, i32>> = map.into_boxed_slice();
-    assert_eq!(boxed_slice.len(), 100);
-    for i in 0..100 {
-        assert_eq!(boxed_slice[i], i as i32 * 10);
-    }
+    assert_eq!(boxed_slice.len(), 5);
+    assert_eq!(
+        boxed_slice.as_ref(),
+        &[(0, 0), (1, 10), (2, 20), (3, 30), (4, 40)]
+    );
 }
 
 #[test]
@@ -755,10 +767,7 @@ fn get_range() {
     let result = index_map.get_range(2..4);
     let slice: &Slice<i32, i32> = result.unwrap();
     assert_eq!(slice.len(), 2);
-    for i in 0..slice.len() {
-        assert_eq!(slice.entries[i].key, i as i32 + 3);
-        assert_eq!(slice.entries[i].value, (i as i32 + 3) * 10);
-    }
+    assert_eq!(slice, &[(3, 30), (4, 40)]);
 }
 
 #[test]
@@ -779,16 +788,12 @@ fn get_range_mut() {
     let result = index_map.get_range_mut(2..4);
     let slice: &mut Slice<i32, i32> = result.unwrap();
     assert_eq!(slice.len(), 2);
-    for i in 0..slice.len() {
-        assert_eq!(slice.entries[i].key, i as i32 + 3);
-        assert_eq!(slice.entries[i].value, (i as i32 + 3) * 10);
-
-        slice.entries[i].value += 1;
-    }
+    assert_eq!(slice, &mut [(3, 30), (4, 40)]);
 
     for i in 0..slice.len() {
-        assert_eq!(slice.entries[i].value, (i as i32 + 3) * 10 + 1);
+        slice.entries[i].value += 1;
     }
+    assert_eq!(slice, &mut [(3, 31), (4, 41)]);
 }
 
 #[test]