src/vendor/rustc-rayon/tests/producer_split_at.rs

   1 #![feature(conservative_impl_trait)]
   2
   3 extern crate rayon;
   4
   5 use rayon::prelude::*;
   6 use rayon::iter::plumbing::*;
   7
   8 /// Stress-test indexes for `Producer::split_at`.
   9 fn check<F, I>(expected: &[I::Item], mut f: F)
  10     where F: FnMut() -> I,
  11           I: IntoParallelIterator,
  12           I::Iter: IndexedParallelIterator,
  13           I::Item: PartialEq + std::fmt::Debug
  14 {
  15     for (i, j, k) in triples(expected.len() + 1) {
  16         Split::forward(f(), i, j, k, expected);
  17         Split::reverse(f(), i, j, k, expected);
  18     }
  19 }
  20
  21 fn triples(end: usize) -> impl Iterator<Item=(usize, usize, usize)> {
  22     (0..end).flat_map(move |i| {
  23         (i..end).flat_map(move |j| {
  24             (j..end).map(move |k| (i, j, k))
  25         })
  26     })
  27 }
  28
  29 #[derive(Debug)]
  30 struct Split {
  31     i: usize,
  32     j: usize,
  33     k: usize,
  34     reverse: bool
  35 }
  36
  37 impl Split {
  38     fn forward<I>(iter: I, i: usize, j: usize, k: usize, expected: &[I::Item])
  39         where I: IntoParallelIterator,
  40               I::Iter: IndexedParallelIterator,
  41               I::Item: PartialEq + std::fmt::Debug
  42     {
  43         let result = iter.into_par_iter()
  44             .with_producer(Split { i, j, k, reverse: false });
  45         assert_eq!(result, expected);
  46     }
  47
  48     fn reverse<I>(iter: I, i: usize, j: usize, k: usize, expected: &[I::Item])
  49         where I: IntoParallelIterator,
  50               I::Iter: IndexedParallelIterator,
  51               I::Item: PartialEq + std::fmt::Debug
  52     {
  53         let result = iter.into_par_iter()
  54             .with_producer(Split { i, j, k, reverse: true });
  55         assert!(result.iter().eq(expected.iter().rev()));
  56     }
  57 }
  58
  59 impl<T> ProducerCallback<T> for Split {
  60     type Output = Vec<T>;
  61
  62     fn callback<P>(self, producer: P) -> Self::Output
  63         where P: Producer<Item = T>
  64     {
  65         println!("{:?}", self);
  66
  67         // Splitting the outer indexes first gets us an arbitrary mid section,
  68         // which we then split further to get full test coverage.
  69         let (left, d) = producer.split_at(self.k);
  70         let (a, mid) = left.split_at(self.i);
  71         let (b, c) = mid.split_at(self.j - self.i);
  72
  73         let a = a.into_iter();
  74         let b = b.into_iter();
  75         let c = c.into_iter();
  76         let d = d.into_iter();
  77
  78         check_len(&a, self.i);
  79         check_len(&b, self.j - self.i);
  80         check_len(&c, self.k - self.j);
  81
  82         let chain = a.chain(b).chain(c).chain(d);
  83         if self.reverse {
  84             chain.rev().collect()
  85         } else {
  86             chain.collect()
  87         }
  88     }
  89 }
  90
  91 fn check_len<I: ExactSizeIterator>(iter: &I, len: usize) {
  92     assert_eq!(iter.size_hint(), (len, Some(len)));
  93     assert_eq!(iter.len(), len);
  94 }
  95
  96
  97 // **** Base Producers ****
  98
  99 #[test]
 100 fn empty() {
 101     let v = vec![42];
 102     check(&v[..0], || rayon::iter::empty());
 103 }
 104
 105 #[test]
 106 fn once() {
 107     let v = vec![42];
 108     check(&v, || rayon::iter::once(42));
 109 }
 110
 111 #[test]
 112 fn option() {
 113     let v = vec![42];
 114     check(&v, || Some(42));
 115 }
 116
 117 #[test]
 118 fn range() {
 119     let v: Vec<_> = (0..10).collect();
 120     check(&v, || 0..10);
 121 }
 122
 123 #[test]
 124 fn repeatn() {
 125     let v: Vec<_> = std::iter::repeat(1).take(5).collect();
 126     check(&v, || rayon::iter::repeatn(1, 5));
 127 }
 128
 129 #[test]
 130 fn slice_iter() {
 131     let s: Vec<_> = (0..10).collect();
 132     let v: Vec<_> = s.iter().collect();
 133     check(&v, || &s);
 134 }
 135
 136 #[test]
 137 fn slice_iter_mut() {
 138     let mut s: Vec<_> = (0..10).collect();
 139     let mut v: Vec<_> = s.clone();
 140     let expected: Vec<_> = v.iter_mut().collect();
 141
 142     for (i, j, k) in triples(expected.len() + 1) {
 143         Split::forward(s.par_iter_mut(), i, j, k, &expected);
 144         Split::reverse(s.par_iter_mut(), i, j, k, &expected);
 145     }
 146 }
 147
 148 #[test]
 149 fn slice_chunks() {
 150     let s: Vec<_> = (0..10).collect();
 151     let v: Vec<_> = s.chunks(2).collect();
 152     check(&v, || s.par_chunks(2));
 153 }
 154
 155 #[test]
 156 fn slice_chunks_mut() {
 157     let mut s: Vec<_> = (0..10).collect();
 158     let mut v: Vec<_> = s.clone();
 159     let expected: Vec<_> = v.chunks_mut(2).collect();
 160
 161     for (i, j, k) in triples(expected.len() + 1) {
 162         Split::forward(s.par_chunks_mut(2), i, j, k, &expected);
 163         Split::reverse(s.par_chunks_mut(2), i, j, k, &expected);
 164     }
 165 }
 166
 167 #[test]
 168 fn slice_windows() {
 169     let s: Vec<_> = (0..10).collect();
 170     let v: Vec<_> = s.windows(2).collect();
 171     check(&v, || s.par_windows(2));
 172 }
 173
 174 #[test]
 175 fn vec() {
 176     let v: Vec<_> = (0..10).collect();
 177     check(&v, || v.clone());
 178 }
 179
 180
 181 // **** Adaptors ****
 182
 183 #[test]
 184 fn chain() {
 185     let v: Vec<_> = (0..10).collect();
 186     check(&v, || (0..5).into_par_iter().chain(5..10));
 187 }
 188
 189 #[test]
 190 fn cloned() {
 191     let v: Vec<_> = (0..10).collect();
 192     check(&v, || v.par_iter().cloned());
 193 }
 194
 195 #[test]
 196 fn enumerate() {
 197     let v: Vec<_> = (0..10).enumerate().collect();
 198     check(&v, || (0..10).into_par_iter().enumerate());
 199 }
 200
 201 #[test]
 202 fn inspect() {
 203     let v: Vec<_> = (0..10).collect();
 204     check(&v, || (0..10).into_par_iter().inspect(|_| ()));
 205 }
 206
 207 #[test]
 208 fn update() {
 209     let v: Vec<_> = (0..10).collect();
 210     check(&v, || (0..10).into_par_iter().update(|_| ()));
 211 }
 212
 213 #[test]
 214 fn interleave() {
 215     let v = [0, 10, 1, 11, 2, 12, 3, 4];
 216     check(&v, || (0..5).into_par_iter().interleave(10..13));
 217     check(&v[..6], || (0..3).into_par_iter().interleave(10..13));
 218
 219     let v = [0, 10, 1, 11, 2, 12, 13, 14];
 220     check(&v, || (0..3).into_par_iter().interleave(10..15));
 221 }
 222
 223 #[test]
 224 fn intersperse() {
 225     let v = [0, -1, 1, -1, 2, -1, 3, -1, 4];
 226     check(&v, || (0..5).into_par_iter().intersperse(-1));
 227 }
 228
 229 #[test]
 230 fn chunks() {
 231     let s: Vec<_> = (0..10).collect();
 232     let v: Vec<_> = s.chunks(2).map(|c| c.to_vec()).collect();
 233     check(&v, || s.par_iter().cloned().chunks(2));
 234 }
 235
 236 #[test]
 237 fn map() {
 238     let v: Vec<_> = (0..10).collect();
 239     check(&v, || v.par_iter().map(Clone::clone));
 240 }
 241
 242 #[test]
 243 fn map_with() {
 244     let v: Vec<_> = (0..10).collect();
 245     check(&v, || v.par_iter().map_with(vec![0], |_, &x| x));
 246 }
 247
 248 #[test]
 249 fn rev() {
 250     let v: Vec<_> = (0..10).rev().collect();
 251     check(&v, || (0..10).into_par_iter().rev());
 252 }
 253
 254 #[test]
 255 fn with_max_len() {
 256     let v: Vec<_> = (0..10).collect();
 257     check(&v, || (0..10).into_par_iter().with_max_len(1));
 258 }
 259
 260 #[test]
 261 fn with_min_len() {
 262     let v: Vec<_> = (0..10).collect();
 263     check(&v, || (0..10).into_par_iter().with_min_len(1));
 264 }
 265
 266 #[test]
 267 fn zip() {
 268     let v: Vec<_> = (0..10).zip(10..20).collect();
 269     check(&v, || (0..10).into_par_iter().zip(10..20));
 270     check(&v[..5], || (0..5).into_par_iter().zip(10..20));
 271     check(&v[..5], || (0..10).into_par_iter().zip(10..15));
 272 }