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