vendor/hashbrown-0.9.1/tests/rayon.rs

   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]
  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]
  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]
  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]
  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]
  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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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 }