-use super::SortedMap;
+use super::{SortedIndexMultiMap, SortedMap};
+
+#[test]
+fn test_sorted_index_multi_map() {
+ let entries: Vec<_> = vec![(2, 0), (1, 0), (2, 1), (3, 0), (2, 2)];
+ let set: SortedIndexMultiMap<usize, _, _> = entries.iter().copied().collect();
+
+ // Insertion order is preserved.
+ assert!(entries.iter().map(|(ref k, ref v)| (k, v)).eq(set.iter()));
+
+ // Indexing
+ for (i, expect) in entries.iter().enumerate() {
+ assert_eq!(set[i], expect.1);
+ }
+
+ // `get_by_key` works.
+ assert_eq!(set.get_by_key(&3).copied().collect::<Vec<_>>(), vec![0]);
+ assert!(set.get_by_key(&4).next().is_none());
+
+ // `get_by_key` returns items in insertion order.
+ let twos: Vec<_> = set.get_by_key_enumerated(&2).collect();
+ let idxs: Vec<usize> = twos.iter().map(|(i, _)| *i).collect();
+ let values: Vec<usize> = twos.iter().map(|(_, &v)| v).collect();
+
+ assert_eq!(idxs, vec![0, 2, 4]);
+ assert_eq!(values, vec![0, 1, 2]);
+}
#[test]
fn test_insert_and_iter() {
let mut map = SortedMap::new();
let mut expected = Vec::new();
- for x in 0 .. 100 {
+ for x in 0..100 {
assert_eq!(map.iter().cloned().collect::<Vec<_>>(), expected);
let x = 1000 - x * 2;
let mut map = SortedMap::new();
let mut expected = Vec::new();
- for x in 0 .. 100 {
+ for x in 0..100 {
let x = 1000 - x;
if x & 1 == 0 {
map.insert(x, x);
map.insert(6, 6);
map.insert(9, 9);
- let keys = |s: &[(_, _)]| {
- s.into_iter().map(|e| e.0).collect::<Vec<u32>>()
- };
+ let keys = |s: &[(_, _)]| s.into_iter().map(|e| e.0).collect::<Vec<u32>>();
- for start in 0 .. 11 {
- for end in 0 .. 11 {
+ for start in 0..11 {
+ for end in 0..11 {
if end < start {
- continue
+ continue;
}
let mut expected = vec![1, 3, 6, 9];
}
}
-
#[test]
fn test_offset_keys() {
let mut map = SortedMap::new();
map.insert(6, 6);
map.insert(9, 9);
- for start in 0 .. 11 {
- for end in 0 .. 11 {
+ for start in 0..11 {
+ for end in 0..11 {
if end < start {
- continue
+ continue;
}
let mut expected = vec![1, 3, 6, 9];
expected.retain(|&x| x < start || x >= end);
let mut map = map.clone();
- map.remove_range(start .. end);
+ map.remove_range(start..end);
assert_eq!(keys(map), expected, "range = {}..{}", start, end);
}
expected.push((x, x));
}
- for x in 0 .. 10 {
+ for x in 0..10 {
let mut map = map.clone();
let mut expected = expected.clone();