Debian Codegraph @

.cargo/vendor/rayon/tests/debug.rs

raw
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 mut heap: BinaryHeap<_> = (0..10).collect();
15 check(heap.par_iter());
16 check(heap.par_drain());
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.par_drain());
44 check(map.into_par_iter());
45 }
46
47 #[test]
48 fn debug_hash_set() {
49 use std::collections::HashSet;
50 let mut set: HashSet<_> = (0..10).collect();
51 check(set.par_iter());
52 check(set.par_drain());
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());
71 check(deque.par_drain(..));
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
96 #[test]
97 fn debug_range_inclusive() {
98 check((0..=10).into_par_iter());
99 }
100
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_inclusive('\n'));
108 check(s.par_split_terminator('\n'));
109 check(s.par_split_whitespace());
110 check(s.par_split_ascii_whitespace());
111 }
112
113 #[test]
114 fn debug_string() {
115 let mut s = "a b c d\ne f g".to_string();
116 s.par_drain(..);
117 }
118
119 #[test]
120 fn debug_vec() {
121 let mut v: Vec<_> = (0..10).collect();
122 check(v.par_iter());
123 check(v.par_iter_mut());
124 check(v.par_chunk_by(i32::eq));
125 check(v.par_chunk_by_mut(i32::eq));
126 check(v.par_chunks(42));
127 check(v.par_chunks_exact(42));
128 check(v.par_chunks_mut(42));
129 check(v.par_chunks_exact_mut(42));
130 check(v.par_rchunks(42));
131 check(v.par_rchunks_exact(42));
132 check(v.par_rchunks_mut(42));
133 check(v.par_rchunks_exact_mut(42));
134 check(v.par_windows(42));
135 check(v.par_split(|x| x % 3 == 0));
136 check(v.par_split_inclusive(|x| x % 3 == 0));
137 check(v.par_split_mut(|x| x % 3 == 0));
138 check(v.par_split_inclusive_mut(|x| x % 3 == 0));
139 check(v.par_drain(..));
140 check(v.into_par_iter());
141 }
142
143 #[test]
144 fn debug_array() {
145 let a = [0i32; 10];
146 check(a.into_par_iter());
147 }
148
149 #[test]
150 fn debug_adaptors() {
151 let v: Vec<_> = (0..10).collect();
152 check(v.par_iter().by_exponential_blocks());
153 check(v.par_iter().by_uniform_blocks(5));
154 check(v.par_iter().chain(&v));
155 check(v.par_iter().cloned());
156 check(v.par_iter().copied());
157 check(v.par_iter().enumerate());
158 check(v.par_iter().filter(|_| true));
159 check(v.par_iter().filter_map(Some));
160 check(v.par_iter().flat_map(Some));
161 check(v.par_iter().flat_map_iter(Some));
162 check(v.par_iter().map(Some).flatten());
163 check(v.par_iter().map(Some).flatten_iter());
164 check(v.par_iter().fold(|| 0, |x, _| x));
165 check(v.par_iter().fold_with(0, |x, _| x));
166 check(v.par_iter().fold_chunks(3, || 0, |x, _| x));
167 check(v.par_iter().fold_chunks_with(3, 0, |x, _| x));
168 check(v.par_iter().try_fold(|| 0, |x, _| Some(x)));
169 check(v.par_iter().try_fold_with(0, |x, _| Some(x)));
170 check(v.par_iter().inspect(|_| ()));
171 check(v.par_iter().update(|_| ()));
172 check(v.par_iter().interleave(&v));
173 check(v.par_iter().interleave_shortest(&v));
174 check(v.par_iter().intersperse(&-1));
175 check(v.par_iter().chunks(3));
176 check(v.par_iter().map(|x| x));
177 check(v.par_iter().map_with(0, |_, x| x));
178 check(v.par_iter().map_init(|| 0, |_, x| x));
179 check(v.par_iter().panic_fuse());
180 check(v.par_iter().positions(|_| true));
181 check(v.par_iter().rev());
182 check(v.par_iter().skip(1));
183 check(v.par_iter().skip_any(1));
184 check(v.par_iter().skip_any_while(|_| false));
185 check(v.par_iter().take(1));
186 check(v.par_iter().take_any(1));
187 check(v.par_iter().take_any_while(|_| true));
188 check(v.par_iter().map(Some).while_some());
189 check(v.par_iter().with_max_len(1));
190 check(v.par_iter().with_min_len(1));
191 check(v.par_iter().zip(&v));
192 check(v.par_iter().zip_eq(&v));
193 check(v.par_iter().step_by(2));
194 }
195
196 #[test]
197 fn debug_empty() {
198 check(rayon::iter::empty::<i32>());
199 }
200
201 #[test]
202 fn debug_once() {
203 check(rayon::iter::once(10));
204 }
205
206 #[test]
207 fn debug_repeat() {
208 let x: Option<i32> = None;
209 check(rayon::iter::repeat(x));
210 check(rayon::iter::repeatn(x, 10));
211 }
212
213 #[test]
214 fn debug_splitter() {
215 check(rayon::iter::split(0..10, |x| (x, None)));
216 }
217
218 #[test]
219 fn debug_multizip() {
220 let v: &Vec<_> = &(0..10).collect();
221 check((v,).into_par_iter());
222 check((v, v).into_par_iter());
223 check((v, v, v).into_par_iter());
224 check((v, v, v, v).into_par_iter());
225 check((v, v, v, v, v).into_par_iter());
226 check((v, v, v, v, v, v).into_par_iter());
227 check((v, v, v, v, v, v, v).into_par_iter());
228 check((v, v, v, v, v, v, v, v).into_par_iter());
229 check((v, v, v, v, v, v, v, v, v).into_par_iter());
230 check((v, v, v, v, v, v, v, v, v, v).into_par_iter());
231 check((v, v, v, v, v, v, v, v, v, v, v).into_par_iter());
232 check((v, v, v, v, v, v, v, v, v, v, v, v).into_par_iter());
233 }