diff --git a/src/map/slice.rs b/src/map/slice.rs
index 035744ef..960f66c1 100644
--- a/src/map/slice.rs
+++ b/src/map/slice.rs
@@ -628,4 +628,123 @@ mod tests {
             }
         }
     }
+
+    #[test]
+    fn slice_new() {
+        let slice: &Slice<i32, i32> = Slice::new();
+        assert!(slice.is_empty());
+        assert_eq!(slice.len(), 0);
+    }
+
+    #[test]
+    fn slice_new_mut() {
+        let slice: &mut Slice<i32, i32> = Slice::new_mut();
+        assert!(slice.is_empty());
+        assert_eq!(slice.len(), 0);
+    }
+
+    #[test]
+    fn slice_get_index_mut() {
+        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 (key, value) = slice.get_index_mut(0).unwrap();
+            assert_eq!(*key, 0);
+            assert_eq!(*value, 0);
+
+            *value = 11;
+        }
+
+        assert_eq!(slice[0], 11);
+
+        {
+            let result = slice.get_index_mut(11);
+            assert!(result.is_none());
+        }
+    }
+
+    #[test]
+    fn slice_split_first() {
+        let slice: &mut Slice<i32, i32> = Slice::new_mut();
+        let result = slice.split_first();
+        assert!(result.is_none());
+
+        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!(rest.len(), 9);
+        }
+        assert_eq!(slice.len(), 10);
+    }
+
+    #[test]
+    fn slice_split_first_mut() {
+        let slice: &mut Slice<i32, i32> = Slice::new_mut();
+        let result = slice.split_first_mut();
+        assert!(result.is_none());
+
+        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, &mut 0));
+            assert_eq!(rest.len(), 9);
+
+            *first.1 = 11;
+        }
+        assert_eq!(slice.len(), 10);
+        assert_eq!(slice[0], 11);
+    }
+
+    #[test]
+    fn slice_split_last() {
+        let slice: &mut Slice<i32, i32> = Slice::new_mut();
+        let result = slice.split_last();
+        assert!(result.is_none());
+
+        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, (&9, &81));
+            assert_eq!(rest.len(), 9);
+        }
+        assert_eq!(slice.len(), 10);
+    }
+
+    #[test]
+    fn slice_split_last_mut() {
+        let slice: &mut Slice<i32, i32> = Slice::new_mut();
+        let result = slice.split_last_mut();
+        assert!(result.is_none());
+
+        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, (&9, &mut 81));
+            assert_eq!(rest.len(), 9);
+
+            *last.1 = 100;
+        }
+
+        assert_eq!(slice.len(), 10);
+        assert_eq!(slice[slice.len() - 1], 100);
+    }
+
+    #[test]
+    fn slice_get_range() {
+        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 subslice = slice.get_range(3..6).unwrap();
+        assert_eq!(subslice.len(), 3);
+        assert_eq!(subslice, &[(3, 9), (4, 16), (5, 25)]);
+    }
 }
diff --git a/src/map/tests.rs b/src/map/tests.rs
index f97f2f14..25ef7947 100644
--- a/src/map/tests.rs
+++ b/src/map/tests.rs
@@ -593,6 +593,226 @@ fn iter_default() {
     assert_default::<IntoValues<K, V>>();
 }
 
