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