Debian Codegraph @

.cargo/vendor/rayon/src/iter/test.rs

raw
1 use std::sync::atomic::{AtomicUsize, Ordering};
2
3 use super::*;
4 use crate::prelude::*;
5 use rayon_core::*;
6
7 use rand::distributions::Standard;
8 use rand::{Rng, SeedableRng};
9 use rand_xorshift::XorShiftRng;
10 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
11 use std::collections::{BinaryHeap, VecDeque};
12 use std::f64;
13 use std::ffi::OsStr;
14 use std::fmt::Debug;
15 use std::sync::mpsc;
16 use std::usize;
17
18 fn is_indexed<T: IndexedParallelIterator>(_: T) {}
19
20 fn seeded_rng() -> XorShiftRng {
21 let mut seed = <XorShiftRng as SeedableRng>::Seed::default();
22 (0..).zip(seed.as_mut()).for_each(|(i, x)| *x = i);
23 XorShiftRng::from_seed(seed)
24 }
25
26 #[test]
27 fn execute() {
28 let a: Vec<i32> = (0..1024).collect();
29 let mut b = vec![];
30 a.par_iter().map(|&i| i + 1).collect_into_vec(&mut b);
31 let c: Vec<i32> = (0..1024).map(|i| i + 1).collect();
32 assert_eq!(b, c);
33 }
34
35 #[test]
36 fn execute_cloned() {
37 let a: Vec<i32> = (0..1024).collect();
38 let mut b: Vec<i32> = vec![];
39 a.par_iter().cloned().collect_into_vec(&mut b);
40 let c: Vec<i32> = (0..1024).collect();
41 assert_eq!(b, c);
42 }
43
44 #[test]
45 fn execute_range() {
46 let a = 0i32..1024;
47 let mut b = vec![];
48 a.into_par_iter().map(|i| i + 1).collect_into_vec(&mut b);
49 let c: Vec<i32> = (0..1024).map(|i| i + 1).collect();
50 assert_eq!(b, c);
51 }
52
53 #[test]
54 fn execute_unindexed_range() {
55 let a = 0i64..1024;
56 let b: LinkedList<i64> = a.into_par_iter().map(|i| i + 1).collect();
57 let c: LinkedList<i64> = (0..1024).map(|i| i + 1).collect();
58 assert_eq!(b, c);
59 }
60
61 #[test]
62 fn execute_pseudo_indexed_range() {
63 let range = i128::MAX - 1024..i128::MAX;
64
65 // Given `Some` length, collecting `Vec` will try to act indexed.
66 let a = range.clone().into_par_iter();
67 assert_eq!(a.opt_len(), Some(1024));
68
69 let b: Vec<i128> = a.map(|i| i + 1).collect();
70 let c: Vec<i128> = range.map(|i| i + 1).collect();
71 assert_eq!(b, c);
72 }
73
74 #[test]
75 fn check_map_indexed() {
76 let a = [1, 2, 3];
77 is_indexed(a.par_iter().map(|x| x));
78 }
79
80 #[test]
81 fn map_sum() {
82 let a: Vec<i32> = (0..1024).collect();
83 let r1: i32 = a.par_iter().map(|&i| i + 1).sum();
84 let r2 = a.iter().map(|&i| i + 1).sum();
85 assert_eq!(r1, r2);
86 }
87
88 #[test]
89 fn map_reduce() {
90 let a: Vec<i32> = (0..1024).collect();
91 let r1 = a.par_iter().map(|&i| i + 1).reduce(|| 0, |i, j| i + j);
92 let r2 = a.iter().map(|&i| i + 1).sum();
93 assert_eq!(r1, r2);
94 }
95
96 #[test]
97 fn map_reduce_with() {
98 let a: Vec<i32> = (0..1024).collect();
99 let r1 = a.par_iter().map(|&i| i + 1).reduce_with(|i, j| i + j);
100 let r2 = a.iter().map(|&i| i + 1).sum();
101 assert_eq!(r1, Some(r2));
102 }
103
104 #[test]
105 fn fold_map_reduce() {
106 // Kind of a weird test, but it demonstrates various
107 // transformations that are taking place. Relies on
108 // `with_max_len(1).fold()` being equivalent to `map()`.
109 //
110 // Take each number from 0 to 32 and fold them by appending to a
111 // vector. Because of `with_max_len(1)`, this will produce 32 vectors,
112 // each with one item. We then collect all of these into an
113 // individual vector by mapping each into their own vector (so we
114 // have Vec<Vec<i32>>) and then reducing those into a single
115 // vector.
116 let r1 = (0_i32..32)
117 .into_par_iter()
118 .with_max_len(1)
119 .fold(Vec::new, |mut v, e| {
120 v.push(e);
121 v
122 })
123 .map(|v| vec![v])
124 .reduce_with(|mut v_a, v_b| {
125 v_a.extend(v_b);
126 v_a
127 });
128 assert_eq!(
129 r1,
130 Some(vec![
131 vec![0],
132 vec![1],
133 vec![2],
134 vec![3],
135 vec![4],
136 vec![5],
137 vec![6],
138 vec![7],
139 vec![8],
140 vec![9],
141 vec![10],
142 vec![11],
143 vec![12],
144 vec![13],
145 vec![14],
146 vec![15],
147 vec![16],
148 vec![17],
149 vec![18],
150 vec![19],
151 vec![20],
152 vec![21],
153 vec![22],
154 vec![23],
155 vec![24],
156 vec![25],
157 vec![26],
158 vec![27],
159 vec![28],
160 vec![29],
161 vec![30],
162 vec![31]
163 ])
164 );
165 }
166
167 #[test]
168 fn fold_is_full() {
169 let counter = AtomicUsize::new(0);
170 let a = (0_i32..2048)
171 .into_par_iter()
172 .inspect(|_| {
173 counter.fetch_add(1, Ordering::SeqCst);
174 })
175 .fold(|| 0, |a, b| a + b)
176 .find_any(|_| true);
177 assert!(a.is_some());
178 assert!(counter.load(Ordering::SeqCst) < 2048); // should not have visited every single one
179 }
180
181 #[test]
182 fn check_step_by() {
183 let a: Vec<i32> = (0..1024).step_by(2).collect();
184 let b: Vec<i32> = (0..1024).into_par_iter().step_by(2).collect();
185
186 assert_eq!(a, b);
187 }
188
189 #[test]
190 fn check_step_by_unaligned() {
191 let a: Vec<i32> = (0..1029).step_by(10).collect();
192 let b: Vec<i32> = (0..1029).into_par_iter().step_by(10).collect();
193
194 assert_eq!(a, b)
195 }
196
197 #[test]
198 fn check_step_by_rev() {
199 let a: Vec<i32> = (0..1024).step_by(2).rev().collect();
200 let b: Vec<i32> = (0..1024).into_par_iter().step_by(2).rev().collect();
201
202 assert_eq!(a, b);
203 }
204
205 #[test]
206 fn check_enumerate() {
207 let a: Vec<usize> = (0..1024).rev().collect();
208
209 let mut b = vec![];
210 a.par_iter()
211 .enumerate()
212 .map(|(i, &x)| i + x)
213 .collect_into_vec(&mut b);
214 assert!(b.iter().all(|&x| x == a.len() - 1));
215 }
216
217 #[test]
218 fn check_enumerate_rev() {
219 let a: Vec<usize> = (0..1024).rev().collect();
220
221 let mut b = vec![];
222 a.par_iter()
223 .enumerate()
224 .rev()
225 .map(|(i, &x)| i + x)
226 .collect_into_vec(&mut b);
227 assert!(b.iter().all(|&x| x == a.len() - 1));
228 }
229
230 #[test]
231 fn check_indices_after_enumerate_split() {
232 let a: Vec<i32> = (0..1024).collect();
233 a.par_iter().enumerate().with_producer(WithProducer);
234
235 struct WithProducer;
236 impl<'a> ProducerCallback<(usize, &'a i32)> for WithProducer {
237 type Output = ();
238 fn callback<P>(self, producer: P)
239 where
240 P: Producer<Item = (usize, &'a i32)>,
241 {
242 let (a, b) = producer.split_at(512);
243 for ((index, value), trusted_index) in a.into_iter().zip(0..) {
244 assert_eq!(index, trusted_index);
245 assert_eq!(index, *value as usize);
246 }
247 for ((index, value), trusted_index) in b.into_iter().zip(512..) {
248 assert_eq!(index, trusted_index);
249 assert_eq!(index, *value as usize);
250 }
251 }
252 }
253 }
254
255 #[test]
256 fn check_increment() {
257 let mut a: Vec<usize> = (0..1024).rev().collect();
258
259 a.par_iter_mut().enumerate().for_each(|(i, v)| *v += i);
260
261 assert!(a.iter().all(|&x| x == a.len() - 1));
262 }
263
264 #[test]
265 fn check_skip() {
266 let a: Vec<usize> = (0..1024).collect();
267
268 let mut v1 = Vec::new();
269 a.par_iter().skip(16).collect_into_vec(&mut v1);
270 let v2 = a.iter().skip(16).collect::<Vec<_>>();
271 assert_eq!(v1, v2);
272
273 let mut v1 = Vec::new();
274 a.par_iter().skip(2048).collect_into_vec(&mut v1);
275 let v2 = a.iter().skip(2048).collect::<Vec<_>>();
276 assert_eq!(v1, v2);
277
278 let mut v1 = Vec::new();
279 a.par_iter().skip(0).collect_into_vec(&mut v1);
280 #[allow(clippy::iter_skip_zero)]
281 let v2 = a.iter().skip(0).collect::<Vec<_>>();
282 assert_eq!(v1, v2);
283
284 // Check that the skipped elements side effects are executed
285 use std::sync::atomic::{AtomicUsize, Ordering};
286 let num = AtomicUsize::new(0);
287 a.par_iter()
288 .map(|&n| num.fetch_add(n, Ordering::Relaxed))
289 .skip(512)
290 .count();
291 assert_eq!(num.load(Ordering::Relaxed), a.iter().sum::<usize>());
292 }
293
294 #[test]
295 fn check_take() {
296 let a: Vec<usize> = (0..1024).collect();
297
298 let mut v1 = Vec::new();
299 a.par_iter().take(16).collect_into_vec(&mut v1);
300 let v2 = a.iter().take(16).collect::<Vec<_>>();
301 assert_eq!(v1, v2);
302
303 let mut v1 = Vec::new();
304 a.par_iter().take(2048).collect_into_vec(&mut v1);
305 let v2 = a.iter().take(2048).collect::<Vec<_>>();
306 assert_eq!(v1, v2);
307
308 let mut v1 = Vec::new();
309 a.par_iter().take(0).collect_into_vec(&mut v1);
310 let v2 = a.iter().take(0).collect::<Vec<_>>();
311 assert_eq!(v1, v2);
312 }
313
314 #[test]
315 fn check_inspect() {
316 use std::sync::atomic::{AtomicUsize, Ordering};
317
318 let a = AtomicUsize::new(0);
319 let b: usize = (0_usize..1024)
320 .into_par_iter()
321 .inspect(|&i| {
322 a.fetch_add(i, Ordering::Relaxed);
323 })
324 .sum();
325
326 assert_eq!(a.load(Ordering::Relaxed), b);
327 }
328
329 #[test]
330 fn check_move() {
331 let a = vec![vec![1, 2, 3]];
332 let ptr = a[0].as_ptr();
333
334 let mut b = vec![];
335 a.into_par_iter().collect_into_vec(&mut b);
336
337 // a simple move means the inner vec will be completely unchanged
338 assert_eq!(ptr, b[0].as_ptr());
339 }
340
341 #[test]
342 fn check_drops() {
343 use std::sync::atomic::{AtomicUsize, Ordering};
344
345 let c = AtomicUsize::new(0);
346 let a = vec![DropCounter(&c); 10];
347
348 let mut b = vec![];
349 a.clone().into_par_iter().collect_into_vec(&mut b);
350 assert_eq!(c.load(Ordering::Relaxed), 0);
351
352 b.into_par_iter();
353 assert_eq!(c.load(Ordering::Relaxed), 10);
354
355 a.into_par_iter().with_producer(Partial);
356 assert_eq!(c.load(Ordering::Relaxed), 20);
357
358 #[derive(Clone)]
359 struct DropCounter<'a>(&'a AtomicUsize);
360 impl<'a> Drop for DropCounter<'a> {
361 fn drop(&mut self) {
362 self.0.fetch_add(1, Ordering::Relaxed);
363 }
364 }
365
366 struct Partial;
367 impl<'a> ProducerCallback<DropCounter<'a>> for Partial {
368 type Output = ();
369 fn callback<P>(self, producer: P)
370 where
371 P: Producer<Item = DropCounter<'a>>,
372 {
373 let (a, _) = producer.split_at(5);
374 a.into_iter().next();
375 }
376 }
377 }
378
379 #[test]
380 fn check_slice_indexed() {
381 let a = vec![1, 2, 3];
382 is_indexed(a.par_iter());
383 }
384
385 #[test]
386 fn check_slice_mut_indexed() {
387 let mut a = vec![1, 2, 3];
388 is_indexed(a.par_iter_mut());
389 }
390
391 #[test]
392 fn check_vec_indexed() {
393 let a = vec![1, 2, 3];
394 is_indexed(a.into_par_iter());
395 }
396
397 #[test]
398 fn check_range_indexed() {
399 is_indexed((1..5).into_par_iter());
400 }
401
402 #[test]
403 fn check_cmp_direct() {
404 let a = (0..1024).into_par_iter();
405 let b = (0..1024).into_par_iter();
406
407 let result = a.cmp(b);
408
409 assert!(result == ::std::cmp::Ordering::Equal);
410 }
411
412 #[test]
413 fn check_cmp_to_seq() {
414 assert_eq!(
415 (0..1024).into_par_iter().cmp(0..1024),
416 (0..1024).cmp(0..1024)
417 );
418 }
419
420 #[test]
421 fn check_cmp_rng_to_seq() {
422 let mut rng = seeded_rng();
423 let rng = &mut rng;
424 let a: Vec<i32> = rng.sample_iter(&Standard).take(1024).collect();
425 let b: Vec<i32> = rng.sample_iter(&Standard).take(1024).collect();
426 for i in 0..a.len() {
427 let par_result = a[i..].par_iter().cmp(b[i..].par_iter());
428 let seq_result = a[i..].iter().cmp(b[i..].iter());
429
430 assert_eq!(par_result, seq_result);
431 }
432 }
433
434 #[test]
435 fn check_cmp_lt_direct() {
436 let a = (0..1024).into_par_iter();
437 let b = (1..1024).into_par_iter();
438
439 let result = a.cmp(b);
440
441 assert!(result == ::std::cmp::Ordering::Less);
442 }
443
444 #[test]
445 fn check_cmp_lt_to_seq() {
446 assert_eq!(
447 (0..1024).into_par_iter().cmp(1..1024),
448 (0..1024).cmp(1..1024)
449 )
450 }
451
452 #[test]
453 fn check_cmp_gt_direct() {
454 let a = (1..1024).into_par_iter();
455 let b = (0..1024).into_par_iter();
456
457 let result = a.cmp(b);
458
459 assert!(result == ::std::cmp::Ordering::Greater);
460 }
461
462 #[test]
463 fn check_cmp_gt_to_seq() {
464 assert_eq!(
465 (1..1024).into_par_iter().cmp(0..1024),
466 (1..1024).cmp(0..1024)
467 )
468 }
469
470 #[test]
471 #[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
472 fn check_cmp_short_circuit() {
473 // We only use a single thread in order to make the short-circuit behavior deterministic.
474 let pool = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
475
476 let a = vec![0; 1024];
477 let mut b = a.clone();
478 b[42] = 1;
479
480 pool.install(|| {
481 let expected = ::std::cmp::Ordering::Less;
482 assert_eq!(a.par_iter().cmp(&b), expected);
483
484 for len in 1..10 {
485 let counter = AtomicUsize::new(0);
486 let result = a
487 .par_iter()
488 .with_max_len(len)
489 .inspect(|_| {
490 counter.fetch_add(1, Ordering::SeqCst);
491 })
492 .cmp(&b);
493 assert_eq!(result, expected);
494 // should not have visited every single one
495 assert!(counter.into_inner() < a.len());
496 }
497 });
498 }
499
500 #[test]
501 #[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
502 fn check_partial_cmp_short_circuit() {
503 // We only use a single thread to make the short-circuit behavior deterministic.
504 let pool = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
505
506 let a = vec![0; 1024];
507 let mut b = a.clone();
508 b[42] = 1;
509
510 pool.install(|| {
511 let expected = Some(::std::cmp::Ordering::Less);
512 assert_eq!(a.par_iter().partial_cmp(&b), expected);
513
514 for len in 1..10 {
515 let counter = AtomicUsize::new(0);
516 let result = a
517 .par_iter()
518 .with_max_len(len)
519 .inspect(|_| {
520 counter.fetch_add(1, Ordering::SeqCst);
521 })
522 .partial_cmp(&b);
523 assert_eq!(result, expected);
524 // should not have visited every single one
525 assert!(counter.into_inner() < a.len());
526 }
527 });
528 }
529
530 #[test]
531 #[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
532 fn check_partial_cmp_nan_short_circuit() {
533 // We only use a single thread to make the short-circuit behavior deterministic.
534 let pool = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
535
536 let a = vec![0.0; 1024];
537 let mut b = a.clone();
538 b[42] = f64::NAN;
539
540 pool.install(|| {
541 let expected = None;
542 assert_eq!(a.par_iter().partial_cmp(&b), expected);
543
544 for len in 1..10 {
545 let counter = AtomicUsize::new(0);
546 let result = a
547 .par_iter()
548 .with_max_len(len)
549 .inspect(|_| {
550 counter.fetch_add(1, Ordering::SeqCst);
551 })
552 .partial_cmp(&b);
553 assert_eq!(result, expected);
554 // should not have visited every single one
555 assert!(counter.into_inner() < a.len());
556 }
557 });
558 }
559
560 #[test]
561 fn check_partial_cmp_direct() {
562 let a = (0..1024).into_par_iter();
563 let b = (0..1024).into_par_iter();
564
565 let result = a.partial_cmp(b);
566
567 assert!(result == Some(::std::cmp::Ordering::Equal));
568 }
569
570 #[test]
571 fn check_partial_cmp_to_seq() {
572 let par_result = (0..1024).into_par_iter().partial_cmp(0..1024);
573 let seq_result = (0..1024).partial_cmp(0..1024);
574 assert_eq!(par_result, seq_result);
575 }
576
577 #[test]
578 fn check_partial_cmp_rng_to_seq() {
579 let mut rng = seeded_rng();
580 let rng = &mut rng;
581 let a: Vec<i32> = rng.sample_iter(&Standard).take(1024).collect();
582 let b: Vec<i32> = rng.sample_iter(&Standard).take(1024).collect();
583 for i in 0..a.len() {
584 let par_result = a[i..].par_iter().partial_cmp(b[i..].par_iter());
585 let seq_result = a[i..].iter().partial_cmp(b[i..].iter());
586
587 assert_eq!(par_result, seq_result);
588 }
589 }
590
591 #[test]
592 fn check_partial_cmp_lt_direct() {
593 let a = (0..1024).into_par_iter();
594 let b = (1..1024).into_par_iter();
595
596 let result = a.partial_cmp(b);
597
598 assert!(result == Some(::std::cmp::Ordering::Less));
599 }
600
601 #[test]
602 fn check_partial_cmp_lt_to_seq() {
603 let par_result = (0..1024).into_par_iter().partial_cmp(1..1024);
604 let seq_result = (0..1024).partial_cmp(1..1024);
605 assert_eq!(par_result, seq_result);
606 }
607
608 #[test]
609 fn check_partial_cmp_gt_direct() {
610 let a = (1..1024).into_par_iter();
611 let b = (0..1024).into_par_iter();
612
613 let result = a.partial_cmp(b);
614
615 assert!(result == Some(::std::cmp::Ordering::Greater));
616 }
617
618 #[test]
619 fn check_partial_cmp_gt_to_seq() {
620 let par_result = (1..1024).into_par_iter().partial_cmp(0..1024);
621 let seq_result = (1..1024).partial_cmp(0..1024);
622 assert_eq!(par_result, seq_result);
623 }
624
625 #[test]
626 fn check_partial_cmp_none_direct() {
627 let a = vec![f64::NAN, 0.0];
628 let b = vec![0.0, 1.0];
629
630 let result = a.par_iter().partial_cmp(b.par_iter());
631
632 assert!(result.is_none());
633 }
634
635 #[test]
636 fn check_partial_cmp_none_to_seq() {
637 let a = vec![f64::NAN, 0.0];
638 let b = vec![0.0, 1.0];
639
640 let par_result = a.par_iter().partial_cmp(b.par_iter());
641 let seq_result = a.iter().partial_cmp(b.iter());
642
643 assert_eq!(par_result, seq_result);
644 }
645
646 #[test]
647 fn check_partial_cmp_late_nan_direct() {
648 let a = vec![0.0, f64::NAN];
649 let b = vec![1.0, 1.0];
650
651 let result = a.par_iter().partial_cmp(b.par_iter());
652
653 assert!(result == Some(::std::cmp::Ordering::Less));
654 }
655
656 #[test]
657 fn check_partial_cmp_late_nan_to_seq() {
658 let a = vec![0.0, f64::NAN];
659 let b = vec![1.0, 1.0];
660
661 let par_result = a.par_iter().partial_cmp(b.par_iter());
662 let seq_result = a.iter().partial_cmp(b.iter());
663
664 assert_eq!(par_result, seq_result);
665 }
666
667 #[test]
668 fn check_cmp_lengths() {
669 // comparisons should consider length if they are otherwise equal
670 let a = vec![0; 1024];
671 let b = vec![0; 1025];
672
673 assert_eq!(a.par_iter().cmp(&b), a.iter().cmp(&b));
674 assert_eq!(a.par_iter().partial_cmp(&b), a.iter().partial_cmp(&b));
675 }
676
677 #[test]
678 fn check_eq_direct() {
679 let a = (0..1024).into_par_iter();
680 let b = (0..1024).into_par_iter();
681
682 let result = a.eq(b);
683
684 assert!(result);
685 }
686
687 #[test]
688 fn check_eq_to_seq() {
689 let par_result = (0..1024).into_par_iter().eq((0..1024).into_par_iter());
690 let seq_result = (0..1024).eq(0..1024);
691
692 assert_eq!(par_result, seq_result);
693 }
694
695 #[test]
696 fn check_ne_direct() {
697 let a = (0..1024).into_par_iter();
698 let b = (1..1024).into_par_iter();
699
700 let result = a.ne(b);
701
702 assert!(result);
703 }
704
705 #[test]
706 fn check_ne_to_seq() {
707 let par_result = (0..1024).into_par_iter().ne((1..1025).into_par_iter());
708 let seq_result = (0..1024).ne(1..1025);
709
710 assert_eq!(par_result, seq_result);
711 }
712
713 #[test]
714 fn check_ne_lengths() {
715 // equality should consider length too
716 let a = vec![0; 1024];
717 let b = vec![0; 1025];
718
719 assert_eq!(a.par_iter().eq(&b), a.iter().eq(&b));
720 assert_eq!(a.par_iter().ne(&b), a.iter().ne(&b));
721 }
722
723 #[test]
724 fn check_lt_direct() {
725 assert!((0..1024).into_par_iter().lt(1..1024));
726 assert!(!(1..1024).into_par_iter().lt(0..1024));
727 }
728
729 #[test]
730 fn check_lt_to_seq() {
731 let par_result = (0..1024).into_par_iter().lt((1..1024).into_par_iter());
732 let seq_result = (0..1024).lt(1..1024);
733
734 assert_eq!(par_result, seq_result);
735 }
736
737 #[test]
738 fn check_le_equal_direct() {
739 assert!((0..1024).into_par_iter().le((0..1024).into_par_iter()));
740 }
741
742 #[test]
743 fn check_le_equal_to_seq() {
744 let par_result = (0..1024).into_par_iter().le((0..1024).into_par_iter());
745 let seq_result = (0..1024).le(0..1024);
746
747 assert_eq!(par_result, seq_result);
748 }
749
750 #[test]
751 fn check_le_less_direct() {
752 assert!((0..1024).into_par_iter().le((1..1024).into_par_iter()));
753 }
754
755 #[test]
756 fn check_le_less_to_seq() {
757 let par_result = (0..1024).into_par_iter().le((1..1024).into_par_iter());
758 let seq_result = (0..1024).le(1..1024);
759
760 assert_eq!(par_result, seq_result);
761 }
762
763 #[test]
764 fn check_gt_direct() {
765 assert!((1..1024).into_par_iter().gt((0..1024).into_par_iter()));
766 }
767
768 #[test]
769 fn check_gt_to_seq() {
770 let par_result = (1..1024).into_par_iter().gt((0..1024).into_par_iter());
771 let seq_result = (1..1024).gt(0..1024);
772
773 assert_eq!(par_result, seq_result);
774 }
775
776 #[test]
777 fn check_ge_equal_direct() {
778 assert!((0..1024).into_par_iter().ge((0..1024).into_par_iter()));
779 }
780
781 #[test]
782 fn check_ge_equal_to_seq() {
783 let par_result = (0..1024).into_par_iter().ge((0..1024).into_par_iter());
784 let seq_result = (0..1024).ge(0..1024);
785
786 assert_eq!(par_result, seq_result);
787 }
788
789 #[test]
790 fn check_ge_greater_direct() {
791 assert!((1..1024).into_par_iter().ge((0..1024).into_par_iter()));
792 }
793
794 #[test]
795 fn check_ge_greater_to_seq() {
796 let par_result = (1..1024).into_par_iter().ge((0..1024).into_par_iter());
797 let seq_result = (1..1024).ge(0..1024);
798
799 assert_eq!(par_result, seq_result);
800 }
801
802 #[test]
803 fn check_zip() {
804 let mut a: Vec<usize> = (0..1024).rev().collect();
805 let b: Vec<usize> = (0..1024).collect();
806
807 a.par_iter_mut().zip(&b[..]).for_each(|(a, &b)| *a += b);
808
809 assert!(a.iter().all(|&x| x == a.len() - 1));
810 }
811
812 #[test]
813 fn check_zip_into_par_iter() {
814 let mut a: Vec<usize> = (0..1024).rev().collect();
815 let b: Vec<usize> = (0..1024).collect();
816
817 a.par_iter_mut()
818 .zip(&b) // here we rely on &b iterating over &usize
819 .for_each(|(a, &b)| *a += b);
820
821 assert!(a.iter().all(|&x| x == a.len() - 1));
822 }
823
824 #[test]
825 fn check_zip_into_mut_par_iter() {
826 let a: Vec<usize> = (0..1024).rev().collect();
827 let mut b: Vec<usize> = (0..1024).collect();
828
829 a.par_iter().zip(&mut b).for_each(|(&a, b)| *b += a);
830
831 assert!(b.iter().all(|&x| x == b.len() - 1));
832 }
833
834 #[test]
835 fn check_zip_range() {
836 let mut a: Vec<usize> = (0..1024).rev().collect();
837
838 a.par_iter_mut()
839 .zip(0usize..1024)
840 .for_each(|(a, b)| *a += b);
841
842 assert!(a.iter().all(|&x| x == a.len() - 1));
843 }
844
845 #[test]
846 fn check_zip_eq() {
847 let mut a: Vec<usize> = (0..1024).rev().collect();
848 let b: Vec<usize> = (0..1024).collect();
849
850 a.par_iter_mut().zip_eq(&b[..]).for_each(|(a, &b)| *a += b);
851
852 assert!(a.iter().all(|&x| x == a.len() - 1));
853 }
854
855 #[test]
856 fn check_zip_eq_into_par_iter() {
857 let mut a: Vec<usize> = (0..1024).rev().collect();
858 let b: Vec<usize> = (0..1024).collect();
859
860 a.par_iter_mut()
861 .zip_eq(&b) // here we rely on &b iterating over &usize
862 .for_each(|(a, &b)| *a += b);
863
864 assert!(a.iter().all(|&x| x == a.len() - 1));
865 }
866
867 #[test]
868 fn check_zip_eq_into_mut_par_iter() {
869 let a: Vec<usize> = (0..1024).rev().collect();
870 let mut b: Vec<usize> = (0..1024).collect();
871
872 a.par_iter().zip_eq(&mut b).for_each(|(&a, b)| *b += a);
873
874 assert!(b.iter().all(|&x| x == b.len() - 1));
875 }
876
877 #[test]
878 fn check_zip_eq_range() {
879 let mut a: Vec<usize> = (0..1024).rev().collect();
880
881 a.par_iter_mut()
882 .zip_eq(0usize..1024)
883 .for_each(|(a, b)| *a += b);
884
885 assert!(a.iter().all(|&x| x == a.len() - 1));
886 }
887
888 #[test]
889 fn check_sum_filtered_ints() {
890 let a: Vec<i32> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
891 let par_sum_evens: i32 = a.par_iter().filter(|&x| (x & 1) == 0).sum();
892 let seq_sum_evens = a.iter().filter(|&x| (x & 1) == 0).sum();
893 assert_eq!(par_sum_evens, seq_sum_evens);
894 }
895
896 #[test]
897 fn check_sum_filtermap_ints() {
898 let a: Vec<i32> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
899 let par_sum_evens: u32 = a
900 .par_iter()
901 .filter_map(|&x| if (x & 1) == 0 { Some(x as u32) } else { None })
902 .sum();
903 let seq_sum_evens = a
904 .iter()
905 .filter_map(|&x| if (x & 1) == 0 { Some(x as u32) } else { None })
906 .sum();
907 assert_eq!(par_sum_evens, seq_sum_evens);
908 }
909
910 #[test]
911 fn check_flat_map_nested_ranges() {
912 // FIXME -- why are precise type hints required on the integers here?
913
914 let v: i32 = (0_i32..10)
915 .into_par_iter()
916 .flat_map(|i| (0_i32..10).into_par_iter().map(move |j| (i, j)))
917 .map(|(i, j)| i * j)
918 .sum();
919
920 let w = (0_i32..10)
921 .flat_map(|i| (0_i32..10).map(move |j| (i, j)))
922 .map(|(i, j)| i * j)
923 .sum();
924
925 assert_eq!(v, w);
926 }
927
928 #[test]
929 fn check_empty_flat_map_sum() {
930 let a: Vec<i32> = (0..1024).collect();
931 let empty = &a[..0];
932
933 // empty on the inside
934 let b: i32 = a.par_iter().flat_map(|_| empty).sum();
935 assert_eq!(b, 0);
936
937 // empty on the outside
938 let c: i32 = empty.par_iter().flat_map(|_| a.par_iter()).sum();
939 assert_eq!(c, 0);
940 }
941
942 #[test]
943 fn check_flatten_vec() {
944 let a: Vec<i32> = (0..1024).collect();
945 let b: Vec<Vec<i32>> = vec![a.clone(), a.clone(), a.clone(), a.clone()];
946 let c: Vec<i32> = b.par_iter().flatten().cloned().collect();
947 let mut d = a.clone();
948 d.extend(&a);
949 d.extend(&a);
950 d.extend(&a);
951
952 assert_eq!(d, c);
953 }
954
955 #[test]
956 fn check_flatten_vec_empty() {
957 let a: Vec<Vec<i32>> = vec![vec![]];
958 let b: Vec<i32> = a.par_iter().flatten().cloned().collect();
959
960 assert_eq!(vec![] as Vec<i32>, b);
961 }
962
963 #[test]
964 fn check_slice_split() {
965 let v: Vec<_> = (0..1000).collect();
966 for m in 1..100 {
967 let a: Vec<_> = v.split(|x| x % m == 0).collect();
968 let b: Vec<_> = v.par_split(|x| x % m == 0).collect();
969 assert_eq!(a, b);
970 }
971
972 // same as std::slice::split() examples
973 let slice = [10, 40, 33, 20];
974 let v: Vec<_> = slice.par_split(|num| num % 3 == 0).collect();
975 assert_eq!(v, &[&slice[..2], &slice[3..]]);
976
977 let slice = [10, 40, 33];
978 let v: Vec<_> = slice.par_split(|num| num % 3 == 0).collect();
979 assert_eq!(v, &[&slice[..2], &slice[..0]]);
980
981 let slice = [10, 6, 33, 20];
982 let v: Vec<_> = slice.par_split(|num| num % 3 == 0).collect();
983 assert_eq!(v, &[&slice[..1], &slice[..0], &slice[3..]]);
984 }
985
986 #[test]
987 fn check_slice_split_inclusive() {
988 let v: Vec<_> = (0..1000).collect();
989 for m in 1..100 {
990 let a: Vec<_> = v.split_inclusive(|x| x % m == 0).collect();
991 let b: Vec<_> = v.par_split_inclusive(|x| x % m == 0).collect();
992 assert_eq!(a, b);
993 }
994
995 // same as std::slice::split_inclusive() examples
996 let slice = [10, 40, 33, 20];
997 let v: Vec<_> = slice.par_split_inclusive(|num| num % 3 == 0).collect();
998 assert_eq!(v, &[&slice[..3], &slice[3..]]);
999
1000 let slice = [3, 10, 40, 33];
1001 let v: Vec<_> = slice.par_split_inclusive(|num| num % 3 == 0).collect();
1002 assert_eq!(v, &[&slice[..1], &slice[1..]]);
1003 }
1004
1005 #[test]
1006 fn check_slice_split_mut() {
1007 let mut v1: Vec<_> = (0..1000).collect();
1008 let mut v2 = v1.clone();
1009 for m in 1..100 {
1010 let a: Vec<_> = v1.split_mut(|x| x % m == 0).collect();
1011 let b: Vec<_> = v2.par_split_mut(|x| x % m == 0).collect();
1012 assert_eq!(a, b);
1013 }
1014
1015 // same as std::slice::split_mut() example
1016 let mut v = [10, 40, 30, 20, 60, 50];
1017 v.par_split_mut(|num| num % 3 == 0).for_each(|group| {
1018 group[0] = 1;
1019 });
1020 assert_eq!(v, [1, 40, 30, 1, 60, 1]);
1021 }
1022
1023 #[test]
1024 fn check_slice_split_inclusive_mut() {
1025 let mut v1: Vec<_> = (0..1000).collect();
1026 let mut v2 = v1.clone();
1027 for m in 1..100 {
1028 let a: Vec<_> = v1.split_inclusive_mut(|x| x % m == 0).collect();
1029 let b: Vec<_> = v2.par_split_inclusive_mut(|x| x % m == 0).collect();
1030 assert_eq!(a, b);
1031 }
1032
1033 // same as std::slice::split_inclusive_mut() example
1034 let mut v = [10, 40, 30, 20, 60, 50];
1035 v.par_split_inclusive_mut(|num| num % 3 == 0)
1036 .for_each(|group| {
1037 let terminator_idx = group.len() - 1;
1038 group[terminator_idx] = 1;
1039 });
1040 assert_eq!(v, [10, 40, 1, 20, 1, 1]);
1041 }
1042
1043 #[test]
1044 fn check_chunks() {
1045 let a: Vec<i32> = vec![1, 5, 10, 4, 100, 3, 1000, 2, 10000, 1];
1046 let par_sum_product_pairs: i32 = a.par_chunks(2).map(|c| c.iter().product::<i32>()).sum();
1047 let seq_sum_product_pairs = a.chunks(2).map(|c| c.iter().product::<i32>()).sum();
1048 assert_eq!(par_sum_product_pairs, 12345);
1049 assert_eq!(par_sum_product_pairs, seq_sum_product_pairs);
1050
1051 let par_sum_product_triples: i32 = a.par_chunks(3).map(|c| c.iter().product::<i32>()).sum();
1052 let seq_sum_product_triples = a.chunks(3).map(|c| c.iter().product::<i32>()).sum();
1053 assert_eq!(par_sum_product_triples, 5_0 + 12_00 + 20_000_000 + 1);
1054 assert_eq!(par_sum_product_triples, seq_sum_product_triples);
1055 }
1056
1057 #[test]
1058 fn check_chunks_mut() {
1059 let mut a: Vec<i32> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1060 let mut b: Vec<i32> = a.clone();
1061 a.par_chunks_mut(2).for_each(|c| c[0] = c.iter().sum());
1062 b.chunks_mut(2).for_each(|c| c[0] = c.iter().sum());
1063 assert_eq!(a, &[3, 2, 7, 4, 11, 6, 15, 8, 19, 10]);
1064 assert_eq!(a, b);
1065
1066 let mut a: Vec<i32> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1067 let mut b: Vec<i32> = a.clone();
1068 a.par_chunks_mut(3).for_each(|c| c[0] = c.iter().sum());
1069 b.chunks_mut(3).for_each(|c| c[0] = c.iter().sum());
1070 assert_eq!(a, &[6, 2, 3, 15, 5, 6, 24, 8, 9, 10]);
1071 assert_eq!(a, b);
1072 }
1073
1074 #[test]
1075 fn check_windows() {
1076 let a: Vec<i32> = (0..1024).collect();
1077 let par: Vec<_> = a.par_windows(2).collect();
1078 let seq: Vec<_> = a.windows(2).collect();
1079 assert_eq!(par, seq);
1080
1081 let par: Vec<_> = a.par_windows(100).collect();
1082 let seq: Vec<_> = a.windows(100).collect();
1083 assert_eq!(par, seq);
1084
1085 let par: Vec<_> = a.par_windows(1_000_000).collect();
1086 let seq: Vec<_> = a.windows(1_000_000).collect();
1087 assert_eq!(par, seq);
1088
1089 let par: Vec<_> = a
1090 .par_windows(2)
1091 .chain(a.par_windows(1_000_000))
1092 .zip(a.par_windows(2))
1093 .collect();
1094 let seq: Vec<_> = a
1095 .windows(2)
1096 .chain(a.windows(1_000_000))
1097 .zip(a.windows(2))
1098 .collect();
1099 assert_eq!(par, seq);
1100 }
1101
1102 #[test]
1103 fn check_options() {
1104 let mut a = vec![None, Some(1), None, None, Some(2), Some(4)];
1105
1106 assert_eq!(7, a.par_iter().flat_map(|opt| opt).sum::<i32>());
1107 assert_eq!(7, a.par_iter().flat_map(|opt| opt).sum::<i32>());
1108
1109 a.par_iter_mut()
1110 .flat_map(|opt| opt)
1111 .for_each(|x| *x = *x * *x);
1112
1113 assert_eq!(21, a.into_par_iter().flat_map(|opt| opt).sum::<i32>());
1114 }
1115
1116 #[test]
1117 fn check_results() {
1118 let mut a = vec![Err(()), Ok(1i32), Err(()), Err(()), Ok(2), Ok(4)];
1119
1120 assert_eq!(7, a.par_iter().flat_map(|res| res).sum::<i32>());
1121
1122 assert_eq!(Err::<i32, ()>(()), a.par_iter().cloned().sum());
1123 assert_eq!(Ok(7), a.par_iter().cloned().filter(Result::is_ok).sum());
1124
1125 assert_eq!(Err::<i32, ()>(()), a.par_iter().cloned().product());
1126 assert_eq!(Ok(8), a.par_iter().cloned().filter(Result::is_ok).product());
1127
1128 a.par_iter_mut()
1129 .flat_map(|res| res)
1130 .for_each(|x| *x = *x * *x);
1131
1132 assert_eq!(21, a.into_par_iter().flat_map(|res| res).sum::<i32>());
1133 }
1134
1135 #[test]
1136 fn check_binary_heap() {
1137 use std::collections::BinaryHeap;
1138
1139 let a: BinaryHeap<i32> = (0..10).collect();
1140
1141 assert_eq!(45, a.par_iter().sum::<i32>());
1142 assert_eq!(45, a.into_par_iter().sum::<i32>());
1143 }
1144
1145 #[test]
1146 fn check_btree_map() {
1147 use std::collections::BTreeMap;
1148
1149 let mut a: BTreeMap<i32, i32> = (0..10).map(|i| (i, -i)).collect();
1150
1151 assert_eq!(45, a.par_iter().map(|(&k, _)| k).sum::<i32>());
1152 assert_eq!(-45, a.par_iter().map(|(_, &v)| v).sum::<i32>());
1153
1154 a.par_iter_mut().for_each(|(k, v)| *v += *k);
1155
1156 assert_eq!(0, a.into_par_iter().map(|(_, v)| v).sum::<i32>());
1157 }
1158
1159 #[test]
1160 fn check_btree_set() {
1161 use std::collections::BTreeSet;
1162
1163 let a: BTreeSet<i32> = (0..10).collect();
1164
1165 assert_eq!(45, a.par_iter().sum::<i32>());
1166 assert_eq!(45, a.into_par_iter().sum::<i32>());
1167 }
1168
1169 #[test]
1170 fn check_hash_map() {
1171 use std::collections::HashMap;
1172
1173 let mut a: HashMap<i32, i32> = (0..10).map(|i| (i, -i)).collect();
1174
1175 assert_eq!(45, a.par_iter().map(|(&k, _)| k).sum::<i32>());
1176 assert_eq!(-45, a.par_iter().map(|(_, &v)| v).sum::<i32>());
1177
1178 a.par_iter_mut().for_each(|(k, v)| *v += *k);
1179
1180 assert_eq!(0, a.into_par_iter().map(|(_, v)| v).sum::<i32>());
1181 }
1182
1183 #[test]
1184 fn check_hash_set() {
1185 use std::collections::HashSet;
1186
1187 let a: HashSet<i32> = (0..10).collect();
1188
1189 assert_eq!(45, a.par_iter().sum::<i32>());
1190 assert_eq!(45, a.into_par_iter().sum::<i32>());
1191 }
1192
1193 #[test]
1194 fn check_linked_list() {
1195 use std::collections::LinkedList;
1196
1197 let mut a: LinkedList<i32> = (0..10).collect();
1198
1199 assert_eq!(45, a.par_iter().sum::<i32>());
1200
1201 a.par_iter_mut().for_each(|x| *x = -*x);
1202
1203 assert_eq!(-45, a.into_par_iter().sum::<i32>());
1204 }
1205
1206 #[test]
1207 fn check_vec_deque() {
1208 use std::collections::VecDeque;
1209
1210 let mut a: VecDeque<i32> = (0..10).collect();
1211
1212 // try to get it to wrap around
1213 a.drain(..5);
1214 a.extend(0..5);
1215
1216 assert_eq!(45, a.par_iter().sum::<i32>());
1217
1218 a.par_iter_mut().for_each(|x| *x = -*x);
1219
1220 assert_eq!(-45, a.into_par_iter().sum::<i32>());
1221 }
1222
1223 #[test]
1224 fn check_chain() {
1225 let mut res = vec![];
1226
1227 // stays indexed in the face of madness
1228 Some(0)
1229 .into_par_iter()
1230 .chain(Ok::<_, ()>(1))
1231 .chain(1..4)
1232 .chain(Err("huh?"))
1233 .chain(None)
1234 .chain(vec![5, 8, 13])
1235 .map(|x| (x as u8 + b'a') as char)
1236 .chain(vec!['x', 'y', 'z'])
1237 .zip((0i32..1000).into_par_iter().map(|x| -x))
1238 .enumerate()
1239 .map(|(a, (b, c))| (a, b, c))
1240 .chain(None)
1241 .collect_into_vec(&mut res);
1242
1243 assert_eq!(
1244 res,
1245 vec![
1246 (0, 'a', 0),
1247 (1, 'b', -1),
1248 (2, 'b', -2),
1249 (3, 'c', -3),
1250 (4, 'd', -4),
1251 (5, 'f', -5),
1252 (6, 'i', -6),
1253 (7, 'n', -7),
1254 (8, 'x', -8),
1255 (9, 'y', -9),
1256 (10, 'z', -10)
1257 ]
1258 );
1259
1260 // unindexed is ok too
1261 let res: Vec<i32> = Some(1i32)
1262 .into_par_iter()
1263 .chain(
1264 (2i32..4)
1265 .into_par_iter()
1266 .chain(vec![5, 6, 7, 8, 9])
1267 .chain(Some((10, 100)).into_par_iter().flat_map(|(a, b)| a..b))
1268 .filter(|x| x & 1 == 1),
1269 )
1270 .collect();
1271 let other: Vec<i32> = (0..100).filter(|x| x & 1 == 1).collect();
1272 assert_eq!(res, other);
1273
1274 // chain collect is ok with the "fake" specialization
1275 let res: Vec<i32> = Some(1i32).into_par_iter().chain(None).collect();
1276 assert_eq!(res, &[1]);
1277 }
1278
1279 #[test]
1280 fn check_count() {
1281 let c0 = (0_u32..24 * 1024).filter(|i| i % 2 == 0).count();
1282 let c1 = (0_u32..24 * 1024)
1283 .into_par_iter()
1284 .filter(|i| i % 2 == 0)
1285 .count();
1286 assert_eq!(c0, c1);
1287 }
1288
1289 #[test]
1290 fn find_any() {
1291 let a: Vec<i32> = (0..1024).collect();
1292
1293 assert!(a.par_iter().find_any(|&&x| x % 42 == 41).is_some());
1294 assert_eq!(
1295 a.par_iter().find_any(|&&x| x % 19 == 1 && x % 53 == 0),
1296 Some(&742_i32)
1297 );
1298 assert_eq!(a.par_iter().find_any(|&&x| x < 0), None);
1299
1300 assert!(a.par_iter().position_any(|&x| x % 42 == 41).is_some());
1301 assert_eq!(
1302 a.par_iter().position_any(|&x| x % 19 == 1 && x % 53 == 0),
1303 Some(742_usize)
1304 );
1305 assert_eq!(a.par_iter().position_any(|&x| x < 0), None);
1306
1307 assert!(a.par_iter().any(|&x| x > 1000));
1308 assert!(!a.par_iter().any(|&x| x < 0));
1309
1310 assert!(!a.par_iter().all(|&x| x > 1000));
1311 assert!(a.par_iter().all(|&x| x >= 0));
1312 }
1313
1314 #[test]
1315 fn find_first_or_last() {
1316 let a: Vec<i32> = (0..1024).collect();
1317
1318 assert_eq!(a.par_iter().find_first(|&&x| x % 42 == 41), Some(&41_i32));
1319 assert_eq!(
1320 a.par_iter().find_first(|&&x| x % 19 == 1 && x % 53 == 0),
1321 Some(&742_i32)
1322 );
1323 assert_eq!(a.par_iter().find_first(|&&x| x < 0), None);
1324
1325 assert_eq!(
1326 a.par_iter().position_first(|&x| x % 42 == 41),
1327 Some(41_usize)
1328 );
1329 assert_eq!(
1330 a.par_iter().position_first(|&x| x % 19 == 1 && x % 53 == 0),
1331 Some(742_usize)
1332 );
1333 assert_eq!(a.par_iter().position_first(|&x| x < 0), None);
1334
1335 assert_eq!(a.par_iter().find_last(|&&x| x % 42 == 41), Some(&1007_i32));
1336 assert_eq!(
1337 a.par_iter().find_last(|&&x| x % 19 == 1 && x % 53 == 0),
1338 Some(&742_i32)
1339 );
1340 assert_eq!(a.par_iter().find_last(|&&x| x < 0), None);
1341
1342 assert_eq!(
1343 a.par_iter().position_last(|&x| x % 42 == 41),
1344 Some(1007_usize)
1345 );
1346 assert_eq!(
1347 a.par_iter().position_last(|&x| x % 19 == 1 && x % 53 == 0),
1348 Some(742_usize)
1349 );
1350 assert_eq!(a.par_iter().position_last(|&x| x < 0), None);
1351 }
1352
1353 #[test]
1354 fn find_map_first_or_last_or_any() {
1355 let mut a: Vec<i32> = vec![];
1356
1357 assert!(a.par_iter().find_map_any(half_if_positive).is_none());
1358 assert!(a.par_iter().find_map_first(half_if_positive).is_none());
1359 assert!(a.par_iter().find_map_last(half_if_positive).is_none());
1360
1361 a = (-1024..-3).collect();
1362
1363 assert!(a.par_iter().find_map_any(half_if_positive).is_none());
1364 assert!(a.par_iter().find_map_first(half_if_positive).is_none());
1365 assert!(a.par_iter().find_map_last(half_if_positive).is_none());
1366
1367 assert!(a.par_iter().find_map_any(half_if_negative).is_some());
1368 assert_eq!(
1369 a.par_iter().find_map_first(half_if_negative),
1370 Some(-512_i32)
1371 );
1372 assert_eq!(a.par_iter().find_map_last(half_if_negative), Some(-2_i32));
1373
1374 a.append(&mut (2..1025).collect());
1375
1376 assert!(a.par_iter().find_map_any(half_if_positive).is_some());
1377 assert_eq!(a.par_iter().find_map_first(half_if_positive), Some(1_i32));
1378 assert_eq!(a.par_iter().find_map_last(half_if_positive), Some(512_i32));
1379
1380 fn half_if_positive(x: &i32) -> Option<i32> {
1381 if *x > 0 {
1382 Some(x / 2)
1383 } else {
1384 None
1385 }
1386 }
1387
1388 fn half_if_negative(x: &i32) -> Option<i32> {
1389 if *x < 0 {
1390 Some(x / 2)
1391 } else {
1392 None
1393 }
1394 }
1395 }
1396
1397 #[test]
1398 fn check_find_not_present() {
1399 let counter = AtomicUsize::new(0);
1400 let value: Option<i32> = (0_i32..2048).into_par_iter().find_any(|&p| {
1401 counter.fetch_add(1, Ordering::SeqCst);
1402 p >= 2048
1403 });
1404 assert!(value.is_none());
1405 assert!(counter.load(Ordering::SeqCst) == 2048); // should have visited every single one
1406 }
1407
1408 #[test]
1409 fn check_find_is_present() {
1410 let counter = AtomicUsize::new(0);
1411 let value: Option<i32> = (0_i32..2048).into_par_iter().find_any(|&p| {
1412 counter.fetch_add(1, Ordering::SeqCst);
1413 (1024..1096).contains(&p)
1414 });
1415 let q = value.unwrap();
1416 assert!((1024..1096).contains(&q));
1417 assert!(counter.load(Ordering::SeqCst) < 2048); // should not have visited every single one
1418 }
1419
1420 #[test]
1421 fn check_while_some() {
1422 let value = (0_i32..2048).into_par_iter().map(Some).while_some().max();
1423 assert_eq!(value, Some(2047));
1424
1425 let counter = AtomicUsize::new(0);
1426 let value = (0_i32..2048)
1427 .into_par_iter()
1428 .map(|x| {
1429 counter.fetch_add(1, Ordering::SeqCst);
1430 if x < 1024 {
1431 Some(x)
1432 } else {
1433 None
1434 }
1435 })
1436 .while_some()
1437 .max();
1438 assert!(value < Some(1024));
1439 assert!(counter.load(Ordering::SeqCst) < 2048); // should not have visited every single one
1440 }
1441
1442 #[test]
1443 fn par_iter_collect_option() {
1444 let a: Option<Vec<_>> = (0_i32..2048).map(Some).collect();
1445 let b: Option<Vec<_>> = (0_i32..2048).into_par_iter().map(Some).collect();
1446 assert_eq!(a, b);
1447
1448 let c: Option<Vec<_>> = (0_i32..2048)
1449 .into_par_iter()
1450 .map(|x| if x == 1234 { None } else { Some(x) })
1451 .collect();
1452 assert_eq!(c, None);
1453 }
1454
1455 #[test]
1456 fn par_iter_collect_result() {
1457 let a: Result<Vec<_>, ()> = (0_i32..2048).map(Ok).collect();
1458 let b: Result<Vec<_>, ()> = (0_i32..2048).into_par_iter().map(Ok).collect();
1459 assert_eq!(a, b);
1460
1461 let c: Result<Vec<_>, _> = (0_i32..2048)
1462 .into_par_iter()
1463 .map(|x| if x == 1234 { Err(x) } else { Ok(x) })
1464 .collect();
1465 assert_eq!(c, Err(1234));
1466
1467 let d: Result<Vec<_>, _> = (0_i32..2048)
1468 .into_par_iter()
1469 .map(|x| if x % 100 == 99 { Err(x) } else { Ok(x) })
1470 .collect();
1471 assert_eq!(d.map_err(|x| x % 100), Err(99));
1472 }
1473
1474 #[test]
1475 fn par_iter_collect() {
1476 let a: Vec<i32> = (0..1024).collect();
1477 let b: Vec<i32> = a.par_iter().map(|&i| i + 1).collect();
1478 let c: Vec<i32> = (0..1024).map(|i| i + 1).collect();
1479 assert_eq!(b, c);
1480 }
1481
1482 #[test]
1483 fn par_iter_collect_vecdeque() {
1484 let a: Vec<i32> = (0..1024).collect();
1485 let b: VecDeque<i32> = a.par_iter().cloned().collect();
1486 let c: VecDeque<i32> = a.iter().cloned().collect();
1487 assert_eq!(b, c);
1488 }
1489
1490 #[test]
1491 fn par_iter_collect_binaryheap() {
1492 let a: Vec<i32> = (0..1024).collect();
1493 let mut b: BinaryHeap<i32> = a.par_iter().cloned().collect();
1494 assert_eq!(b.peek(), Some(&1023));
1495 assert_eq!(b.len(), 1024);
1496 for n in (0..1024).rev() {
1497 assert_eq!(b.pop(), Some(n));
1498 assert_eq!(b.len() as i32, n);
1499 }
1500 }
1501
1502 #[test]
1503 fn par_iter_collect_hashmap() {
1504 let a: Vec<i32> = (0..1024).collect();
1505 let b: HashMap<i32, String> = a.par_iter().map(|&i| (i, format!("{}", i))).collect();
1506 assert_eq!(&b[&3], "3");
1507 assert_eq!(b.len(), 1024);
1508 }
1509
1510 #[test]
1511 fn par_iter_collect_hashset() {
1512 let a: Vec<i32> = (0..1024).collect();
1513 let b: HashSet<i32> = a.par_iter().cloned().collect();
1514 assert_eq!(b.len(), 1024);
1515 }
1516
1517 #[test]
1518 fn par_iter_collect_btreemap() {
1519 let a: Vec<i32> = (0..1024).collect();
1520 let b: BTreeMap<i32, String> = a.par_iter().map(|&i| (i, format!("{}", i))).collect();
1521 assert_eq!(&b[&3], "3");
1522 assert_eq!(b.len(), 1024);
1523 }
1524
1525 #[test]
1526 fn par_iter_collect_btreeset() {
1527 let a: Vec<i32> = (0..1024).collect();
1528 let b: BTreeSet<i32> = a.par_iter().cloned().collect();
1529 assert_eq!(b.len(), 1024);
1530 }
1531
1532 #[test]
1533 fn par_iter_collect_linked_list() {
1534 let a: Vec<i32> = (0..1024).collect();
1535 let b: LinkedList<_> = a.par_iter().map(|&i| (i, format!("{}", i))).collect();
1536 let c: LinkedList<_> = a.iter().map(|&i| (i, format!("{}", i))).collect();
1537 assert_eq!(b, c);
1538 }
1539
1540 #[test]
1541 fn par_iter_collect_linked_list_flat_map_filter() {
1542 let b: LinkedList<i32> = (0_i32..1024)
1543 .into_par_iter()
1544 .flat_map(|i| (0..i))
1545 .filter(|&i| i % 2 == 0)
1546 .collect();
1547 let c: LinkedList<i32> = (0_i32..1024)
1548 .flat_map(|i| (0..i))
1549 .filter(|&i| i % 2 == 0)
1550 .collect();
1551 assert_eq!(b, c);
1552 }
1553
1554 #[test]
1555 fn par_iter_collect_cows() {
1556 use std::borrow::Cow;
1557
1558 let s = "Fearless Concurrency with Rust";
1559
1560 // Collects `i32` into a `Vec`
1561 let a: Cow<'_, [i32]> = (0..1024).collect();
1562 let b: Cow<'_, [i32]> = a.par_iter().cloned().collect();
1563 assert_eq!(a, b);
1564
1565 // Collects `char` into a `String`
1566 let a: Cow<'_, str> = s.chars().collect();
1567 let b: Cow<'_, str> = s.par_chars().collect();
1568 assert_eq!(a, b);
1569
1570 // Collects `str` into a `String`
1571 let sw = s.split_whitespace();
1572 let psw = s.par_split_whitespace();
1573 let a: Cow<'_, str> = sw.clone().collect();
1574 let b: Cow<'_, str> = psw.clone().collect();
1575 assert_eq!(a, b);
1576
1577 // Collects `String` into a `String`
1578 let a: Cow<'_, str> = sw.map(str::to_owned).collect();
1579 let b: Cow<'_, str> = psw.map(str::to_owned).collect();
1580 assert_eq!(a, b);
1581
1582 // Collects `OsStr` into a `OsString`
1583 let sw = s.split_whitespace().map(OsStr::new);
1584 let psw = s.par_split_whitespace().map(OsStr::new);
1585 let a: Cow<'_, OsStr> = Cow::Owned(sw.clone().collect());
1586 let b: Cow<'_, OsStr> = psw.clone().collect();
1587 assert_eq!(a, b);
1588
1589 // Collects `OsString` into a `OsString`
1590 let a: Cow<'_, OsStr> = Cow::Owned(sw.map(OsStr::to_owned).collect());
1591 let b: Cow<'_, OsStr> = psw.map(OsStr::to_owned).collect();
1592 assert_eq!(a, b);
1593 }
1594
1595 #[test]
1596 fn par_iter_unindexed_flat_map() {
1597 let b: Vec<i64> = (0_i64..1024).into_par_iter().flat_map(Some).collect();
1598 let c: Vec<i64> = (0_i64..1024).flat_map(Some).collect();
1599 assert_eq!(b, c);
1600 }
1601
1602 #[test]
1603 fn min_max() {
1604 let rng = seeded_rng();
1605 let a: Vec<i32> = rng.sample_iter(&Standard).take(1024).collect();
1606 for i in 0..=a.len() {
1607 let slice = &a[..i];
1608 assert_eq!(slice.par_iter().min(), slice.iter().min());
1609 assert_eq!(slice.par_iter().max(), slice.iter().max());
1610 }
1611 }
1612
1613 #[test]
1614 fn min_max_by() {
1615 let rng = seeded_rng();
1616 // Make sure there are duplicate keys, for testing sort stability
1617 let r: Vec<i32> = rng.sample_iter(&Standard).take(512).collect();
1618 let a: Vec<(i32, u16)> = r.iter().chain(&r).cloned().zip(0..).collect();
1619 for i in 0..=a.len() {
1620 let slice = &a[..i];
1621 assert_eq!(
1622 slice.par_iter().min_by(|x, y| x.0.cmp(&y.0)),
1623 slice.iter().min_by(|x, y| x.0.cmp(&y.0))
1624 );
1625 assert_eq!(
1626 slice.par_iter().max_by(|x, y| x.0.cmp(&y.0)),
1627 slice.iter().max_by(|x, y| x.0.cmp(&y.0))
1628 );
1629 }
1630 }
1631
1632 #[test]
1633 fn min_max_by_key() {
1634 let rng = seeded_rng();
1635 // Make sure there are duplicate keys, for testing sort stability
1636 let r: Vec<i32> = rng.sample_iter(&Standard).take(512).collect();
1637 let a: Vec<(i32, u16)> = r.iter().chain(&r).cloned().zip(0..).collect();
1638 for i in 0..=a.len() {
1639 let slice = &a[..i];
1640 assert_eq!(
1641 slice.par_iter().min_by_key(|x| x.0),
1642 slice.iter().min_by_key(|x| x.0)
1643 );
1644 assert_eq!(
1645 slice.par_iter().max_by_key(|x| x.0),
1646 slice.iter().max_by_key(|x| x.0)
1647 );
1648 }
1649 }
1650
1651 #[test]
1652 fn check_rev() {
1653 let a: Vec<usize> = (0..1024).rev().collect();
1654 let b: Vec<usize> = (0..1024).collect();
1655
1656 assert!(a.par_iter().rev().zip(b).all(|(&a, b)| a == b));
1657 }
1658
1659 #[test]
1660 fn scope_mix() {
1661 let counter_p = &AtomicUsize::new(0);
1662 scope(|s| {
1663 s.spawn(move |s| {
1664 divide_and_conquer(s, counter_p, 1024);
1665 });
1666 s.spawn(move |_| {
1667 let a: Vec<i32> = (0..1024).collect();
1668 let r1 = a.par_iter().map(|&i| i + 1).reduce_with(|i, j| i + j);
1669 let r2 = a.iter().map(|&i| i + 1).sum();
1670 assert_eq!(r1.unwrap(), r2);
1671 });
1672 });
1673 }
1674
1675 fn divide_and_conquer<'scope>(scope: &Scope<'scope>, counter: &'scope AtomicUsize, size: usize) {
1676 if size > 1 {
1677 scope.spawn(move |scope| divide_and_conquer(scope, counter, size / 2));
1678 scope.spawn(move |scope| divide_and_conquer(scope, counter, size / 2));
1679 } else {
1680 // count the leaves
1681 counter.fetch_add(1, Ordering::SeqCst);
1682 }
1683 }
1684
1685 #[test]
1686 fn check_split() {
1687 use std::ops::Range;
1688
1689 let a = (0..1024).into_par_iter();
1690
1691 let b = split(0..1024, |Range { start, end }| {
1692 let mid = (end - start) / 2;
1693 if mid > start {
1694 (start..mid, Some(mid..end))
1695 } else {
1696 (start..end, None)
1697 }
1698 })
1699 .flat_map(|range| range);
1700
1701 assert_eq!(a.collect::<Vec<_>>(), b.collect::<Vec<_>>());
1702 }
1703
1704 #[test]
1705 fn check_lengths() {
1706 fn check(min: usize, max: usize) {
1707 let range = 0..1024 * 1024;
1708
1709 // Check against normalized values.
1710 let min_check = Ord::min(Ord::max(min, 1), range.len());
1711 let max_check = Ord::max(max, min_check.saturating_add(min_check - 1));
1712
1713 assert!(
1714 range
1715 .into_par_iter()
1716 .with_min_len(min)
1717 .with_max_len(max)
1718 .fold(|| 0, |count, _| count + 1)
1719 .all(|c| c >= min_check && c <= max_check),
1720 "check_lengths failed {:?} -> {:?} ",
1721 (min, max),
1722 (min_check, max_check)
1723 );
1724 }
1725
1726 let lengths = [0, 1, 10, 100, 1_000, 10_000, 100_000, 1_000_000, usize::MAX];
1727 for &min in &lengths {
1728 for &max in &lengths {
1729 check(min, max);
1730 }
1731 }
1732 }
1733
1734 #[test]
1735 fn check_map_with() {
1736 let (sender, receiver) = mpsc::channel();
1737 let a: HashSet<_> = (0..1024).collect();
1738
1739 a.par_iter()
1740 .cloned()
1741 .map_with(sender, |s, i| s.send(i).unwrap())
1742 .count();
1743
1744 let b: HashSet<_> = receiver.iter().collect();
1745 assert_eq!(a, b);
1746 }
1747
1748 #[test]
1749 fn check_fold_with() {
1750 let (sender, receiver) = mpsc::channel();
1751 let a: HashSet<_> = (0..1024).collect();
1752
1753 a.par_iter()
1754 .cloned()
1755 .fold_with(sender, |s, i| {
1756 s.send(i).unwrap();
1757 s
1758 })
1759 .count();
1760
1761 let b: HashSet<_> = receiver.iter().collect();
1762 assert_eq!(a, b);
1763 }
1764
1765 #[test]
1766 fn check_for_each_with() {
1767 let (sender, receiver) = mpsc::channel();
1768 let a: HashSet<_> = (0..1024).collect();
1769
1770 a.par_iter()
1771 .cloned()
1772 .for_each_with(sender, |s, i| s.send(i).unwrap());
1773
1774 let b: HashSet<_> = receiver.iter().collect();
1775 assert_eq!(a, b);
1776 }
1777
1778 #[test]
1779 fn check_extend_items() {
1780 fn check<C>()
1781 where
1782 C: Default
1783 + Eq
1784 + Debug
1785 + Extend<i32>
1786 + for<'a> Extend<&'a i32>
1787 + ParallelExtend<i32>
1788 + for<'a> ParallelExtend<&'a i32>,
1789 {
1790 let mut serial = C::default();
1791 let mut parallel = C::default();
1792
1793 // extend with references
1794 let v: Vec<_> = (0..128).collect();
1795 serial.extend(&v);
1796 parallel.par_extend(&v);
1797 assert_eq!(serial, parallel);
1798
1799 // extend with values
1800 serial.extend(-128..0);
1801 parallel.par_extend(-128..0);
1802 assert_eq!(serial, parallel);
1803 }
1804
1805 check::<BTreeSet<_>>();
1806 check::<HashSet<_>>();
1807 check::<LinkedList<_>>();
1808 check::<Vec<_>>();
1809 check::<VecDeque<_>>();
1810 }
1811
1812 #[test]
1813 fn check_extend_heap() {
1814 let mut serial: BinaryHeap<_> = Default::default();
1815 let mut parallel: BinaryHeap<_> = Default::default();
1816
1817 // extend with references
1818 let v: Vec<_> = (0..128).collect();
1819 serial.extend(&v);
1820 parallel.par_extend(&v);
1821 assert_eq!(
1822 serial.clone().into_sorted_vec(),
1823 parallel.clone().into_sorted_vec()
1824 );
1825
1826 // extend with values
1827 serial.extend(-128..0);
1828 parallel.par_extend(-128..0);
1829 assert_eq!(serial.into_sorted_vec(), parallel.into_sorted_vec());
1830 }
1831
1832 #[test]
1833 fn check_extend_pairs() {
1834 fn check<C>()
1835 where
1836 C: Default
1837 + Eq
1838 + Debug
1839 + Extend<(usize, i32)>
1840 + for<'a> Extend<(&'a usize, &'a i32)>
1841 + ParallelExtend<(usize, i32)>
1842 + for<'a> ParallelExtend<(&'a usize, &'a i32)>,
1843 {
1844 let mut serial = C::default();
1845 let mut parallel = C::default();
1846
1847 // extend with references
1848 let m: HashMap<_, _> = (0..128).enumerate().collect();
1849 serial.extend(&m);
1850 parallel.par_extend(&m);
1851 assert_eq!(serial, parallel);
1852
1853 // extend with values
1854 let v: Vec<(_, _)> = (-128..0).enumerate().collect();
1855 serial.extend(v.clone());
1856 parallel.par_extend(v);
1857 assert_eq!(serial, parallel);
1858 }
1859
1860 check::<BTreeMap<usize, i32>>();
1861 check::<HashMap<usize, i32>>();
1862 }
1863
1864 #[test]
1865 fn check_unzip_into_vecs() {
1866 let mut a = vec![];
1867 let mut b = vec![];
1868 (0..1024)
1869 .into_par_iter()
1870 .map(|i| i * i)
1871 .enumerate()
1872 .unzip_into_vecs(&mut a, &mut b);
1873
1874 let (c, d): (Vec<_>, Vec<_>) = (0..1024).map(|i| i * i).enumerate().unzip();
1875 assert_eq!(a, c);
1876 assert_eq!(b, d);
1877 }
1878
1879 #[test]
1880 fn check_unzip() {
1881 // indexed, unindexed
1882 let (a, b): (Vec<_>, HashSet<_>) = (0..1024).into_par_iter().map(|i| i * i).enumerate().unzip();
1883 let (c, d): (Vec<_>, HashSet<_>) = (0..1024).map(|i| i * i).enumerate().unzip();
1884 assert_eq!(a, c);
1885 assert_eq!(b, d);
1886
1887 // unindexed, indexed
1888 let (a, b): (HashSet<_>, Vec<_>) = (0..1024).into_par_iter().map(|i| i * i).enumerate().unzip();
1889 let (c, d): (HashSet<_>, Vec<_>) = (0..1024).map(|i| i * i).enumerate().unzip();
1890 assert_eq!(a, c);
1891 assert_eq!(b, d);
1892
1893 // indexed, indexed
1894 let (a, b): (Vec<_>, Vec<_>) = (0..1024).into_par_iter().map(|i| i * i).enumerate().unzip();
1895 let (c, d): (Vec<_>, Vec<_>) = (0..1024).map(|i| i * i).enumerate().unzip();
1896 assert_eq!(a, c);
1897 assert_eq!(b, d);
1898
1899 // unindexed producer
1900 let (a, b): (Vec<_>, Vec<_>) = (0..1024)
1901 .into_par_iter()
1902 .filter_map(|i| Some((i, i * i)))
1903 .unzip();
1904 let (c, d): (Vec<_>, Vec<_>) = (0..1024).map(|i| (i, i * i)).unzip();
1905 assert_eq!(a, c);
1906 assert_eq!(b, d);
1907 }
1908
1909 #[test]
1910 fn check_partition() {
1911 let (a, b): (Vec<_>, Vec<_>) = (0..1024).into_par_iter().partition(|&i| i % 3 == 0);
1912 let (c, d): (Vec<_>, Vec<_>) = (0..1024).partition(|&i| i % 3 == 0);
1913 assert_eq!(a, c);
1914 assert_eq!(b, d);
1915 }
1916
1917 #[test]
1918 fn check_partition_map() {
1919 let input = "a b c 1 2 3 x y z";
1920 let (a, b): (Vec<_>, String) =
1921 input
1922 .par_split_whitespace()
1923 .partition_map(|s| match s.parse::<i32>() {
1924 Ok(n) => Either::Left(n),
1925 Err(_) => Either::Right(s),
1926 });
1927 assert_eq!(a, vec![1, 2, 3]);
1928 assert_eq!(b, "abcxyz");
1929 }
1930
1931 #[test]
1932 fn check_either() {
1933 type I = crate::vec::IntoIter<i32>;
1934 type E = Either<I, I>;
1935
1936 let v: Vec<i32> = (0..1024).collect();
1937
1938 // try iterating the left side
1939 let left: E = Either::Left(v.clone().into_par_iter());
1940 assert!(left.eq(v.clone()));
1941
1942 // try iterating the right side
1943 let right: E = Either::Right(v.clone().into_par_iter());
1944 assert!(right.eq(v.clone()));
1945
1946 // try an indexed iterator
1947 let left: E = Either::Left(v.clone().into_par_iter());
1948 assert!(left.enumerate().eq(v.into_par_iter().enumerate()));
1949 }
1950
1951 #[test]
1952 fn check_either_extend() {
1953 type E = Either<Vec<i32>, HashSet<i32>>;
1954
1955 let v: Vec<i32> = (0..1024).collect();
1956
1957 // try extending the left side
1958 let mut left: E = Either::Left(vec![]);
1959 left.par_extend(v.clone());
1960 assert_eq!(left.as_ref(), Either::Left(&v));
1961
1962 // try extending the right side
1963 let mut right: E = Either::Right(HashSet::default());
1964 right.par_extend(v.clone());
1965 assert_eq!(right, Either::Right(v.iter().cloned().collect()));
1966 }
1967
1968 #[test]
1969 fn check_interleave_eq() {
1970 let xs: Vec<usize> = (0..10).collect();
1971 let ys: Vec<usize> = (10..20).collect();
1972
1973 let mut actual = vec![];
1974 xs.par_iter()
1975 .interleave(&ys)
1976 .map(|&i| i)
1977 .collect_into_vec(&mut actual);
1978
1979 let expected: Vec<usize> = (0..10)
1980 .zip(10..20)
1981 .flat_map(|(i, j)| vec![i, j].into_iter())
1982 .collect();
1983 assert_eq!(expected, actual);
1984 }
1985
1986 #[test]
1987 fn check_interleave_uneven() {
1988 let cases: Vec<(Vec<usize>, Vec<usize>, Vec<usize>)> = vec![
1989 (
1990 (0..9).collect(),
1991 vec![10],
1992 vec![0, 10, 1, 2, 3, 4, 5, 6, 7, 8],
1993 ),
1994 (
1995 vec![10],
1996 (0..9).collect(),
1997 vec![10, 0, 1, 2, 3, 4, 5, 6, 7, 8],
1998 ),
1999 (
2000 (0..5).collect(),
2001 (5..10).collect(),
2002 (0..5)
2003 .zip(5..10)
2004 .flat_map(|(i, j)| vec![i, j].into_iter())
2005 .collect(),
2006 ),
2007 (vec![], (0..9).collect(), (0..9).collect()),
2008 ((0..9).collect(), vec![], (0..9).collect()),
2009 (
2010 (0..50).collect(),
2011 (50..100).collect(),
2012 (0..50)
2013 .zip(50..100)
2014 .flat_map(|(i, j)| vec![i, j].into_iter())
2015 .collect(),
2016 ),
2017 ];
2018
2019 for (i, (xs, ys, expected)) in cases.into_iter().enumerate() {
2020 let mut res = vec![];
2021 xs.par_iter()
2022 .interleave(&ys)
2023 .map(|&i| i)
2024 .collect_into_vec(&mut res);
2025 assert_eq!(expected, res, "Case {} failed", i);
2026
2027 res.truncate(0);
2028 xs.par_iter()
2029 .interleave(&ys)
2030 .rev()
2031 .map(|&i| i)
2032 .collect_into_vec(&mut res);
2033 assert_eq!(
2034 expected.into_iter().rev().collect::<Vec<usize>>(),
2035 res,
2036 "Case {} reversed failed",
2037 i
2038 );
2039 }
2040 }
2041
2042 #[test]
2043 fn check_interleave_shortest() {
2044 let cases: Vec<(Vec<usize>, Vec<usize>, Vec<usize>)> = vec![
2045 ((0..9).collect(), vec![10], vec![0, 10, 1]),
2046 (vec![10], (0..9).collect(), vec![10, 0]),
2047 (
2048 (0..5).collect(),
2049 (5..10).collect(),
2050 (0..5)
2051 .zip(5..10)
2052 .flat_map(|(i, j)| vec![i, j].into_iter())
2053 .collect(),
2054 ),
2055 (vec![], (0..9).collect(), vec![]),
2056 ((0..9).collect(), vec![], vec![0]),
2057 (
2058 (0..50).collect(),
2059 (50..100).collect(),
2060 (0..50)
2061 .zip(50..100)
2062 .flat_map(|(i, j)| vec![i, j].into_iter())
2063 .collect(),
2064 ),
2065 ];
2066
2067 for (i, (xs, ys, expected)) in cases.into_iter().enumerate() {
2068 let mut res = vec![];
2069 xs.par_iter()
2070 .interleave_shortest(&ys)
2071 .map(|&i| i)
2072 .collect_into_vec(&mut res);
2073 assert_eq!(expected, res, "Case {} failed", i);
2074
2075 res.truncate(0);
2076 xs.par_iter()
2077 .interleave_shortest(&ys)
2078 .rev()
2079 .map(|&i| i)
2080 .collect_into_vec(&mut res);
2081 assert_eq!(
2082 expected.into_iter().rev().collect::<Vec<usize>>(),
2083 res,
2084 "Case {} reversed failed",
2085 i
2086 );
2087 }
2088 }
2089
2090 #[test]
2091 #[should_panic(expected = "chunk_size must not be zero")]
2092 fn check_chunks_zero_size() {
2093 let _: Vec<Vec<i32>> = vec![1, 2, 3].into_par_iter().chunks(0).collect();
2094 }
2095
2096 #[test]
2097 fn check_chunks_even_size() {
2098 assert_eq!(
2099 vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]],
2100 (1..10).into_par_iter().chunks(3).collect::<Vec<Vec<i32>>>()
2101 );
2102 }
2103
2104 #[test]
2105 fn check_chunks_empty() {
2106 let v: Vec<i32> = vec![];
2107 let expected: Vec<Vec<i32>> = vec![];
2108 assert_eq!(
2109 expected,
2110 v.into_par_iter().chunks(2).collect::<Vec<Vec<i32>>>()
2111 );
2112 }
2113
2114 #[test]
2115 fn check_chunks_len() {
2116 assert_eq!(4, (0..8).into_par_iter().chunks(2).len());
2117 assert_eq!(3, (0..9).into_par_iter().chunks(3).len());
2118 assert_eq!(3, (0..8).into_par_iter().chunks(3).len());
2119 assert_eq!(1, [1].par_iter().chunks(3).len());
2120 assert_eq!(0, (0..0).into_par_iter().chunks(3).len());
2121 }
2122
2123 #[test]
2124 fn check_chunks_uneven() {
2125 let cases: Vec<(Vec<u32>, usize, Vec<Vec<u32>>)> = vec![
2126 ((0..5).collect(), 3, vec![vec![0, 1, 2], vec![3, 4]]),
2127 (vec![1], 5, vec![vec![1]]),
2128 ((0..4).collect(), 3, vec![vec![0, 1, 2], vec![3]]),
2129 ];
2130
2131 for (i, (v, n, expected)) in cases.into_iter().enumerate() {
2132 let mut res: Vec<Vec<u32>> = vec![];
2133 v.par_iter()
2134 .chunks(n)
2135 .map(|v| v.into_iter().cloned().collect())
2136 .collect_into_vec(&mut res);
2137 assert_eq!(expected, res, "Case {} failed", i);
2138
2139 res.truncate(0);
2140 v.into_par_iter().chunks(n).rev().collect_into_vec(&mut res);
2141 assert_eq!(
2142 expected.into_iter().rev().collect::<Vec<Vec<u32>>>(),
2143 res,
2144 "Case {} reversed failed",
2145 i
2146 );
2147 }
2148 }
2149
2150 #[test]
2151 #[ignore] // it's quick enough on optimized 32-bit platforms, but otherwise... ... ...
2152 #[should_panic(expected = "overflow")]
2153 #[cfg(debug_assertions)]
2154 fn check_repeat_unbounded() {
2155 // use just one thread, so we don't get infinite adaptive splitting
2156 // (forever stealing and re-splitting jobs that will panic on overflow)
2157 let pool = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
2158 pool.install(|| {
2159 println!("counted {} repeats", repeat(()).count());
2160 });
2161 }
2162
2163 #[test]
2164 fn check_repeat_find_any() {
2165 let even = repeat(4).find_any(|&x| x % 2 == 0);
2166 assert_eq!(even, Some(4));
2167 }
2168
2169 #[test]
2170 fn check_repeat_take() {
2171 let v: Vec<_> = repeat(4).take(4).collect();
2172 assert_eq!(v, [4, 4, 4, 4]);
2173 }
2174
2175 #[test]
2176 fn check_repeat_zip() {
2177 let v = vec![4, 4, 4, 4];
2178 let mut fours: Vec<_> = repeat(4).zip(v).collect();
2179 assert_eq!(fours.len(), 4);
2180 while let Some(item) = fours.pop() {
2181 assert_eq!(item, (4, 4));
2182 }
2183 }
2184
2185 #[test]
2186 fn check_repeatn_zip_left() {
2187 let v = vec![4, 4, 4, 4];
2188 let mut fours: Vec<_> = repeatn(4, usize::MAX).zip(v).collect();
2189 assert_eq!(fours.len(), 4);
2190 while let Some(item) = fours.pop() {
2191 assert_eq!(item, (4, 4));
2192 }
2193 }
2194
2195 #[test]
2196 fn check_repeatn_zip_right() {
2197 let v = vec![4, 4, 4, 4];
2198 let mut fours: Vec<_> = v.into_par_iter().zip(repeatn(4, usize::MAX)).collect();
2199 assert_eq!(fours.len(), 4);
2200 while let Some(item) = fours.pop() {
2201 assert_eq!(item, (4, 4));
2202 }
2203 }
2204
2205 #[test]
2206 fn check_empty() {
2207 // drive_unindexed
2208 let mut v: Vec<i32> = empty().filter(|_| unreachable!()).collect();
2209 assert!(v.is_empty());
2210
2211 // drive (indexed)
2212 empty().collect_into_vec(&mut v);
2213 assert!(v.is_empty());
2214
2215 // with_producer
2216 let v: Vec<(i32, i32)> = empty().zip(1..10).collect();
2217 assert!(v.is_empty());
2218 }
2219
2220 #[test]
2221 fn check_once() {
2222 // drive_unindexed
2223 let mut v: Vec<i32> = once(42).filter(|_| true).collect();
2224 assert_eq!(v, &[42]);
2225
2226 // drive (indexed)
2227 once(42).collect_into_vec(&mut v);
2228 assert_eq!(v, &[42]);
2229
2230 // with_producer
2231 let v: Vec<(i32, i32)> = once(42).zip(1..10).collect();
2232 assert_eq!(v, &[(42, 1)]);
2233 }
2234
2235 #[test]
2236 fn check_update() {
2237 let mut v: Vec<Vec<_>> = vec![vec![1], vec![3, 2, 1]];
2238 v.par_iter_mut().update(|v| v.push(0)).for_each(|_| ());
2239
2240 assert_eq!(v, vec![vec![1, 0], vec![3, 2, 1, 0]]);
2241 }
2242
2243 #[test]
2244 fn walk_tree_prefix() {
2245 let v: Vec<u32> = crate::iter::walk_tree_prefix(0u32..100, |r| {
2246 // root is smallest
2247 let mid = (r.start + 1 + r.end) / 2;
2248 // small indices to the left, large to the right
2249 std::iter::once((r.start + 1)..mid)
2250 .chain(std::iter::once(mid..r.end))
2251 .filter(|r| !r.is_empty())
2252 })
2253 .map(|r| r.start)
2254 .collect();
2255 assert!(v.into_iter().eq(0..100));
2256 }
2257
2258 #[test]
2259 fn walk_tree_postfix() {
2260 let v: Vec<_> = crate::iter::walk_tree_postfix(0u64..100, |r| {
2261 // root is largest
2262 let mid = (r.start + r.end - 1) / 2;
2263 // small indices to the left, large to the right
2264 std::iter::once(r.start..mid)
2265 .chain(std::iter::once(mid..(r.end - 1)))
2266 .filter(|r| !r.is_empty())
2267 })
2268 .map(|r| r.end - 1)
2269 .collect();
2270 assert!(v.into_iter().eq(0..100));
2271 }
2272
2273 #[test]
2274 fn walk_flat_tree_prefix() {
2275 let v: Vec<_> =
2276 crate::iter::walk_tree_prefix(0, |&e| if e < 99 { Some(e + 1) } else { None }).collect();
2277 assert!(v.into_iter().eq(0..100));
2278 }
2279
2280 #[test]
2281 fn walk_flat_tree_postfix() {
2282 let v: Vec<_> =
2283 crate::iter::walk_tree_postfix(99, |&e| if e > 0 { Some(e - 1) } else { None }).collect();
2284 assert!(v.into_iter().eq(0..100));
2285 }
2286
2287 #[test]
2288 fn walk_tree_prefix_degree5() {
2289 let depth = 5;
2290 let nodes_number = (1 - 5i32.pow(depth)) / (1 - 5);
2291 let nodes = (0..nodes_number).collect::<Vec<_>>();
2292 let v: Vec<i32> = crate::iter::walk_tree_prefix(nodes.as_slice(), |&r| {
2293 r.split_first()
2294 .into_iter()
2295 .filter_map(|(_, r)| if r.is_empty() { None } else { Some(r) })
2296 .flat_map(|r| r.chunks(r.len() / 5))
2297 })
2298 .filter_map(|r| r.first().copied())
2299 .collect();
2300 assert_eq!(v, nodes);
2301 }
2302
2303 #[test]
2304 fn walk_tree_postfix_degree5() {
2305 let depth = 5;
2306 let nodes_number = (1 - 5i32.pow(depth)) / (1 - 5);
2307 let nodes = (0..nodes_number).collect::<Vec<_>>();
2308 let v: Vec<i32> = crate::iter::walk_tree_postfix(nodes.as_slice(), |&r| {
2309 r.split_last()
2310 .into_iter()
2311 .filter_map(|(_, r)| if r.is_empty() { None } else { Some(r) })
2312 .flat_map(|r| r.chunks(r.len() / 5))
2313 })
2314 .filter_map(|r| r.last().copied())
2315 .collect();
2316 assert_eq!(v, nodes)
2317 }
2318
2319 #[test]
2320 fn blocks() {
2321 let count = AtomicUsize::new(0);
2322 let v: Vec<usize> = (0..1000)
2323 .into_par_iter()
2324 .map(|_| count.fetch_add(1, Ordering::Relaxed))
2325 .by_uniform_blocks(100)
2326 .collect();
2327 let m = v
2328 .chunks(100)
2329 .map(|c| c.iter().max().copied().unwrap())
2330 .collect::<Vec<usize>>();
2331 assert!(m.windows(2).all(|w| w[0].lt(&w[1])));
2332 assert_eq!(v.len(), 1000);
2333 }