+#[test]
+fn get_index_mut2() {
+    let mut map: IndexMap<i32, i32> = IndexMap::new();
+    map.insert(1, 2);
+    map.insert(3, 4);
+    map.insert(5, 6);
+
+    {
+        let (key, value) = map.get_index_mut2(0).unwrap();
+        assert_eq!(*key, 1);
+        assert_eq!(*value, 2);
+
+        *value = 7;
+    }
+    assert_eq!(map[0], 7);
+
+    {
+        let (key, _) = map.get_index_mut2(0).unwrap();
+        *key = 8;
+    }
+    assert_eq!(map.get_index(0).unwrap().0, &8);
+}
+
+#[test]
+fn shift_shift_remove_index() {
+    let mut map: IndexMap<i32, i32> = IndexMap::new();
+    map.insert(1, 2);
+    map.insert(3, 4);
+    map.insert(5, 6);
+    map.insert(7, 8);
+    map.insert(9, 10);
+
+    let result = map.shift_remove_index(1);
+    assert_eq!(result, Some((3, 4)));
+    assert_eq!(map.len(), 4);
+    assert_eq!(map.as_slice(), &[(1, 2), (5, 6), (7, 8), (9, 10)]);
+
+    let result = map.shift_remove_index(1);
+    assert_eq!(result, Some((5, 6)));
+    assert_eq!(map.len(), 3);
+    assert_eq!(map.as_slice(), &[(1, 2), (7, 8), (9, 10)]);
+
+    let result = map.shift_remove_index(2);
+    assert_eq!(result, Some((9, 10)));
+    assert_eq!(map.len(), 2);
+    assert_eq!(map.as_slice(), &[(1, 2), (7, 8)]);
+
+    let result = map.shift_remove_index(2);
+    assert_eq!(result, None);
+    assert_eq!(map.len(), 2);
+    assert_eq!(map.as_slice(), &[(1, 2), (7, 8)]);
+}
+
+#[test]
+fn shift_remove_entry() {
+    let mut map: IndexMap<i32, i32> = IndexMap::new();
+    map.insert(1, 2);
+    map.insert(3, 4);
+    map.insert(5, 6);
+    map.insert(7, 8);
+    map.insert(9, 10);
+
+    let result = map.shift_remove_entry(&3);
+    assert_eq!(result, Some((3, 4)));
+    assert_eq!(map.len(), 4);
+    assert_eq!(map.as_slice(), &[(1, 2), (5, 6), (7, 8), (9, 10)]);
+
+    let result = map.shift_remove_entry(&9);
+    assert_eq!(result, Some((9, 10)));
+    assert_eq!(map.len(), 3);
+    assert_eq!(map.as_slice(), &[(1, 2), (5, 6), (7, 8)]);
+
+    let result = map.shift_remove_entry(&9);
+    assert_eq!(result, None);
+    assert_eq!(map.len(), 3);
+    assert_eq!(map.as_slice(), &[(1, 2), (5, 6), (7, 8)]);
+}
+
+#[test]
+fn shift_remove_full() {
+    let mut map: IndexMap<i32, i32> = IndexMap::new();
+    map.insert(1, 2);
+    map.insert(3, 4);
+    map.insert(5, 6);
+    map.insert(7, 8);
+    map.insert(9, 10);
+
+    let result = map.shift_remove_full(&3);
+    assert_eq!(result, Some((1, 3, 4)));
+    assert_eq!(map.len(), 4);
+    assert_eq!(map.as_slice(), &[(1, 2), (5, 6), (7, 8), (9, 10)]);
+
+    let result = map.shift_remove_full(&9);
+    assert_eq!(result, Some((3, 9, 10)));
+    assert_eq!(map.len(), 3);
+    assert_eq!(map.as_slice(), &[(1, 2), (5, 6), (7, 8)]);
+
+    let result = map.shift_remove_full(&9);
+    assert_eq!(result, None);
+    assert_eq!(map.len(), 3);
+    assert_eq!(map.as_slice(), &[(1, 2), (5, 6), (7, 8)]);
+}
+
+#[test]
+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));
+
+    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..5 {
+        map.insert(i, i * 10);
+    }
+    let boxed_slice: Box<Slice<i32, i32>> = map.into_boxed_slice();
+    assert_eq!(boxed_slice.len(), 5);
+    assert_eq!(
+        boxed_slice.as_ref(),
+        &[(0, 0), (1, 10), (2, 20), (3, 30), (4, 40)]
+    );
+}
+
+#[test]
+fn last_mut() {
+    let mut map: IndexMap<&str, i32> = IndexMap::new();
+
+    let last_entry = map.last_mut();
+    assert_eq!(last_entry, None);
+
+    map.insert("key1", 1);
+    map.insert("key2", 2);
+    map.insert("key3", 3);
+    let last_entry = map.last_mut();
+    assert_eq!(last_entry, Some((&"key3", &mut 3)));
+
+    *last_entry.unwrap().1 = 4;
+    assert_eq!(map.get("key3"), Some(&4));
+}
+
+#[test]
+#[should_panic = "index out of bounds"]
+fn insert_before_oob() {
+    let mut map: IndexMap<char, ()> = IndexMap::new();
+    let _ = map.insert_before(0, 'a', ());
+    let _ = map.insert_before(1, 'b', ());
+    map.insert_before(3, 'd', ());
+}
+
+#[test]
+fn clear() {
+    let mut map: IndexMap<i32, i32> = IndexMap::new();
+    map.extend(vec![(1, 10), (2, 20), (3, 30), (4, 40), (5, 50)]);
+    map.clear();
+    assert_eq!(map.len(), 0);
+}
+
+#[test]
+fn get_range() {
+    let mut index_map: IndexMap<i32, i32> = IndexMap::new();
+    index_map.insert(1, 10);
+    index_map.insert(2, 20);
+    index_map.insert(3, 30);
+    index_map.insert(4, 40);
+    index_map.insert(5, 50);
+
+    let result = index_map.get_range(2..2);
+    assert!(result.unwrap().is_empty());
+
+    let result = index_map.get_range(4..2);
+    assert!(result.is_none());
+
+    let result = index_map.get_range(2..4);
+    let slice: &Slice<i32, i32> = result.unwrap();
+    assert_eq!(slice.len(), 2);
+    assert_eq!(slice, &[(3, 30), (4, 40)]);
+}
+
+#[test]
+fn get_range_mut() {
+    let mut index_map: IndexMap<i32, i32> = IndexMap::new();
+    index_map.insert(1, 10);
+    index_map.insert(2, 20);
+    index_map.insert(3, 30);
+    index_map.insert(4, 40);
+    index_map.insert(5, 50);
+
+    let result = index_map.get_range_mut(2..2);
+    assert!(result.unwrap().is_empty());
+
+    let result = index_map.get_range_mut(4..2);
+    assert!(result.is_none());
+
+    let result = index_map.get_range_mut(2..4);
+    let slice: &mut Slice<i32, i32> = result.unwrap();
+    assert_eq!(slice.len(), 2);
+    assert_eq!(slice, &mut [(3, 30), (4, 40)]);
+
+    for i in 0..slice.len() {
+        slice[i] += 1;
+    }
+    assert_eq!(slice, &mut [(3, 31), (4, 41)]);
+}
+
+#[test]
+#[should_panic = "index out of bounds"]
+fn shift_insert_oob() {
+    let mut map: IndexMap<u32, u32> = IndexMap::new();
+    map.shift_insert(0, 1, 10);
+    map.shift_insert(1, 2, 20);
+    map.shift_insert(2, 3, 30);
+    map.shift_insert(5, 4, 40);
+}
+
 #[test]
 fn test_binary_search_by() {
     // adapted from std's test for binary_search
diff --git a/src/set/tests.rs b/src/set/tests.rs
index 35a076e8..f844470e 100644
--- a/src/set/tests.rs
+++ b/src/set/tests.rs
@@ -583,6 +583,276 @@ fn iter_default() {
     assert_default::<IntoIter<Item>>();
 }
 
+#[test]
+#[allow(deprecated)]
+fn take() {
+    let mut index_set: IndexSet<i32> = IndexSet::new();
+    index_set.insert(10);
+    assert_eq!(index_set.len(), 1);
+
+    let result = index_set.take(&10);
+    assert_eq!(result, Some(10));
+    assert_eq!(index_set.len(), 0);
+
+    let result = index_set.take(&20);
+    assert_eq!(result, None);
+}
+
+#[test]
+fn swap_take() {
+    let mut index_set: IndexSet<i32> = IndexSet::new();
+    index_set.insert(10);
+    index_set.insert(20);
+    index_set.insert(30);
+    index_set.insert(40);
+    assert_eq!(index_set.len(), 4);
+
+    let result = index_set.swap_take(&20);
+    assert_eq!(result, Some(20));
+    assert_eq!(index_set.len(), 3);
+    assert_eq!(index_set.as_slice(), &[10, 40, 30]);
+
+    let result = index_set.swap_take(&50);
+    assert_eq!(result, None);
+}
+
+#[test]
+fn sort_unstable() {
+    let mut index_set: IndexSet<i32> = IndexSet::new();
+    index_set.insert(30);
+    index_set.insert(20);
+    index_set.insert(10);
+
+    index_set.sort_unstable();
+    assert_eq!(index_set.as_slice(), &[10, 20, 30]);
+}
+
+#[test]
+fn try_reserve_exact() {
+    let mut index_set: IndexSet<i32> = IndexSet::new();
+    index_set.insert(10);
+    index_set.insert(20);
+    index_set.insert(30);
+    index_set.shrink_to_fit();
+    assert_eq!(index_set.capacity(), 3);
+
+    index_set.try_reserve_exact(2).unwrap();
+    assert_eq!(index_set.capacity(), 5);
+}
+
+#[test]
+fn shift_remove_full() {
+    let mut set: IndexSet<i32> = IndexSet::new();
+    set.insert(10);
+    set.insert(20);
+    set.insert(30);
+    set.insert(40);
+    set.insert(50);
+
+    let result = set.shift_remove_full(&20);
+    assert_eq!(result, Some((1, 20)));
+    assert_eq!(set.len(), 4);
+    assert_eq!(set.as_slice(), &[10, 30, 40, 50]);
+
+    let result = set.shift_remove_full(&50);
+    assert_eq!(result, Some((3, 50)));
+    assert_eq!(set.len(), 3);
+    assert_eq!(set.as_slice(), &[10, 30, 40]);
+
+    let result = set.shift_remove_full(&60);
+    assert_eq!(result, None);
+    assert_eq!(set.len(), 3);
+    assert_eq!(set.as_slice(), &[10, 30, 40]);
+}
+
+#[test]
+fn shift_remove_index() {
+    let mut set: IndexSet<i32> = IndexSet::new();
+    set.insert(10);
+    set.insert(20);
+    set.insert(30);
+    set.insert(40);
+    set.insert(50);
+
+    let result = set.shift_remove_index(1);
+    assert_eq!(result, Some(20));
+    assert_eq!(set.len(), 4);
+    assert_eq!(set.as_slice(), &[10, 30, 40, 50]);
+
+    let result = set.shift_remove_index(1);
+    assert_eq!(result, Some(30));
+    assert_eq!(set.len(), 3);
+    assert_eq!(set.as_slice(), &[10, 40, 50]);
+
+    let result = set.shift_remove_index(3);
+    assert_eq!(result, None);
+    assert_eq!(set.len(), 3);
+    assert_eq!(set.as_slice(), &[10, 40, 50]);
+}
+
+#[test]
+fn sort_unstable_by() {
+    let mut set: IndexSet<i32> = IndexSet::from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+    set.sort_unstable_by(|a, b| b.cmp(a));
+    assert_eq!(set.as_slice(), &[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]);
+}
+
+#[test]
+fn sort_by() {
+    let mut set: IndexSet<i32> = IndexSet::new();
+    set.insert(3);
+    set.insert(1);
+    set.insert(2);
+    set.sort_by(|a, b| a.cmp(b));
+    assert_eq!(set.as_slice(), &[1, 2, 3]);
+}
+
+#[test]
+fn drain() {
+    let mut set: IndexSet<i32> = IndexSet::new();
+    set.insert(1);
+    set.insert(2);
+    set.insert(3);
+
+    {
+        let drain = set.drain(0..2);
+        assert_eq!(drain.as_slice(), &[1, 2]);
+    }
+
+    assert_eq!(set.len(), 1);
+    assert_eq!(set.as_slice(), &[3]);
+}
+
+#[test]
+fn split_off() {
+    let mut set: IndexSet<i32> = IndexSet::from([1, 2, 3, 4, 5]);
+    let split_set: IndexSet<i32> = set.split_off(3);
+
+    assert_eq!(split_set.len(), 2);
+    assert_eq!(split_set.as_slice(), &[4, 5]);
+
+    assert_eq!(set.len(), 3);
+    assert_eq!(set.as_slice(), &[1, 2, 3]);
+}
+
+#[test]
+fn retain() {
+    let mut set: IndexSet<i32> = IndexSet::from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+    set.retain(|&x| x > 4);
+    assert_eq!(set.len(), 6);
+    assert_eq!(set.as_slice(), &[5, 6, 7, 8, 9, 10]);
+
+    set.retain(|_| false);
+    assert_eq!(set.len(), 0);
+}
+
+#[test]
+fn first() {
+    let mut index_set: IndexSet<i32> = IndexSet::new();
+    index_set.insert(10);
+    index_set.insert(20);
+    index_set.insert(30);
+
+    let result = index_set.first();
+    assert_eq!(*result.unwrap(), 10);
+
+    index_set.clear();
+    let result = index_set.first();
+    assert!(result.is_none());
+}
+
+#[test]
+fn sort_by_cached_key() {
+    let mut index_set: IndexSet<i32> = IndexSet::new();
+    index_set.insert(3);
+    index_set.insert(1);
+    index_set.insert(2);
+    index_set.insert(0);
+    index_set.sort_by_cached_key(|&x| -x);
+    assert_eq!(index_set.as_slice(), &[3, 2, 1, 0]);
+}
+
+#[test]
+fn insert_sorted() {
+    let mut set: IndexSet<i32> = IndexSet::<i32>::new();
+    set.insert_sorted(1);
+    set.insert_sorted(3);
+    assert_eq!(set.insert_sorted(2), (1, true));
+}
+
+#[test]
+fn binary_search() {
+    let mut set: IndexSet<i32> = IndexSet::new();
+    set.insert(100);
+    set.insert(300);
+    set.insert(200);
+    set.insert(400);
+    let result = set.binary_search(&200);
+    assert_eq!(result, Ok(2));
+
+    let result = set.binary_search(&500);
+    assert_eq!(result, Err(4));
+}
+
+#[test]
+fn sorted_unstable_by() {
+    let mut set: IndexSet<i32> = IndexSet::from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+    set.sort_unstable_by(|a, b| b.cmp(a));
+    assert_eq!(set.as_slice(), &[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]);
+}
+
+#[test]
+fn last() {
+    let mut set: IndexSet<i32> = IndexSet::new();
+    set.insert(1);
+    set.insert(2);
+    set.insert(3);
+    set.insert(4);
+    set.insert(5);
+    set.insert(6);
+
+    assert_eq!(set.last(), Some(&6));
+    
+    set.pop();
+    assert_eq!(set.last(), Some(&5));
+
+    set.clear();
+    assert_eq!(set.last(), None);
+}
+
+#[test]
+fn get_range() {
+    let set: IndexSet<i32> = IndexSet::from([1, 2, 3, 4, 5]);
+    let result = set.get_range(0..3);
+    let slice: &Slice<i32> = result.unwrap();
+    assert_eq!(slice, &[1, 2, 3]);
+
+    let result = set.get_range(0..0);
+    assert_eq!(result.unwrap().len(), 0);
+
+    let result = set.get_range(2..1);
+    assert!(result.is_none());
+}
+
+#[test]
+fn shift_take() {
+    let mut set: IndexSet<i32> = IndexSet::new();
+    set.insert(1);
+    set.insert(2);
+    set.insert(3);
+    set.insert(4);
+    set.insert(5);
+
+    let result = set.shift_take(&2);
+    assert_eq!(result, Some(2));
+
+    set.swap_remove(&3);
+    assert_eq!(set.as_slice(), &[1, 5, 4]);
+
+    let result = set.shift_take(&6);
+    assert_eq!(result, None);
+}
+
 #[test]
 fn test_binary_search_by() {
     // adapted from std's test for binary_search