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