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 = Slice::new(); + assert!(slice.is_empty()); + assert_eq!(slice.len(), 0); + } + + #[test] + fn slice_new_mut() { + let slice: &mut Slice = Slice::new_mut(); + assert!(slice.is_empty()); + assert_eq!(slice.len(), 0); + } + + #[test] + fn slice_get_index_mut() { + let mut map: IndexMap = (0..10).map(|i| (i, i * i)).collect(); + let slice: &mut Slice = 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 = Slice::new_mut(); + let result = slice.split_first(); + assert!(result.is_none()); + + let mut map: IndexMap = (0..10).map(|i| (i, i * i)).collect(); + let slice: &mut Slice = 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 = Slice::new_mut(); + let result = slice.split_first_mut(); + assert!(result.is_none()); + + let mut map: IndexMap = (0..10).map(|i| (i, i * i)).collect(); + let slice: &mut Slice = 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 = Slice::new_mut(); + let result = slice.split_last(); + assert!(result.is_none()); + + let mut map: IndexMap = (0..10).map(|i| (i, i * i)).collect(); + let slice: &mut Slice = 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 = Slice::new_mut(); + let result = slice.split_last_mut(); + assert!(result.is_none()); + + let mut map: IndexMap = (0..10).map(|i| (i, i * i)).collect(); + let slice: &mut Slice = 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 = (0..10).map(|i| (i, i * i)).collect(); + let slice: &mut Slice = 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::>(); } +#[test] +fn get_index_mut2() { + let mut map: IndexMap = 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 = 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 = 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 = 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 = 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 = IndexMap::new(); + for i in 0..5 { + map.insert(i, i * 10); + } + let boxed_slice: Box> = 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 = 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 = 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 = 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 = result.unwrap(); + assert_eq!(slice.len(), 2); + assert_eq!(slice, &[(3, 30), (4, 40)]); +} + +#[test] +fn get_range_mut() { + let mut index_map: IndexMap = 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 = 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 = 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::>(); } +#[test] +#[allow(deprecated)] +fn take() { + let mut index_set: IndexSet = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = IndexSet::from([1, 2, 3, 4, 5]); + let split_set: IndexSet = 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 = 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 = 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 = 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 = IndexSet::::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 = 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 = 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 = 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 = IndexSet::from([1, 2, 3, 4, 5]); + let result = set.get_range(0..3); + let slice: &Slice = 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 = 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