1 use alloc::{vec, vec::Vec};
2 use core::{iter, ops::Range};
3 
4 use super::{convert, FallibleIterator, IntoFallible};
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     fn assert_debug(_: &impl core::fmt::Debug) {}
194     assert_debug(&it);
195     assert_eq!(it.clone().collect::<Vec<_>>().unwrap(), [0, 2, 4, 6, 8]);
196     assert_eq!(it.rev().collect::<Vec<_>>().unwrap(), [8, 6, 4, 2, 0]);
197 
198     let it = convert(vec![0, 1, 2, 3, 4].into_iter().map(Ok::<u32, ()>)).map(|n| {
199         if n == 2 {
200             Err(())
201         } else {
202             Ok(n * 2)
203         }
204     });
205 
206     {
207         let mut it = it.clone();
208         assert_eq!(it.next(), Ok(Some(0)));
209         assert_eq!(it.next(), Ok(Some(2)));
210         assert_eq!(it.next(), Err(()));
211     }
212 
213     {
214         let mut it = it.rev();
215         assert_eq!(it.next(), Ok(Some(8)));
216         assert_eq!(it.next(), Ok(Some(6)));
217         assert_eq!(it.next(), Err(()));
218     }
219 }
220 
221 #[test]
map_err()222 fn map_err() {
223     let it = convert(
224         vec![0, 1, 2, 3]
225             .into_iter()
226             .map(|n| if n % 2 == 0 { Ok(n) } else { Err(n) }),
227     );
228 
229     assert_eq!(it.clone().collect::<Vec<_>>(), Err(1));
230     assert_eq!(it.rev().collect::<Vec<_>>(), Err(3));
231 }
232 
233 #[test]
max()234 fn max() {
235     let it = convert(vec![0, 3, 1, -10].into_iter().map(Ok::<i32, ()>));
236     assert_eq!(it.max().unwrap(), Some(3));
237 }
238 
239 #[test]
max_by_key()240 fn max_by_key() {
241     let it = convert(vec![0, 3, 1, -10].into_iter().map(Ok::<i32, i32>));
242     assert_eq!(it.clone().max_by_key(|&i| Ok(-i)), Ok(Some(-10)));
243     // Exercise failure both on the first item, and later.
244     assert_eq!(it.clone().max_by_key(|&i| Err::<i32, _>(i)), Err(0));
245     assert_eq!(
246         it.max_by_key(|&i| if i > 0 { Err(i) } else { Ok(-i) }),
247         Err(3)
248     );
249 }
250 
251 #[test]
max_by()252 fn max_by() {
253     let it = convert(vec![0, 3, 1, -10].into_iter().map(Ok::<i32, ()>));
254     assert_eq!(it.max_by(|a, b| Ok(b.cmp(a))), Ok(Some(-10)));
255 }
256 
257 #[test]
min()258 fn min() {
259     let it = convert(vec![0, 3, -10, 1].into_iter().map(Ok::<i32, ()>));
260     assert_eq!(it.min().unwrap(), Some(-10));
261 }
262 
263 #[test]
min_by_key()264 fn min_by_key() {
265     let it = convert(vec![0, 3, 1, -10].into_iter().map(Ok::<i32, i32>));
266     assert_eq!(it.clone().min_by_key(|&i| Ok(-i)), Ok(Some(3)));
267     // Exercise failure both on the first item, and later.
268     assert_eq!(it.clone().min_by_key(|&i| Err::<i32, _>(i)), Err(0));
269     assert_eq!(
270         it.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 mut 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.position(|n| if n == 3 { Err(42) } else { Ok(n == 4) }),
315         Err(42)
316     );
317 }
318 
319 #[test]
scan()320 fn scan() {
321     let it = convert(vec![1, 2, 3, 4].into_iter().map(Ok::<i32, ()>)).scan(0, |st, v| {
322         if v > 3 {
323             Ok(None)
324         } else {
325             *st += v;
326             Ok(Some(-*st))
327         }
328     });
329     assert_eq!(it.collect::<Vec<_>>(), Ok(vec![-1, -3, -6]));
330 }
331 
332 #[test]
skip()333 fn skip() {
334     let it = convert(vec![1, 2, 3, 4].into_iter().map(Ok::<i32, ()>));
335     assert_eq!(it.clone().skip(0).collect::<Vec<_>>(), Ok(vec![1, 2, 3, 4]));
336     assert_eq!(it.clone().skip(2).collect::<Vec<_>>(), Ok(vec![3, 4]));
337     assert_eq!(it.skip(4).collect::<Vec<_>>(), Ok(vec![]));
338 }
339 
340 #[test]
skip_while()341 fn skip_while() {
342     let it = convert(vec![1, 2, 3, 4, 1].into_iter().map(Ok::<i32, ()>));
343     assert_eq!(
344         it.clone().skip_while(|x| Ok(*x < 1)).collect::<Vec<_>>(),
345         Ok(vec![1, 2, 3, 4, 1])
346     );
347     assert_eq!(
348         it.clone().skip_while(|x| Ok(*x < 3)).collect::<Vec<_>>(),
349         Ok(vec![3, 4, 1])
350     );
351     assert_eq!(
352         it.skip_while(|x| Ok(*x < 5)).collect::<Vec<_>>(),
353         Ok(vec![])
354     );
355 }
356 
357 #[test]
step_by()358 fn step_by() {
359     let it = convert(
360         vec![0, 1, 2, 3, 4, 5, 6, 7, 8]
361             .into_iter()
362             .map(Ok::<i32, ()>),
363     )
364     .step_by(3);
365     assert_eq!(it.collect::<Vec<_>>(), Ok(vec![0, 3, 6]));
366 }
367 
368 #[test]
take()369 fn take() {
370     let it = convert(vec![0, 1, 2, 3].into_iter().map(Ok::<i32, ()>)).take(2);
371     assert_eq!(it.collect::<Vec<_>>().unwrap(), [0, 1]);
372 }
373 
374 #[test]
take_while()375 fn take_while() {
376     let it = convert(vec![0, 1, 2, 3, 0].into_iter().map(Ok::<i32, ()>));
377     assert_eq!(
378         it.clone().take_while(|x| Ok(*x < 0)).collect::<Vec<_>>(),
379         Ok(vec![])
380     );
381     assert_eq!(
382         it.clone().take_while(|x| Ok(*x < 2)).collect::<Vec<_>>(),
383         Ok(vec![0, 1])
384     );
385     assert_eq!(
386         it.take_while(|x| Ok(*x < 4)).collect::<Vec<_>>(),
387         Ok(vec![0, 1, 2, 3, 0])
388     );
389 }
390 
391 #[test]
flat_map()392 fn flat_map() {
393     let it = convert(vec![0..1, 0..0, 1..5].into_iter().map(Ok::<Range<i32>, ()>))
394         .flat_map(|r| Ok(convert(r.map(Ok::<i32, ()>))));
395     assert_eq!(it.collect::<Vec<_>>(), Ok(vec![0, 1, 2, 3, 4]));
396 }
397 
398 #[test]
flatten()399 fn flatten() {
400     let it = convert(
401         vec![0..1, 0..0, 1..5]
402             .into_iter()
403             .map(|r| convert(r.map(Ok::<i32, ()>)))
404             .map(Ok::<_, ()>),
405     )
406     .flatten();
407     assert_eq!(it.collect::<Vec<_>>(), Ok(vec![0, 1, 2, 3, 4]));
408 }
409 
410 #[test]
inspect()411 fn inspect() {
412     let mut buf = vec![];
413     let it = convert(vec![0, 1, 2, 3].into_iter().map(Ok::<i32, ()>)).inspect(|&v| {
414         buf.push(v);
415         Ok(())
416     });
417     it.count().unwrap();
418     assert_eq!(buf, vec![0, 1, 2, 3]);
419 }
420 
421 #[test]
partition()422 fn partition() {
423     let it = convert(vec![0, 1, 2, 3].into_iter().map(Ok::<i32, ()>));
424     let (even, odd): (Vec<i32>, Vec<i32>) = it.partition(|i| Ok(*i % 2 == 0)).unwrap();
425     assert_eq!(even, vec![0, 2]);
426     assert_eq!(odd, vec![1, 3]);
427 }
428 
429 #[test]
find_map()430 fn find_map() {
431     let mut it = convert(vec![0, 1, 2, 3].into_iter().map(Ok::<i32, ()>));
432     assert_eq!(
433         it.find_map(|v| match v {
434             2 => Ok(Some("hi")),
435             _ => Ok(None),
436         }),
437         Ok(Some("hi"))
438     );
439 }
440 
441 #[test]
unzip()442 fn unzip() {
443     let it = convert(
444         vec![(0, 0), (1, -1), (2, -2), (3, -3)]
445             .into_iter()
446             .map(Ok::<_, ()>),
447     );
448     let (pos, neg): (Vec<i32>, Vec<i32>) = it.unzip().unwrap();
449     assert_eq!(pos, vec![0, 1, 2, 3]);
450     assert_eq!(neg, vec![0, -1, -2, -3]);
451 }
452 
453 #[test]
cycle()454 fn cycle() {
455     let it = convert(vec![0, 1, 2, 3].into_iter().map(Ok::<i32, ()>)).cycle();
456     assert_eq!(it.take(6).collect::<Vec<_>>(), Ok(vec![0, 1, 2, 3, 0, 1]));
457 }
458 
459 #[test]
unwrap()460 fn unwrap() {
461     let it = convert(vec![0, 1, 2, 3].into_iter().map(Ok::<i32, ()>)).unwrap();
462     assert_eq!(it.collect::<Vec<_>>(), vec![0, 1, 2, 3]);
463 }
464 
465 #[test]
466 #[should_panic]
unwrap_panic()467 fn unwrap_panic() {
468     let _ = convert(vec![Ok(0), Err(())].into_iter())
469         .unwrap()
470         .collect::<Vec<_>>();
471 }
472 
473 #[test]
wrap_std_iter_into_fallible()474 fn wrap_std_iter_into_fallible() {
475     let it = IntoFallible::from(vec![0, 1, 2, 3].into_iter());
476     assert_eq!(it.collect::<Vec<_>>().unwrap(), vec![0, 1, 2, 3]);
477 }
478