1 use super::{SortedIndexMultiMap, SortedMap};
4 fn test_sorted_index_multi_map() {
5 let entries: Vec<_> = vec![(2, 0), (1, 0), (2, 1), (3, 0), (2, 2)];
6 let set: SortedIndexMultiMap<usize, _, _> = entries.iter().copied().collect();
8 // Insertion order is preserved.
9 assert!(entries.iter().map(|(ref k, ref v)| (k, v)).eq(set.iter()));
12 for (i, expect) in entries.iter().enumerate() {
13 assert_eq!(set[i], expect.1);
16 // `get_by_key` works.
17 assert_eq!(set.get_by_key(&3).copied().collect::<Vec<_>>(), vec![0]);
18 assert!(set.get_by_key(&4).next().is_none());
20 // `get_by_key` returns items in insertion order.
21 let twos: Vec<_> = set.get_by_key_enumerated(&2).collect();
22 let idxs: Vec<usize> = twos.iter().map(|(i, _)| *i).collect();
23 let values: Vec<usize> = twos.iter().map(|(_, &v)| v).collect();
25 assert_eq!(idxs, vec![0, 2, 4]);
26 assert_eq!(values, vec![0, 1, 2]);
30 fn test_insert_and_iter() {
31 let mut map = SortedMap::new();
32 let mut expected = Vec::new();
35 assert_eq!(map.iter().cloned().collect::<Vec<_>>(), expected);
39 expected.insert(0, (x, x));
44 fn test_get_and_index() {
45 let mut map = SortedMap::new();
46 let mut expected = Vec::new();
56 for mut x in expected {
58 assert_eq!(map.get(&x), Some(&x));
59 assert_eq!(map.get_mut(&x), Some(&mut x));
60 assert_eq!(map[&x], x);
61 assert_eq!(&mut map[&x], &mut x);
63 assert_eq!(map.get(&x), None);
64 assert_eq!(map.get_mut(&x), None);
71 let mut map = SortedMap::new();
77 let keys = |s: &[(_, _)]| s.into_iter().map(|e| e.0).collect::<Vec<u32>>();
85 let mut expected = vec![1, 3, 6, 9];
86 expected.retain(|&x| x >= start && x < end);
88 assert_eq!(keys(map.range(start..end)), expected, "range = {}..{}", start, end);
94 fn test_offset_keys() {
95 let mut map = SortedMap::new();
100 map.offset_keys(|k| *k += 1);
102 let mut expected = SortedMap::new();
103 expected.insert(2, 1);
104 expected.insert(4, 3);
105 expected.insert(7, 6);
107 assert_eq!(map, expected);
110 fn keys(s: SortedMap<u32, u32>) -> Vec<u32> {
111 s.into_iter().map(|(k, _)| k).collect::<Vec<u32>>()
114 fn elements(s: SortedMap<u32, u32>) -> Vec<(u32, u32)> {
115 s.into_iter().collect::<Vec<(u32, u32)>>()
119 fn test_remove_range() {
120 let mut map = SortedMap::new();
132 let mut expected = vec![1, 3, 6, 9];
133 expected.retain(|&x| x < start || x >= end);
135 let mut map = map.clone();
136 map.remove_range(start..end);
138 assert_eq!(keys(map), expected, "range = {}..{}", start, end);
145 let mut map = SortedMap::new();
146 let mut expected = Vec::new();
150 expected.push((x, x));
154 let mut map = map.clone();
155 let mut expected = expected.clone();
157 assert_eq!(map.remove(&x), Some(x));
158 expected.remove(x as usize);
160 assert_eq!(map.iter().cloned().collect::<Vec<_>>(), expected);
165 fn test_insert_presorted_non_overlapping() {
166 let mut map = SortedMap::new();
170 map.insert_presorted(vec![(3, 0), (7, 0)]);
172 let expected = vec![2, 3, 7, 8];
173 assert_eq!(keys(map), expected);
177 fn test_insert_presorted_first_elem_equal() {
178 let mut map = SortedMap::new();
182 map.insert_presorted(vec![(2, 0), (7, 7)]);
184 let expected = vec![(2, 0), (7, 7), (8, 8)];
185 assert_eq!(elements(map), expected);
189 fn test_insert_presorted_last_elem_equal() {
190 let mut map = SortedMap::new();
194 map.insert_presorted(vec![(3, 3), (8, 0)]);
196 let expected = vec![(2, 2), (3, 3), (8, 0)];
197 assert_eq!(elements(map), expected);
201 fn test_insert_presorted_shuffle() {
202 let mut map = SortedMap::new();
206 map.insert_presorted(vec![(1, 1), (3, 3), (8, 8)]);
208 let expected = vec![(1, 1), (2, 2), (3, 3), (7, 7), (8, 8)];
209 assert_eq!(elements(map), expected);
213 fn test_insert_presorted_at_end() {
214 let mut map = SortedMap::new();
218 map.insert_presorted(vec![(3, 3), (8, 8)]);
220 let expected = vec![(1, 1), (2, 2), (3, 3), (8, 8)];
221 assert_eq!(elements(map), expected);