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