1 #![cfg(feature = "rayon")]
4 extern crate lazy_static
;
6 use hashbrown
::{HashMap, HashSet}
;
8 IntoParallelIterator
, IntoParallelRefIterator
, IntoParallelRefMutIterator
, ParallelExtend
,
12 macro_rules
! assert_eq3
{
13 ($e1
:expr
, $e2
:expr
, $e3
:expr
) => {{
21 static ref MAP_EMPTY
: HashMap
<char, u32> = HashMap
::new();
22 static ref MAP
: HashMap
<char, u32> = {
23 let mut m
= HashMap
::new();
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
<_
>>();
39 assert_eq3
!(vec_seq
, vec_par
, []);
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
<_
>>();
47 assert_eq
!(vec_seq
, vec_par
);
49 // Do not depend on the exact order of values
50 let expected_sorted
= [
59 vec_seq
.sort_unstable();
60 vec_par
.sort_unstable();
62 assert_eq3
!(vec_seq
, vec_par
, expected_sorted
);
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>>();
70 let expected
: [&char; 0] = [];
72 assert_eq3
!(vec_seq
, vec_par
, expected
);
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
<_
>>();
80 assert_eq
!(vec_seq
, vec_par
);
82 // Do not depend on the exact order of values
83 let expected_sorted
= [&'a'
, &'b'
, &'c'
, &'d'
, &'e'
, &'f'
];
85 vec_seq
.sort_unstable();
86 vec_par
.sort_unstable();
88 assert_eq3
!(vec_seq
, vec_par
, expected_sorted
);
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
<_
>>();
96 let expected
: [&u32; 0] = [];
98 assert_eq3
!(vec_seq
, vec_par
, expected
);
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
<_
>>();
106 assert_eq
!(vec_seq
, vec_par
);
108 // Do not depend on the exact order of values
109 let expected_sorted
= [&10, &20, &30, &40, &50, &60];
111 vec_seq
.sort_unstable();
112 vec_par
.sort_unstable();
114 assert_eq3
!(vec_seq
, vec_par
, expected_sorted
);
118 fn map_seq_par_equivalence_iter_mut_empty() {
119 let mut map1
= MAP_EMPTY
.clone();
120 let mut map2
= MAP_EMPTY
.clone();
122 let vec_seq
= map1
.iter_mut().collect
::<Vec
<_
>>();
123 let vec_par
= map2
.par_iter_mut().collect
::<Vec
<_
>>();
125 assert_eq3
!(vec_seq
, vec_par
, []);
129 fn map_seq_par_equivalence_iter_mut() {
130 let mut map1
= MAP
.clone();
131 let mut map2
= MAP
.clone();
133 let mut vec_seq
= map1
.iter_mut().collect
::<Vec
<_
>>();
134 let mut vec_par
= map2
.par_iter_mut().collect
::<Vec
<_
>>();
136 assert_eq
!(vec_seq
, vec_par
);
138 // Do not depend on the exact order of values
139 let expected_sorted
= [
148 vec_seq
.sort_unstable();
149 vec_par
.sort_unstable();
151 assert_eq3
!(vec_seq
, vec_par
, expected_sorted
);
155 fn map_seq_par_equivalence_values_mut_empty() {
156 let mut map1
= MAP_EMPTY
.clone();
157 let mut map2
= MAP_EMPTY
.clone();
159 let vec_seq
= map1
.values_mut().collect
::<Vec
<_
>>();
160 let vec_par
= map2
.par_values_mut().collect
::<Vec
<_
>>();
162 let expected
: [&u32; 0] = [];
164 assert_eq3
!(vec_seq
, vec_par
, expected
);
168 fn map_seq_par_equivalence_values_mut() {
169 let mut map1
= MAP
.clone();
170 let mut map2
= MAP
.clone();
172 let mut vec_seq
= map1
.values_mut().collect
::<Vec
<_
>>();
173 let mut vec_par
= map2
.par_values_mut().collect
::<Vec
<_
>>();
175 assert_eq
!(vec_seq
, vec_par
);
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];
180 vec_seq
.sort_unstable();
181 vec_par
.sort_unstable();
183 assert_eq3
!(vec_seq
, vec_par
, expected_sorted
);
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
<_
>>();
191 assert_eq3
!(vec_seq
, vec_par
, []);
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
<_
>>();
199 assert_eq
!(vec_seq
, vec_par
);
201 // Do not depend on the exact order of values
202 let expected_sorted
= [
211 vec_seq
.sort_unstable();
212 vec_par
.sort_unstable();
214 assert_eq3
!(vec_seq
, vec_par
, expected_sorted
);
218 static ref MAP_VEC_EMPTY
: Vec
<(char, u32)> = vec
![];
219 static ref MAP_VEC
: Vec
<(char, u32)> = vec
![
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
236 .collect
::<HashMap
<_
, _
>>();
238 assert_eq
!(map_seq
, map_par
);
239 assert_eq
!(map_seq
, map_expected
);
240 assert_eq
!(map_par
, map_expected
);
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
<_
, _
>>();
249 assert_eq
!(map_seq
, map_par
);
250 assert_eq
!(map_seq
, map_expected
);
251 assert_eq
!(map_par
, map_expected
);
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();
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),];
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();
272 map_seq
.extend(MAP_EXTENSION_EMPTY
.iter().cloned());
273 map_par
.par_extend(MAP_EXTENSION_EMPTY
.par_iter().cloned());
275 assert_eq3
!(map_seq
, map_par
, expected
);
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();
284 map_seq
.extend(MAP_EXTENSION
.iter().cloned());
285 map_par
.par_extend(MAP_EXTENSION
.par_iter().cloned());
287 assert_eq3
!(map_seq
, map_par
, expected
);
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();
296 map_seq
.extend(MAP_EXTENSION_EMPTY
.iter().cloned());
297 map_par
.par_extend(MAP_EXTENSION_EMPTY
.par_iter().cloned());
299 assert_eq3
!(map_seq
, map_par
, expected
);
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();
308 map_seq
.extend(MAP_EXTENSION
.iter().cloned());
309 map_par
.par_extend(MAP_EXTENSION
.par_iter().cloned());
311 assert_eq3
!(map_seq
, map_par
, expected
);
315 static ref SET_EMPTY
: HashSet
<char> = HashSet
::new();
316 static ref SET
: HashSet
<char> = {
317 let mut s
= HashSet
::new();
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
<_
>>();
333 let expected
: [&char; 0] = [];
335 assert_eq3
!(vec_seq
, vec_par
, expected
);
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
<_
>>();
343 assert_eq
!(vec_seq
, vec_par
);
345 // Do not depend on the exact order of values
346 let expected_sorted
= [&'a'
, &'b'
, &'c'
, &'d'
, &'e'
, &'f'
];
348 vec_seq
.sort_unstable();
349 vec_par
.sort_unstable();
351 assert_eq3
!(vec_seq
, vec_par
, expected_sorted
);
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
<_
>>();
359 assert_eq3
!(vec_seq
, vec_par
, []);
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
<_
>>();
367 assert_eq
!(vec_seq
, vec_par
);
369 // Do not depend on the exact order of values
370 let expected_sorted
= ['a'
, 'b'
, 'c'
, 'd'
, 'e'
, 'f'
];
372 vec_seq
.sort_unstable();
373 vec_par
.sort_unstable();
375 assert_eq3
!(vec_seq
, vec_par
, expected_sorted
);
379 static ref SET_VEC_EMPTY
: Vec
<char> = vec
![];
380 static ref SET_VEC
: Vec
<char> = vec
!['b'
, 'a'
, 'c'
, 'e'
, 'f'
, 'd'
,];
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
390 .collect
::<HashSet
<_
>>();
392 assert_eq
!(set_seq
, set_par
);
393 assert_eq
!(set_seq
, set_expected
);
394 assert_eq
!(set_par
, set_expected
);
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
<_
>>();
403 assert_eq
!(set_seq
, set_par
);
404 assert_eq
!(set_seq
, set_expected
);
405 assert_eq
!(set_par
, set_expected
);
409 static ref SET_EXISTING_EMPTY
: HashSet
<char> = HashSet
::new();
410 static ref SET_EXISTING
: HashSet
<char> = {
411 let mut s
= HashSet
::new();
416 static ref SET_EXTENSION_EMPTY
: Vec
<char> = vec
![];
417 static ref SET_EXTENSION
: Vec
<char> = vec
!['c'
, 'e'
, 'f'
, 'd'
,];
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();
426 set_seq
.extend(SET_EXTENSION_EMPTY
.iter().cloned());
427 set_par
.par_extend(SET_EXTENSION_EMPTY
.par_iter().cloned());
429 assert_eq3
!(set_seq
, set_par
, expected
);
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();
438 set_seq
.extend(SET_EXTENSION
.iter().cloned());
439 set_par
.par_extend(SET_EXTENSION
.par_iter().cloned());
441 assert_eq3
!(set_seq
, set_par
, expected
);
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();
450 set_seq
.extend(SET_EXTENSION_EMPTY
.iter().cloned());
451 set_par
.par_extend(SET_EXTENSION_EMPTY
.par_iter().cloned());
453 assert_eq3
!(set_seq
, set_par
, expected
);
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();
462 set_seq
.extend(SET_EXTENSION
.iter().cloned());
463 set_par
.par_extend(SET_EXTENSION
.par_iter().cloned());
465 assert_eq3
!(set_seq
, set_par
, expected
);
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();
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
)
485 .collect
::<HashSet
<_
>>();
487 assert_eq3
!(diff_ab_seq
, diff_ab_par
, *SET_DIFF_AB
);
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
)
493 .collect
::<HashSet
<_
>>();
495 assert_eq3
!(diff_ba_seq
, diff_ba_par
, *SET_DIFF_BA
);
499 fn set_seq_par_equivalence_symmetric_difference() {
500 let symm_diff_ab_seq
= SET_A
501 .symmetric_difference(&*SET_B
)
503 .collect
::<HashSet
<_
>>();
504 let symm_diff_ab_par
= SET_A
505 .par_symmetric_difference(&*SET_B
)
507 .collect
::<HashSet
<_
>>();
509 assert_eq3
!(symm_diff_ab_seq
, symm_diff_ab_par
, *SET_SYMM_DIFF_AB
);
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
)
518 .collect
::<HashSet
<_
>>();
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
<_
>>();
532 assert_eq3
!(union_ab_seq
, union_ab_par
, *SET_UNION_AB
);