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

   1 #![feature(clone_closures)]
   2
   3 extern crate rayon;
   4
   5 use rayon::prelude::*;
   6
   7 fn check<I>(iter: I)
   8     where I: ParallelIterator + Clone,
   9           I::Item: std::fmt::Debug + PartialEq
  10 {
  11     let a: Vec<_> = iter.clone().collect();
  12     let b: Vec<_> = iter.collect();
  13     assert_eq!(a, b);
  14 }
  15
  16 #[test]
  17 fn clone_binary_heap() {
  18     use std::collections::BinaryHeap;
  19     let heap: BinaryHeap<_> = (0..1000).collect();
  20     check(heap.par_iter());
  21     check(heap.into_par_iter());
  22 }
  23
  24 #[test]
  25 fn clone_btree_map() {
  26     use std::collections::BTreeMap;
  27     let map: BTreeMap<_,_> = (0..1000).enumerate().collect();
  28     check(map.par_iter());
  29 }
  30
  31 #[test]
  32 fn clone_btree_set() {
  33     use std::collections::BTreeSet;
  34     let set: BTreeSet<_> = (0..1000).collect();
  35     check(set.par_iter());
  36 }
  37
  38 #[test]
  39 fn clone_hash_map() {
  40     use std::collections::HashMap;
  41     let map: HashMap<_,_> = (0..1000).enumerate().collect();
  42     check(map.par_iter());
  43 }
  44
  45 #[test]
  46 fn clone_hash_set() {
  47     use std::collections::HashSet;
  48     let set: HashSet<_> = (0..1000).collect();
  49     check(set.par_iter());
  50 }
  51
  52 #[test]
  53 fn clone_linked_list() {
  54     use std::collections::LinkedList;
  55     let list: LinkedList<_> = (0..1000).collect();
  56     check(list.par_iter());
  57     check(list.into_par_iter());
  58 }
  59
  60 #[test]
  61 fn clone_vec_deque() {
  62     use std::collections::VecDeque;
  63     let deque: VecDeque<_> = (0..1000).collect();
  64     check(deque.par_iter());
  65     check(deque.into_par_iter());
  66 }
  67
  68 #[test]
  69 fn clone_option() {
  70     let option = Some(0);
  71     check(option.par_iter());
  72     check(option.into_par_iter());
  73 }
  74
  75 #[test]
  76 fn clone_result() {
  77     let result = Ok::<_, ()>(0);
  78     check(result.par_iter());
  79     check(result.into_par_iter());
  80 }
  81
  82 #[test]
  83 fn clone_range() {
  84     check((0..1000).into_par_iter());
  85 }
  86
  87 #[test]
  88 fn clone_str() {
  89     let s = include_str!("clones.rs");
  90     check(s.par_chars());
  91     check(s.par_lines());
  92     check(s.par_split('\n'));
  93     check(s.par_split_terminator('\n'));
  94     check(s.par_split_whitespace());
  95 }
  96
  97 #[test]
  98 fn clone_vec() {
  99     let v: Vec<_> = (0..1000).collect();
 100     check(v.par_iter());
 101     check(v.par_chunks(42));
 102     check(v.par_windows(42));
 103     check(v.par_split(|x| x % 3 == 0));
 104     check(v.into_par_iter());
 105 }
 106
 107 #[test]
 108 fn clone_adaptors() {
 109     let v: Vec<_> = (0..1000).map(Some).collect();
 110     check(v.par_iter().chain(&v));
 111     check(v.par_iter().cloned());
 112     check(v.par_iter().enumerate());
 113     check(v.par_iter().filter(|_| true));
 114     check(v.par_iter().filter_map(|x| *x));
 115     check(v.par_iter().flat_map(|x| *x));
 116     check(v.par_iter().flatten());
 117     check(v.par_iter().with_max_len(1).fold(|| 0, |x, _| x));
 118     check(v.par_iter().with_max_len(1).fold_with(0, |x, _| x));
 119     check(v.par_iter().inspect(|_| ()));
 120     check(v.par_iter().update(|_| ()));
 121     check(v.par_iter().interleave(&v));
 122     check(v.par_iter().interleave_shortest(&v));
 123     check(v.par_iter().intersperse(&None));
 124     check(v.par_iter().chunks(3));
 125     check(v.par_iter().map(|x| x));
 126     check(v.par_iter().map_with(0, |_, x| x));
 127     check(v.par_iter().rev());
 128     check(v.par_iter().skip(1));
 129     check(v.par_iter().take(1));
 130     check(v.par_iter().cloned().while_some());
 131     check(v.par_iter().with_max_len(1));
 132     check(v.par_iter().with_min_len(1));
 133     check(v.par_iter().zip(&v));
 134     check(v.par_iter().zip_eq(&v));
 135 }
 136
 137 #[test]
 138 fn clone_empty() {
 139     check(rayon::iter::empty::<i32>());
 140 }
 141
 142 #[test]
 143 fn clone_once() {
 144     check(rayon::iter::once(10));
 145 }
 146
 147 #[test]
 148 fn clone_repeat() {
 149     let x: Option<i32> = None;
 150     check(rayon::iter::repeat(x).while_some());
 151     check(rayon::iter::repeatn(x, 1000));
 152 }
 153
 154 #[test]
 155 fn clone_splitter() {
 156     check(rayon::iter::split(0..1000, |x| (x, None)));
 157 }
 158