1 use core::iter;
2 use core::ops::Range;
3
4 use super::{convert, FallibleIterator, Vec};
5
6 #[test]
all()7 fn all() {
8 assert!(convert([0, 1, 2, 3].iter().map(Ok::<&u32, ()>))
9 .all(|&i| Ok(i < 4))
10 .unwrap());
11 assert!(!convert([0, 1, 2, 4].iter().map(Ok::<&u32, ()>))
12 .all(|&i| Ok(i < 4))
13 .unwrap());
14 assert!(convert([0, 1, 2, 4].iter().map(Ok::<&u32, ()>))
15 .all(|_| Err(()))
16 .is_err());
17 }
18
19 #[test]
any()20 fn any() {
21 assert!(convert([0, 1, 2, 3].iter().map(Ok::<&u32, ()>))
22 .any(|&i| Ok(i == 3))
23 .unwrap());
24 assert!(!convert([0, 1, 2, 4].iter().map(Ok::<&u32, ()>))
25 .any(|&i| Ok(i == 3))
26 .unwrap());
27 assert!(convert([0, 1, 2, 4].iter().map(Ok::<&u32, ()>))
28 .any(|_| Err(()))
29 .is_err());
30 }
31
32 #[test]
chain()33 fn chain() {
34 let a = convert(vec![0, 1, 2, 3].into_iter().map(Ok::<u32, ()>));
35 let b = convert(vec![4, 5, 6, 7].into_iter().map(Ok::<u32, ()>));
36 let it = a.chain(b);
37
38 assert_eq!(it.collect::<Vec<_>>().unwrap(), [0, 1, 2, 3, 4, 5, 6, 7]);
39
40 let a = convert(vec![0, 1, 2, 3].into_iter().map(Ok::<u32, ()>));
41 let b = convert(vec![4, 5, 6, 7].into_iter().map(Ok::<u32, ()>));
42 let it = a.chain(b).rev();
43
44 assert_eq!(it.collect::<Vec<_>>().unwrap(), [7, 6, 5, 4, 3, 2, 1, 0]);
45 }
46
47 #[test]
count()48 fn count() {
49 assert_eq!(
50 convert([0, 1, 2, 3].iter().map(Ok::<&u32, ()>))
51 .count()
52 .unwrap(),
53 4
54 );
55
56 let it = Some(Ok(1)).into_iter().chain(iter::repeat(Err(())));
57 assert!(convert(it).count().is_err());
58 }
59
60 #[test]
enumerate()61 fn enumerate() {
62 let it = convert(vec![5, 6, 7, 8].into_iter().map(Ok::<u32, ()>)).enumerate();
63
64 assert_eq!(
65 it.collect::<Vec<_>>().unwrap(),
66 [(0, 5), (1, 6), (2, 7), (3, 8)]
67 );
68 }
69
70 #[test]
filter()71 fn filter() {
72 let it = convert(vec![0, 1, 2, 3].into_iter().map(Ok::<u32, u32>));
73 let it = it.filter(|&x| if x % 2 == 0 { Ok(x % 3 == 0) } else { Err(x) });
74
75 assert_eq!(it.clone().collect::<Vec<_>>(), Err(1));
76 assert_eq!(it.rev().collect::<Vec<_>>(), Err(3));
77
78 let it = convert(vec![0, 2, 4, 6].into_iter().map(Ok::<u32, u32>));
79 let it = it.filter(|&x| if x % 2 == 0 { Ok(x % 3 == 0) } else { Err(x) });
80
81 assert_eq!(it.clone().collect::<Vec<_>>(), Ok(vec![0, 6]));
82 assert_eq!(it.rev().collect::<Vec<_>>(), Ok(vec![6, 0]))
83 }
84
85 #[test]
filter_map()86 fn filter_map() {
87 fn twos_and_threes(x: u32) -> Result<Option<u32>, u32> {
88 if x % 2 == 0 {
89 Ok(Some(x + 10))
90 } else if x % 3 == 0 {
91 Ok(None)
92 } else {
93 Err(x)
94 }
95 }
96
97 let it = convert(vec![0, 1, 2, 3, 4, 5, 6].into_iter().map(Ok::<u32, u32>))
98 .filter_map(twos_and_threes);
99
100 assert_eq!(it.clone().collect::<Vec<_>>(), Err(1));
101 assert_eq!(it.rev().collect::<Vec<_>>(), Err(5));
102
103 let it =
104 convert(vec![0, 2, 3, 4, 6].into_iter().map(Ok::<u32, u32>)).filter_map(twos_and_threes);
105
106 assert_eq!(it.clone().collect::<Vec<_>>(), Ok(vec![10, 12, 14, 16]));
107 assert_eq!(it.rev().collect::<Vec<_>>(), Ok(vec![16, 14, 12, 10]));
108 }
109
110 #[test]
find()111 fn find() {
112 let mut it = convert(vec![0, 1, 2, 3].into_iter().map(Ok::<u32, u32>));
113
114 assert_eq!(it.find(|x| Ok(x % 2 == 1)), Ok(Some(1)));
115 assert_eq!(it.next(), Ok(Some(2)));
116
117 let it = convert(vec![0, 1, 2, 3].into_iter().map(Ok::<u32, u32>));
118 assert_eq!(
119 it.clone()
120 .find(|&x| if x == 2 { Err(29) } else { Ok(false) }),
121 Err(29)
122 );
123 assert_eq!(
124 it.clone()
125 .find(|&x| if x == 2 { Err(29) } else { Ok(true) }),
126 Ok(Some(0))
127 );
128 assert_eq!(
129 it.clone()
130 .rev()
131 .find(|&x| if x == 2 { Err(29) } else { Ok(false) }),
132 Err(29)
133 );
134 assert_eq!(
135 it.rev().find(|&x| if x == 2 { Err(29) } else { Ok(true) }),
136 Ok(Some(3))
137 );
138 }
139
140 #[test]
fold()141 fn fold() {
142 fn add_smol(a: u32, b: u32) -> Result<u32, u32> {
143 if b <= 2 {
144 Ok(a + b)
145 } else {
146 Err(b)
147 }
148 }
149
150 let it = convert(vec![0, 1, 3, 2].into_iter().map(Ok::<u32, u32>));
151 assert_eq!(it.fold(0, add_smol), Err(3));
152
153 let it = convert(vec![0, 1, 2, 1].into_iter().map(Ok::<u32, u32>));
154 assert_eq!(it.fold(0, add_smol), Ok(4));
155 }
156
157 #[test]
for_each()158 fn for_each() {
159 let it = convert(vec![0, 1, 2, 3].into_iter().map(Ok::<u32, ()>));
160
161 let mut acc = vec![];
162 it.for_each(|n| {
163 acc.push(n);
164 Ok(())
165 })
166 .unwrap();
167 assert_eq!(acc, vec![0, 1, 2, 3]);
168 }
169
170 #[test]
iterator()171 fn iterator() {
172 let it = convert(
173 "ab cd"
174 .chars()
175 .map(|c| if c.is_whitespace() { Err(()) } else { Ok(c) }),
176 );
177
178 assert!(it.clone().count().is_err());
179 assert!(it.clone().rev().count().is_err());
180 assert_eq!(it.clone().iterator().count(), 5);
181 assert_eq!(it.clone().iterator().rev().count(), 5);
182 }
183
184 #[test]
last()185 fn last() {
186 let it = convert(vec![0, 1, 2, 3].into_iter().map(Ok::<u32, ()>));
187 assert_eq!(it.last().unwrap(), Some(3));
188 }
189
190 #[test]
map()191 fn map() {
192 let it = convert(vec![0, 1, 2, 3, 4].into_iter().map(Ok::<u32, ()>)).map(|n| Ok(n * 2));
193 assert_eq!(it.clone().collect::<Vec<_>>().unwrap(), [0, 2, 4, 6, 8]);
194 assert_eq!(it.rev().collect::<Vec<_>>().unwrap(), [8, 6, 4, 2, 0]);
195
196 let it = convert(vec![0, 1, 2, 3, 4].into_iter().map(Ok::<u32, ()>)).map(|n| {
197 if n == 2 {
198 Err(())
199 } else {
200 Ok(n * 2)
201 }
202 });
203
204 {
205 let mut it = it.clone();
206 assert_eq!(it.next(), Ok(Some(0)));
207 assert_eq!(it.next(), Ok(Some(2)));
208 assert_eq!(it.next(), Err(()));
209 }
210
211 {
212 let mut it = it.rev();
213 assert_eq!(it.next(), Ok(Some(8)));
214 assert_eq!(it.next(), Ok(Some(6)));
215 assert_eq!(it.next(), Err(()));
216 }
217 }
218
219 #[test]
map_err()220 fn map_err() {
221 let it = convert(
222 vec![0, 1, 2, 3]
223 .into_iter()
224 .map(|n| if n % 2 == 0 { Ok(n) } else { Err(n) }),
225 );
226
227 assert_eq!(it.clone().collect::<Vec<_>>(), Err(1));
228 assert_eq!(it.rev().collect::<Vec<_>>(), Err(3));
229 }
230
231 #[test]
max()232 fn max() {
233 let it = convert(vec![0, 3, 1, -10].into_iter().map(Ok::<i32, ()>));
234 assert_eq!(it.max().unwrap(), Some(3));
235 }
236
237 #[test]
max_by_key()238 fn max_by_key() {
239 let it = convert(vec![0, 3, 1, -10].into_iter().map(Ok::<i32, i32>));
240 assert_eq!(it.clone().max_by_key(|&i| Ok(-i)), Ok(Some(-10)));
241 // Exercise failure both on the first item, and later.
242 assert_eq!(it.clone().max_by_key(|&i| Err::<i32, _>(i)), Err(0));
243 assert_eq!(
244 it.clone()
245 .max_by_key(|&i| if i > 0 { Err(i) } else { Ok(-i) }),
246 Err(3)
247 );
248 }
249
250 #[test]
max_by()251 fn max_by() {
252 let it = convert(vec![0, 3, 1, -10].into_iter().map(Ok::<i32, ()>));
253 assert_eq!(it.max_by(|a, b| Ok(b.cmp(a))), Ok(Some(-10)));
254 }
255
256 #[test]
min()257 fn min() {
258 let it = convert(vec![0, 3, -10, 1].into_iter().map(Ok::<i32, ()>));
259 assert_eq!(it.min().unwrap(), Some(-10));
260 }
261
262 #[test]
min_by_key()263 fn min_by_key() {
264 let it = convert(vec![0, 3, 1, -10].into_iter().map(Ok::<i32, i32>));
265 assert_eq!(it.clone().min_by_key(|&i| Ok(-i)), Ok(Some(3)));
266 // Exercise failure both on the first item, and later.
267 assert_eq!(it.clone().min_by_key(|&i| Err::<i32, _>(i)), Err(0));
268 assert_eq!(
269 it.clone()
270 .min_by_key(|&i| if i > 0 { Err(i) } else { Ok(-i) }),
271 Err(3)
272 );
273 }
274
275 #[test]
min_by()276 fn min_by() {
277 let it = convert(vec![0, 3, 1, -10].into_iter().map(Ok::<i32, ()>));
278 assert_eq!(it.min_by(|a, b| Ok(b.cmp(a))), Ok(Some(3)));
279 }
280
281 #[test]
nth()282 fn nth() {
283 let mut it = convert(vec![0, 1, 2, 3].into_iter().map(Ok::<i32, ()>));
284 assert_eq!(it.nth(1).unwrap(), Some(1));
285 assert_eq!(it.nth(0).unwrap(), Some(2));
286 assert_eq!(it.nth(2).unwrap(), None);
287 }
288
289 #[test]
peekable()290 fn peekable() {
291 let mut it = convert(vec![0, 1].into_iter().map(Ok::<i32, ()>)).peekable();
292 assert_eq!(it.peek().unwrap(), Some(&0));
293 assert_eq!(it.peek().unwrap(), Some(&0));
294 assert_eq!(it.next().unwrap(), Some(0));
295 assert_eq!(it.next().unwrap(), Some(1));
296 assert_eq!(it.peek().unwrap(), None);
297 assert_eq!(it.next().unwrap(), None);
298 }
299
300 #[test]
position()301 fn position() {
302 let mut it = convert(vec![1, 2, 3, 4].into_iter().map(Ok::<i32, ()>));
303 assert_eq!(it.position(|n| Ok(n == 2)).unwrap(), Some(1));
304 assert_eq!(it.position(|n| Ok(n == 3)).unwrap(), Some(0));
305 assert_eq!(it.position(|n| Ok(n == 5)).unwrap(), None);
306
307 let it = convert(vec![1, 2, 3, 4].into_iter().map(Ok::<i32, i32>));
308 assert_eq!(
309 it.clone()
310 .position(|n| if n == 3 { Err(42) } else { Ok(n == 2) }),
311 Ok(Some(1))
312 );
313 assert_eq!(
314 it.clone()
315 .position(|n| if n == 3 { Err(42) } else { Ok(n == 4) }),
316 Err(42)
317 );
318 }
319
320 #[test]
scan()321 fn scan() {
322 let it = convert(vec![1, 2, 3, 4].into_iter().map(Ok::<i32, ()>)).scan(0, |st, v| {
323 if v > 3 {
324 Ok(None)
325 } else {
326 *st += v;
327 Ok(Some(-*st))
328 }
329 });
330 assert_eq!(it.collect::<Vec<_>>(), Ok(vec![-1, -3, -6]));
331 }
332
333 #[test]
skip()334 fn skip() {
335 let it = convert(vec![1, 2, 3, 4].into_iter().map(Ok::<i32, ()>));
336 assert_eq!(it.clone().skip(0).collect::<Vec<_>>(), Ok(vec![1, 2, 3, 4]));
337 assert_eq!(it.clone().skip(2).collect::<Vec<_>>(), Ok(vec![3, 4]));
338 assert_eq!(it.clone().skip(4).collect::<Vec<_>>(), Ok(vec![]));
339 }
340
341 #[test]
skip_while()342 fn skip_while() {
343 let it = convert(vec![1, 2, 3, 4, 1].into_iter().map(Ok::<i32, ()>));
344 assert_eq!(
345 it.clone().skip_while(|x| Ok(*x < 1)).collect::<Vec<_>>(),
346 Ok(vec![1, 2, 3, 4, 1])
347 );
348 assert_eq!(
349 it.clone().skip_while(|x| Ok(*x < 3)).collect::<Vec<_>>(),
350 Ok(vec![3, 4, 1])
351 );
352 assert_eq!(
353 it.clone().skip_while(|x| Ok(*x < 5)).collect::<Vec<_>>(),
354 Ok(vec![])
355 );
356 }
357
358 #[test]
step_by()359 fn step_by() {
360 let it = convert(
361 vec![0, 1, 2, 3, 4, 5, 6, 7, 8]
362 .into_iter()
363 .map(Ok::<i32, ()>),
364 )
365 .step_by(3);
366 assert_eq!(it.collect::<Vec<_>>(), Ok(vec![0, 3, 6]));
367 }
368
369 #[test]
take()370 fn take() {
371 let it = convert(vec![0, 1, 2, 3].into_iter().map(Ok::<i32, ()>)).take(2);
372 assert_eq!(it.collect::<Vec<_>>().unwrap(), [0, 1]);
373 }
374
375 #[test]
take_while()376 fn take_while() {
377 let it = convert(vec![0, 1, 2, 3, 0].into_iter().map(Ok::<i32, ()>));
378 assert_eq!(
379 it.clone().take_while(|x| Ok(*x < 0)).collect::<Vec<_>>(),
380 Ok(vec![])
381 );
382 assert_eq!(
383 it.clone().take_while(|x| Ok(*x < 2)).collect::<Vec<_>>(),
384 Ok(vec![0, 1])
385 );
386 assert_eq!(
387 it.clone().take_while(|x| Ok(*x < 4)).collect::<Vec<_>>(),
388 Ok(vec![0, 1, 2, 3, 0])
389 );
390 }
391
392 #[test]
flat_map()393 fn flat_map() {
394 let it = convert(vec![0..1, 0..0, 1..5].into_iter().map(Ok::<Range<i32>, ()>))
395 .flat_map(|r| Ok(convert(r.map(Ok::<i32, ()>))));
396 assert_eq!(it.collect::<Vec<_>>(), Ok(vec![0, 1, 2, 3, 4]));
397 }
398
399 #[test]
flatten()400 fn flatten() {
401 let it = convert(
402 vec![0..1, 0..0, 1..5]
403 .into_iter()
404 .map(|r| convert(r.map(Ok::<i32, ()>)))
405 .map(Ok::<_, ()>),
406 )
407 .flatten();
408 assert_eq!(it.collect::<Vec<_>>(), Ok(vec![0, 1, 2, 3, 4]));
409 }
410
411 #[test]
inspect()412 fn inspect() {
413 let mut buf = vec![];
414 let it = convert(vec![0, 1, 2, 3].into_iter().map(Ok::<i32, ()>)).inspect(|v| Ok(buf.push(*v)));
415 it.count().unwrap();
416 assert_eq!(buf, vec![0, 1, 2, 3]);
417 }
418
419 #[test]
partition()420 fn partition() {
421 let it = convert(vec![0, 1, 2, 3].into_iter().map(Ok::<i32, ()>));
422 let (even, odd): (Vec<i32>, Vec<i32>) = it.partition(|i| Ok(*i % 2 == 0)).unwrap();
423 assert_eq!(even, vec![0, 2]);
424 assert_eq!(odd, vec![1, 3]);
425 }
426
427 #[test]
find_map()428 fn find_map() {
429 let mut it = convert(vec![0, 1, 2, 3].into_iter().map(Ok::<i32, ()>));
430 assert_eq!(
431 it.find_map(|v| match v {
432 2 => Ok(Some("hi")),
433 _ => Ok(None),
434 }),
435 Ok(Some("hi"))
436 );
437 }
438
439 #[test]
unzip()440 fn unzip() {
441 let it = convert(
442 vec![(0, 0), (1, -1), (2, -2), (3, -3)]
443 .into_iter()
444 .map(Ok::<_, ()>),
445 );
446 let (pos, neg): (Vec<i32>, Vec<i32>) = it.unzip().unwrap();
447 assert_eq!(pos, vec![0, 1, 2, 3]);
448 assert_eq!(neg, vec![0, -1, -2, -3]);
449 }
450
451 #[test]
cycle()452 fn cycle() {
453 let it = convert(vec![0, 1, 2, 3].into_iter().map(Ok::<i32, ()>)).cycle();
454 assert_eq!(it.take(6).clone().collect::<Vec<_>>(), Ok(vec![0, 1, 2, 3, 0, 1]));
455 }
456