Skip to content

Commit e2d0c7f

Browse files
committed
Externalize tests
1 parent 3e6b767 commit e2d0c7f

File tree

2 files changed

+225
-222
lines changed

2 files changed

+225
-222
lines changed

src/lib.rs

Lines changed: 3 additions & 222 deletions
Original file line numberDiff line numberDiff line change
@@ -873,230 +873,11 @@ impl<'a, K: Hash + Eq, V, S: HashState> IntoIterator for &'a mut LinkedHashMap<K
873873
}
874874

875875
#[cfg(test)]
876-
mod tests {
877-
use super::LinkedHashMap;
878-
879-
fn assert_opt_eq<V: PartialEq>(opt: Option<&V>, v: V) {
880-
assert!(opt.is_some());
881-
assert!(opt.unwrap() == &v);
882-
}
883-
884-
#[test]
885-
fn test_insert_and_get() {
886-
let mut map = LinkedHashMap::new();
887-
map.insert(1, 10);
888-
map.insert(2, 20);
889-
assert_opt_eq(map.get(&1), 10);
890-
assert_opt_eq(map.get(&2), 20);
891-
assert_eq!(map.len(), 2);
892-
}
893-
894-
#[test]
895-
fn test_index() {
896-
let mut map = LinkedHashMap::new();
897-
map.insert(1, 10);
898-
map.insert(2, 20);
899-
assert_eq!(10, map[&1]);
900-
map[&2] = 22;
901-
assert_eq!(22, map[&2]);
902-
}
903-
904-
#[test]
905-
fn test_insert_update() {
906-
let mut map = LinkedHashMap::new();
907-
map.insert("1".to_string(), vec![10, 10]);
908-
map.insert("1".to_string(), vec![10, 19]);
909-
assert_opt_eq(map.get(&"1".to_string()), vec![10, 19]);
910-
assert_eq!(map.len(), 1);
911-
}
912-
913-
#[test]
914-
fn test_debug() {
915-
let mut map = LinkedHashMap::new();
916-
assert_eq!(format!("{:?}", map), "{}");
917-
map.insert(1, 10);
918-
map.insert(2, 20);
919-
map.insert(3, 30);
920-
assert_eq!(format!("{:?}", map), "{1: 10, 2: 20, 3: 30}");
921-
map.insert(2, 22);
922-
assert_eq!(format!("{:?}", map), "{1: 10, 3: 30, 2: 22}");
923-
map.get(&3);
924-
assert_eq!(format!("{:?}", map), "{1: 10, 3: 30, 2: 22}");
925-
map.get_refresh(&mut 3);
926-
assert_eq!(format!("{:?}", map), "{1: 10, 2: 22, 3: 30}");
927-
map.clear();
928-
assert_eq!(format!("{:?}", map), "{}");
929-
}
930-
931-
#[test]
932-
fn test_remove() {
933-
let mut map = LinkedHashMap::new();
934-
map.insert(1, 10);
935-
map.insert(2, 20);
936-
map.insert(3, 30);
937-
map.insert(4, 40);
938-
map.insert(5, 50);
939-
map.remove(&3);
940-
map.remove(&4);
941-
assert!(map.get(&3).is_none());
942-
assert!(map.get(&4).is_none());
943-
map.insert(6, 60);
944-
map.insert(7, 70);
945-
map.insert(8, 80);
946-
assert_opt_eq(map.get(&6), 60);
947-
assert_opt_eq(map.get(&7), 70);
948-
assert_opt_eq(map.get(&8), 80);
949-
}
950-
951-
952-
#[test]
953-
fn test_pop() {
954-
let mut map = LinkedHashMap::new();
955-
map.insert(1, 10);
956-
map.insert(2, 20);
957-
map.insert(3, 30);
958-
map.insert(4, 40);
959-
map.insert(5, 50);
960-
assert_eq!(map.pop_front(), Some((1, 10)));
961-
assert!(map.get(&1).is_none());
962-
assert_eq!(map.pop_back(), Some((5, 50)));
963-
assert!(map.get(&5).is_none());
964-
map.insert(6, 60);
965-
map.insert(7, 70);
966-
map.insert(8, 80);
967-
assert_eq!(map.pop_front(), Some((2, 20)));
968-
assert!(map.get(&2).is_none());
969-
assert_eq!(map.pop_back(), Some((8, 80)));
970-
assert!(map.get(&8).is_none());
971-
map.insert(3, 30);
972-
assert_eq!(map.pop_front(), Some((4, 40)));
973-
assert!(map.get(&4).is_none());
974-
assert_eq!(map.pop_back(), Some((3, 30)));
975-
assert!(map.get(&3).is_none());
976-
}
977-
978-
#[test]
979-
fn test_clear() {
980-
let mut map = LinkedHashMap::new();
981-
map.insert(1, 10);
982-
map.insert(2, 20);
983-
map.clear();
984-
assert!(map.get(&1).is_none());
985-
assert!(map.get(&2).is_none());
986-
assert_eq!(format!("{:?}", map), "{}");
987-
}
988-
989-
#[test]
990-
fn test_iter() {
991-
let mut map = LinkedHashMap::new();
992-
993-
// empty iter
994-
assert_eq!(None, map.iter().next());
995-
996-
map.insert("a", 10);
997-
map.insert("b", 20);
998-
map.insert("c", 30);
999-
1000-
// regular iter
1001-
let mut iter = map.iter();
1002-
assert_eq!((&"a", &10), iter.next().unwrap());
1003-
assert_eq!((&"b", &20), iter.next().unwrap());
1004-
assert_eq!((&"c", &30), iter.next().unwrap());
1005-
assert_eq!(None, iter.next());
1006-
assert_eq!(None, iter.next());
1007-
1008-
// reversed iter
1009-
let mut rev_iter = map.iter().rev();
1010-
assert_eq!((&"c", &30), rev_iter.next().unwrap());
1011-
assert_eq!((&"b", &20), rev_iter.next().unwrap());
1012-
assert_eq!((&"a", &10), rev_iter.next().unwrap());
1013-
assert_eq!(None, rev_iter.next());
1014-
assert_eq!(None, rev_iter.next());
1015-
1016-
// mixed
1017-
let mut mixed_iter = map.iter();
1018-
assert_eq!((&"a", &10), mixed_iter.next().unwrap());
1019-
assert_eq!((&"c", &30), mixed_iter.next_back().unwrap());
1020-
assert_eq!((&"b", &20), mixed_iter.next().unwrap());
1021-
assert_eq!(None, mixed_iter.next());
1022-
assert_eq!(None, mixed_iter.next_back());
1023-
}
1024-
1025-
#[test]
1026-
fn test_iter_mut() {
1027-
let mut map = LinkedHashMap::new();
1028-
map.insert("a", 10);
1029-
map.insert("c", 30);
1030-
map.insert("b", 20);
1031-
1032-
{
1033-
let mut iter = map.iter_mut();
1034-
let entry = iter.next().unwrap();
1035-
assert_eq!(&"a", entry.0);
1036-
*entry.1 = 17;
1037-
1038-
// reverse iterator
1039-
let mut iter = iter.rev();
1040-
let entry = iter.next().unwrap();
1041-
assert_eq!(&"b", entry.0);
1042-
*entry.1 = 23;
1043-
1044-
let entry = iter.next().unwrap();
1045-
assert_eq!(&"c", entry.0);
1046-
assert_eq!(None, iter.next());
1047-
assert_eq!(None, iter.next());
1048-
}
1049-
1050-
assert_eq!(17, map[&"a"]);
1051-
assert_eq!(23, map[&"b"]);
1052-
}
1053-
1054-
#[test]
1055-
fn test_borrow() {
1056-
#[derive(PartialEq, Eq, Hash)] struct Foo(Bar);
1057-
#[derive(PartialEq, Eq, Hash)] struct Bar(i32);
1058-
1059-
impl ::std::borrow::Borrow<Bar> for Foo {
1060-
fn borrow(&self) -> &Bar { &self.0 }
1061-
}
1062-
1063-
let mut map = LinkedHashMap::new();
1064-
map.insert(Foo(Bar(1)), "a");
1065-
map.insert(Foo(Bar(2)), "b");
1066-
1067-
assert!(map.contains_key(&Bar(1)));
1068-
assert!(map.contains_key(&Bar(2)));
1069-
assert!(map.contains_key(&Foo(Bar(1))));
1070-
assert!(map.contains_key(&Foo(Bar(2))));
1071-
1072-
assert_eq!(map.get(&Bar(1)), Some(&"a"));
1073-
assert_eq!(map.get(&Bar(2)), Some(&"b"));
1074-
assert_eq!(map.get(&Foo(Bar(1))), Some(&"a"));
1075-
assert_eq!(map.get(&Foo(Bar(2))), Some(&"b"));
1076-
1077-
assert_eq!(map.get_refresh(&Bar(1)), Some(&mut "a"));
1078-
assert_eq!(map.get_refresh(&Bar(2)), Some(&mut "b"));
1079-
assert_eq!(map.get_refresh(&Foo(Bar(1))), Some(&mut "a"));
1080-
assert_eq!(map.get_refresh(&Foo(Bar(2))), Some(&mut "b"));
1081-
1082-
assert_eq!(map.get_mut(&Bar(1)), Some(&mut "a"));
1083-
assert_eq!(map.get_mut(&Bar(2)), Some(&mut "b"));
1084-
assert_eq!(map.get_mut(&Foo(Bar(1))), Some(&mut "a"));
1085-
assert_eq!(map.get_mut(&Foo(Bar(2))), Some(&mut "b"));
1086-
1087-
assert_eq!(map[&Bar(1)], "a");
1088-
assert_eq!(map[&Bar(2)], "b");
1089-
assert_eq!(map[&Foo(Bar(1))], "a");
1090-
assert_eq!(map[&Foo(Bar(2))], "b");
1091-
1092-
assert_eq!(map.remove(&Bar(1)), Some("a"));
1093-
assert_eq!(map.remove(&Bar(2)), Some("b"));
1094-
assert_eq!(map.remove(&Foo(Bar(1))), None);
1095-
assert_eq!(map.remove(&Foo(Bar(2))), None);
1096-
}
1097-
876+
mod bench {
1098877
extern crate test;
1099878

879+
use super::LinkedHashMap;
880+
1100881
#[bench]
1101882
fn not_recycled_cycling(b: &mut test::Bencher) {
1102883
let mut hash_map = LinkedHashMap::with_capacity(1000);

0 commit comments

Comments
 (0)