1 use rayon::iter::plumbing::*;
2 use rayon::prelude::*;
3
4 /// Stress-test indexes for `Producer::split_at`.
check<F, I>(expected: &[I::Item], mut f: F) where F: FnMut() -> I, I: IntoParallelIterator, I::Iter: IndexedParallelIterator, I::Item: PartialEq + std::fmt::Debug,5 fn check<F, I>(expected: &[I::Item], mut f: F)
6 where
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
map_triples<F>(end: usize, mut f: F) where F: FnMut(usize, usize, usize),18 fn map_triples<F>(end: usize, mut f: F)
19 where
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)]
32 struct Split {
33 i: usize,
34 j: usize,
35 k: usize,
36 reverse: bool,
37 }
38
39 impl Split {
forward<I>(iter: I, i: usize, j: usize, k: usize, expected: &[I::Item]) where I: IntoParallelIterator, I::Iter: IndexedParallelIterator, I::Item: PartialEq + std::fmt::Debug,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
reverse<I>(iter: I, i: usize, j: usize, k: usize, expected: &[I::Item]) where I: IntoParallelIterator, I::Iter: IndexedParallelIterator, I::Item: PartialEq + std::fmt::Debug,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
71 impl<T> ProducerCallback<T> for Split {
72 type Output = Vec<T>;
73
callback<P>(self, producer: P) -> Self::Output where P: Producer<Item = T>,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
check_len<I: ExactSizeIterator>(iter: &I, len: usize)104 fn 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]
array()112 fn array() {
113 let a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
114 check(&a, || a);
115 }
116
117 #[test]
empty()118 fn empty() {
119 let v = vec![42];
120 check(&v[..0], rayon::iter::empty);
121 }
122
123 #[test]
once()124 fn once() {
125 let v = vec![42];
126 check(&v, || rayon::iter::once(42));
127 }
128
129 #[test]
option()130 fn option() {
131 let v = vec![42];
132 check(&v, || Some(42));
133 }
134
135 #[test]
range()136 fn range() {
137 let v: Vec<_> = (0..10).collect();
138 check(&v, || 0..10);
139 }
140
141 #[test]
range_inclusive()142 fn range_inclusive() {
143 let v: Vec<_> = (0u16..=10).collect();
144 check(&v, || 0u16..=10);
145 }
146
147 #[test]
repeatn()148 fn repeatn() {
149 let v: Vec<_> = std::iter::repeat(1).take(5).collect();
150 check(&v, || rayon::iter::repeatn(1, 5));
151 }
152
153 #[test]
slice_iter()154 fn slice_iter() {
155 let s: Vec<_> = (0..10).collect();
156 let v: Vec<_> = s.iter().collect();
157 check(&v, || &s);
158 }
159
160 #[test]
slice_iter_mut()161 fn 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]
slice_chunks()173 fn 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]
slice_chunks_exact()182 fn 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]
slice_chunks_mut()191 fn 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]
slice_chunks_exact_mut()204 fn 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]
slice_windows()217 fn slice_windows() {
218 let s: Vec<_> = (0..10).collect();
219 let v: Vec<_> = s.windows(2).collect();
220 check(&v, || s.par_windows(2));
221 }
222
223 #[test]
vec()224 fn vec() {
225 let v: Vec<_> = (0..10).collect();
226 check(&v, || v.clone());
227 }
228
229 // **** Adaptors ****
230
231 #[test]
chain()232 fn chain() {
233 let v: Vec<_> = (0..10).collect();
234 check(&v, || (0..5).into_par_iter().chain(5..10));
235 }
236
237 #[test]
cloned()238 fn cloned() {
239 let v: Vec<_> = (0..10).collect();
240 check(&v, || v.par_iter().cloned());
241 }
242
243 #[test]
copied()244 fn copied() {
245 let v: Vec<_> = (0..10).collect();
246 check(&v, || v.par_iter().copied());
247 }
248
249 #[test]
enumerate()250 fn enumerate() {
251 let v: Vec<_> = (0..10).enumerate().collect();
252 check(&v, || (0..10).into_par_iter().enumerate());
253 }
254
255 #[test]
step_by()256 fn step_by() {
257 let v: Vec<_> = (0..10).step_by(2).collect();
258 check(&v, || (0..10).into_par_iter().step_by(2))
259 }
260
261 #[test]
step_by_unaligned()262 fn step_by_unaligned() {
263 let v: Vec<_> = (0..10).step_by(3).collect();
264 check(&v, || (0..10).into_par_iter().step_by(3))
265 }
266
267 #[test]
inspect()268 fn inspect() {
269 let v: Vec<_> = (0..10).collect();
270 check(&v, || (0..10).into_par_iter().inspect(|_| ()));
271 }
272
273 #[test]
update()274 fn update() {
275 let v: Vec<_> = (0..10).collect();
276 check(&v, || (0..10).into_par_iter().update(|_| ()));
277 }
278
279 #[test]
interleave()280 fn interleave() {
281 let v = [0, 10, 1, 11, 2, 12, 3, 4];
282 check(&v, || (0..5).into_par_iter().interleave(10..13));
283 check(&v[..6], || (0..3).into_par_iter().interleave(10..13));
284
285 let v = [0, 10, 1, 11, 2, 12, 13, 14];
286 check(&v, || (0..3).into_par_iter().interleave(10..15));
287 }
288
289 #[test]
intersperse()290 fn intersperse() {
291 let v = [0, -1, 1, -1, 2, -1, 3, -1, 4];
292 check(&v, || (0..5).into_par_iter().intersperse(-1));
293 }
294
295 #[test]
chunks()296 fn chunks() {
297 let s: Vec<_> = (0..10).collect();
298 let v: Vec<_> = s.chunks(2).map(|c| c.to_vec()).collect();
299 check(&v, || s.par_iter().cloned().chunks(2));
300 }
301
302 #[test]
map()303 fn map() {
304 let v: Vec<_> = (0..10).collect();
305 check(&v, || v.par_iter().map(Clone::clone));
306 }
307
308 #[test]
map_with()309 fn map_with() {
310 let v: Vec<_> = (0..10).collect();
311 check(&v, || v.par_iter().map_with(vec![0], |_, &x| x));
312 }
313
314 #[test]
map_init()315 fn map_init() {
316 let v: Vec<_> = (0..10).collect();
317 check(&v, || v.par_iter().map_init(|| vec![0], |_, &x| x));
318 }
319
320 #[test]
panic_fuse()321 fn panic_fuse() {
322 let v: Vec<_> = (0..10).collect();
323 check(&v, || (0..10).into_par_iter().panic_fuse());
324 }
325
326 #[test]
rev()327 fn rev() {
328 let v: Vec<_> = (0..10).rev().collect();
329 check(&v, || (0..10).into_par_iter().rev());
330 }
331
332 #[test]
with_max_len()333 fn with_max_len() {
334 let v: Vec<_> = (0..10).collect();
335 check(&v, || (0..10).into_par_iter().with_max_len(1));
336 }
337
338 #[test]
with_min_len()339 fn with_min_len() {
340 let v: Vec<_> = (0..10).collect();
341 check(&v, || (0..10).into_par_iter().with_min_len(1));
342 }
343
344 #[test]
zip()345 fn zip() {
346 let v: Vec<_> = (0..10).zip(10..20).collect();
347 check(&v, || (0..10).into_par_iter().zip(10..20));
348 check(&v[..5], || (0..5).into_par_iter().zip(10..20));
349 check(&v[..5], || (0..10).into_par_iter().zip(10..15));
350 }
351