vendor/rustc-rayon/tests/debug.rs

   1 use rayon::prelude::*;
   2 use std::fmt::Debug;
   3
   4 fn check<I>(iter: I)
   5 where
   6     I: ParallelIterator + Debug,
   7 {
   8     println!("{:?}", iter);
   9 }
  10
  11 #[test]
  12 fn debug_binary_heap() {
  13     use std::collections::BinaryHeap;
  14     let heap: BinaryHeap<_> = (0..10).collect();
  15     check(heap.par_iter());
  16     check(heap.into_par_iter());
  17 }
  18
  19 #[test]
  20 fn debug_btree_map() {
  21     use std::collections::BTreeMap;
  22     let mut map: BTreeMap<_, _> = (0..10).enumerate().collect();
  23     check(map.par_iter());
  24     check(map.par_iter_mut());
  25     check(map.into_par_iter());
  26 }
  27
  28 #[test]
  29 fn debug_btree_set() {
  30     use std::collections::BTreeSet;
  31     let set: BTreeSet<_> = (0..10).collect();
  32     check(set.par_iter());
  33     check(set.into_par_iter());
  34 }
  35
  36 #[test]
  37 fn debug_hash_map() {
  38     use std::collections::HashMap;
  39     let mut map: HashMap<_, _> = (0..10).enumerate().collect();
  40     check(map.par_iter());
  41     check(map.par_iter_mut());
  42     check(map.into_par_iter());
  43 }
  44
  45 #[test]
  46 fn debug_hash_set() {
  47     use std::collections::HashSet;
  48     let set: HashSet<_> = (0..10).collect();
  49     check(set.par_iter());
  50     check(set.into_par_iter());
  51 }
  52
  53 #[test]
  54 fn debug_linked_list() {
  55     use std::collections::LinkedList;
  56     let mut list: LinkedList<_> = (0..10).collect();
  57     check(list.par_iter());
  58     check(list.par_iter_mut());
  59     check(list.into_par_iter());
  60 }
  61
  62 #[test]
  63 fn debug_vec_deque() {
  64     use std::collections::VecDeque;
  65     let mut deque: VecDeque<_> = (0..10).collect();
  66     check(deque.par_iter());
  67     check(deque.par_iter_mut());
  68     check(deque.into_par_iter());
  69 }
  70
  71 #[test]
  72 fn debug_option() {
  73     let mut option = Some(0);
  74     check(option.par_iter());
  75     check(option.par_iter_mut());
  76     check(option.into_par_iter());
  77 }
  78
  79 #[test]
  80 fn debug_result() {
  81     let mut result = Ok::<_, ()>(0);
  82     check(result.par_iter());
  83     check(result.par_iter_mut());
  84     check(result.into_par_iter());
  85 }
  86
  87 #[test]
  88 fn debug_range() {
  89     check((0..10).into_par_iter());
  90 }
  91
  92 #[test]
  93 fn debug_range_inclusive() {
  94     check((0..=10).into_par_iter());
  95 }
  96
  97 #[test]
  98 fn debug_str() {
  99     let s = "a b c d\ne f g";
 100     check(s.par_chars());
 101     check(s.par_lines());
 102     check(s.par_split('\n'));
 103     check(s.par_split_terminator('\n'));
 104     check(s.par_split_whitespace());
 105 }
 106
 107 #[test]
 108 fn debug_vec() {
 109     let mut v: Vec<_> = (0..10).collect();
 110     check(v.par_iter());
 111     check(v.par_iter_mut());
 112     check(v.par_chunks(42));
 113     check(v.par_chunks_mut(42));
 114     check(v.par_windows(42));
 115     check(v.par_split(|x| x % 3 == 0));
 116     check(v.par_split_mut(|x| x % 3 == 0));
 117     check(v.into_par_iter());
 118 }
 119
 120 #[test]
 121 fn debug_adaptors() {
 122     let v: Vec<_> = (0..10).collect();
 123     check(v.par_iter().chain(&v));
 124     check(v.par_iter().cloned());
 125     check(v.par_iter().copied());
 126     check(v.par_iter().enumerate());
 127     check(v.par_iter().filter(|_| true));
 128     check(v.par_iter().filter_map(Some));
 129     check(v.par_iter().flat_map(Some));
 130     check(v.par_iter().map(Some).flatten());
 131     check(v.par_iter().fold(|| 0, |x, _| x));
 132     check(v.par_iter().fold_with(0, |x, _| x));
 133     check(v.par_iter().try_fold(|| 0, |x, _| Some(x)));
 134     check(v.par_iter().try_fold_with(0, |x, _| Some(x)));
 135     check(v.par_iter().inspect(|_| ()));
 136     check(v.par_iter().update(|_| ()));
 137     check(v.par_iter().interleave(&v));
 138     check(v.par_iter().interleave_shortest(&v));
 139     check(v.par_iter().intersperse(&-1));
 140     check(v.par_iter().chunks(3));
 141     check(v.par_iter().map(|x| x));
 142     check(v.par_iter().map_with(0, |_, x| x));
 143     check(v.par_iter().map_init(|| 0, |_, x| x));
 144     check(v.par_iter().panic_fuse());
 145     check(v.par_iter().rev());
 146     check(v.par_iter().skip(1));
 147     check(v.par_iter().take(1));
 148     check(v.par_iter().map(Some).while_some());
 149     check(v.par_iter().with_max_len(1));
 150     check(v.par_iter().with_min_len(1));
 151     check(v.par_iter().zip(&v));
 152     check(v.par_iter().zip_eq(&v));
 153 }
 154
 155 #[test]
 156 fn debug_empty() {
 157     check(rayon::iter::empty::<i32>());
 158 }
 159
 160 #[test]
 161 fn debug_once() {
 162     check(rayon::iter::once(10));
 163 }
 164
 165 #[test]
 166 fn debug_repeat() {
 167     let x: Option<i32> = None;
 168     check(rayon::iter::repeat(x));
 169     check(rayon::iter::repeatn(x, 10));
 170 }
 171
 172 #[test]
 173 fn debug_splitter() {
 174     check(rayon::iter::split(0..10, |x| (x, None)));
 175 }
 176
 177 #[test]
 178 fn debug_multizip() {
 179     let v: &Vec<_> = &(0..10).collect();
 180     check((v,).into_par_iter());
 181     check((v, v).into_par_iter());
 182     check((v, v, v).into_par_iter());
 183     check((v, v, v, v).into_par_iter());
 184     check((v, v, v, v, v).into_par_iter());
 185     check((v, v, v, v, v, v).into_par_iter());
 186     check((v, v, v, v, v, v, v).into_par_iter());
 187     check((v, v, v, v, v, v, v, v).into_par_iter());
 188     check((v, v, v, v, v, v, v, v, v).into_par_iter());
 189     check((v, v, v, v, v, v, v, v, v, v).into_par_iter());
 190     check((v, v, v, v, v, v, v, v, v, v, v).into_par_iter());
 191     check((v, v, v, v, v, v, v, v, v, v, v, v).into_par_iter());
 192 }