]>
git.proxmox.com Git - rustc.git/blob - vendor/rustc-rayon/tests/producer_split_at.rs
1 use rayon
::iter
::plumbing
::*;
4 /// Stress-test indexes for `Producer::split_at`.
5 fn check
<F
, I
>(expected
: &[I
::Item
], mut f
: F
)
8 I
: IntoParallelIterator
,
9 I
::Iter
: IndexedParallelIterator
,
10 I
::Item
: PartialEq
+ std
::fmt
::Debug
,
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
);
18 fn map_triples
<F
>(end
: usize, mut f
: F
)
20 F
: FnMut(usize, usize, usize),
40 fn forward
<I
>(iter
: I
, i
: usize, j
: usize, k
: usize, expected
: &[I
::Item
])
42 I
: IntoParallelIterator
,
43 I
::Iter
: IndexedParallelIterator
,
44 I
::Item
: PartialEq
+ std
::fmt
::Debug
,
46 let result
= iter
.into_par_iter().with_producer(Split
{
52 assert_eq
!(result
, expected
);
55 fn reverse
<I
>(iter
: I
, i
: usize, j
: usize, k
: usize, expected
: &[I
::Item
])
57 I
: IntoParallelIterator
,
58 I
::Iter
: IndexedParallelIterator
,
59 I
::Item
: PartialEq
+ std
::fmt
::Debug
,
61 let result
= iter
.into_par_iter().with_producer(Split
{
67 assert
!(result
.iter().eq(expected
.iter().rev()));
71 impl<T
> ProducerCallback
<T
> for Split
{
74 fn callback
<P
>(self, producer
: P
) -> Self::Output
76 P
: Producer
<Item
= T
>,
78 println
!("{:?}", self);
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
);
86 let a
= a
.into_iter();
87 let b
= b
.into_iter();
88 let c
= c
.into_iter();
89 let d
= d
.into_iter();
91 check_len(&a
, self.i
);
92 check_len(&b
, self.j
- self.i
);
93 check_len(&c
, self.k
- self.j
);
95 let chain
= a
.chain(b
).chain(c
).chain(d
);
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
);
109 // **** Base Producers ****
114 check(&v
[..0], rayon
::iter
::empty
);
120 check(&v
, || rayon
::iter
::once(42));
126 check(&v
, || Some(42));
131 let v
: Vec
<_
> = (0..10).collect();
136 fn range_inclusive() {
137 let v
: Vec
<_
> = (0u16..=10).collect();
138 check(&v
, || 0u16..=10);
143 let v
: Vec
<_
> = std
::iter
::repeat(1).take(5).collect();
144 check(&v
, || rayon
::iter
::repeatn(1, 5));
149 let s
: Vec
<_
> = (0..10).collect();
150 let v
: Vec
<_
> = s
.iter().collect();
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();
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
);
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
));
176 fn slice_chunks_mut() {
177 let mut s
: Vec
<_
> = (0..10).collect();
178 let mut v
: Vec
<_
> = s
.clone();
179 for len
in 1..s
.len() + 2 {
180 let expected
: Vec
<_
> = v
.chunks_mut(len
).collect();
181 map_triples(expected
.len() + 1, |i
, j
, k
| {
182 Split
::forward(s
.par_chunks_mut(len
), i
, j
, k
, &expected
);
183 Split
::reverse(s
.par_chunks_mut(len
), i
, j
, k
, &expected
);
190 let s
: Vec
<_
> = (0..10).collect();
191 let v
: Vec
<_
> = s
.windows(2).collect();
192 check(&v
, || s
.par_windows(2));
197 let v
: Vec
<_
> = (0..10).collect();
198 check(&v
, || v
.clone());
201 // **** Adaptors ****
205 let v
: Vec
<_
> = (0..10).collect();
206 check(&v
, || (0..5).into_par_iter().chain(5..10));
211 let v
: Vec
<_
> = (0..10).collect();
212 check(&v
, || v
.par_iter().cloned());
217 let v
: Vec
<_
> = (0..10).collect();
218 check(&v
, || v
.par_iter().copied());
223 let v
: Vec
<_
> = (0..10).enumerate().collect();
224 check(&v
, || (0..10).into_par_iter().enumerate());
229 let v
: Vec
<_
> = (0..10).collect();
230 check(&v
, || (0..10).into_par_iter().inspect(|_
| ()));
235 let v
: Vec
<_
> = (0..10).collect();
236 check(&v
, || (0..10).into_par_iter().update(|_
| ()));
241 let v
= [0, 10, 1, 11, 2, 12, 3, 4];
242 check(&v
, || (0..5).into_par_iter().interleave(10..13));
243 check(&v
[..6], || (0..3).into_par_iter().interleave(10..13));
245 let v
= [0, 10, 1, 11, 2, 12, 13, 14];
246 check(&v
, || (0..3).into_par_iter().interleave(10..15));
251 let v
= [0, -1, 1, -1, 2, -1, 3, -1, 4];
252 check(&v
, || (0..5).into_par_iter().intersperse(-1));
257 let s
: Vec
<_
> = (0..10).collect();
258 let v
: Vec
<_
> = s
.chunks(2).map(|c
| c
.to_vec()).collect();
259 check(&v
, || s
.par_iter().cloned().chunks(2));
264 let v
: Vec
<_
> = (0..10).collect();
265 check(&v
, || v
.par_iter().map(Clone
::clone
));
270 let v
: Vec
<_
> = (0..10).collect();
271 check(&v
, || v
.par_iter().map_with(vec
![0], |_
, &x
| x
));
276 let v
: Vec
<_
> = (0..10).collect();
277 check(&v
, || v
.par_iter().map_init(|| vec
![0], |_
, &x
| x
));
282 let v
: Vec
<_
> = (0..10).collect();
283 check(&v
, || (0..10).into_par_iter().panic_fuse());
288 let v
: Vec
<_
> = (0..10).rev().collect();
289 check(&v
, || (0..10).into_par_iter().rev());
294 let v
: Vec
<_
> = (0..10).collect();
295 check(&v
, || (0..10).into_par_iter().with_max_len(1));
300 let v
: Vec
<_
> = (0..10).collect();
301 check(&v
, || (0..10).into_par_iter().with_min_len(1));
306 let v
: Vec
<_
> = (0..10).zip(10..20).collect();
307 check(&v
, || (0..10).into_par_iter().zip(10..20));
308 check(&v
[..5], || (0..5).into_par_iter().zip(10..20));
309 check(&v
[..5], || (0..10).into_par_iter().zip(10..15));