1 #![cfg(feature = "rayon")]
2
3 #[macro_use]
4 extern crate lazy_static;
5
6 use hashbrown::{HashMap, HashSet};
7 use rayon::iter::{
8 IntoParallelIterator, IntoParallelRefIterator, IntoParallelRefMutIterator, ParallelExtend,
9 ParallelIterator,
10 };
11
12 macro_rules! assert_eq3 {
13 ($e1:expr, $e2:expr, $e3:expr) => {{
14 assert_eq!($e1, $e2);
15 assert_eq!($e1, $e3);
16 assert_eq!($e2, $e3);
17 }};
18 }
19
20 lazy_static! {
21 static ref MAP_EMPTY: HashMap<char, u32> = HashMap::new();
22 static ref MAP: HashMap<char, u32> = {
23 let mut m = HashMap::new();
24 m.insert('b', 20);
25 m.insert('a', 10);
26 m.insert('c', 30);
27 m.insert('e', 50);
28 m.insert('f', 60);
29 m.insert('d', 40);
30 m
31 };
32 }
33
34 #[test]
map_seq_par_equivalence_iter_empty()35 fn map_seq_par_equivalence_iter_empty() {
36 let vec_seq = MAP_EMPTY.iter().collect::<Vec<_>>();
37 let vec_par = MAP_EMPTY.par_iter().collect::<Vec<_>>();
38
39 assert_eq3!(vec_seq, vec_par, []);
40 }
41
42 #[test]
map_seq_par_equivalence_iter()43 fn map_seq_par_equivalence_iter() {
44 let mut vec_seq = MAP.iter().collect::<Vec<_>>();
45 let mut vec_par = MAP.par_iter().collect::<Vec<_>>();
46
47 assert_eq!(vec_seq, vec_par);
48
49 // Do not depend on the exact order of values
50 let expected_sorted = [
51 (&'a', &10),
52 (&'b', &20),
53 (&'c', &30),
54 (&'d', &40),
55 (&'e', &50),
56 (&'f', &60),
57 ];
58
59 vec_seq.sort_unstable();
60 vec_par.sort_unstable();
61
62 assert_eq3!(vec_seq, vec_par, expected_sorted);
63 }
64
65 #[test]
map_seq_par_equivalence_keys_empty()66 fn map_seq_par_equivalence_keys_empty() {
67 let vec_seq = MAP_EMPTY.keys().collect::<Vec<&char>>();
68 let vec_par = MAP_EMPTY.par_keys().collect::<Vec<&char>>();
69
70 let expected: [&char; 0] = [];
71
72 assert_eq3!(vec_seq, vec_par, expected);
73 }
74
75 #[test]
map_seq_par_equivalence_keys()76 fn map_seq_par_equivalence_keys() {
77 let mut vec_seq = MAP.keys().collect::<Vec<_>>();
78 let mut vec_par = MAP.par_keys().collect::<Vec<_>>();
79
80 assert_eq!(vec_seq, vec_par);
81
82 // Do not depend on the exact order of values
83 let expected_sorted = [&'a', &'b', &'c', &'d', &'e', &'f'];
84
85 vec_seq.sort_unstable();
86 vec_par.sort_unstable();
87
88 assert_eq3!(vec_seq, vec_par, expected_sorted);
89 }
90
91 #[test]
map_seq_par_equivalence_values_empty()92 fn map_seq_par_equivalence_values_empty() {
93 let vec_seq = MAP_EMPTY.values().collect::<Vec<_>>();
94 let vec_par = MAP_EMPTY.par_values().collect::<Vec<_>>();
95
96 let expected: [&u32; 0] = [];
97
98 assert_eq3!(vec_seq, vec_par, expected);
99 }
100
101 #[test]
map_seq_par_equivalence_values()102 fn map_seq_par_equivalence_values() {
103 let mut vec_seq = MAP.values().collect::<Vec<_>>();
104 let mut vec_par = MAP.par_values().collect::<Vec<_>>();
105
106 assert_eq!(vec_seq, vec_par);
107
108 // Do not depend on the exact order of values
109 let expected_sorted = [&10, &20, &30, &40, &50, &60];
110
111 vec_seq.sort_unstable();
112 vec_par.sort_unstable();
113
114 assert_eq3!(vec_seq, vec_par, expected_sorted);
115 }
116
117 #[test]
map_seq_par_equivalence_iter_mut_empty()118 fn map_seq_par_equivalence_iter_mut_empty() {
119 let mut map1 = MAP_EMPTY.clone();
120 let mut map2 = MAP_EMPTY.clone();
121
122 let vec_seq = map1.iter_mut().collect::<Vec<_>>();
123 let vec_par = map2.par_iter_mut().collect::<Vec<_>>();
124
125 assert_eq3!(vec_seq, vec_par, []);
126 }
127
128 #[test]
map_seq_par_equivalence_iter_mut()129 fn map_seq_par_equivalence_iter_mut() {
130 let mut map1 = MAP.clone();
131 let mut map2 = MAP.clone();
132
133 let mut vec_seq = map1.iter_mut().collect::<Vec<_>>();
134 let mut vec_par = map2.par_iter_mut().collect::<Vec<_>>();
135
136 assert_eq!(vec_seq, vec_par);
137
138 // Do not depend on the exact order of values
139 let expected_sorted = [
140 (&'a', &mut 10),
141 (&'b', &mut 20),
142 (&'c', &mut 30),
143 (&'d', &mut 40),
144 (&'e', &mut 50),
145 (&'f', &mut 60),
146 ];
147
148 vec_seq.sort_unstable();
149 vec_par.sort_unstable();
150
151 assert_eq3!(vec_seq, vec_par, expected_sorted);
152 }
153
154 #[test]
map_seq_par_equivalence_values_mut_empty()155 fn map_seq_par_equivalence_values_mut_empty() {
156 let mut map1 = MAP_EMPTY.clone();
157 let mut map2 = MAP_EMPTY.clone();
158
159 let vec_seq = map1.values_mut().collect::<Vec<_>>();
160 let vec_par = map2.par_values_mut().collect::<Vec<_>>();
161
162 let expected: [&u32; 0] = [];
163
164 assert_eq3!(vec_seq, vec_par, expected);
165 }
166
167 #[test]
map_seq_par_equivalence_values_mut()168 fn map_seq_par_equivalence_values_mut() {
169 let mut map1 = MAP.clone();
170 let mut map2 = MAP.clone();
171
172 let mut vec_seq = map1.values_mut().collect::<Vec<_>>();
173 let mut vec_par = map2.par_values_mut().collect::<Vec<_>>();
174
175 assert_eq!(vec_seq, vec_par);
176
177 // Do not depend on the exact order of values
178 let expected_sorted = [&mut 10, &mut 20, &mut 30, &mut 40, &mut 50, &mut 60];
179
180 vec_seq.sort_unstable();
181 vec_par.sort_unstable();
182
183 assert_eq3!(vec_seq, vec_par, expected_sorted);
184 }
185
186 #[test]
map_seq_par_equivalence_into_iter_empty()187 fn map_seq_par_equivalence_into_iter_empty() {
188 let vec_seq = MAP_EMPTY.clone().into_iter().collect::<Vec<_>>();
189 let vec_par = MAP_EMPTY.clone().into_par_iter().collect::<Vec<_>>();
190
191 assert_eq3!(vec_seq, vec_par, []);
192 }
193
194 #[test]
map_seq_par_equivalence_into_iter()195 fn map_seq_par_equivalence_into_iter() {
196 let mut vec_seq = MAP.clone().into_iter().collect::<Vec<_>>();
197 let mut vec_par = MAP.clone().into_par_iter().collect::<Vec<_>>();
198
199 assert_eq!(vec_seq, vec_par);
200
201 // Do not depend on the exact order of values
202 let expected_sorted = [
203 ('a', 10),
204 ('b', 20),
205 ('c', 30),
206 ('d', 40),
207 ('e', 50),
208 ('f', 60),
209 ];
210
211 vec_seq.sort_unstable();
212 vec_par.sort_unstable();
213
214 assert_eq3!(vec_seq, vec_par, expected_sorted);
215 }
216
217 lazy_static! {
218 static ref MAP_VEC_EMPTY: Vec<(char, u32)> = vec![];
219 static ref MAP_VEC: Vec<(char, u32)> = vec![
220 ('b', 20),
221 ('a', 10),
222 ('c', 30),
223 ('e', 50),
224 ('f', 60),
225 ('d', 40),
226 ];
227 }
228
229 #[test]
map_seq_par_equivalence_collect_empty()230 fn map_seq_par_equivalence_collect_empty() {
231 let map_expected = MAP_EMPTY.clone();
232 let map_seq = MAP_VEC_EMPTY.clone().into_iter().collect::<HashMap<_, _>>();
233 let map_par = MAP_VEC_EMPTY
234 .clone()
235 .into_par_iter()
236 .collect::<HashMap<_, _>>();
237
238 assert_eq!(map_seq, map_par);
239 assert_eq!(map_seq, map_expected);
240 assert_eq!(map_par, map_expected);
241 }
242
243 #[test]
map_seq_par_equivalence_collect()244 fn map_seq_par_equivalence_collect() {
245 let map_expected = MAP.clone();
246 let map_seq = MAP_VEC.clone().into_iter().collect::<HashMap<_, _>>();
247 let map_par = MAP_VEC.clone().into_par_iter().collect::<HashMap<_, _>>();
248
249 assert_eq!(map_seq, map_par);
250 assert_eq!(map_seq, map_expected);
251 assert_eq!(map_par, map_expected);
252 }
253
254 lazy_static! {
255 static ref MAP_EXISTING_EMPTY: HashMap<char, u32> = HashMap::new();
256 static ref MAP_EXISTING: HashMap<char, u32> = {
257 let mut m = HashMap::new();
258 m.insert('b', 20);
259 m.insert('a', 10);
260 m
261 };
262 static ref MAP_EXTENSION_EMPTY: Vec<(char, u32)> = vec![];
263 static ref MAP_EXTENSION: Vec<(char, u32)> = vec![('c', 30), ('e', 50), ('f', 60), ('d', 40),];
264 }
265
266 #[test]
map_seq_par_equivalence_existing_empty_extend_empty()267 fn map_seq_par_equivalence_existing_empty_extend_empty() {
268 let expected = HashMap::new();
269 let mut map_seq = MAP_EXISTING_EMPTY.clone();
270 let mut map_par = MAP_EXISTING_EMPTY.clone();
271
272 map_seq.extend(MAP_EXTENSION_EMPTY.iter().cloned());
273 map_par.par_extend(MAP_EXTENSION_EMPTY.par_iter().cloned());
274
275 assert_eq3!(map_seq, map_par, expected);
276 }
277
278 #[test]
map_seq_par_equivalence_existing_empty_extend()279 fn map_seq_par_equivalence_existing_empty_extend() {
280 let expected = MAP_EXTENSION.iter().cloned().collect::<HashMap<_, _>>();
281 let mut map_seq = MAP_EXISTING_EMPTY.clone();
282 let mut map_par = MAP_EXISTING_EMPTY.clone();
283
284 map_seq.extend(MAP_EXTENSION.iter().cloned());
285 map_par.par_extend(MAP_EXTENSION.par_iter().cloned());
286
287 assert_eq3!(map_seq, map_par, expected);
288 }
289
290 #[test]
map_seq_par_equivalence_existing_extend_empty()291 fn map_seq_par_equivalence_existing_extend_empty() {
292 let expected = MAP_EXISTING.clone();
293 let mut map_seq = MAP_EXISTING.clone();
294 let mut map_par = MAP_EXISTING.clone();
295
296 map_seq.extend(MAP_EXTENSION_EMPTY.iter().cloned());
297 map_par.par_extend(MAP_EXTENSION_EMPTY.par_iter().cloned());
298
299 assert_eq3!(map_seq, map_par, expected);
300 }
301
302 #[test]
map_seq_par_equivalence_existing_extend()303 fn map_seq_par_equivalence_existing_extend() {
304 let expected = MAP.clone();
305 let mut map_seq = MAP_EXISTING.clone();
306 let mut map_par = MAP_EXISTING.clone();
307
308 map_seq.extend(MAP_EXTENSION.iter().cloned());
309 map_par.par_extend(MAP_EXTENSION.par_iter().cloned());
310
311 assert_eq3!(map_seq, map_par, expected);
312 }
313
314 lazy_static! {
315 static ref SET_EMPTY: HashSet<char> = HashSet::new();
316 static ref SET: HashSet<char> = {
317 let mut s = HashSet::new();
318 s.insert('b');
319 s.insert('a');
320 s.insert('c');
321 s.insert('e');
322 s.insert('f');
323 s.insert('d');
324 s
325 };
326 }
327
328 #[test]
set_seq_par_equivalence_iter_empty()329 fn set_seq_par_equivalence_iter_empty() {
330 let vec_seq = SET_EMPTY.iter().collect::<Vec<_>>();
331 let vec_par = SET_EMPTY.par_iter().collect::<Vec<_>>();
332
333 let expected: [&char; 0] = [];
334
335 assert_eq3!(vec_seq, vec_par, expected);
336 }
337
338 #[test]
set_seq_par_equivalence_iter()339 fn set_seq_par_equivalence_iter() {
340 let mut vec_seq = SET.iter().collect::<Vec<_>>();
341 let mut vec_par = SET.par_iter().collect::<Vec<_>>();
342
343 assert_eq!(vec_seq, vec_par);
344
345 // Do not depend on the exact order of values
346 let expected_sorted = [&'a', &'b', &'c', &'d', &'e', &'f'];
347
348 vec_seq.sort_unstable();
349 vec_par.sort_unstable();
350
351 assert_eq3!(vec_seq, vec_par, expected_sorted);
352 }
353
354 #[test]
set_seq_par_equivalence_into_iter_empty()355 fn set_seq_par_equivalence_into_iter_empty() {
356 let vec_seq = SET_EMPTY.clone().into_iter().collect::<Vec<_>>();
357 let vec_par = SET_EMPTY.clone().into_par_iter().collect::<Vec<_>>();
358
359 assert_eq3!(vec_seq, vec_par, []);
360 }
361
362 #[test]
set_seq_par_equivalence_into_iter()363 fn set_seq_par_equivalence_into_iter() {
364 let mut vec_seq = SET.clone().into_iter().collect::<Vec<_>>();
365 let mut vec_par = SET.clone().into_par_iter().collect::<Vec<_>>();
366
367 assert_eq!(vec_seq, vec_par);
368
369 // Do not depend on the exact order of values
370 let expected_sorted = ['a', 'b', 'c', 'd', 'e', 'f'];
371
372 vec_seq.sort_unstable();
373 vec_par.sort_unstable();
374
375 assert_eq3!(vec_seq, vec_par, expected_sorted);
376 }
377
378 lazy_static! {
379 static ref SET_VEC_EMPTY: Vec<char> = vec![];
380 static ref SET_VEC: Vec<char> = vec!['b', 'a', 'c', 'e', 'f', 'd',];
381 }
382
383 #[test]
set_seq_par_equivalence_collect_empty()384 fn set_seq_par_equivalence_collect_empty() {
385 let set_expected = SET_EMPTY.clone();
386 let set_seq = SET_VEC_EMPTY.clone().into_iter().collect::<HashSet<_>>();
387 let set_par = SET_VEC_EMPTY
388 .clone()
389 .into_par_iter()
390 .collect::<HashSet<_>>();
391
392 assert_eq!(set_seq, set_par);
393 assert_eq!(set_seq, set_expected);
394 assert_eq!(set_par, set_expected);
395 }
396
397 #[test]
set_seq_par_equivalence_collect()398 fn set_seq_par_equivalence_collect() {
399 let set_expected = SET.clone();
400 let set_seq = SET_VEC.clone().into_iter().collect::<HashSet<_>>();
401 let set_par = SET_VEC.clone().into_par_iter().collect::<HashSet<_>>();
402
403 assert_eq!(set_seq, set_par);
404 assert_eq!(set_seq, set_expected);
405 assert_eq!(set_par, set_expected);
406 }
407
408 lazy_static! {
409 static ref SET_EXISTING_EMPTY: HashSet<char> = HashSet::new();
410 static ref SET_EXISTING: HashSet<char> = {
411 let mut s = HashSet::new();
412 s.insert('b');
413 s.insert('a');
414 s
415 };
416 static ref SET_EXTENSION_EMPTY: Vec<char> = vec![];
417 static ref SET_EXTENSION: Vec<char> = vec!['c', 'e', 'f', 'd',];
418 }
419
420 #[test]
set_seq_par_equivalence_existing_empty_extend_empty()421 fn set_seq_par_equivalence_existing_empty_extend_empty() {
422 let expected = HashSet::new();
423 let mut set_seq = SET_EXISTING_EMPTY.clone();
424 let mut set_par = SET_EXISTING_EMPTY.clone();
425
426 set_seq.extend(SET_EXTENSION_EMPTY.iter().cloned());
427 set_par.par_extend(SET_EXTENSION_EMPTY.par_iter().cloned());
428
429 assert_eq3!(set_seq, set_par, expected);
430 }
431
432 #[test]
set_seq_par_equivalence_existing_empty_extend()433 fn set_seq_par_equivalence_existing_empty_extend() {
434 let expected = SET_EXTENSION.iter().cloned().collect::<HashSet<_>>();
435 let mut set_seq = SET_EXISTING_EMPTY.clone();
436 let mut set_par = SET_EXISTING_EMPTY.clone();
437
438 set_seq.extend(SET_EXTENSION.iter().cloned());
439 set_par.par_extend(SET_EXTENSION.par_iter().cloned());
440
441 assert_eq3!(set_seq, set_par, expected);
442 }
443
444 #[test]
set_seq_par_equivalence_existing_extend_empty()445 fn set_seq_par_equivalence_existing_extend_empty() {
446 let expected = SET_EXISTING.clone();
447 let mut set_seq = SET_EXISTING.clone();
448 let mut set_par = SET_EXISTING.clone();
449
450 set_seq.extend(SET_EXTENSION_EMPTY.iter().cloned());
451 set_par.par_extend(SET_EXTENSION_EMPTY.par_iter().cloned());
452
453 assert_eq3!(set_seq, set_par, expected);
454 }
455
456 #[test]
set_seq_par_equivalence_existing_extend()457 fn set_seq_par_equivalence_existing_extend() {
458 let expected = SET.clone();
459 let mut set_seq = SET_EXISTING.clone();
460 let mut set_par = SET_EXISTING.clone();
461
462 set_seq.extend(SET_EXTENSION.iter().cloned());
463 set_par.par_extend(SET_EXTENSION.par_iter().cloned());
464
465 assert_eq3!(set_seq, set_par, expected);
466 }
467
468 lazy_static! {
469 static ref SET_A: HashSet<char> = ['a', 'b', 'c', 'd'].iter().cloned().collect();
470 static ref SET_B: HashSet<char> = ['a', 'b', 'e', 'f'].iter().cloned().collect();
471 static ref SET_DIFF_AB: HashSet<char> = ['c', 'd'].iter().cloned().collect();
472 static ref SET_DIFF_BA: HashSet<char> = ['e', 'f'].iter().cloned().collect();
473 static ref SET_SYMM_DIFF_AB: HashSet<char> = ['c', 'd', 'e', 'f'].iter().cloned().collect();
474 static ref SET_INTERSECTION_AB: HashSet<char> = ['a', 'b'].iter().cloned().collect();
475 static ref SET_UNION_AB: HashSet<char> =
476 ['a', 'b', 'c', 'd', 'e', 'f'].iter().cloned().collect();
477 }
478
479 #[test]
set_seq_par_equivalence_difference()480 fn set_seq_par_equivalence_difference() {
481 let diff_ab_seq = SET_A.difference(&*SET_B).cloned().collect::<HashSet<_>>();
482 let diff_ab_par = SET_A
483 .par_difference(&*SET_B)
484 .cloned()
485 .collect::<HashSet<_>>();
486
487 assert_eq3!(diff_ab_seq, diff_ab_par, *SET_DIFF_AB);
488
489 let diff_ba_seq = SET_B.difference(&*SET_A).cloned().collect::<HashSet<_>>();
490 let diff_ba_par = SET_B
491 .par_difference(&*SET_A)
492 .cloned()
493 .collect::<HashSet<_>>();
494
495 assert_eq3!(diff_ba_seq, diff_ba_par, *SET_DIFF_BA);
496 }
497
498 #[test]
set_seq_par_equivalence_symmetric_difference()499 fn set_seq_par_equivalence_symmetric_difference() {
500 let symm_diff_ab_seq = SET_A
501 .symmetric_difference(&*SET_B)
502 .cloned()
503 .collect::<HashSet<_>>();
504 let symm_diff_ab_par = SET_A
505 .par_symmetric_difference(&*SET_B)
506 .cloned()
507 .collect::<HashSet<_>>();
508
509 assert_eq3!(symm_diff_ab_seq, symm_diff_ab_par, *SET_SYMM_DIFF_AB);
510 }
511
512 #[test]
set_seq_par_equivalence_intersection()513 fn set_seq_par_equivalence_intersection() {
514 let intersection_ab_seq = SET_A.intersection(&*SET_B).cloned().collect::<HashSet<_>>();
515 let intersection_ab_par = SET_A
516 .par_intersection(&*SET_B)
517 .cloned()
518 .collect::<HashSet<_>>();
519
520 assert_eq3!(
521 intersection_ab_seq,
522 intersection_ab_par,
523 *SET_INTERSECTION_AB
524 );
525 }
526
527 #[test]
set_seq_par_equivalence_union()528 fn set_seq_par_equivalence_union() {
529 let union_ab_seq = SET_A.union(&*SET_B).cloned().collect::<HashSet<_>>();
530 let union_ab_par = SET_A.par_union(&*SET_B).cloned().collect::<HashSet<_>>();
531
532 assert_eq3!(union_ab_seq, union_ab_par, *SET_UNION_AB);
533 }
534