vendor/rustc-rayon/tests/producer_split_at.rs

   1 use rayon::iter::plumbing::*;
   2 use rayon::prelude::*;
   3
   4 /// Stress-test indexes for `Producer::split_at`.
   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
  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 {
  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
  71 impl<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
 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]
 112 fn array() {
 113     let a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
 114     check(&a, || a);
 115 }
 116
 117 #[test]
 118 fn empty() {
 119     let v = vec![42];
 120     check(&v[..0], rayon::iter::empty);
 121 }
 122
 123 #[test]
 124 fn once() {
 125     let v = vec![42];
 126     check(&v, || rayon::iter::once(42));
 127 }
 128
 129 #[test]
 130 fn option() {
 131     let v = vec![42];
 132     check(&v, || Some(42));
 133 }
 134
 135 #[test]
 136 fn range() {
 137     let v: Vec<_> = (0..10).collect();
 138     check(&v, || 0..10);
 139 }
 140
 141 #[test]
 142 fn range_inclusive() {
 143     let v: Vec<_> = (0u16..=10).collect();
 144     check(&v, || 0u16..=10);
 145 }
 146
 147 #[test]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 217 fn 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]
 226 fn 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]
 235 fn 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]
 248 fn 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]
 261 fn 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]
 268 fn vec() {
 269     let v: Vec<_> = (0..10).collect();
 270     check(&v, || v.clone());
 271 }
 272
 273 // **** Adaptors ****
 274
 275 #[test]
 276 fn chain() {
 277     let v: Vec<_> = (0..10).collect();
 278     check(&v, || (0..5).into_par_iter().chain(5..10));
 279 }
 280
 281 #[test]
 282 fn cloned() {
 283     let v: Vec<_> = (0..10).collect();
 284     check(&v, || v.par_iter().cloned());
 285 }
 286
 287 #[test]
 288 fn copied() {
 289     let v: Vec<_> = (0..10).collect();
 290     check(&v, || v.par_iter().copied());
 291 }
 292
 293 #[test]
 294 fn enumerate() {
 295     let v: Vec<_> = (0..10).enumerate().collect();
 296     check(&v, || (0..10).into_par_iter().enumerate());
 297 }
 298
 299 #[test]
 300 fn 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]
 306 fn 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]
 312 fn inspect() {
 313     let v: Vec<_> = (0..10).collect();
 314     check(&v, || (0..10).into_par_iter().inspect(|_| ()));
 315 }
 316
 317 #[test]
 318 fn update() {
 319     let v: Vec<_> = (0..10).collect();
 320     check(&v, || (0..10).into_par_iter().update(|_| ()));
 321 }
 322
 323 #[test]
 324 fn 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]
 334 fn 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]
 340 fn 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]
 347 fn map() {
 348     let v: Vec<_> = (0..10).collect();
 349     check(&v, || v.par_iter().map(Clone::clone));
 350 }
 351
 352 #[test]
 353 fn 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]
 359 fn 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]
 365 fn panic_fuse() {
 366     let v: Vec<_> = (0..10).collect();
 367     check(&v, || (0..10).into_par_iter().panic_fuse());
 368 }
 369
 370 #[test]
 371 fn rev() {
 372     let v: Vec<_> = (0..10).rev().collect();
 373     check(&v, || (0..10).into_par_iter().rev());
 374 }
 375
 376 #[test]
 377 fn 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]
 383 fn 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]
 389 fn 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 }