1use rayon::iter::plumbing::*;
2use rayon::prelude::*;
3
4/// Stress-test indexes for `Producer::split_at`.
5fn check<F, I>(expected: &[I::Item], mut f: F)
6where
7 F: FnMut() -> I,
8 I: IntoParallelIterator,
9 I::Iter: IndexedParallelIterator,
10 I::Item: PartialEq + std::fmt::Debug,
11{
12 map_triples(expected.len() + 1, |i, j, k| {
13 Split::forward(f(), i, j, k, expected);
14 Split::reverse(f(), i, j, k, expected);
15 });
16}
17
18fn map_triples<F>(end: usize, mut f: F)
19where
20 F: FnMut(usize, usize, usize),
21{
22 for i in 0..end {
23 for j in i..end {
24 for k in j..end {
25 f(i, j, k);
26 }
27 }
28 }
29}
30
31#[derive(Debug)]
32struct Split {
33 i: usize,
34 j: usize,
35 k: usize,
36 reverse: bool,
37}
38
39impl Split {
40 fn forward<I>(iter: I, i: usize, j: usize, k: usize, expected: &[I::Item])
41 where
42 I: IntoParallelIterator,
43 I::Iter: IndexedParallelIterator,
44 I::Item: PartialEq + std::fmt::Debug,
45 {
46 let result = iter.into_par_iter().with_producer(Split {
47 i,
48 j,
49 k,
50 reverse: false,
51 });
52 assert_eq!(result, expected);
53 }
54
55 fn reverse<I>(iter: I, i: usize, j: usize, k: usize, expected: &[I::Item])
56 where
57 I: IntoParallelIterator,
58 I::Iter: IndexedParallelIterator,
59 I::Item: PartialEq + std::fmt::Debug,
60 {
61 let result = iter.into_par_iter().with_producer(Split {
62 i,
63 j,
64 k,
65 reverse: true,
66 });
67 assert!(result.iter().eq(expected.iter().rev()));
68 }
69}
70
71impl<T> ProducerCallback<T> for Split {
72 type Output = Vec<T>;
73
74 fn callback<P>(self, producer: P) -> Self::Output
75 where
76 P: Producer<Item = T>,
77 {
78 println!("{:?}", self);
79
80 // Splitting the outer indexes first gets us an arbitrary mid section,
81 // which we then split further to get full test coverage.
82 let (left, d) = producer.split_at(self.k);
83 let (a, mid) = left.split_at(self.i);
84 let (b, c) = mid.split_at(self.j - self.i);
85
86 let a = a.into_iter();
87 let b = b.into_iter();
88 let c = c.into_iter();
89 let d = d.into_iter();
90
91 check_len(&a, self.i);
92 check_len(&b, self.j - self.i);
93 check_len(&c, self.k - self.j);
94
95 let chain = a.chain(b).chain(c).chain(d);
96 if self.reverse {
97 chain.rev().collect()
98 } else {
99 chain.collect()
100 }
101 }
102}
103
104fn check_len<I: ExactSizeIterator>(iter: &I, len: usize) {
105 assert_eq!(iter.size_hint(), (len, Some(len)));
106 assert_eq!(iter.len(), len);
107}
108
109// **** Base Producers ****
110
111#[test]
112fn array() {
113 let a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
114 check(&a, || a);
115}
116
117#[test]
118fn empty() {
119 let v = vec![42];
120 check(&v[..0], rayon::iter::empty);
121}
122
123#[test]
124fn once() {
125 let v = vec![42];
126 check(&v, || rayon::iter::once(42));
127}
128
129#[test]
130fn option() {
131 let v = vec![42];
132 check(&v, || Some(42));
133}
134
135#[test]
136fn range() {
137 let v: Vec<_> = (0..10).collect();
138 check(&v, || 0..10);
139}
140
141#[test]
142fn range_inclusive() {
143 let v: Vec<_> = (0u16..=10).collect();
144 check(&v, || 0u16..=10);
145}
146
147#[test]
148fn repeatn() {
149 let v: Vec<_> = std::iter::repeat(1).take(5).collect();
150 check(&v, || rayon::iter::repeatn(1, 5));
151}
152
153#[test]
154fn slice_iter() {
155 let s: Vec<_> = (0..10).collect();
156 let v: Vec<_> = s.iter().collect();
157 check(&v, || &s);
158}
159
160#[test]
161fn slice_iter_mut() {
162 let mut s: Vec<_> = (0..10).collect();
163 let mut v: Vec<_> = s.clone();
164 let expected: Vec<_> = v.iter_mut().collect();
165
166 map_triples(expected.len() + 1, |i, j, k| {
167 Split::forward(s.par_iter_mut(), i, j, k, &expected);
168 Split::reverse(s.par_iter_mut(), i, j, k, &expected);
169 });
170}
171
172#[test]
173fn slice_chunks() {
174 let s: Vec<_> = (0..10).collect();
175 for len in 1..s.len() + 2 {
176 let v: Vec<_> = s.chunks(len).collect();
177 check(&v, || s.par_chunks(len));
178 }
179}
180
181#[test]
182fn slice_chunks_exact() {
183 let s: Vec<_> = (0..10).collect();
184 for len in 1..s.len() + 2 {
185 let v: Vec<_> = s.chunks_exact(len).collect();
186 check(&v, || s.par_chunks_exact(len));
187 }
188}
189
190#[test]
191fn slice_chunks_mut() {
192 let mut s: Vec<_> = (0..10).collect();
193 let mut v: Vec<_> = s.clone();
194 for len in 1..s.len() + 2 {
195 let expected: Vec<_> = v.chunks_mut(len).collect();
196 map_triples(expected.len() + 1, |i, j, k| {
197 Split::forward(s.par_chunks_mut(len), i, j, k, &expected);
198 Split::reverse(s.par_chunks_mut(len), i, j, k, &expected);
199 });
200 }
201}
202
203#[test]
204fn slice_chunks_exact_mut() {
205 let mut s: Vec<_> = (0..10).collect();
206 let mut v: Vec<_> = s.clone();
207 for len in 1..s.len() + 2 {
208 let expected: Vec<_> = v.chunks_exact_mut(len).collect();
209 map_triples(expected.len() + 1, |i, j, k| {
210 Split::forward(s.par_chunks_exact_mut(len), i, j, k, &expected);
211 Split::reverse(s.par_chunks_exact_mut(len), i, j, k, &expected);
212 });
213 }
214}
215
216#[test]
217fn slice_rchunks() {
218 let s: Vec<_> = (0..10).collect();
219 for len in 1..s.len() + 2 {
220 let v: Vec<_> = s.rchunks(len).collect();
221 check(&v, || s.par_rchunks(len));
222 }
223}
224
225#[test]
226fn slice_rchunks_exact() {
227 let s: Vec<_> = (0..10).collect();
228 for len in 1..s.len() + 2 {
229 let v: Vec<_> = s.rchunks_exact(len).collect();
230 check(&v, || s.par_rchunks_exact(len));
231 }
232}
233
234#[test]
235fn slice_rchunks_mut() {
236 let mut s: Vec<_> = (0..10).collect();
237 let mut v: Vec<_> = s.clone();
238 for len in 1..s.len() + 2 {
239 let expected: Vec<_> = v.rchunks_mut(len).collect();
240 map_triples(expected.len() + 1, |i, j, k| {
241 Split::forward(s.par_rchunks_mut(len), i, j, k, &expected);
242 Split::reverse(s.par_rchunks_mut(len), i, j, k, &expected);
243 });
244 }
245}
246
247#[test]
248fn slice_rchunks_exact_mut() {
249 let mut s: Vec<_> = (0..10).collect();
250 let mut v: Vec<_> = s.clone();
251 for len in 1..s.len() + 2 {
252 let expected: Vec<_> = v.rchunks_exact_mut(len).collect();
253 map_triples(expected.len() + 1, |i, j, k| {
254 Split::forward(s.par_rchunks_exact_mut(len), i, j, k, &expected);
255 Split::reverse(s.par_rchunks_exact_mut(len), i, j, k, &expected);
256 });
257 }
258}
259
260#[test]
261fn slice_windows() {
262 let s: Vec<_> = (0..10).collect();
263 let v: Vec<_> = s.windows(2).collect();
264 check(&v, || s.par_windows(2));
265}
266
267#[test]
268fn vec() {
269 let v: Vec<_> = (0..10).collect();
270 check(&v, || v.clone());
271}
272
273// **** Adaptors ****
274
275#[test]
276fn chain() {
277 let v: Vec<_> = (0..10).collect();
278 check(&v, || (0..5).into_par_iter().chain(5..10));
279}
280
281#[test]
282fn cloned() {
283 let v: Vec<_> = (0..10).collect();
284 check(&v, || v.par_iter().cloned());
285}
286
287#[test]
288fn copied() {
289 let v: Vec<_> = (0..10).collect();
290 check(&v, || v.par_iter().copied());
291}
292
293#[test]
294fn enumerate() {
295 let v: Vec<_> = (0..10).enumerate().collect();
296 check(&v, || (0..10).into_par_iter().enumerate());
297}
298
299#[test]
300fn step_by() {
301 let v: Vec<_> = (0..10).step_by(2).collect();
302 check(&v, || (0..10).into_par_iter().step_by(2))
303}
304
305#[test]
306fn step_by_unaligned() {
307 let v: Vec<_> = (0..10).step_by(3).collect();
308 check(&v, || (0..10).into_par_iter().step_by(3))
309}
310
311#[test]
312fn inspect() {
313 let v: Vec<_> = (0..10).collect();
314 check(&v, || (0..10).into_par_iter().inspect(|_| ()));
315}
316
317#[test]
318fn update() {
319 let v: Vec<_> = (0..10).collect();
320 check(&v, || (0..10).into_par_iter().update(|_| ()));
321}
322
323#[test]
324fn interleave() {
325 let v = [0, 10, 1, 11, 2, 12, 3, 4];
326 check(&v, || (0..5).into_par_iter().interleave(10..13));
327 check(&v[..6], || (0..3).into_par_iter().interleave(10..13));
328
329 let v = [0, 10, 1, 11, 2, 12, 13, 14];
330 check(&v, || (0..3).into_par_iter().interleave(10..15));
331}
332
333#[test]
334fn intersperse() {
335 let v = [0, -1, 1, -1, 2, -1, 3, -1, 4];
336 check(&v, || (0..5).into_par_iter().intersperse(-1));
337}
338
339#[test]
340fn chunks() {
341 let s: Vec<_> = (0..10).collect();
342 let v: Vec<_> = s.chunks(2).map(|c| c.to_vec()).collect();
343 check(&v, || s.par_iter().cloned().chunks(2));
344}
345
346#[test]
347fn map() {
348 let v: Vec<_> = (0..10).collect();
349 check(&v, || v.par_iter().map(Clone::clone));
350}
351
352#[test]
353fn map_with() {
354 let v: Vec<_> = (0..10).collect();
355 check(&v, || v.par_iter().map_with(vec![0], |_, &x| x));
356}
357
358#[test]
359fn map_init() {
360 let v: Vec<_> = (0..10).collect();
361 check(&v, || v.par_iter().map_init(|| vec![0], |_, &x| x));
362}
363
364#[test]
365fn panic_fuse() {
366 let v: Vec<_> = (0..10).collect();
367 check(&v, || (0..10).into_par_iter().panic_fuse());
368}
369
370#[test]
371fn rev() {
372 let v: Vec<_> = (0..10).rev().collect();
373 check(&v, || (0..10).into_par_iter().rev());
374}
375
376#[test]
377fn with_max_len() {
378 let v: Vec<_> = (0..10).collect();
379 check(&v, || (0..10).into_par_iter().with_max_len(1));
380}
381
382#[test]
383fn with_min_len() {
384 let v: Vec<_> = (0..10).collect();
385 check(&v, || (0..10).into_par_iter().with_min_len(1));
386}
387
388#[test]
389fn zip() {
390 let v: Vec<_> = (0..10).zip(10..20).collect();
391 check(&v, || (0..10).into_par_iter().zip(10..20));
392 check(&v[..5], || (0..5).into_par_iter().zip(10..20));
393 check(&v[..5], || (0..10).into_par_iter().zip(10..15));
394}
395