1 extern crate linked_hash_map;
2
3 use linked_hash_map::{LinkedHashMap, Entry};
4
assert_opt_eq<V: PartialEq>(opt: Option<&V>, v: V)5 fn assert_opt_eq<V: PartialEq>(opt: Option<&V>, v: V) {
6 assert!(opt.is_some());
7 assert!(opt.unwrap() == &v);
8 }
9
10 #[test]
test_insert_and_get()11 fn test_insert_and_get() {
12 let mut map = LinkedHashMap::new();
13 map.insert(1, 10);
14 map.insert(2, 20);
15 assert_opt_eq(map.get(&1), 10);
16 assert_opt_eq(map.get(&2), 20);
17 assert_eq!(map.len(), 2);
18 }
19
20 #[test]
test_index()21 fn test_index() {
22 let mut map = LinkedHashMap::new();
23 map.insert(1, 10);
24 map.insert(2, 20);
25 assert_eq!(10, map[&1]);
26 map[&2] = 22;
27 assert_eq!(22, map[&2]);
28 }
29
30 #[test]
test_insert_update()31 fn test_insert_update() {
32 let mut map = LinkedHashMap::new();
33 map.insert("1".to_string(), vec![10, 10]);
34 map.insert("1".to_string(), vec![10, 19]);
35 assert_opt_eq(map.get(&"1".to_string()), vec![10, 19]);
36 assert_eq!(map.len(), 1);
37 }
38
39 #[test]
test_entry_insert_vacant()40 fn test_entry_insert_vacant() {
41 let mut map = LinkedHashMap::new();
42 match map.entry("1".to_string()) {
43 Entry::Vacant(e) => {
44 assert_eq!(*e.insert(vec![10, 10]), vec![10, 10]);
45 }
46 _ => panic!("fail"),
47 }
48 assert!(map.contains_key("1"));
49 assert_eq!(map["1"], vec![10, 10]);
50
51 match map.entry("1".to_string()) {
52 Entry::Occupied(mut e) => {
53 assert_eq!(*e.get(), vec![10, 10]);
54 assert_eq!(e.insert(vec![10, 16]), vec![10, 10]);
55 }
56 _ => panic!("fail"),
57 }
58
59 assert!(map.contains_key("1"));
60 assert_eq!(map["1"], vec![10, 16]);
61
62 match map.entry("1".to_string()) {
63 Entry::Occupied(e) => {
64 assert_eq!(e.remove(), vec![10, 16]);
65 }
66 _ => panic!("fail"),
67 }
68 }
69
70 #[test]
test_entries_replacing()71 fn test_entries_replacing() {
72 let mut map = LinkedHashMap::new();
73 map.insert("a", 10);
74
75 {
76 let mut iter = map.entries();
77 let mut entry = iter.next().unwrap();
78 assert_eq!(entry.insert(20), 10);
79 assert!(iter.next().is_none());
80 }
81
82 assert_eq!(map["a"], 20);
83 }
84
85 #[test]
test_entries_remove()86 fn test_entries_remove() {
87 let mut map = LinkedHashMap::new();
88 map.insert("a", 10);
89 map.insert("b", 20);
90 map.insert("c", 30);
91 map.insert("d", 40);
92
93 // remove middle
94 {
95 let mut iter = map.entries();
96 iter.next().unwrap();
97 let b = iter.next().unwrap();
98 assert_eq!(*b.key(), "b");
99 assert_eq!(b.remove(), 20);
100 assert_eq!(*iter.next().unwrap().key(), "c");
101 }
102
103 assert_eq!(map.len(), 3);
104 assert_eq!(map["a"], 10);
105 assert_eq!(map["c"], 30);
106 assert_eq!(map["d"], 40);
107
108 // remove first
109 {
110 let mut iter = map.entries();
111 let a = iter.next().unwrap();
112 assert_eq!(*a.key(), "a");
113 assert_eq!(a.remove(), 10);
114 }
115
116 assert_eq!(map.len(), 2);
117 assert_eq!(map["c"], 30);
118 assert_eq!(map["d"], 40);
119
120 // remove last
121 {
122 let mut iter = map.entries();
123 iter.next().unwrap();
124 let d = iter.next().unwrap();
125 assert_eq!(*d.key(), "d");
126 assert_eq!(d.remove(), 40);
127 assert!(iter.next().is_none());
128 }
129
130 assert_eq!(map.len(), 1);
131 assert_eq!(map["c"], 30);
132
133 // remove only
134 {
135 let mut iter = map.entries();
136 let c = iter.next().unwrap();
137 assert_eq!(*c.key(), "c");
138 assert_eq!(c.remove(), 30);
139 }
140
141 assert!(map.is_empty());
142 }
143 #[test]
entries_insert()144 fn entries_insert() {
145 let mut map = LinkedHashMap::new();
146 map.insert(0, 0);
147 map.insert(1, 1);
148
149 let mut iter = map.entries();
150
151 iter.next().unwrap().insert(0);
152 iter.next().unwrap(); // 1
153 assert!(iter.next().is_none());
154 }
155
156 #[test]
test_debug()157 fn test_debug() {
158 let mut map = LinkedHashMap::new();
159 assert_eq!(format!("{:?}", map), "{}");
160 map.insert(1, 10);
161 map.insert(2, 20);
162 map.insert(3, 30);
163 assert_eq!(format!("{:?}", map), "{1: 10, 2: 20, 3: 30}");
164 map.insert(2, 22);
165 assert_eq!(format!("{:?}", map), "{1: 10, 3: 30, 2: 22}");
166 map.get(&3);
167 assert_eq!(format!("{:?}", map), "{1: 10, 3: 30, 2: 22}");
168 map.get_refresh(&mut 3);
169 assert_eq!(format!("{:?}", map), "{1: 10, 2: 22, 3: 30}");
170 map.clear();
171 assert_eq!(format!("{:?}", map), "{}");
172 }
173
174 #[test]
test_remove()175 fn test_remove() {
176 let mut map = LinkedHashMap::new();
177 map.insert(1, 10);
178 map.insert(2, 20);
179 map.insert(3, 30);
180 map.insert(4, 40);
181 map.insert(5, 50);
182 map.remove(&3);
183 map.remove(&4);
184 assert!(map.get(&3).is_none());
185 assert!(map.get(&4).is_none());
186 map.insert(6, 60);
187 map.insert(7, 70);
188 map.insert(8, 80);
189 assert_opt_eq(map.get(&6), 60);
190 assert_opt_eq(map.get(&7), 70);
191 assert_opt_eq(map.get(&8), 80);
192 }
193
194
195 #[test]
test_pop()196 fn test_pop() {
197 let mut map = LinkedHashMap::new();
198 map.insert(1, 10);
199 map.insert(2, 20);
200 map.insert(3, 30);
201 map.insert(4, 40);
202 map.insert(5, 50);
203 assert_eq!(map.pop_front(), Some((1, 10)));
204 assert!(map.get(&1).is_none());
205 assert_eq!(map.pop_back(), Some((5, 50)));
206 assert!(map.get(&5).is_none());
207 map.insert(6, 60);
208 map.insert(7, 70);
209 map.insert(8, 80);
210 assert_eq!(map.pop_front(), Some((2, 20)));
211 assert!(map.get(&2).is_none());
212 assert_eq!(map.pop_back(), Some((8, 80)));
213 assert!(map.get(&8).is_none());
214 map.insert(3, 30);
215 assert_eq!(map.pop_front(), Some((4, 40)));
216 assert!(map.get(&4).is_none());
217 assert_eq!(map.pop_back(), Some((3, 30)));
218 assert!(map.get(&3).is_none());
219 }
220
221 #[test]
test_clear()222 fn test_clear() {
223 let mut map = LinkedHashMap::new();
224 map.insert(1, 10);
225 map.insert(2, 20);
226 map.clear();
227 assert!(map.get(&1).is_none());
228 assert!(map.get(&2).is_none());
229 assert_eq!(format!("{:?}", map), "{}");
230 }
231
232 #[test]
test_iter()233 fn test_iter() {
234 let mut map = LinkedHashMap::new();
235
236 // empty iter
237 assert_eq!(None, map.iter().next());
238
239 map.insert("a", 10);
240 map.insert("b", 20);
241 map.insert("c", 30);
242
243 // regular iter
244 let mut iter = map.iter();
245 assert_eq!((&"a", &10), iter.next().unwrap());
246 assert_eq!((&"b", &20), iter.next().unwrap());
247 assert_eq!((&"c", &30), iter.next().unwrap());
248 assert_eq!(None, iter.next());
249 assert_eq!(None, iter.next());
250
251 // reversed iter
252 let mut rev_iter = map.iter().rev();
253 assert_eq!((&"c", &30), rev_iter.next().unwrap());
254 assert_eq!((&"b", &20), rev_iter.next().unwrap());
255 assert_eq!((&"a", &10), rev_iter.next().unwrap());
256 assert_eq!(None, rev_iter.next());
257 assert_eq!(None, rev_iter.next());
258
259 // mixed
260 let mut mixed_iter = map.iter();
261 assert_eq!((&"a", &10), mixed_iter.next().unwrap());
262 assert_eq!((&"c", &30), mixed_iter.next_back().unwrap());
263 assert_eq!((&"b", &20), mixed_iter.next().unwrap());
264 assert_eq!(None, mixed_iter.next());
265 assert_eq!(None, mixed_iter.next_back());
266 }
267
268 #[test]
test_iter_mut()269 fn test_iter_mut() {
270 let mut map = LinkedHashMap::new();
271 map.insert("a", 10);
272 map.insert("c", 30);
273 map.insert("b", 20);
274
275 {
276 let mut iter = map.iter_mut();
277 let entry = iter.next().unwrap();
278 assert_eq!(&"a", entry.0);
279 *entry.1 = 17;
280
281 // reverse iterator
282 let mut iter = iter.rev();
283 let entry = iter.next().unwrap();
284 assert_eq!(&"b", entry.0);
285 *entry.1 = 23;
286
287 let entry = iter.next().unwrap();
288 assert_eq!(&"c", entry.0);
289 assert_eq!(None, iter.next());
290 assert_eq!(None, iter.next());
291 }
292
293 assert_eq!(17, map[&"a"]);
294 assert_eq!(23, map[&"b"]);
295 }
296
297 #[test]
test_consuming_iter()298 fn test_consuming_iter() {
299 let map = {
300 let mut map = LinkedHashMap::new();
301 map.insert("a", 10);
302 map.insert("c", 30);
303 map.insert("b", 20);
304 map
305 };
306
307 let mut iter = map.into_iter();
308 assert_eq!(Some(("a", 10)), iter.next());
309
310 let clone = iter.clone();
311 for iter in &mut [iter, clone] {
312 assert_eq!(Some(("b", 20)), iter.next_back());
313 assert_eq!(1, iter.len());
314 assert_eq!(Some(("c", 30)), iter.next());
315 assert_eq!(None, iter.next());
316 }
317 }
318
319 #[test]
test_consuming_iter_empty()320 fn test_consuming_iter_empty() {
321 let map = LinkedHashMap::<&str, i32>::new();
322 let mut iter = map.into_iter();
323 assert_eq!(None, iter.next());
324 let mut clone = iter.clone();
325 assert_eq!(None, clone.next());
326 }
327
328 #[test]
test_consuming_iter_with_free_list()329 fn test_consuming_iter_with_free_list() {
330 let mut map = LinkedHashMap::new();
331 map.insert("a", 10);
332 map.insert("c", 30);
333 map.insert("b", 20);
334 map.remove("a");
335 map.remove("b");
336
337 let mut iter = map.into_iter();
338 assert_eq!(Some(("c", 30)), iter.next());
339 assert_eq!(None, iter.next());
340 }
341
342 #[test]
test_into_iter_drop()343 fn test_into_iter_drop() {
344 struct Counter<'a>(&'a mut usize);
345
346 impl<'a> Drop for Counter<'a> {
347 fn drop(&mut self) {
348 *self.0 += 1;
349 }
350 }
351
352 let mut a = 0;
353 let mut b = 0;
354 let mut c = 0;
355
356 {
357 let mut map = LinkedHashMap::new();
358 map.insert("a", Counter(&mut a));
359 map.insert("b", Counter(&mut b));
360 map.insert("c", Counter(&mut c));
361
362 let mut iter = map.into_iter();
363 iter.next();
364 iter.next_back();
365 }
366
367 assert_eq!(a, 1);
368 assert_eq!(b, 1);
369 assert_eq!(c, 1);
370 }
371
372 #[test]
test_borrow()373 fn test_borrow() {
374 #[derive(PartialEq, Eq, Hash)] struct Foo(Bar);
375 #[derive(PartialEq, Eq, Hash)] struct Bar(i32);
376
377 impl ::std::borrow::Borrow<Bar> for Foo {
378 fn borrow(&self) -> &Bar { &self.0 }
379 }
380
381 let mut map = LinkedHashMap::new();
382 map.insert(Foo(Bar(1)), "a");
383 map.insert(Foo(Bar(2)), "b");
384
385 assert!(map.contains_key(&Bar(1)));
386 assert!(map.contains_key(&Bar(2)));
387 assert!(map.contains_key(&Foo(Bar(1))));
388 assert!(map.contains_key(&Foo(Bar(2))));
389
390 assert_eq!(map.get(&Bar(1)), Some(&"a"));
391 assert_eq!(map.get(&Bar(2)), Some(&"b"));
392 assert_eq!(map.get(&Foo(Bar(1))), Some(&"a"));
393 assert_eq!(map.get(&Foo(Bar(2))), Some(&"b"));
394
395 assert_eq!(map.get_refresh(&Bar(1)), Some(&mut "a"));
396 assert_eq!(map.get_refresh(&Bar(2)), Some(&mut "b"));
397 assert_eq!(map.get_refresh(&Foo(Bar(1))), Some(&mut "a"));
398 assert_eq!(map.get_refresh(&Foo(Bar(2))), Some(&mut "b"));
399
400 assert_eq!(map.get_mut(&Bar(1)), Some(&mut "a"));
401 assert_eq!(map.get_mut(&Bar(2)), Some(&mut "b"));
402 assert_eq!(map.get_mut(&Foo(Bar(1))), Some(&mut "a"));
403 assert_eq!(map.get_mut(&Foo(Bar(2))), Some(&mut "b"));
404
405 assert_eq!(map[&Bar(1)], "a");
406 assert_eq!(map[&Bar(2)], "b");
407 assert_eq!(map[&Foo(Bar(1))], "a");
408 assert_eq!(map[&Foo(Bar(2))], "b");
409
410 assert_eq!(map.remove(&Bar(1)), Some("a"));
411 assert_eq!(map.remove(&Bar(2)), Some("b"));
412 assert_eq!(map.remove(&Foo(Bar(1))), None);
413 assert_eq!(map.remove(&Foo(Bar(2))), None);
414 }
415
416 #[test]
test_send_sync()417 fn test_send_sync() {
418 fn is_send_sync<T: Send + Sync>() {}
419
420 is_send_sync::<LinkedHashMap<u32, i32>>();
421 is_send_sync::<linked_hash_map::Iter<u32, i32>>();
422 is_send_sync::<linked_hash_map::IterMut<u32, i32>>();
423 is_send_sync::<linked_hash_map::IntoIter<u32, i32>>();
424 is_send_sync::<linked_hash_map::Keys<u32, i32>>();
425 is_send_sync::<linked_hash_map::Values<u32, i32>>();
426 }
427