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]
empty()112 fn empty() {
113 let v = vec![42];
114 check(&v[..0], rayon::iter::empty);
115 }
116
117 #[test]
once()118 fn once() {
119 let v = vec![42];
120 check(&v, || rayon::iter::once(42));
121 }
122
123 #[test]
option()124 fn option() {
125 let v = vec![42];
126 check(&v, || Some(42));
127 }
128
129 #[test]
range()130 fn range() {
131 let v: Vec<_> = (0..10).collect();
132 check(&v, || 0..10);
133 }
134
135 #[test]
range_inclusive()136 fn range_inclusive() {
137 let v: Vec<_> = (0u16..=10).collect();
138 check(&v, || 0u16..=10);
139 }
140
141 #[test]
repeatn()142 fn repeatn() {
143 let v: Vec<_> = std::iter::repeat(1).take(5).collect();
144 check(&v, || rayon::iter::repeatn(1, 5));
145 }
146
147 #[test]
slice_iter()148 fn slice_iter() {
149 let s: Vec<_> = (0..10).collect();
150 let v: Vec<_> = s.iter().collect();
151 check(&v, || &s);
152 }
153
154 #[test]
slice_iter_mut()155 fn slice_iter_mut() {
156 let mut s: Vec<_> = (0..10).collect();
157 let mut v: Vec<_> = s.clone();
158 let expected: Vec<_> = v.iter_mut().collect();
159
160 map_triples(expected.len() + 1, |i, j, k| {
161 Split::forward(s.par_iter_mut(), i, j, k, &expected);
162 Split::reverse(s.par_iter_mut(), i, j, k, &expected);
163 });
164 }
165
166 #[test]
slice_chunks()167 fn slice_chunks() {
168 let s: Vec<_> = (0..10).collect();
169 for len in 1..s.len() + 2 {
170 let v: Vec<_> = s.chunks(len).collect();
171 check(&v, || s.par_chunks(len));
172 }
173 }
174
175 #[test]
slice_chunks_exact()176 fn slice_chunks_exact() {
177 let s: Vec<_> = (0..10).collect();
178 for len in 1..s.len() + 2 {
179 let v: Vec<_> = s.chunks_exact(len).collect();
180 check(&v, || s.par_chunks_exact(len));
181 }
182 }
183
184 #[test]
slice_chunks_mut()185 fn slice_chunks_mut() {
186 let mut s: Vec<_> = (0..10).collect();
187 let mut v: Vec<_> = s.clone();
188 for len in 1..s.len() + 2 {
189 let expected: Vec<_> = v.chunks_mut(len).collect();
190 map_triples(expected.len() + 1, |i, j, k| {
191 Split::forward(s.par_chunks_mut(len), i, j, k, &expected);
192 Split::reverse(s.par_chunks_mut(len), i, j, k, &expected);
193 });
194 }
195 }
196
197 #[test]
slice_chunks_exact_mut()198 fn slice_chunks_exact_mut() {
199 let mut s: Vec<_> = (0..10).collect();
200 let mut v: Vec<_> = s.clone();
201 for len in 1..s.len() + 2 {
202 let expected: Vec<_> = v.chunks_exact_mut(len).collect();
203 map_triples(expected.len() + 1, |i, j, k| {
204 Split::forward(s.par_chunks_exact_mut(len), i, j, k, &expected);
205 Split::reverse(s.par_chunks_exact_mut(len), i, j, k, &expected);
206 });
207 }
208 }
209
210 #[test]
slice_windows()211 fn slice_windows() {
212 let s: Vec<_> = (0..10).collect();
213 let v: Vec<_> = s.windows(2).collect();
214 check(&v, || s.par_windows(2));
215 }
216
217 #[test]
vec()218 fn vec() {
219 let v: Vec<_> = (0..10).collect();
220 check(&v, || v.clone());
221 }
222
223 // **** Adaptors ****
224
225 #[test]
chain()226 fn chain() {
227 let v: Vec<_> = (0..10).collect();
228 check(&v, || (0..5).into_par_iter().chain(5..10));
229 }
230
231 #[test]
cloned()232 fn cloned() {
233 let v: Vec<_> = (0..10).collect();
234 check(&v, || v.par_iter().cloned());
235 }
236
237 #[test]
copied()238 fn copied() {
239 let v: Vec<_> = (0..10).collect();
240 check(&v, || v.par_iter().copied());
241 }
242
243 #[test]
enumerate()244 fn enumerate() {
245 let v: Vec<_> = (0..10).enumerate().collect();
246 check(&v, || (0..10).into_par_iter().enumerate());
247 }
248
249 #[test]
step_by()250 fn step_by() {
251 let v: Vec<_> = (0..10).step_by(2).collect();
252 check(&v, || (0..10).into_par_iter().step_by(2))
253 }
254
255 #[test]
step_by_unaligned()256 fn step_by_unaligned() {
257 let v: Vec<_> = (0..10).step_by(3).collect();
258 check(&v, || (0..10).into_par_iter().step_by(3))
259 }
260
261 #[test]
inspect()262 fn inspect() {
263 let v: Vec<_> = (0..10).collect();
264 check(&v, || (0..10).into_par_iter().inspect(|_| ()));
265 }
266
267 #[test]
update()268 fn update() {
269 let v: Vec<_> = (0..10).collect();
270 check(&v, || (0..10).into_par_iter().update(|_| ()));
271 }
272
273 #[test]
interleave()274 fn interleave() {
275 let v = [0, 10, 1, 11, 2, 12, 3, 4];
276 check(&v, || (0..5).into_par_iter().interleave(10..13));
277 check(&v[..6], || (0..3).into_par_iter().interleave(10..13));
278
279 let v = [0, 10, 1, 11, 2, 12, 13, 14];
280 check(&v, || (0..3).into_par_iter().interleave(10..15));
281 }
282
283 #[test]
intersperse()284 fn intersperse() {
285 let v = [0, -1, 1, -1, 2, -1, 3, -1, 4];
286 check(&v, || (0..5).into_par_iter().intersperse(-1));
287 }
288
289 #[test]
chunks()290 fn chunks() {
291 let s: Vec<_> = (0..10).collect();
292 let v: Vec<_> = s.chunks(2).map(|c| c.to_vec()).collect();
293 check(&v, || s.par_iter().cloned().chunks(2));
294 }
295
296 #[test]
map()297 fn map() {
298 let v: Vec<_> = (0..10).collect();
299 check(&v, || v.par_iter().map(Clone::clone));
300 }
301
302 #[test]
map_with()303 fn map_with() {
304 let v: Vec<_> = (0..10).collect();
305 check(&v, || v.par_iter().map_with(vec![0], |_, &x| x));
306 }
307
308 #[test]
map_init()309 fn map_init() {
310 let v: Vec<_> = (0..10).collect();
311 check(&v, || v.par_iter().map_init(|| vec![0], |_, &x| x));
312 }
313
314 #[test]
panic_fuse()315 fn panic_fuse() {
316 let v: Vec<_> = (0..10).collect();
317 check(&v, || (0..10).into_par_iter().panic_fuse());
318 }
319
320 #[test]
rev()321 fn rev() {
322 let v: Vec<_> = (0..10).rev().collect();
323 check(&v, || (0..10).into_par_iter().rev());
324 }
325
326 #[test]
with_max_len()327 fn with_max_len() {
328 let v: Vec<_> = (0..10).collect();
329 check(&v, || (0..10).into_par_iter().with_max_len(1));
330 }
331
332 #[test]
with_min_len()333 fn with_min_len() {
334 let v: Vec<_> = (0..10).collect();
335 check(&v, || (0..10).into_par_iter().with_min_len(1));
336 }
337
338 #[test]
zip()339 fn zip() {
340 let v: Vec<_> = (0..10).zip(10..20).collect();
341 check(&v, || (0..10).into_par_iter().zip(10..20));
342 check(&v[..5], || (0..5).into_par_iter().zip(10..20));
343 check(&v[..5], || (0..10).into_par_iter().zip(10..15));
344 }
345