#![cfg(test)]
macro_rules! set_multimap_tests {
($type:tt) => {
#[test]
fn insert_ignores_duplicates() {
let mut map = $type::new();
assert_eq!(0, map.len());
assert!(map.insert(0, "A".to_string()));
assert_eq!(1, map.len());
assert!(map.contains(&0, &"A".to_string()));
assert!(!map.insert(0, "A".to_string()));
assert_eq!(1, map.len());
assert!(map.contains(&0, &"A".to_string()));
}
};
}
macro_rules! index_multimap_tests {
($type:tt, $multimap_macro:tt, $values_macro:tt) => {
#[test]
fn shift_remove_removes_key_when_needed() {
let data = vec![(0, "A1"), (0, "A2"), (0, "A3"), (1, "B1"), (2, "C1")];
let mut map = data.clone().into_iter().collect::<$type<_, _>>();
assert_eq!(
data.iter().map(|(x, y)| (x, y)).collect::<Vec<_>>(),
map.iter().collect::<Vec<_>>()
);
assert_eq!(5, map.len());
assert_eq!(3, map.keys_len());
assert!(!map.is_empty());
assert_eq!(Some("A2"), map.shift_remove(&0, &"A2"));
assert!(!map.contains(&0, &"A2"));
assert_eq!(
vec![(0, "A1"), (0, "A3"), (1, "B1"), (2, "C1")],
map.clone().into_iter().collect::<Vec<_>>()
);
assert_eq!(4, map.len());
assert_eq!(3, map.keys_len());
assert!(!map.is_empty());
let values_for_0 = map.get(&0);
assert!(values_for_0.is_some());
assert_eq!(2, values_for_0.unwrap().len());
assert_eq!(
vec![&"A1", &"A3"],
values_for_0.unwrap().iter().collect::<Vec<_>>()
);
assert_eq!(Some("B1"), map.shift_remove(&1, &"B1"));
assert!(!map.contains(&1, &"B1"));
assert_eq!(
vec![(0, "A1"), (0, "A3"), (2, "C1")],
map.clone().into_iter().collect::<Vec<_>>()
);
assert_eq!(3, map.len());
assert_eq!(2, map.keys_len());
assert!(!map.is_empty());
assert_eq!(None, map.get(&1));
}
#[test]
fn swap_remove_removes_key_when_needed() {
let data = vec![
(0, "A1"),
(0, "A2"),
(0, "A3"),
(1, "B1"),
(2, "C1"),
(3, "D1"),
];
let mut map = data.clone().into_iter().collect::<$type<_, _>>();
assert_eq!(
data.iter().map(|(x, y)| (x, y)).collect::<Vec<_>>(),
map.iter().collect::<Vec<_>>()
);
assert_eq!(6, map.len());
assert_eq!(4, map.keys_len());
assert!(!map.is_empty());
assert_eq!(Some("A1"), map.swap_remove(&0, &"A1"));
assert!(!map.contains(&0, &"A1"));
assert_eq!(
vec![(0, "A3"), (0, "A2"), (1, "B1"), (2, "C1"), (3, "D1")],
map.clone().into_iter().collect::<Vec<_>>()
);
assert_eq!(5, map.len());
assert_eq!(4, map.keys_len());
assert!(!map.is_empty());
let values_for_0 = map.get(&0);
assert!(values_for_0.is_some());
assert_eq!(2, values_for_0.unwrap().len());
assert_eq!(
vec![&"A3", &"A2"],
values_for_0.unwrap().iter().collect::<Vec<_>>()
);
assert_eq!(Some("B1"), map.swap_remove(&1, &"B1"));
assert!(!map.contains(&1, &"B1"));
assert_eq!(
vec![(0, "A3"), (0, "A2"), (3, "D1"), (2, "C1")],
map.clone().into_iter().collect::<Vec<_>>()
);
assert_eq!(4, map.len());
assert_eq!(3, map.keys_len());
assert!(!map.is_empty());
assert_eq!(None, map.get(&1));
}
#[test]
fn shift_remove_key_returns_entire_value_collection_when_present() {
let mut map = vec![(0, "A1"), (0, "A2"), (1, "B1"), (2, "C1")]
.into_iter()
.collect::<$type<_, _>>();
assert_eq!(4, map.len());
assert_eq!(3, map.keys_len());
let expected = Some(maplit::hashset!["A1", "A2"]);
assert_eq!(
expected,
map.shift_remove_key(&0)
.map(|r| r.into_iter().collect::<std::collections::HashSet<_>>())
);
assert_eq!(2, map.len());
assert_eq!(2, map.keys_len());
assert_eq!(
vec![(1, "B1"), (2, "C1")],
map.clone().into_iter().collect::<Vec<_>>()
);
assert_eq!(None, map.shift_remove_key(&0));
}
#[test]
fn swap_remove_key_returns_entire_value_collection_when_present() {
let mut map = vec![(0, "A1"), (0, "A2"), (1, "B1"), (2, "C1")]
.into_iter()
.collect::<$type<_, _>>();
assert_eq!(4, map.len());
assert_eq!(3, map.keys_len());
let expected = Some(maplit::hashset!["A1", "A2"]);
assert_eq!(
expected,
map.swap_remove_key(&0)
.map(|r| r.into_iter().collect::<std::collections::HashSet<_>>())
);
assert_eq!(2, map.len());
assert_eq!(2, map.keys_len());
assert_eq!(
vec![(2, "C1"), (1, "B1")],
map.clone().into_iter().collect::<Vec<_>>()
);
assert_eq!(None, map.swap_remove_key(&0));
}
#[test]
fn shift_remove_key_entry_returns_entire_value_collection_when_present() {
let mut map = $multimap_macro! {
0 => {"A"},
1 => {"B"},
2 => {"C"}
};
let actual = map.shift_remove_key_entry(&0);
let expected = Some((0, $values_macro! { "A" }));
assert_eq!(expected, actual);
assert_eq!(
vec![(1, "B"), (2, "C")],
map.clone().into_iter().collect::<Vec<_>>()
);
assert_eq!(None, map.shift_remove_key_entry(&0));
}
#[test]
fn swap_remove_key_entry_returns_entire_value_collection_when_present() {
let mut map = $multimap_macro! {
0 => {"A"},
1 => {"B"},
2 => {"C"}
};
let actual = map.swap_remove_key_entry(&0);
let expected = Some((0, $values_macro! { "A" }));
assert_eq!(expected, actual);
assert_eq!(
vec![(2, "C"), (1, "B")],
map.clone().into_iter().collect::<Vec<_>>()
);
assert_eq!(None, map.swap_remove_key_entry(&0));
}
#[test]
fn shift_remove_is_noop_when_key_value_is_not_there() {
let data = vec![(0, "A1".to_string()), (0, "A2".to_string())];
let mut map = data.into_iter().collect::<$type<_, _>>();
assert_eq!(None, map.shift_remove(&0, &"A3".to_string()));
assert_eq!(2, map.len());
assert_eq!(1, map.keys_len());
}
#[test]
fn swap_remove_is_noop_when_key_value_is_not_there() {
let data = vec![(0, "A1".to_string()), (0, "A2".to_string())];
let mut map = data.into_iter().collect::<$type<_, _>>();
assert_eq!(None, map.swap_remove(&0, &"A3".to_string()));
assert_eq!(2, map.len());
assert_eq!(1, map.keys_len());
}
#[test]
fn with_capacity_constructs_instance_with_correct_capacity() {
let map7: $type<usize, usize> = $type::with_key_capacity(7);
let map17: $type<usize, usize> = $type::with_key_capacity(35);
assert_eq!(7, map7.key_capacity());
assert_eq!(35, map17.key_capacity());
}
#[test]
fn get_full_returns_correct_values() {
let map = $multimap_macro! {
0 => {1, 2, 3},
2 => {2, 3},
1 => {3}
};
assert_eq!(Some((0, &0, &$values_macro! { 1, 2, 3 })), map.get_full(&0));
assert_eq!(Some((1, &2, &$values_macro! { 2, 3 })), map.get_full(&2));
assert_eq!(None, map.get_full(&3));
}
#[test]
fn get_key_index_returns_correct_value() {
let map = $multimap_macro! {
0 => {1, 2, 3},
2 => {2, 3},
1 => {3}
};
assert_eq!(Some(0), map.get_key_index(&0));
assert_eq!(Some(2), map.get_key_index(&1));
assert_eq!(Some(1), map.get_key_index(&2));
assert_eq!(None, map.get_key_index(&3));
}
#[test]
fn iter_has_insertion_order() {
let map = $multimap_macro! {
"a" => {1, 2, 3},
"b" => {2, 3},
"c" => {3}
};
let actual = map.iter().collect::<Vec<_>>();
let expected = vec![
(&"a", &1),
(&"a", &2),
(&"a", &3),
(&"b", &2),
(&"b", &3),
(&"c", &3),
];
assert_eq!(expected, actual);
let empty = $type::<&str, usize>::new();
let actual = empty.iter().collect::<Vec<_>>();
let expected = Vec::<(&&str, &usize)>::new();
assert_eq!(expected, actual);
}
#[test]
fn keys_has_insertion_order() {
let map = $multimap_macro! {
"a" => {1, 2, 3},
"b" => {2, 3},
"c" => {3}
};
let actual = map.keys().collect::<Vec<_>>();
let expected = vec![&"a", &"b", &"c"];
assert_eq!(expected, actual);
let empty = $type::<&str, usize>::new();
let actual = empty.keys().collect::<Vec<_>>();
let expected = Vec::<&&str>::new();
assert_eq!(expected, actual);
}
#[test]
fn values_has_insertion_order() {
let map = $multimap_macro! {
"a" => {1, 2, 3},
"b" => {2, 3},
"c" => {3}
};
let actual = map.values().collect::<Vec<_>>();
let expected = vec![&1, &2, &3, &2, &3, &3];
assert_eq!(expected, actual);
let empty = $type::<&str, usize>::new();
let actual = empty.values().collect::<Vec<_>>();
let expected = Vec::<&usize>::new();
assert_eq!(expected, actual);
}
#[test]
fn into_iter_has_insertion_order() {
let map = $multimap_macro! {
"a" => {1, 2, 3},
"b" => {2, 3},
"c" => {3}
};
let actual = map.into_iter().collect::<Vec<_>>();
let expected = vec![("a", 1), ("a", 2), ("a", 3), ("b", 2), ("b", 3), ("c", 3)];
assert_eq!(expected, actual);
let empty = $type::<&str, usize>::new();
let actual = empty.into_iter().collect::<Vec<_>>();
let expected = Vec::<(&str, usize)>::new();
assert_eq!(expected, actual);
}
#[test]
fn into_keys_has_insertion_order() {
let map = $multimap_macro! {
"a" => {1, 2, 3},
"b" => {2, 3},
"c" => {3}
};
let actual = map.into_keys().collect::<Vec<_>>();
let expected = vec!["a", "b", "c"];
assert_eq!(expected, actual);
let empty = $type::<&str, usize>::new();
let actual = empty.into_keys().collect::<Vec<_>>();
let expected = Vec::<&str>::new();
assert_eq!(expected, actual);
}
#[test]
fn into_values_has_insertion_order() {
let map = $multimap_macro! {
"a" => {1, 2, 3},
"b" => {2, 3},
"c" => {3}
};
let actual = map.into_values().collect::<Vec<_>>();
let expected = vec![1, 2, 3, 2, 3, 3];
assert_eq!(expected, actual);
let empty = $type::<&str, usize>::new();
let actual = empty.into_values().collect::<Vec<_>>();
let expected = Vec::<usize>::new();
assert_eq!(expected, actual);
}
};
}
macro_rules! hash_multimap_tests {
($type:tt, $multimap_macro:tt, $values_macro:tt) => {
use std::collections::HashSet;
#[test]
fn remove_removes_key_when_needed() {
let data = vec![(0, "A1".to_string()), (0, "A2".to_string())];
let mut map = data.into_iter().collect::<$type<_, _>>();
assert_eq!(2, map.len());
assert_eq!(1, map.keys_len());
assert!(!map.is_empty());
assert_eq!(Some("A2".to_string()), map.remove(&0, &"A2".to_string()));
assert!(!map.contains(&0, &"A2".to_string()));
assert_eq!(1, map.len());
assert_eq!(1, map.keys_len());
assert!(!map.is_empty());
let result = map.get(&0);
assert!(result.is_some());
assert_eq!(1, result.unwrap().len());
assert_eq!(
vec![&"A1".to_string()],
result.unwrap().iter().collect::<Vec<_>>()
);
assert_eq!(Some("A1".to_string()), map.remove(&0, &"A1".to_string()));
assert!(!map.contains(&0, &"A1".to_string()));
assert_eq!(0, map.len());
assert_eq!(0, map.keys_len());
assert!(map.is_empty());
assert_eq!(None, map.get(&0));
}
#[test]
fn remove_key_returns_entire_value_collection_when_present() {
let mut map = vec![(0, "A1".to_string()), (0, "A2".to_string())]
.into_iter()
.collect::<$type<_, _>>();
assert_eq!(2, map.len());
assert_eq!(1, map.keys_len());
assert!(!map.is_empty());
let expected = Some(maplit::hashset!["A1".to_string(), "A2".to_string()]);
assert_eq!(
expected,
map.remove_key(&0)
.map(|r| r.into_iter().collect::<std::collections::HashSet<_>>())
);
assert_eq!(0, map.len());
assert_eq!(0, map.keys_len());
assert!(map.is_empty());
let empty: $type<usize, String> = $multimap_macro! {};
assert_eq!(empty, map);
assert_eq!(None, map.remove_key(&0));
}
#[test]
fn remove_key_entry_returns_entire_value_collection_when_present() {
let mut map = $multimap_macro! {
0 => {"A".to_string() }
};
let actual = map.remove_key_entry(&0);
let expected = Some((0, $values_macro! { "A".to_string() }));
assert_eq!(expected, actual);
assert!(map.is_empty());
assert_eq!(None, map.remove_key_entry(&0));
}
#[test]
fn remove_is_noop_when_key_value_is_not_there() {
let data = vec![(0, "A1".to_string()), (0, "A2".to_string())];
let mut map = data.into_iter().collect::<$type<_, _>>();
assert_eq!(None, map.remove(&0, &"A3".to_string()));
assert_eq!(2, map.len());
assert_eq!(1, map.keys_len());
}
#[test]
fn with_capacity_constructs_instance_with_correct_capacity() {
let map7: $type<usize, usize> = $type::with_key_capacity(7);
let map17: $type<usize, usize> = $type::with_key_capacity(35);
assert_eq!(7, map7.key_capacity());
assert!(35 <= map17.key_capacity());
}
#[test]
fn iter_contains_all_values() {
let map = $multimap_macro! {
"a" => {1, 2, 3},
"b" => {2, 3},
"c" => {3}
};
let actual = map.iter().collect::<HashSet<_>>();
let expected = maplit::hashset! {
(&"a", &1),
(&"a", &2),
(&"a", &3),
(&"b", &2),
(&"b", &3),
(&"c", &3),
};
assert_eq!(expected, actual);
let empty = $type::<&str, usize>::new();
let actual = empty.iter().collect::<HashSet<_>>();
let expected = HashSet::<(&&str, &usize)>::new();
assert_eq!(expected, actual);
}
#[test]
fn keys_contains_all_values() {
let map = $multimap_macro! {
"a" => {1, 2, 3},
"b" => {2, 3},
"c" => {3}
};
let actual = map.keys().collect::<HashSet<_>>();
let expected = maplit::hashset! {&"a", &"b", &"c"};
assert_eq!(expected, actual);
let empty = $type::<&str, usize>::new();
let actual = empty.keys().collect::<HashSet<_>>();
let expected = HashSet::<&&str>::new();
assert_eq!(expected, actual);
}
#[test]
fn values_contains_all_values() {
let map = $multimap_macro! {
"a" => {1, 2, 3},
"b" => {4, 5},
"c" => {6}
};
let actual = map.values().collect::<HashSet<_>>();
let expected = maplit::hashset! {&1, &2, &3, &4, &5, &6};
assert_eq!(expected, actual);
let empty = $type::<&str, usize>::new();
let actual = empty.values().collect::<HashSet<_>>();
let expected = HashSet::<&usize>::new();
assert_eq!(expected, actual);
}
#[test]
fn into_iter_contains_all_values() {
let map = $multimap_macro! {
"a" => {1, 2, 3},
"b" => {2, 3},
"c" => {3}
};
let actual = map.into_iter().collect::<HashSet<_>>();
let expected =
maplit::hashset![("a", 1), ("a", 2), ("a", 3), ("b", 2), ("b", 3), ("c", 3)];
assert_eq!(expected, actual);
let empty = $type::<&str, usize>::new();
let actual = empty.into_iter().collect::<HashSet<_>>();
let expected = HashSet::<(&str, usize)>::new();
assert_eq!(expected, actual);
}
#[test]
fn into_keys_contains_all_values() {
let map = $multimap_macro! {
"a" => {1, 2, 3},
"b" => {2, 3},
"c" => {3}
};
let actual = map.into_keys().collect::<HashSet<_>>();
let expected = maplit::hashset! {"a", "b", "c"};
assert_eq!(expected, actual);
let empty = $type::<&str, usize>::new();
let actual = empty.into_keys().collect::<HashSet<_>>();
let expected = HashSet::<&str>::new();
assert_eq!(expected, actual);
}
#[test]
fn into_values_contains_all_values() {
let map = $multimap_macro! {
"a" => {1, 2, 3},
"b" => {4, 5},
"c" => {6}
};
let actual = map.into_values().collect::<HashSet<_>>();
let expected = maplit::hashset! {1, 2, 3, 4, 5, 6};
assert_eq!(expected, actual);
let empty = $type::<&str, usize>::new();
let actual = empty.into_values().collect::<HashSet<_>>();
let expected = HashSet::<usize>::new();
assert_eq!(expected, actual);
}
};
}
macro_rules! general_multimap_tests {
($type:tt, $multimap_macro:tt, $keys_macro:tt, $values_macro:tt) => {
#[test]
fn retain_on_key_filter() {
let mut map = $multimap_macro! {
0 => {1, 2, 3 },
4 => {5},
7 => {3, 9}
};
map.retain(|k, _v| k == &4);
assert_eq!(1, map.len());
let expected = $multimap_macro! {
4 => {5}
};
assert_eq!(expected, map);
}
#[test]
fn retain_on_value_filter() {
let mut map = $multimap_macro! {
0 => {1, 2, 3 },
4 => {5},
7 => {3, 9}
};
map.retain(|_k, v| v == &3);
assert_eq!(2, map.len());
let expected = $multimap_macro! {
0 => {3},
7 => {3}
};
assert_eq!(expected, map);
}
#[test]
fn retain_on_key_value_filter() {
let mut map = $multimap_macro! {
0 => {1, 2, 3 },
4 => {5},
7 => {3, 9}
};
map.retain(|k, v| (k + v) % 2 == 0);
assert_eq!(3, map.len());
let expected = $multimap_macro! {
0 => {2},
7 => {3, 9}
};
assert_eq!(expected, map);
}
#[test]
fn len_is_consistent() {
let data = vec![
(0, "A".to_string()),
(1, "B".to_string()),
(2, "C".to_string()),
(3, "D".to_string()),
(4, "E".to_string()),
(4, "E2".to_string()),
(0, "A2".to_string()),
];
let mut map = $type::new();
for (i, (k, v)) in data.iter().enumerate() {
assert_eq!(map.len(), i);
map.insert(*k, v.to_string());
assert_eq!(map.len(), i + 1);
}
let map = data.into_iter().collect::<$type<_, _>>();
assert_eq!(7, map.len());
assert_eq!(5, map.keys_len());
}
#[test]
fn shrink_keys_to_fit_sets_capacity_at_most_len() {
let mut map7: $type<usize, usize> = $type::with_key_capacity(7);
map7.shrink_keys_to_fit();
assert_eq!(0, map7.key_capacity());
let mut map: $type<usize, usize> = $type::with_key_capacity(7);
map.insert(0, 1);
map.insert(0, 2);
map.insert(1, 7);
map.shrink_keys_to_fit();
assert!(map.key_capacity() >= 2);
}
#[test]
fn shrink_values_to_fit_sets_capacity_at_most_len() {
let mut map: $type<usize, usize> = $type::with_key_capacity(7);
map.insert(0, 1);
map.insert(0, 2);
map.insert(0, 3);
map.insert(1, 7);
map.shrink_values_to_fit();
assert!(map[&0].capacity() >= 3);
assert!(map[&1].capacity() >= 1);
}
#[test]
fn contains_key_returns_correct_value() {
let map = $multimap_macro! {
0 => { 1, 2, 3 },
9 => { 2, 3 },
333 => { 3 }
};
assert!(map.contains_key(&0));
assert!(map.contains_key(&9));
assert!(map.contains_key(&333));
assert!(!map.contains_key(&1));
assert!(!map.contains_key(&456));
assert!(!map.contains_key(&7));
}
#[test]
fn as_map_returns_borrowed_inner() {
let mm = $multimap_macro! {
0 => { 1, 2, 3 },
9 => { 2, 3 }
};
let actual = mm.as_map();
let expected = &$keys_macro! {
0 => $values_macro! { 1, 2, 3},
9 => $values_macro! {2, 3},
};
assert_eq!(expected, actual);
}
#[test]
fn into_map_returns_owned_inner() {
let mm = $multimap_macro! {
0 => { 1, 2, 3 },
9 => { 2, 3 }
};
let actual = mm.into_map();
let expected = $keys_macro! {
0 => $values_macro! { 1, 2, 3},
9 => $values_macro! {2, 3},
};
assert_eq!(expected, actual);
}
#[test]
fn extend_works_with_empty_multimap() {
let mut actual = $multimap_macro! {};
actual.extend(vec![(0, 1), (2, 3)]);
let expected = $multimap_macro! {
0 => { 1 },
2 => { 3 }
};
assert_eq!(expected, actual);
}
#[test]
fn extend_works_with_non_empty_multimap() {
let mut actual = $multimap_macro! {
0 => { 1 },
2 => { 3 }
};
actual.extend(vec![(0, 2), (2, 4), (4, 5)]);
let expected = $multimap_macro! {
0 => { 1, 2 },
2 => { 3, 4 },
4 => { 5 }
};
assert_eq!(expected, actual);
}
#[test]
fn extend_works_with_copy_iter() {
let mut actual = $multimap_macro! {};
actual.extend(vec![(&0, &1), (&2, &3)]);
let expected = $multimap_macro! {
0 => { 1 },
2 => { 3 }
};
assert_eq!(expected, actual);
}
#[test]
fn from_ignores_empty_sets() {
let map = $multimap_macro! {
0 => { 1, 2, 3 },
9 => { },
333 => { 3 }
};
assert_eq!(2, map.keys_len());
assert_eq!(4, map.len());
assert!(!map.contains_key(&9));
let expected = $multimap_macro! {
0 => { 1, 2, 3 },
333 => { 3 }
};
assert_eq!(expected, map);
}
#[test]
fn equality_test_fails_on_different_len() {
let a = $multimap_macro! {0 => { 0 }};
let b = $multimap_macro! {0 => { 0 }, 1 => { 1 }};
assert!(!a.eq(&b))
}
#[test]
fn equality_test_fails_on_same_len_but_distinct_elem_count() {
let a = $multimap_macro! {0 => { 0 }};
let b = $multimap_macro! {0 => { 0, 1 }};
assert!(!a.eq(&b))
}
#[test]
fn equality_test_succeeds_on_inversely_ordered_sets() {
let a = $multimap_macro! {
0 => { 1, 0 },
1 => { 2, 3 }
};
let b = $multimap_macro! {
1 => { 3, 2 },
0 => { 0, 1 }
};
assert!(a.eq(&b))
}
#[test]
fn get_and_index_give_same_result() {
let a = $multimap_macro! {
0 => { 1, 0, 7 },
1 => { 2, 3 }
};
let index = &a[&0];
let get = a.get(&0).unwrap();
assert_eq!(index, &$values_macro! { 1, 0, 7});
assert_eq!(index, get);
}
#[test]
fn test_get_key_values() {
let mm = $multimap_macro! {
0 => { 1, 0, 7, 1 },
1 => { 2, 3 }
};
let actual = mm.get_key_values(&0);
let values = $values_macro! { 1, 0, 7, 1 };
let expected = Some((&0, &values));
assert_eq!(actual, expected);
assert_eq!(None, mm.get_key_values(&2));
}
#[test]
#[should_panic(expected = "no entry found for key")]
fn index_panics_for_unknown_key() {
let a = $multimap_macro! {
0 => { 1, 0, 7 }
};
let _ = &a[&1];
}
#[test]
fn iter_supports_clone() {
let map = $multimap_macro! {
"a" => {1, 2, 3},
"b" => {2, 3},
"c" => {3}
};
let mut iter = map.iter();
let holdout = iter.next().unwrap();
let actual = iter.clone().collect::<std::collections::HashSet<_>>();
let mut expected = map.iter().collect::<std::collections::HashSet<_>>();
expected.remove(&holdout);
assert_eq!(expected, actual);
}
#[test]
fn keys_supports_clone() {
let map = $multimap_macro! {
"a" => {1, 2, 3},
"b" => {2, 3},
"c" => {3}
};
let mut keys = map.keys();
let holdout = keys.next().unwrap();
let actual = keys.clone().collect::<std::collections::HashSet<_>>();
let mut expected = map.keys().collect::<std::collections::HashSet<_>>();
expected.remove(holdout);
assert_eq!(expected, actual);
}
#[test]
fn values_supports_clone() {
let map = $multimap_macro! {
"a" => {1, 2, 3},
"b" => {2, 3},
"c" => {3}
};
let mut values = map.values();
let holdout = values.next().unwrap();
let actual = values.clone().collect::<Vec<_>>();
let mut expected = map.values().collect::<Vec<_>>();
let mut found = false;
expected.retain(|v| {
if !found && v == &holdout {
found = true;
false
} else {
true
}
});
assert_eq!(expected, actual);
}
};
}
mod hash_set_multimap {
use maplit::hashmap;
use maplit::hashset;
use more_collections::hashsetmultimap;
use more_collections::HashSetMultimap;
general_multimap_tests! {HashSetMultimap, hashsetmultimap, hashmap, hashset}
hash_multimap_tests! {HashSetMultimap, hashsetmultimap, hashset}
set_multimap_tests! {HashSetMultimap}
}
mod hash_vec_multimap {
use maplit::hashmap;
use more_collections::hashvecmultimap;
use more_collections::HashVecMultimap;
general_multimap_tests! {HashVecMultimap, hashvecmultimap, hashmap, vec}
hash_multimap_tests! {HashVecMultimap, hashvecmultimap, vec}
}
mod index_set_multimap {
use indexmap::indexmap;
use indexmap::indexset;
use more_collections::indexsetmultimap;
use more_collections::IndexSetMultimap;
general_multimap_tests! {IndexSetMultimap, indexsetmultimap, indexmap, indexset}
set_multimap_tests! {IndexSetMultimap}
index_multimap_tests! {IndexSetMultimap, indexsetmultimap, indexset}
#[test]
fn insert_full_returns_correct_values() {
let mut map = indexsetmultimap! {
0 => {1, 2, 3},
2 => {2, 3},
1 => {3}
};
assert_eq!((3, 0, true), map.insert_full(7, 2));
assert_eq!(7, map.len());
assert_eq!((2, 1, true), map.insert_full(1, 2));
assert_eq!(8, map.len());
assert_eq!((0, 1, false), map.insert_full(0, 2));
assert_eq!(8, map.len());
}
}
mod index_vec_multimap {
use indexmap::indexmap;
use more_collections::indexvecmultimap;
use more_collections::IndexVecMultimap;
general_multimap_tests! {IndexVecMultimap, indexvecmultimap, indexmap, vec}
index_multimap_tests! {IndexVecMultimap, indexvecmultimap, vec}
#[test]
fn insert_full_returns_correct_values() {
let mut map = indexvecmultimap! {
0 => {1, 2, 3},
2 => {2, 3},
1 => {3}
};
assert_eq!((3, 0), map.insert_full(7, 2));
assert_eq!(7, map.len());
assert_eq!((2, 1), map.insert_full(1, 2));
assert_eq!(8, map.len());
assert_eq!((0, 3), map.insert_full(0, 2));
assert_eq!(9, map.len());
}
}