1 // ignore-tidy-filelength
4 use core
::convert
::TryFrom
;
9 let empty
: [isize; 0] = [];
13 assert
!(!xs
.iter().lt(ys
.iter()));
14 assert
!(!xs
.iter().le(ys
.iter()));
15 assert
!(xs
.iter().gt(ys
.iter()));
16 assert
!(xs
.iter().ge(ys
.iter()));
18 assert
!(ys
.iter().lt(xs
.iter()));
19 assert
!(ys
.iter().le(xs
.iter()));
20 assert
!(!ys
.iter().gt(xs
.iter()));
21 assert
!(!ys
.iter().ge(xs
.iter()));
23 assert
!(empty
.iter().lt(xs
.iter()));
24 assert
!(empty
.iter().le(xs
.iter()));
25 assert
!(!empty
.iter().gt(xs
.iter()));
26 assert
!(!empty
.iter().ge(xs
.iter()));
29 let u
= [1.0f64, 2.0];
30 let v
= [0.0f64 / 0.0, 3.0];
32 assert
!(!u
.iter().lt(v
.iter()));
33 assert
!(!u
.iter().le(v
.iter()));
34 assert
!(!u
.iter().gt(v
.iter()));
35 assert
!(!u
.iter().ge(v
.iter()));
37 let a
= [0.0f64 / 0.0];
41 assert
!(a
.iter().lt(b
.iter()) == (a
[0] < b
[0]));
42 assert
!(a
.iter().le(b
.iter()) == (a
[0] <= b
[0]));
43 assert
!(a
.iter().gt(b
.iter()) == (a
[0] > b
[0]));
44 assert
!(a
.iter().ge(b
.iter()) == (a
[0] >= b
[0]));
46 assert
!(c
.iter().lt(b
.iter()) == (c
[0] < b
[0]));
47 assert
!(c
.iter().le(b
.iter()) == (c
[0] <= b
[0]));
48 assert
!(c
.iter().gt(b
.iter()) == (c
[0] > b
[0]));
49 assert
!(c
.iter().ge(b
.iter()) == (c
[0] >= b
[0]));
53 fn test_multi_iter() {
54 let xs
= [1, 2, 3, 4];
55 let ys
= [4, 3, 2, 1];
56 assert
!(xs
.iter().eq(ys
.iter().rev()));
57 assert
!(xs
.iter().lt(xs
.iter().skip(2)));
62 use core
::cmp
::Ordering
;
64 let f
= |x
: i32, y
: i32| (x
* x
).cmp(&y
);
65 let xs
= || [1, 2, 3, 4].iter().copied();
66 let ys
= || [1, 4, 16].iter().copied();
68 assert_eq
!(xs().cmp_by(ys(), f
), Ordering
::Less
);
69 assert_eq
!(ys().cmp_by(xs(), f
), Ordering
::Greater
);
70 assert_eq
!(xs().cmp_by(xs().map(|x
| x
* x
), f
), Ordering
::Equal
);
71 assert_eq
!(xs().rev().cmp_by(ys().rev(), f
), Ordering
::Greater
);
72 assert_eq
!(xs().cmp_by(ys().rev(), f
), Ordering
::Less
);
73 assert_eq
!(xs().cmp_by(ys().take(2), f
), Ordering
::Greater
);
77 fn test_partial_cmp_by() {
78 use core
::cmp
::Ordering
;
80 let f
= |x
: i32, y
: i32| (x
* x
).partial_cmp(&y
);
81 let xs
= || [1, 2, 3, 4].iter().copied();
82 let ys
= || [1, 4, 16].iter().copied();
84 assert_eq
!(xs().partial_cmp_by(ys(), f
), Some(Ordering
::Less
));
85 assert_eq
!(ys().partial_cmp_by(xs(), f
), Some(Ordering
::Greater
));
86 assert_eq
!(xs().partial_cmp_by(xs().map(|x
| x
* x
), f
), Some(Ordering
::Equal
));
87 assert_eq
!(xs().rev().partial_cmp_by(ys().rev(), f
), Some(Ordering
::Greater
));
88 assert_eq
!(xs().partial_cmp_by(xs().rev(), f
), Some(Ordering
::Less
));
89 assert_eq
!(xs().partial_cmp_by(ys().take(2), f
), Some(Ordering
::Greater
));
91 let f
= |x
: f64, y
: f64| (x
* x
).partial_cmp(&y
);
92 let xs
= || [1.0, 2.0, 3.0, 4.0].iter().copied();
93 let ys
= || [1.0, 4.0, f64::NAN
, 16.0].iter().copied();
95 assert_eq
!(xs().partial_cmp_by(ys(), f
), None
);
96 assert_eq
!(ys().partial_cmp_by(xs(), f
), Some(Ordering
::Greater
));
101 let f
= |x
: i32, y
: i32| x
* x
== y
;
102 let xs
= || [1, 2, 3, 4].iter().copied();
103 let ys
= || [1, 4, 9, 16].iter().copied();
105 assert
!(xs().eq_by(ys(), f
));
106 assert
!(!ys().eq_by(xs(), f
));
107 assert
!(!xs().eq_by(xs(), f
));
108 assert
!(!ys().eq_by(ys(), f
));
110 assert
!(!xs().take(3).eq_by(ys(), f
));
111 assert
!(!xs().eq_by(ys().take(3), f
));
112 assert
!(xs().take(3).eq_by(ys().take(3), f
));
116 fn test_counter_from_iter() {
117 let it
= (0..).step_by(5).take(10);
118 let xs
: Vec
<isize> = FromIterator
::from_iter(it
);
119 assert_eq
!(xs
, [0, 5, 10, 15, 20, 25, 30, 35, 40, 45]);
123 fn test_iterator_chain() {
124 let xs
= [0, 1, 2, 3, 4, 5];
125 let ys
= [30, 40, 50, 60];
126 let expected
= [0, 1, 2, 3, 4, 5, 30, 40, 50, 60];
127 let it
= xs
.iter().chain(&ys
);
130 assert_eq
!(x
, expected
[i
]);
133 assert_eq
!(i
, expected
.len());
135 let ys
= (30..).step_by(10).take(4);
136 let it
= xs
.iter().cloned().chain(ys
);
139 assert_eq
!(x
, expected
[i
]);
142 assert_eq
!(i
, expected
.len());
146 fn test_iterator_chain_nth() {
147 let xs
= [0, 1, 2, 3, 4, 5];
148 let ys
= [30, 40, 50, 60];
150 let expected
= [0, 1, 2, 3, 4, 5, 30, 40, 50, 60];
151 for (i
, x
) in expected
.iter().enumerate() {
152 assert_eq
!(Some(x
), xs
.iter().chain(&ys
).nth(i
));
154 assert_eq
!(zs
.iter().chain(&xs
).nth(0), Some(&0));
156 let mut it
= xs
.iter().chain(&zs
);
157 assert_eq
!(it
.nth(5), Some(&5));
158 assert_eq
!(it
.next(), None
);
162 fn test_iterator_chain_nth_back() {
163 let xs
= [0, 1, 2, 3, 4, 5];
164 let ys
= [30, 40, 50, 60];
166 let expected
= [0, 1, 2, 3, 4, 5, 30, 40, 50, 60];
167 for (i
, x
) in expected
.iter().rev().enumerate() {
168 assert_eq
!(Some(x
), xs
.iter().chain(&ys
).nth_back(i
));
170 assert_eq
!(zs
.iter().chain(&xs
).nth_back(0), Some(&5));
172 let mut it
= xs
.iter().chain(&zs
);
173 assert_eq
!(it
.nth_back(5), Some(&0));
174 assert_eq
!(it
.next(), None
);
178 fn test_iterator_chain_last() {
179 let xs
= [0, 1, 2, 3, 4, 5];
180 let ys
= [30, 40, 50, 60];
182 assert_eq
!(xs
.iter().chain(&ys
).last(), Some(&60));
183 assert_eq
!(zs
.iter().chain(&ys
).last(), Some(&60));
184 assert_eq
!(ys
.iter().chain(&zs
).last(), Some(&60));
185 assert_eq
!(zs
.iter().chain(&zs
).last(), None
);
189 fn test_iterator_chain_count() {
190 let xs
= [0, 1, 2, 3, 4, 5];
191 let ys
= [30, 40, 50, 60];
193 assert_eq
!(xs
.iter().chain(&ys
).count(), 10);
194 assert_eq
!(zs
.iter().chain(&ys
).count(), 4);
198 fn test_iterator_chain_find() {
199 let xs
= [0, 1, 2, 3, 4, 5];
200 let ys
= [30, 40, 50, 60];
201 let mut iter
= xs
.iter().chain(&ys
);
202 assert_eq
!(iter
.find(|&&i
| i
== 4), Some(&4));
203 assert_eq
!(iter
.next(), Some(&5));
204 assert_eq
!(iter
.find(|&&i
| i
== 40), Some(&40));
205 assert_eq
!(iter
.next(), Some(&50));
206 assert_eq
!(iter
.find(|&&i
| i
== 100), None
);
207 assert_eq
!(iter
.next(), None
);
214 impl Iterator
for Toggle
{
217 // alternates between `None` and `Some(())`
218 fn next(&mut self) -> Option
<Self::Item
> {
220 self.is_empty
= false;
223 self.is_empty
= true;
228 fn size_hint(&self) -> (usize, Option
<usize>) {
229 if self.is_empty { (0, Some(0)) }
else { (1, Some(1)) }
233 impl DoubleEndedIterator
for Toggle
{
234 fn next_back(&mut self) -> Option
<Self::Item
> {
240 fn test_iterator_chain_size_hint() {
241 // this chains an iterator of length 0 with an iterator of length 1,
242 // so after calling `.next()` once, the iterator is empty and the
243 // state is `ChainState::Back`. `.size_hint()` should now disregard
244 // the size hint of the left iterator
245 let mut iter
= Toggle { is_empty: true }
.chain(once(()));
246 assert_eq
!(iter
.next(), Some(()));
247 assert_eq
!(iter
.size_hint(), (0, Some(0)));
249 let mut iter
= once(()).chain(Toggle { is_empty: true }
);
250 assert_eq
!(iter
.next_back(), Some(()));
251 assert_eq
!(iter
.size_hint(), (0, Some(0)));
255 fn test_iterator_chain_unfused() {
256 // Chain shouldn't be fused in its second iterator, depending on direction
257 let mut iter
= NonFused
::new(empty()).chain(Toggle { is_empty: true }
);
258 iter
.next().unwrap_none();
259 iter
.next().unwrap();
260 iter
.next().unwrap_none();
262 let mut iter
= Toggle { is_empty: true }
.chain(NonFused
::new(empty()));
263 iter
.next_back().unwrap_none();
264 iter
.next_back().unwrap();
265 iter
.next_back().unwrap_none();
270 let xs
= [0, 1, 2, 4, 5];
271 let ys
= [10, 11, 12];
273 let mut it
= xs
.iter().zip(&ys
);
274 assert_eq
!(it
.nth(0), Some((&0, &10)));
275 assert_eq
!(it
.nth(1), Some((&2, &12)));
276 assert_eq
!(it
.nth(0), None
);
278 let mut it
= xs
.iter().zip(&ys
);
279 assert_eq
!(it
.nth(3), None
);
281 let mut it
= ys
.iter().zip(&xs
);
282 assert_eq
!(it
.nth(3), None
);
286 fn test_zip_nth_side_effects() {
287 let mut a
= Vec
::new();
288 let mut b
= Vec
::new();
289 let value
= [1, 2, 3, 4, 5, 6]
296 .zip([2, 3, 4, 5, 6, 7, 8].iter().cloned().map(|n
| {
302 assert_eq
!(value
, Some((50, 6000)));
303 assert_eq
!(a
, vec
![1, 2, 3, 4, 5]);
304 assert_eq
!(b
, vec
![200, 300, 400, 500, 600]);
308 fn test_zip_next_back_side_effects() {
309 let mut a
= Vec
::new();
310 let mut b
= Vec
::new();
311 let mut iter
= [1, 2, 3, 4, 5, 6]
318 .zip([2, 3, 4, 5, 6, 7, 8].iter().cloned().map(|n
| {
323 // The second iterator is one item longer, so `next_back` is called on it
325 assert_eq
!(iter
.next_back(), Some((60, 7000)));
326 assert_eq
!(iter
.next_back(), Some((50, 6000)));
327 assert_eq
!(iter
.next_back(), Some((40, 5000)));
328 assert_eq
!(iter
.next_back(), Some((30, 4000)));
329 assert_eq
!(a
, vec
![6, 5, 4, 3]);
330 assert_eq
!(b
, vec
![800, 700, 600, 500, 400]);
334 fn test_zip_nth_back_side_effects() {
335 let mut a
= Vec
::new();
336 let mut b
= Vec
::new();
337 let value
= [1, 2, 3, 4, 5, 6]
344 .zip([2, 3, 4, 5, 6, 7, 8].iter().cloned().map(|n
| {
349 assert_eq
!(value
, Some((30, 4000)));
350 assert_eq
!(a
, vec
![6, 5, 4, 3]);
351 assert_eq
!(b
, vec
![800, 700, 600, 500, 400]);
355 fn test_zip_next_back_side_effects_exhausted() {
356 let mut a
= Vec
::new();
357 let mut b
= Vec
::new();
358 let mut iter
= [1, 2, 3, 4, 5, 6]
365 .zip([2, 3, 4].iter().cloned().map(|n
| {
374 assert_eq
!(iter
.next_back(), None
);
375 assert_eq
!(a
, vec
![1, 2, 3, 4, 6, 5]);
376 assert_eq
!(b
, vec
![200, 300, 400]);
380 struct CountClone(Cell
<i32>);
382 fn count_clone() -> CountClone
{
383 CountClone(Cell
::new(0))
386 impl PartialEq
<i32> for CountClone
{
387 fn eq(&self, rhs
: &i32) -> bool
{
392 impl Clone
for CountClone
{
393 fn clone(&self) -> Self {
394 let ret
= CountClone(self.0.clone());
395 let n
= self.0.get();
402 fn test_zip_cloned_sideffectful() {
403 let xs
= [count_clone(), count_clone(), count_clone(), count_clone()];
404 let ys
= [count_clone(), count_clone()];
406 for _
in xs
.iter().cloned().zip(ys
.iter().cloned()) {}
408 assert_eq
!(&xs
, &[1, 1, 1, 0][..]);
409 assert_eq
!(&ys
, &[1, 1][..]);
411 let xs
= [count_clone(), count_clone()];
412 let ys
= [count_clone(), count_clone(), count_clone(), count_clone()];
414 for _
in xs
.iter().cloned().zip(ys
.iter().cloned()) {}
416 assert_eq
!(&xs
, &[1, 1][..]);
417 assert_eq
!(&ys
, &[1, 1, 0, 0][..]);
421 fn test_zip_map_sideffectful() {
425 for _
in xs
.iter_mut().map(|x
| *x
+= 1).zip(ys
.iter_mut().map(|y
| *y
+= 1)) {}
427 assert_eq
!(&xs
, &[1, 1, 1, 1, 1, 0]);
428 assert_eq
!(&ys
, &[1, 1, 1, 1]);
433 for _
in xs
.iter_mut().map(|x
| *x
+= 1).zip(ys
.iter_mut().map(|y
| *y
+= 1)) {}
435 assert_eq
!(&xs
, &[1, 1, 1, 1]);
436 assert_eq
!(&ys
, &[1, 1, 1, 1, 0, 0]);
440 fn test_zip_map_rev_sideffectful() {
445 let mut it
= xs
.iter_mut().map(|x
| *x
+= 1).zip(ys
.iter_mut().map(|y
| *y
+= 1));
448 assert_eq
!(&xs
, &[0, 0, 0, 1, 1, 1]);
449 assert_eq
!(&ys
, &[0, 0, 0, 1]);
455 let mut it
= xs
.iter_mut().map(|x
| *x
+= 1).zip(ys
.iter_mut().map(|y
| *y
+= 1));
456 (&mut it
).take(5).count();
459 assert_eq
!(&xs
, &[1, 1, 1, 1, 1, 1]);
460 assert_eq
!(&ys
, &[1, 1, 1, 1]);
464 fn test_zip_nested_sideffectful() {
469 // test that it has the side effect nested inside enumerate
470 let it
= xs
.iter_mut().map(|x
| *x
= 1).enumerate().zip(&ys
);
473 assert_eq
!(&xs
, &[1, 1, 1, 1, 1, 0]);
477 fn test_zip_nth_back_side_effects_exhausted() {
478 let mut a
= Vec
::new();
479 let mut b
= Vec
::new();
480 let mut iter
= [1, 2, 3, 4, 5, 6]
487 .zip([2, 3, 4].iter().cloned().map(|n
| {
496 assert_eq
!(iter
.nth_back(0), None
);
497 assert_eq
!(a
, vec
![1, 2, 3, 4, 6, 5]);
498 assert_eq
!(b
, vec
![200, 300, 400]);
502 fn test_iterator_step_by() {
504 let mut it
= (0..).step_by(1).take(3);
505 assert_eq
!(it
.next(), Some(0));
506 assert_eq
!(it
.next(), Some(1));
507 assert_eq
!(it
.next(), Some(2));
508 assert_eq
!(it
.next(), None
);
510 let mut it
= (0..).step_by(3).take(4);
511 assert_eq
!(it
.next(), Some(0));
512 assert_eq
!(it
.next(), Some(3));
513 assert_eq
!(it
.next(), Some(6));
514 assert_eq
!(it
.next(), Some(9));
515 assert_eq
!(it
.next(), None
);
517 let mut it
= (0..3).step_by(1);
518 assert_eq
!(it
.next_back(), Some(2));
519 assert_eq
!(it
.next_back(), Some(1));
520 assert_eq
!(it
.next_back(), Some(0));
521 assert_eq
!(it
.next_back(), None
);
523 let mut it
= (0..11).step_by(3);
524 assert_eq
!(it
.next_back(), Some(9));
525 assert_eq
!(it
.next_back(), Some(6));
526 assert_eq
!(it
.next_back(), Some(3));
527 assert_eq
!(it
.next_back(), Some(0));
528 assert_eq
!(it
.next_back(), None
);
532 fn test_iterator_step_by_nth() {
533 let mut it
= (0..16).step_by(5);
534 assert_eq
!(it
.nth(0), Some(0));
535 assert_eq
!(it
.nth(0), Some(5));
536 assert_eq
!(it
.nth(0), Some(10));
537 assert_eq
!(it
.nth(0), Some(15));
538 assert_eq
!(it
.nth(0), None
);
540 let it
= (0..18).step_by(5);
541 assert_eq
!(it
.clone().nth(0), Some(0));
542 assert_eq
!(it
.clone().nth(1), Some(5));
543 assert_eq
!(it
.clone().nth(2), Some(10));
544 assert_eq
!(it
.clone().nth(3), Some(15));
545 assert_eq
!(it
.clone().nth(4), None
);
546 assert_eq
!(it
.clone().nth(42), None
);
550 fn test_iterator_step_by_nth_overflow() {
551 #[cfg(target_pointer_width = "8")]
553 #[cfg(target_pointer_width = "16")]
555 #[cfg(target_pointer_width = "32")]
557 #[cfg(target_pointer_width = "64")]
562 impl Iterator
for &mut Test
{
564 fn next(&mut self) -> Option
<Self::Item
> {
567 fn nth(&mut self, n
: usize) -> Option
<Self::Item
> {
568 self.0 += n
as Bigger
+ 1;
573 let mut it
= Test(0);
574 let root
= usize::MAX
>> (usize::BITS
/ 2);
576 (&mut it
).step_by(n
).nth(n
);
577 assert_eq
!(it
.0, n
as Bigger
* n
as Bigger
);
580 let mut it
= Test(0);
581 (&mut it
).step_by(usize::MAX
).nth(5);
582 assert_eq
!(it
.0, (usize::MAX
as Bigger
) * 5);
585 let mut it
= Test(0);
586 (&mut it
).step_by(2).nth(usize::MAX
);
587 assert_eq
!(it
.0, (usize::MAX
as Bigger
) * 2);
590 let mut it
= Test(0);
591 (&mut it
).step_by(1).nth(usize::MAX
);
592 assert_eq
!(it
.0, (usize::MAX
as Bigger
) * 1);
596 fn test_iterator_step_by_nth_try_fold() {
597 let mut it
= (0..).step_by(10);
598 assert_eq
!(it
.try_fold(0, i8::checked_add
), None
);
599 assert_eq
!(it
.next(), Some(60));
600 assert_eq
!(it
.try_fold(0, i8::checked_add
), None
);
601 assert_eq
!(it
.next(), Some(90));
603 let mut it
= (100..).step_by(10);
604 assert_eq
!(it
.try_fold(50, i8::checked_add
), None
);
605 assert_eq
!(it
.next(), Some(110));
607 let mut it
= (100..=100).step_by(10);
608 assert_eq
!(it
.next(), Some(100));
609 assert_eq
!(it
.try_fold(0, i8::checked_add
), Some(0));
613 fn test_iterator_step_by_nth_back() {
614 let mut it
= (0..16).step_by(5);
615 assert_eq
!(it
.nth_back(0), Some(15));
616 assert_eq
!(it
.nth_back(0), Some(10));
617 assert_eq
!(it
.nth_back(0), Some(5));
618 assert_eq
!(it
.nth_back(0), Some(0));
619 assert_eq
!(it
.nth_back(0), None
);
621 let mut it
= (0..16).step_by(5);
622 assert_eq
!(it
.next(), Some(0)); // to set `first_take` to `false`
623 assert_eq
!(it
.nth_back(0), Some(15));
624 assert_eq
!(it
.nth_back(0), Some(10));
625 assert_eq
!(it
.nth_back(0), Some(5));
626 assert_eq
!(it
.nth_back(0), None
);
628 let it
= || (0..18).step_by(5);
629 assert_eq
!(it().nth_back(0), Some(15));
630 assert_eq
!(it().nth_back(1), Some(10));
631 assert_eq
!(it().nth_back(2), Some(5));
632 assert_eq
!(it().nth_back(3), Some(0));
633 assert_eq
!(it().nth_back(4), None
);
634 assert_eq
!(it().nth_back(42), None
);
638 fn test_iterator_step_by_nth_try_rfold() {
639 let mut it
= (0..100).step_by(10);
640 assert_eq
!(it
.try_rfold(0, i8::checked_add
), None
);
641 assert_eq
!(it
.next_back(), Some(70));
642 assert_eq
!(it
.next(), Some(0));
643 assert_eq
!(it
.try_rfold(0, i8::checked_add
), None
);
644 assert_eq
!(it
.next_back(), Some(30));
646 let mut it
= (0..100).step_by(10);
647 assert_eq
!(it
.try_rfold(50, i8::checked_add
), None
);
648 assert_eq
!(it
.next_back(), Some(80));
650 let mut it
= (100..=100).step_by(10);
651 assert_eq
!(it
.next_back(), Some(100));
652 assert_eq
!(it
.try_fold(0, i8::checked_add
), Some(0));
657 fn test_iterator_step_by_zero() {
658 let mut it
= (0..).step_by(0);
663 fn test_iterator_step_by_size_hint() {
664 struct StubSizeHint(usize, Option
<usize>);
665 impl Iterator
for StubSizeHint
{
667 fn next(&mut self) -> Option
<()> {
669 if let Some(ref mut upper
) = self.1 {
674 fn size_hint(&self) -> (usize, Option
<usize>) {
679 // The two checks in each case are needed because the logic
680 // is different before the first call to `next()`.
682 let mut it
= StubSizeHint(10, Some(10)).step_by(1);
683 assert_eq
!(it
.size_hint(), (10, Some(10)));
685 assert_eq
!(it
.size_hint(), (9, Some(9)));
688 let mut it
= StubSizeHint(10, Some(10)).step_by(3);
689 assert_eq
!(it
.size_hint(), (4, Some(4)));
691 assert_eq
!(it
.size_hint(), (3, Some(3)));
693 // larger base range, but not enough to get another element
694 let mut it
= StubSizeHint(12, Some(12)).step_by(3);
695 assert_eq
!(it
.size_hint(), (4, Some(4)));
697 assert_eq
!(it
.size_hint(), (3, Some(3)));
699 // smaller base range, so fewer resulting elements
700 let mut it
= StubSizeHint(9, Some(9)).step_by(3);
701 assert_eq
!(it
.size_hint(), (3, Some(3)));
703 assert_eq
!(it
.size_hint(), (2, Some(2)));
705 // infinite upper bound
706 let mut it
= StubSizeHint(usize::MAX
, None
).step_by(1);
707 assert_eq
!(it
.size_hint(), (usize::MAX
, None
));
709 assert_eq
!(it
.size_hint(), (usize::MAX
- 1, None
));
711 // still infinite with larger step
712 let mut it
= StubSizeHint(7, None
).step_by(3);
713 assert_eq
!(it
.size_hint(), (3, None
));
715 assert_eq
!(it
.size_hint(), (2, None
));
717 // propagates ExactSizeIterator
718 let a
= [1, 2, 3, 4, 5];
719 let it
= a
.iter().step_by(2);
720 assert_eq
!(it
.len(), 3);
722 // Cannot be TrustedLen as a step greater than one makes an iterator
723 // with (usize::MAX, None) no longer meet the safety requirements
724 trait TrustedLenCheck
{
725 fn test(self) -> bool
;
727 impl<T
: Iterator
> TrustedLenCheck
for T
{
728 default fn test(self) -> bool
{
732 impl<T
: TrustedLen
> TrustedLenCheck
for T
{
733 fn test(self) -> bool
{
737 assert
!(TrustedLenCheck
::test(a
.iter()));
738 assert
!(!TrustedLenCheck
::test(a
.iter().step_by(1)));
742 fn test_filter_map() {
743 let it
= (0..).step_by(1).take(10).filter_map(|x
| if x
% 2 == 0 { Some(x * x) }
else { None }
);
744 assert_eq
!(it
.collect
::<Vec
<usize>>(), [0 * 0, 2 * 2, 4 * 4, 6 * 6, 8 * 8]);
748 fn test_filter_map_fold() {
749 let xs
= [0, 1, 2, 3, 4, 5, 6, 7, 8];
750 let ys
= [0 * 0, 2 * 2, 4 * 4, 6 * 6, 8 * 8];
751 let it
= xs
.iter().filter_map(|&x
| if x
% 2 == 0 { Some(x * x) }
else { None }
);
752 let i
= it
.fold(0, |i
, x
| {
753 assert_eq
!(x
, ys
[i
]);
756 assert_eq
!(i
, ys
.len());
758 let it
= xs
.iter().filter_map(|&x
| if x
% 2 == 0 { Some(x * x) }
else { None }
);
759 let i
= it
.rfold(ys
.len(), |i
, x
| {
760 assert_eq
!(x
, ys
[i
- 1]);
767 fn test_iterator_enumerate() {
768 let xs
= [0, 1, 2, 3, 4, 5];
769 let it
= xs
.iter().enumerate();
776 fn test_iterator_enumerate_nth() {
777 let xs
= [0, 1, 2, 3, 4, 5];
778 for (i
, &x
) in xs
.iter().enumerate() {
782 let mut it
= xs
.iter().enumerate();
783 while let Some((i
, &x
)) = it
.nth(0) {
787 let mut it
= xs
.iter().enumerate();
788 while let Some((i
, &x
)) = it
.nth(1) {
792 let (i
, &x
) = xs
.iter().enumerate().nth(3).unwrap();
798 fn test_iterator_enumerate_nth_back() {
799 let xs
= [0, 1, 2, 3, 4, 5];
800 let mut it
= xs
.iter().enumerate();
801 while let Some((i
, &x
)) = it
.nth_back(0) {
805 let mut it
= xs
.iter().enumerate();
806 while let Some((i
, &x
)) = it
.nth_back(1) {
810 let (i
, &x
) = xs
.iter().enumerate().nth_back(3).unwrap();
816 fn test_iterator_enumerate_count() {
817 let xs
= [0, 1, 2, 3, 4, 5];
818 assert_eq
!(xs
.iter().enumerate().count(), 6);
822 fn test_iterator_enumerate_fold() {
823 let xs
= [0, 1, 2, 3, 4, 5];
824 let mut it
= xs
.iter().enumerate();
825 // steal a couple to get an interesting offset
826 assert_eq
!(it
.next(), Some((0, &0)));
827 assert_eq
!(it
.next(), Some((1, &1)));
828 let i
= it
.fold(2, |i
, (j
, &x
)| {
830 assert_eq
!(x
, xs
[j
]);
833 assert_eq
!(i
, xs
.len());
835 let mut it
= xs
.iter().enumerate();
836 assert_eq
!(it
.next(), Some((0, &0)));
837 let i
= it
.rfold(xs
.len() - 1, |i
, (j
, &x
)| {
839 assert_eq
!(x
, xs
[j
]);
846 fn test_iterator_filter_count() {
847 let xs
= [0, 1, 2, 3, 4, 5, 6, 7, 8];
848 assert_eq
!(xs
.iter().filter(|&&x
| x
% 2 == 0).count(), 5);
852 fn test_iterator_filter_fold() {
853 let xs
= [0, 1, 2, 3, 4, 5, 6, 7, 8];
854 let ys
= [0, 2, 4, 6, 8];
855 let it
= xs
.iter().filter(|&&x
| x
% 2 == 0);
856 let i
= it
.fold(0, |i
, &x
| {
857 assert_eq
!(x
, ys
[i
]);
860 assert_eq
!(i
, ys
.len());
862 let it
= xs
.iter().filter(|&&x
| x
% 2 == 0);
863 let i
= it
.rfold(ys
.len(), |i
, &x
| {
864 assert_eq
!(x
, ys
[i
- 1]);
871 fn test_iterator_peekable() {
872 let xs
= vec
![0, 1, 2, 3, 4, 5];
874 let mut it
= xs
.iter().cloned().peekable();
875 assert_eq
!(it
.len(), 6);
876 assert_eq
!(it
.peek().unwrap(), &0);
877 assert_eq
!(it
.len(), 6);
878 assert_eq
!(it
.next().unwrap(), 0);
879 assert_eq
!(it
.len(), 5);
880 assert_eq
!(it
.next().unwrap(), 1);
881 assert_eq
!(it
.len(), 4);
882 assert_eq
!(it
.next().unwrap(), 2);
883 assert_eq
!(it
.len(), 3);
884 assert_eq
!(it
.peek().unwrap(), &3);
885 assert_eq
!(it
.len(), 3);
886 assert_eq
!(it
.peek().unwrap(), &3);
887 assert_eq
!(it
.len(), 3);
888 assert_eq
!(it
.next().unwrap(), 3);
889 assert_eq
!(it
.len(), 2);
890 assert_eq
!(it
.next().unwrap(), 4);
891 assert_eq
!(it
.len(), 1);
892 assert_eq
!(it
.peek().unwrap(), &5);
893 assert_eq
!(it
.len(), 1);
894 assert_eq
!(it
.next().unwrap(), 5);
895 assert_eq
!(it
.len(), 0);
896 assert
!(it
.peek().is_none());
897 assert_eq
!(it
.len(), 0);
898 assert
!(it
.next().is_none());
899 assert_eq
!(it
.len(), 0);
901 let mut it
= xs
.iter().cloned().peekable();
902 assert_eq
!(it
.len(), 6);
903 assert_eq
!(it
.peek().unwrap(), &0);
904 assert_eq
!(it
.len(), 6);
905 assert_eq
!(it
.next_back().unwrap(), 5);
906 assert_eq
!(it
.len(), 5);
907 assert_eq
!(it
.next_back().unwrap(), 4);
908 assert_eq
!(it
.len(), 4);
909 assert_eq
!(it
.next_back().unwrap(), 3);
910 assert_eq
!(it
.len(), 3);
911 assert_eq
!(it
.peek().unwrap(), &0);
912 assert_eq
!(it
.len(), 3);
913 assert_eq
!(it
.peek().unwrap(), &0);
914 assert_eq
!(it
.len(), 3);
915 assert_eq
!(it
.next_back().unwrap(), 2);
916 assert_eq
!(it
.len(), 2);
917 assert_eq
!(it
.next_back().unwrap(), 1);
918 assert_eq
!(it
.len(), 1);
919 assert_eq
!(it
.peek().unwrap(), &0);
920 assert_eq
!(it
.len(), 1);
921 assert_eq
!(it
.next_back().unwrap(), 0);
922 assert_eq
!(it
.len(), 0);
923 assert
!(it
.peek().is_none());
924 assert_eq
!(it
.len(), 0);
925 assert
!(it
.next_back().is_none());
926 assert_eq
!(it
.len(), 0);
930 fn test_iterator_peekable_count() {
931 let xs
= [0, 1, 2, 3, 4, 5];
933 let zs
: [i32; 0] = [];
935 assert_eq
!(xs
.iter().peekable().count(), 6);
937 let mut it
= xs
.iter().peekable();
938 assert_eq
!(it
.peek(), Some(&&0));
939 assert_eq
!(it
.count(), 6);
941 assert_eq
!(ys
.iter().peekable().count(), 1);
943 let mut it
= ys
.iter().peekable();
944 assert_eq
!(it
.peek(), Some(&&10));
945 assert_eq
!(it
.count(), 1);
947 assert_eq
!(zs
.iter().peekable().count(), 0);
949 let mut it
= zs
.iter().peekable();
950 assert_eq
!(it
.peek(), None
);
954 fn test_iterator_peekable_nth() {
955 let xs
= [0, 1, 2, 3, 4, 5];
956 let mut it
= xs
.iter().peekable();
958 assert_eq
!(it
.peek(), Some(&&0));
959 assert_eq
!(it
.nth(0), Some(&0));
960 assert_eq
!(it
.peek(), Some(&&1));
961 assert_eq
!(it
.nth(1), Some(&2));
962 assert_eq
!(it
.peek(), Some(&&3));
963 assert_eq
!(it
.nth(2), Some(&5));
964 assert_eq
!(it
.next(), None
);
968 fn test_iterator_peekable_last() {
969 let xs
= [0, 1, 2, 3, 4, 5];
972 let mut it
= xs
.iter().peekable();
973 assert_eq
!(it
.peek(), Some(&&0));
974 assert_eq
!(it
.last(), Some(&5));
976 let mut it
= ys
.iter().peekable();
977 assert_eq
!(it
.peek(), Some(&&0));
978 assert_eq
!(it
.last(), Some(&0));
980 let mut it
= ys
.iter().peekable();
981 assert_eq
!(it
.next(), Some(&0));
982 assert_eq
!(it
.peek(), None
);
983 assert_eq
!(it
.last(), None
);
987 fn test_iterator_peekable_fold() {
988 let xs
= [0, 1, 2, 3, 4, 5];
989 let mut it
= xs
.iter().peekable();
990 assert_eq
!(it
.peek(), Some(&&0));
991 let i
= it
.fold(0, |i
, &x
| {
992 assert_eq
!(x
, xs
[i
]);
995 assert_eq
!(i
, xs
.len());
999 fn test_iterator_peekable_rfold() {
1000 let xs
= [0, 1, 2, 3, 4, 5];
1001 let mut it
= xs
.iter().peekable();
1002 assert_eq
!(it
.peek(), Some(&&0));
1003 let i
= it
.rfold(0, |i
, &x
| {
1004 assert_eq
!(x
, xs
[xs
.len() - 1 - i
]);
1007 assert_eq
!(i
, xs
.len());
1011 fn test_iterator_peekable_next_if_eq() {
1012 // first, try on references
1013 let xs
= vec
!["Heart", "of", "Gold"];
1014 let mut it
= xs
.into_iter().peekable();
1015 // try before `peek()`
1016 assert_eq
!(it
.next_if_eq(&"trillian"), None
);
1017 assert_eq
!(it
.next_if_eq(&"Heart"), Some("Heart"));
1019 assert_eq
!(it
.peek(), Some(&"of"));
1020 assert_eq
!(it
.next_if_eq(&"of"), Some("of"));
1021 assert_eq
!(it
.next_if_eq(&"zaphod"), None
);
1022 // make sure `next()` still behaves
1023 assert_eq
!(it
.next(), Some("Gold"));
1025 // make sure comparison works for owned values
1026 let xs
= vec
![String
::from("Ludicrous"), "speed".into()];
1027 let mut it
= xs
.into_iter().peekable();
1028 // make sure basic functionality works
1029 assert_eq
!(it
.next_if_eq("Ludicrous"), Some("Ludicrous".into()));
1030 assert_eq
!(it
.next_if_eq("speed"), Some("speed".into()));
1031 assert_eq
!(it
.next_if_eq(""), None
);
1034 /// This is an iterator that follows the Iterator contract,
1035 /// but it is not fused. After having returned None once, it will start
1036 /// producing elements if .next() is called again.
1037 pub struct CycleIter
<'a
, T
> {
1042 pub fn cycle
<T
>(data
: &[T
]) -> CycleIter
<'_
, T
> {
1043 CycleIter { index: 0, data }
1046 impl<'a
, T
> Iterator
for CycleIter
<'a
, T
> {
1048 fn next(&mut self) -> Option
<Self::Item
> {
1049 let elt
= self.data
.get(self.index
);
1051 self.index
%= 1 + self.data
.len();
1057 fn test_iterator_peekable_remember_peek_none_1() {
1058 // Check that the loop using .peek() terminates
1059 let data
= [1, 2, 3];
1060 let mut iter
= cycle(&data
).peekable();
1063 while let Some(_
) = iter
.next() {
1064 let is_the_last
= iter
.peek().is_none();
1065 assert_eq
!(is_the_last
, n
== data
.len() - 1);
1071 assert_eq
!(n
, data
.len());
1075 fn test_iterator_peekable_remember_peek_none_2() {
1077 let mut iter
= cycle(&data
).peekable();
1079 assert_eq
!(iter
.peek(), None
);
1080 assert_eq
!(iter
.last(), None
);
1084 fn test_iterator_peekable_remember_peek_none_3() {
1086 let mut iter
= cycle(&data
).peekable();
1088 assert_eq
!(iter
.nth(0), Some(&0));
1090 let mut iter
= cycle(&data
).peekable();
1092 assert_eq
!(iter
.peek(), None
);
1093 assert_eq
!(iter
.nth(0), None
);
1097 fn test_iterator_take_while() {
1098 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19];
1099 let ys
= [0, 1, 2, 3, 5, 13];
1100 let it
= xs
.iter().take_while(|&x
| *x
< 15);
1103 assert_eq
!(*x
, ys
[i
]);
1106 assert_eq
!(i
, ys
.len());
1110 fn test_iterator_skip_while() {
1111 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19];
1112 let ys
= [15, 16, 17, 19];
1113 let it
= xs
.iter().skip_while(|&x
| *x
< 15);
1116 assert_eq
!(*x
, ys
[i
]);
1119 assert_eq
!(i
, ys
.len());
1123 fn test_iterator_skip_while_fold() {
1124 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19];
1125 let ys
= [15, 16, 17, 19];
1126 let it
= xs
.iter().skip_while(|&x
| *x
< 15);
1127 let i
= it
.fold(0, |i
, &x
| {
1128 assert_eq
!(x
, ys
[i
]);
1131 assert_eq
!(i
, ys
.len());
1133 let mut it
= xs
.iter().skip_while(|&x
| *x
< 15);
1134 assert_eq
!(it
.next(), Some(&ys
[0])); // process skips before folding
1135 let i
= it
.fold(1, |i
, &x
| {
1136 assert_eq
!(x
, ys
[i
]);
1139 assert_eq
!(i
, ys
.len());
1143 fn test_iterator_skip() {
1144 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
1145 let ys
= [13, 15, 16, 17, 19, 20, 30];
1146 let mut it
= xs
.iter().skip(5);
1148 while let Some(&x
) = it
.next() {
1149 assert_eq
!(x
, ys
[i
]);
1151 assert_eq
!(it
.len(), xs
.len() - 5 - i
);
1153 assert_eq
!(i
, ys
.len());
1154 assert_eq
!(it
.len(), 0);
1158 fn test_iterator_skip_doubleended() {
1159 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
1160 let mut it
= xs
.iter().rev().skip(5);
1161 assert_eq
!(it
.next(), Some(&15));
1162 assert_eq
!(it
.by_ref().rev().next(), Some(&0));
1163 assert_eq
!(it
.next(), Some(&13));
1164 assert_eq
!(it
.by_ref().rev().next(), Some(&1));
1165 assert_eq
!(it
.next(), Some(&5));
1166 assert_eq
!(it
.by_ref().rev().next(), Some(&2));
1167 assert_eq
!(it
.next(), Some(&3));
1168 assert_eq
!(it
.next(), None
);
1169 let mut it
= xs
.iter().rev().skip(5).rev();
1170 assert_eq
!(it
.next(), Some(&0));
1171 assert_eq
!(it
.rev().next(), Some(&15));
1172 let mut it_base
= xs
.iter();
1174 let mut it
= it_base
.by_ref().skip(5).rev();
1175 assert_eq
!(it
.next(), Some(&30));
1176 assert_eq
!(it
.next(), Some(&20));
1177 assert_eq
!(it
.next(), Some(&19));
1178 assert_eq
!(it
.next(), Some(&17));
1179 assert_eq
!(it
.next(), Some(&16));
1180 assert_eq
!(it
.next(), Some(&15));
1181 assert_eq
!(it
.next(), Some(&13));
1182 assert_eq
!(it
.next(), None
);
1184 // make sure the skipped parts have not been consumed
1185 assert_eq
!(it_base
.next(), Some(&0));
1186 assert_eq
!(it_base
.next(), Some(&1));
1187 assert_eq
!(it_base
.next(), Some(&2));
1188 assert_eq
!(it_base
.next(), Some(&3));
1189 assert_eq
!(it_base
.next(), Some(&5));
1190 assert_eq
!(it_base
.next(), None
);
1191 let it
= xs
.iter().skip(5).rev();
1192 assert_eq
!(it
.last(), Some(&13));
1196 fn test_iterator_skip_nth() {
1197 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
1199 let mut it
= xs
.iter().skip(0);
1200 assert_eq
!(it
.nth(0), Some(&0));
1201 assert_eq
!(it
.nth(1), Some(&2));
1203 let mut it
= xs
.iter().skip(5);
1204 assert_eq
!(it
.nth(0), Some(&13));
1205 assert_eq
!(it
.nth(1), Some(&16));
1207 let mut it
= xs
.iter().skip(12);
1208 assert_eq
!(it
.nth(0), None
);
1212 fn test_iterator_skip_count() {
1213 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
1215 assert_eq
!(xs
.iter().skip(0).count(), 12);
1216 assert_eq
!(xs
.iter().skip(1).count(), 11);
1217 assert_eq
!(xs
.iter().skip(11).count(), 1);
1218 assert_eq
!(xs
.iter().skip(12).count(), 0);
1219 assert_eq
!(xs
.iter().skip(13).count(), 0);
1223 fn test_iterator_skip_last() {
1224 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
1226 assert_eq
!(xs
.iter().skip(0).last(), Some(&30));
1227 assert_eq
!(xs
.iter().skip(1).last(), Some(&30));
1228 assert_eq
!(xs
.iter().skip(11).last(), Some(&30));
1229 assert_eq
!(xs
.iter().skip(12).last(), None
);
1230 assert_eq
!(xs
.iter().skip(13).last(), None
);
1232 let mut it
= xs
.iter().skip(5);
1233 assert_eq
!(it
.next(), Some(&13));
1234 assert_eq
!(it
.last(), Some(&30));
1238 fn test_iterator_skip_fold() {
1239 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
1240 let ys
= [13, 15, 16, 17, 19, 20, 30];
1242 let it
= xs
.iter().skip(5);
1243 let i
= it
.fold(0, |i
, &x
| {
1244 assert_eq
!(x
, ys
[i
]);
1247 assert_eq
!(i
, ys
.len());
1249 let mut it
= xs
.iter().skip(5);
1250 assert_eq
!(it
.next(), Some(&ys
[0])); // process skips before folding
1251 let i
= it
.fold(1, |i
, &x
| {
1252 assert_eq
!(x
, ys
[i
]);
1255 assert_eq
!(i
, ys
.len());
1257 let it
= xs
.iter().skip(5);
1258 let i
= it
.rfold(ys
.len(), |i
, &x
| {
1260 assert_eq
!(x
, ys
[i
]);
1265 let mut it
= xs
.iter().skip(5);
1266 assert_eq
!(it
.next(), Some(&ys
[0])); // process skips before folding
1267 let i
= it
.rfold(ys
.len(), |i
, &x
| {
1269 assert_eq
!(x
, ys
[i
]);
1276 fn test_iterator_take() {
1277 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19];
1278 let ys
= [0, 1, 2, 3, 5];
1280 let mut it
= xs
.iter().take(ys
.len());
1282 assert_eq
!(it
.len(), ys
.len());
1283 while let Some(&x
) = it
.next() {
1284 assert_eq
!(x
, ys
[i
]);
1286 assert_eq
!(it
.len(), ys
.len() - i
);
1288 assert_eq
!(i
, ys
.len());
1289 assert_eq
!(it
.len(), 0);
1291 let mut it
= xs
.iter().take(ys
.len());
1293 assert_eq
!(it
.len(), ys
.len());
1294 while let Some(&x
) = it
.next_back() {
1296 assert_eq
!(x
, ys
[ys
.len() - i
]);
1297 assert_eq
!(it
.len(), ys
.len() - i
);
1299 assert_eq
!(i
, ys
.len());
1300 assert_eq
!(it
.len(), 0);
1304 fn test_iterator_take_nth() {
1305 let xs
= [0, 1, 2, 4, 5];
1306 let mut it
= xs
.iter();
1308 let mut take
= it
.by_ref().take(3);
1310 while let Some(&x
) = take
.nth(0) {
1315 assert_eq
!(it
.nth(1), Some(&5));
1316 assert_eq
!(it
.nth(0), None
);
1318 let xs
= [0, 1, 2, 3, 4];
1319 let mut it
= xs
.iter().take(7);
1321 while let Some(&x
) = it
.nth(1) {
1328 fn test_iterator_take_nth_back() {
1329 let xs
= [0, 1, 2, 4, 5];
1330 let mut it
= xs
.iter();
1332 let mut take
= it
.by_ref().take(3);
1334 while let Some(&x
) = take
.nth_back(0) {
1336 assert_eq
!(x
, 3 - i
);
1339 assert_eq
!(it
.nth_back(0), None
);
1341 let xs
= [0, 1, 2, 3, 4];
1342 let mut it
= xs
.iter().take(7);
1343 assert_eq
!(it
.nth_back(1), Some(&3));
1344 assert_eq
!(it
.nth_back(1), Some(&1));
1345 assert_eq
!(it
.nth_back(1), None
);
1349 fn test_iterator_take_short() {
1350 let xs
= [0, 1, 2, 3];
1352 let mut it
= xs
.iter().take(5);
1354 assert_eq
!(it
.len(), xs
.len());
1355 while let Some(&x
) = it
.next() {
1356 assert_eq
!(x
, xs
[i
]);
1358 assert_eq
!(it
.len(), xs
.len() - i
);
1360 assert_eq
!(i
, xs
.len());
1361 assert_eq
!(it
.len(), 0);
1363 let mut it
= xs
.iter().take(5);
1365 assert_eq
!(it
.len(), xs
.len());
1366 while let Some(&x
) = it
.next_back() {
1368 assert_eq
!(x
, xs
[xs
.len() - i
]);
1369 assert_eq
!(it
.len(), xs
.len() - i
);
1371 assert_eq
!(i
, xs
.len());
1372 assert_eq
!(it
.len(), 0);
1376 fn test_iterator_scan() {
1377 // test the type inference
1378 fn add(old
: &mut isize, new
: &usize) -> Option
<f64> {
1379 *old
+= *new
as isize;
1382 let xs
= [0, 1, 2, 3, 4];
1383 let ys
= [0f64, 1.0, 3.0, 6.0, 10.0];
1385 let it
= xs
.iter().scan(0, add
);
1388 assert_eq
!(x
, ys
[i
]);
1391 assert_eq
!(i
, ys
.len());
1395 fn test_iterator_flat_map() {
1397 let ys
= [0, 1, 2, 3, 4, 5, 6, 7, 8];
1398 let it
= xs
.iter().flat_map(|&x
| (x
..).step_by(1).take(3));
1401 assert_eq
!(x
, ys
[i
]);
1404 assert_eq
!(i
, ys
.len());
1407 /// Tests `FlatMap::fold` with items already picked off the front and back,
1408 /// to make sure all parts of the `FlatMap` are folded correctly.
1410 fn test_iterator_flat_map_fold() {
1412 let ys
= [1, 2, 3, 4, 5, 6, 7];
1413 let mut it
= xs
.iter().flat_map(|&x
| x
..x
+ 3);
1414 assert_eq
!(it
.next(), Some(0));
1415 assert_eq
!(it
.next_back(), Some(8));
1416 let i
= it
.fold(0, |i
, x
| {
1417 assert_eq
!(x
, ys
[i
]);
1420 assert_eq
!(i
, ys
.len());
1422 let mut it
= xs
.iter().flat_map(|&x
| x
..x
+ 3);
1423 assert_eq
!(it
.next(), Some(0));
1424 assert_eq
!(it
.next_back(), Some(8));
1425 let i
= it
.rfold(ys
.len(), |i
, x
| {
1426 assert_eq
!(x
, ys
[i
- 1]);
1433 fn test_iterator_flatten() {
1435 let ys
= [0, 1, 2, 3, 4, 5, 6, 7, 8];
1436 let it
= xs
.iter().map(|&x
| (x
..).step_by(1).take(3)).flatten();
1439 assert_eq
!(x
, ys
[i
]);
1442 assert_eq
!(i
, ys
.len());
1445 /// Tests `Flatten::fold` with items already picked off the front and back,
1446 /// to make sure all parts of the `Flatten` are folded correctly.
1448 fn test_iterator_flatten_fold() {
1450 let ys
= [1, 2, 3, 4, 5, 6, 7];
1451 let mut it
= xs
.iter().map(|&x
| x
..x
+ 3).flatten();
1452 assert_eq
!(it
.next(), Some(0));
1453 assert_eq
!(it
.next_back(), Some(8));
1454 let i
= it
.fold(0, |i
, x
| {
1455 assert_eq
!(x
, ys
[i
]);
1458 assert_eq
!(i
, ys
.len());
1460 let mut it
= xs
.iter().map(|&x
| x
..x
+ 3).flatten();
1461 assert_eq
!(it
.next(), Some(0));
1462 assert_eq
!(it
.next_back(), Some(8));
1463 let i
= it
.rfold(ys
.len(), |i
, x
| {
1464 assert_eq
!(x
, ys
[i
- 1]);
1472 let xs
= [1, 2, 3, 4];
1475 let ys
= xs
.iter().cloned().inspect(|_
| n
+= 1).collect
::<Vec
<usize>>();
1477 assert_eq
!(n
, xs
.len());
1478 assert_eq
!(&xs
[..], &ys
[..]);
1482 fn test_inspect_fold() {
1483 let xs
= [1, 2, 3, 4];
1486 let it
= xs
.iter().inspect(|_
| n
+= 1);
1487 let i
= it
.fold(0, |i
, &x
| {
1488 assert_eq
!(x
, xs
[i
]);
1491 assert_eq
!(i
, xs
.len());
1493 assert_eq
!(n
, xs
.len());
1497 let it
= xs
.iter().inspect(|_
| n
+= 1);
1498 let i
= it
.rfold(xs
.len(), |i
, &x
| {
1499 assert_eq
!(x
, xs
[i
- 1]);
1504 assert_eq
!(n
, xs
.len());
1510 let it
= (0..).step_by(1).take(cycle_len
).cycle();
1511 assert_eq
!(it
.size_hint(), (usize::MAX
, None
));
1512 for (i
, x
) in it
.take(100).enumerate() {
1513 assert_eq
!(i
% cycle_len
, x
);
1516 let mut it
= (0..).step_by(1).take(0).cycle();
1517 assert_eq
!(it
.size_hint(), (0, Some(0)));
1518 assert_eq
!(it
.next(), None
);
1520 assert_eq
!(empty
::<i32>().cycle().fold(0, |acc
, x
| acc
+ x
), 0);
1522 assert_eq
!(once(1).cycle().skip(1).take(4).fold(0, |acc
, x
| acc
+ x
), 4);
1524 assert_eq
!((0..10).cycle().take(5).sum
::<i32>(), 10);
1525 assert_eq
!((0..10).cycle().take(15).sum
::<i32>(), 55);
1526 assert_eq
!((0..10).cycle().take(25).sum
::<i32>(), 100);
1528 let mut iter
= (0..10).cycle();
1530 assert_eq
!(iter
.take(8).sum
::<i32>(), 38);
1532 let mut iter
= (0..10).cycle();
1534 assert_eq
!(iter
.take(3).sum
::<i32>(), 3);
1538 fn test_iterator_nth() {
1539 let v
: &[_
] = &[0, 1, 2, 3, 4];
1540 for i
in 0..v
.len() {
1541 assert_eq
!(v
.iter().nth(i
).unwrap(), &v
[i
]);
1543 assert_eq
!(v
.iter().nth(v
.len()), None
);
1547 fn test_iterator_nth_back() {
1548 let v
: &[_
] = &[0, 1, 2, 3, 4];
1549 for i
in 0..v
.len() {
1550 assert_eq
!(v
.iter().nth_back(i
).unwrap(), &v
[v
.len() - 1 - i
]);
1552 assert_eq
!(v
.iter().nth_back(v
.len()), None
);
1556 fn test_iterator_rev_nth_back() {
1557 let v
: &[_
] = &[0, 1, 2, 3, 4];
1558 for i
in 0..v
.len() {
1559 assert_eq
!(v
.iter().rev().nth_back(i
).unwrap(), &v
[i
]);
1561 assert_eq
!(v
.iter().rev().nth_back(v
.len()), None
);
1565 fn test_iterator_rev_nth() {
1566 let v
: &[_
] = &[0, 1, 2, 3, 4];
1567 for i
in 0..v
.len() {
1568 assert_eq
!(v
.iter().rev().nth(i
).unwrap(), &v
[v
.len() - 1 - i
]);
1570 assert_eq
!(v
.iter().rev().nth(v
.len()), None
);
1574 fn test_iterator_advance_by() {
1575 let v
: &[_
] = &[0, 1, 2, 3, 4];
1577 for i
in 0..v
.len() {
1578 let mut iter
= v
.iter();
1579 assert_eq
!(iter
.advance_by(i
), Ok(()));
1580 assert_eq
!(iter
.next().unwrap(), &v
[i
]);
1581 assert_eq
!(iter
.advance_by(100), Err(v
.len() - 1 - i
));
1584 assert_eq
!(v
.iter().advance_by(v
.len()), Ok(()));
1585 assert_eq
!(v
.iter().advance_by(100), Err(v
.len()));
1589 fn test_iterator_advance_back_by() {
1590 let v
: &[_
] = &[0, 1, 2, 3, 4];
1592 for i
in 0..v
.len() {
1593 let mut iter
= v
.iter();
1594 assert_eq
!(iter
.advance_back_by(i
), Ok(()));
1595 assert_eq
!(iter
.next_back().unwrap(), &v
[v
.len() - 1 - i
]);
1596 assert_eq
!(iter
.advance_back_by(100), Err(v
.len() - 1 - i
));
1599 assert_eq
!(v
.iter().advance_back_by(v
.len()), Ok(()));
1600 assert_eq
!(v
.iter().advance_back_by(100), Err(v
.len()));
1604 fn test_iterator_rev_advance_by() {
1605 let v
: &[_
] = &[0, 1, 2, 3, 4];
1607 for i
in 0..v
.len() {
1608 let mut iter
= v
.iter().rev();
1609 assert_eq
!(iter
.advance_by(i
), Ok(()));
1610 assert_eq
!(iter
.next().unwrap(), &v
[v
.len() - 1 - i
]);
1611 assert_eq
!(iter
.advance_by(100), Err(v
.len() - 1 - i
));
1614 assert_eq
!(v
.iter().rev().advance_by(v
.len()), Ok(()));
1615 assert_eq
!(v
.iter().rev().advance_by(100), Err(v
.len()));
1619 fn test_iterator_rev_advance_back_by() {
1620 let v
: &[_
] = &[0, 1, 2, 3, 4];
1622 for i
in 0..v
.len() {
1623 let mut iter
= v
.iter().rev();
1624 assert_eq
!(iter
.advance_back_by(i
), Ok(()));
1625 assert_eq
!(iter
.next_back().unwrap(), &v
[i
]);
1626 assert_eq
!(iter
.advance_back_by(100), Err(v
.len() - 1 - i
));
1629 assert_eq
!(v
.iter().rev().advance_back_by(v
.len()), Ok(()));
1630 assert_eq
!(v
.iter().rev().advance_back_by(100), Err(v
.len()));
1634 fn test_iterator_last() {
1635 let v
: &[_
] = &[0, 1, 2, 3, 4];
1636 assert_eq
!(v
.iter().last().unwrap(), &4);
1637 assert_eq
!(v
[..1].iter().last().unwrap(), &0);
1641 fn test_iterator_len() {
1642 let v
: &[_
] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1643 assert_eq
!(v
[..4].iter().count(), 4);
1644 assert_eq
!(v
[..10].iter().count(), 10);
1645 assert_eq
!(v
[..0].iter().count(), 0);
1649 fn test_iterator_sum() {
1650 let v
: &[i32] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1651 assert_eq
!(v
[..4].iter().cloned().sum
::<i32>(), 6);
1652 assert_eq
!(v
.iter().cloned().sum
::<i32>(), 55);
1653 assert_eq
!(v
[..0].iter().cloned().sum
::<i32>(), 0);
1657 fn test_iterator_sum_result() {
1658 let v
: &[Result
<i32, ()>] = &[Ok(1), Ok(2), Ok(3), Ok(4)];
1659 assert_eq
!(v
.iter().cloned().sum
::<Result
<i32, _
>>(), Ok(10));
1660 let v
: &[Result
<i32, ()>] = &[Ok(1), Err(()), Ok(3), Ok(4)];
1661 assert_eq
!(v
.iter().cloned().sum
::<Result
<i32, _
>>(), Err(()));
1663 #[derive(PartialEq, Debug)]
1664 struct S(Result
<i32, ()>);
1666 impl Sum
<Result
<i32, ()>> for S
{
1667 fn sum
<I
: Iterator
<Item
= Result
<i32, ()>>>(mut iter
: I
) -> Self {
1668 // takes the sum by repeatedly calling `next` on `iter`,
1669 // thus testing that repeated calls to `ResultShunt::try_fold`
1670 // produce the expected results
1671 Self(iter
.by_ref().sum())
1675 let v
: &[Result
<i32, ()>] = &[Ok(1), Ok(2), Ok(3), Ok(4)];
1676 assert_eq
!(v
.iter().cloned().sum
::<S
>(), S(Ok(10)));
1677 let v
: &[Result
<i32, ()>] = &[Ok(1), Err(()), Ok(3), Ok(4)];
1678 assert_eq
!(v
.iter().cloned().sum
::<S
>(), S(Err(())));
1682 fn test_iterator_sum_option() {
1683 let v
: &[Option
<i32>] = &[Some(1), Some(2), Some(3), Some(4)];
1684 assert_eq
!(v
.iter().cloned().sum
::<Option
<i32>>(), Some(10));
1685 let v
: &[Option
<i32>] = &[Some(1), None
, Some(3), Some(4)];
1686 assert_eq
!(v
.iter().cloned().sum
::<Option
<i32>>(), None
);
1690 fn test_iterator_product() {
1691 let v
: &[i32] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1692 assert_eq
!(v
[..4].iter().cloned().product
::<i32>(), 0);
1693 assert_eq
!(v
[1..5].iter().cloned().product
::<i32>(), 24);
1694 assert_eq
!(v
[..0].iter().cloned().product
::<i32>(), 1);
1698 fn test_iterator_product_result() {
1699 let v
: &[Result
<i32, ()>] = &[Ok(1), Ok(2), Ok(3), Ok(4)];
1700 assert_eq
!(v
.iter().cloned().product
::<Result
<i32, _
>>(), Ok(24));
1701 let v
: &[Result
<i32, ()>] = &[Ok(1), Err(()), Ok(3), Ok(4)];
1702 assert_eq
!(v
.iter().cloned().product
::<Result
<i32, _
>>(), Err(()));
1705 /// A wrapper struct that implements `Eq` and `Ord` based on the wrapped
1706 /// integer modulo 3. Used to test that `Iterator::max` and `Iterator::min`
1707 /// return the correct element if some of them are equal.
1711 impl PartialEq
for Mod3
{
1712 fn eq(&self, other
: &Self) -> bool
{
1713 self.0 % 3 == other
.0 % 3
1719 impl PartialOrd
for Mod3
{
1720 fn partial_cmp(&self, other
: &Self) -> Option
<core
::cmp
::Ordering
> {
1721 Some(self.cmp(other
))
1726 fn cmp(&self, other
: &Self) -> core
::cmp
::Ordering
{
1727 (self.0 % 3).cmp(&(other
.0 % 3))
1732 fn test_iterator_product_option() {
1733 let v
: &[Option
<i32>] = &[Some(1), Some(2), Some(3), Some(4)];
1734 assert_eq
!(v
.iter().cloned().product
::<Option
<i32>>(), Some(24));
1735 let v
: &[Option
<i32>] = &[Some(1), None
, Some(3), Some(4)];
1736 assert_eq
!(v
.iter().cloned().product
::<Option
<i32>>(), None
);
1740 fn test_iterator_max() {
1741 let v
: &[_
] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1742 assert_eq
!(v
[..4].iter().cloned().max(), Some(3));
1743 assert_eq
!(v
.iter().cloned().max(), Some(10));
1744 assert_eq
!(v
[..0].iter().cloned().max(), None
);
1745 assert_eq
!(v
.iter().cloned().map(Mod3
).max().map(|x
| x
.0), Some(8));
1749 fn test_iterator_min() {
1750 let v
: &[_
] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1751 assert_eq
!(v
[..4].iter().cloned().min(), Some(0));
1752 assert_eq
!(v
.iter().cloned().min(), Some(0));
1753 assert_eq
!(v
[..0].iter().cloned().min(), None
);
1754 assert_eq
!(v
.iter().cloned().map(Mod3
).min().map(|x
| x
.0), Some(0));
1758 fn test_iterator_size_hint() {
1759 let c
= (0..).step_by(1);
1760 let v
: &[_
] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
1761 let v2
= &[10, 11, 12];
1764 assert_eq
!((0..).size_hint(), (usize::MAX
, None
));
1765 assert_eq
!(c
.size_hint(), (usize::MAX
, None
));
1766 assert_eq
!(vi
.clone().size_hint(), (10, Some(10)));
1768 assert_eq
!(c
.clone().take(5).size_hint(), (5, Some(5)));
1769 assert_eq
!(c
.clone().skip(5).size_hint().1, None
);
1770 assert_eq
!(c
.clone().take_while(|_
| false).size_hint(), (0, None
));
1771 assert_eq
!(c
.clone().map_while(|_
| None
::<()>).size_hint(), (0, None
));
1772 assert_eq
!(c
.clone().skip_while(|_
| false).size_hint(), (0, None
));
1773 assert_eq
!(c
.clone().enumerate().size_hint(), (usize::MAX
, None
));
1774 assert_eq
!(c
.clone().chain(vi
.clone().cloned()).size_hint(), (usize::MAX
, None
));
1775 assert_eq
!(c
.clone().zip(vi
.clone()).size_hint(), (10, Some(10)));
1776 assert_eq
!(c
.clone().scan(0, |_
, _
| Some(0)).size_hint(), (0, None
));
1777 assert_eq
!(c
.clone().filter(|_
| false).size_hint(), (0, None
));
1778 assert_eq
!(c
.clone().map(|_
| 0).size_hint(), (usize::MAX
, None
));
1779 assert_eq
!(c
.filter_map(|_
| Some(0)).size_hint(), (0, None
));
1781 assert_eq
!(vi
.clone().take(5).size_hint(), (5, Some(5)));
1782 assert_eq
!(vi
.clone().take(12).size_hint(), (10, Some(10)));
1783 assert_eq
!(vi
.clone().skip(3).size_hint(), (7, Some(7)));
1784 assert_eq
!(vi
.clone().skip(12).size_hint(), (0, Some(0)));
1785 assert_eq
!(vi
.clone().take_while(|_
| false).size_hint(), (0, Some(10)));
1786 assert_eq
!(vi
.clone().map_while(|_
| None
::<()>).size_hint(), (0, Some(10)));
1787 assert_eq
!(vi
.clone().skip_while(|_
| false).size_hint(), (0, Some(10)));
1788 assert_eq
!(vi
.clone().enumerate().size_hint(), (10, Some(10)));
1789 assert_eq
!(vi
.clone().chain(v2
).size_hint(), (13, Some(13)));
1790 assert_eq
!(vi
.clone().zip(v2
).size_hint(), (3, Some(3)));
1791 assert_eq
!(vi
.clone().scan(0, |_
, _
| Some(0)).size_hint(), (0, Some(10)));
1792 assert_eq
!(vi
.clone().filter(|_
| false).size_hint(), (0, Some(10)));
1793 assert_eq
!(vi
.clone().map(|&i
| i
+ 1).size_hint(), (10, Some(10)));
1794 assert_eq
!(vi
.filter_map(|_
| Some(0)).size_hint(), (0, Some(10)));
1799 let a
= vec
![1, 2, 3, 4, 5];
1800 let b
: Vec
<isize> = a
.iter().cloned().collect();
1806 let v
: Box
<[isize]> = Box
::new([1, 2, 3, 4, 5]);
1807 assert
!(v
.iter().all(|&x
| x
< 10));
1808 assert
!(!v
.iter().all(|&x
| x
% 2 == 0));
1809 assert
!(!v
.iter().all(|&x
| x
> 100));
1810 assert
!(v
[..0].iter().all(|_
| panic
!()));
1815 let v
: Box
<[isize]> = Box
::new([1, 2, 3, 4, 5]);
1816 assert
!(v
.iter().any(|&x
| x
< 10));
1817 assert
!(v
.iter().any(|&x
| x
% 2 == 0));
1818 assert
!(!v
.iter().any(|&x
| x
> 100));
1819 assert
!(!v
[..0].iter().any(|_
| panic
!()));
1824 let v
: &[isize] = &[1, 3, 9, 27, 103, 14, 11];
1825 assert_eq
!(*v
.iter().find(|&&x
| x
& 1 == 0).unwrap(), 14);
1826 assert_eq
!(*v
.iter().find(|&&x
| x
% 3 == 0).unwrap(), 3);
1827 assert
!(v
.iter().find(|&&x
| x
% 12 == 0).is_none());
1831 fn test_find_map() {
1832 let xs
: &[isize] = &[];
1833 assert_eq
!(xs
.iter().find_map(half_if_even
), None
);
1834 let xs
: &[isize] = &[3, 5];
1835 assert_eq
!(xs
.iter().find_map(half_if_even
), None
);
1836 let xs
: &[isize] = &[4, 5];
1837 assert_eq
!(xs
.iter().find_map(half_if_even
), Some(2));
1838 let xs
: &[isize] = &[3, 6];
1839 assert_eq
!(xs
.iter().find_map(half_if_even
), Some(3));
1841 let xs
: &[isize] = &[1, 2, 3, 4, 5, 6, 7];
1842 let mut iter
= xs
.iter();
1843 assert_eq
!(iter
.find_map(half_if_even
), Some(1));
1844 assert_eq
!(iter
.find_map(half_if_even
), Some(2));
1845 assert_eq
!(iter
.find_map(half_if_even
), Some(3));
1846 assert_eq
!(iter
.next(), Some(&7));
1848 fn half_if_even(x
: &isize) -> Option
<isize> {
1849 if x
% 2 == 0 { Some(x / 2) }
else { None }
1854 fn test_try_find() {
1855 let xs
: &[isize] = &[];
1856 assert_eq
!(xs
.iter().try_find(testfn
), Ok(None
));
1857 let xs
: &[isize] = &[1, 2, 3, 4];
1858 assert_eq
!(xs
.iter().try_find(testfn
), Ok(Some(&2)));
1859 let xs
: &[isize] = &[1, 3, 4];
1860 assert_eq
!(xs
.iter().try_find(testfn
), Err(()));
1862 let xs
: &[isize] = &[1, 2, 3, 4, 5, 6, 7];
1863 let mut iter
= xs
.iter();
1864 assert_eq
!(iter
.try_find(testfn
), Ok(Some(&2)));
1865 assert_eq
!(iter
.try_find(testfn
), Err(()));
1866 assert_eq
!(iter
.next(), Some(&5));
1868 fn testfn(x
: &&isize) -> Result
<bool
, ()> {
1880 fn test_try_find_api_usability() -> Result
<(), Box
<dyn std
::error
::Error
>> {
1883 let is_my_num
= |s
: &str, search
: i32| -> Result
<bool
, std
::num
::ParseIntError
> {
1884 Ok(s
.parse
::<i32>()?
== search
)
1887 let val
= a
.iter().try_find(|&&s
| is_my_num(s
, 2))?
;
1888 assert_eq
!(val
, Some(&"2"));
1894 fn test_position() {
1895 let v
= &[1, 3, 9, 27, 103, 14, 11];
1896 assert_eq
!(v
.iter().position(|x
| *x
& 1 == 0).unwrap(), 5);
1897 assert_eq
!(v
.iter().position(|x
| *x
% 3 == 0).unwrap(), 1);
1898 assert
!(v
.iter().position(|x
| *x
% 12 == 0).is_none());
1903 let xs
= &[1, 2, 2, 1, 5, 9, 0, 2];
1904 assert_eq
!(xs
.iter().filter(|x
| **x
== 2).count(), 3);
1905 assert_eq
!(xs
.iter().filter(|x
| **x
== 5).count(), 1);
1906 assert_eq
!(xs
.iter().filter(|x
| **x
== 95).count(), 0);
1910 fn test_max_by_key() {
1911 let xs
: &[isize] = &[-3, 0, 1, 5, -10];
1912 assert_eq
!(*xs
.iter().max_by_key(|x
| x
.abs()).unwrap(), -10);
1917 let xs
: &[isize] = &[-3, 0, 1, 5, -10];
1918 assert_eq
!(*xs
.iter().max_by(|x
, y
| x
.abs().cmp(&y
.abs())).unwrap(), -10);
1922 fn test_min_by_key() {
1923 let xs
: &[isize] = &[-3, 0, 1, 5, -10];
1924 assert_eq
!(*xs
.iter().min_by_key(|x
| x
.abs()).unwrap(), 0);
1929 let xs
: &[isize] = &[-3, 0, 1, 5, -10];
1930 assert_eq
!(*xs
.iter().min_by(|x
, y
| x
.abs().cmp(&y
.abs())).unwrap(), 0);
1936 // sum the first five values
1937 let partial_sum
= xs
.by_ref().take(5).fold(0, |a
, b
| a
+ b
);
1938 assert_eq
!(partial_sum
, 10);
1939 assert_eq
!(xs
.next(), Some(5));
1944 let xs
= [2, 4, 6, 8, 10, 12, 14, 16];
1945 let mut it
= xs
.iter();
1948 assert
!(it
.rev().cloned().collect
::<Vec
<isize>>() == vec
![16, 14, 12, 10, 8, 6]);
1953 let xs
= [2, 4, 6, 8];
1955 let mut it
= xs
.iter().copied();
1956 assert_eq
!(it
.len(), 4);
1957 assert_eq
!(it
.next(), Some(2));
1958 assert_eq
!(it
.len(), 3);
1959 assert_eq
!(it
.next(), Some(4));
1960 assert_eq
!(it
.len(), 2);
1961 assert_eq
!(it
.next_back(), Some(8));
1962 assert_eq
!(it
.len(), 1);
1963 assert_eq
!(it
.next_back(), Some(6));
1964 assert_eq
!(it
.len(), 0);
1965 assert_eq
!(it
.next_back(), None
);
1970 let xs
= [2, 4, 6, 8];
1972 let mut it
= xs
.iter().cloned();
1973 assert_eq
!(it
.len(), 4);
1974 assert_eq
!(it
.next(), Some(2));
1975 assert_eq
!(it
.len(), 3);
1976 assert_eq
!(it
.next(), Some(4));
1977 assert_eq
!(it
.len(), 2);
1978 assert_eq
!(it
.next_back(), Some(8));
1979 assert_eq
!(it
.len(), 1);
1980 assert_eq
!(it
.next_back(), Some(6));
1981 assert_eq
!(it
.len(), 0);
1982 assert_eq
!(it
.next_back(), None
);
1986 fn test_cloned_side_effects() {
1989 let iter
= [1, 2, 3]
1999 assert_eq
!(count
, 2);
2003 fn test_double_ended_map() {
2004 let xs
= [1, 2, 3, 4, 5, 6];
2005 let mut it
= xs
.iter().map(|&x
| x
* -1);
2006 assert_eq
!(it
.next(), Some(-1));
2007 assert_eq
!(it
.next(), Some(-2));
2008 assert_eq
!(it
.next_back(), Some(-6));
2009 assert_eq
!(it
.next_back(), Some(-5));
2010 assert_eq
!(it
.next(), Some(-3));
2011 assert_eq
!(it
.next_back(), Some(-4));
2012 assert_eq
!(it
.next(), None
);
2016 fn test_double_ended_enumerate() {
2017 let xs
= [1, 2, 3, 4, 5, 6];
2018 let mut it
= xs
.iter().cloned().enumerate();
2019 assert_eq
!(it
.next(), Some((0, 1)));
2020 assert_eq
!(it
.next(), Some((1, 2)));
2021 assert_eq
!(it
.next_back(), Some((5, 6)));
2022 assert_eq
!(it
.next_back(), Some((4, 5)));
2023 assert_eq
!(it
.next_back(), Some((3, 4)));
2024 assert_eq
!(it
.next_back(), Some((2, 3)));
2025 assert_eq
!(it
.next(), None
);
2029 fn test_double_ended_zip() {
2030 let xs
= [1, 2, 3, 4, 5, 6];
2031 let ys
= [1, 2, 3, 7];
2032 let a
= xs
.iter().cloned();
2033 let b
= ys
.iter().cloned();
2034 let mut it
= a
.zip(b
);
2035 assert_eq
!(it
.next(), Some((1, 1)));
2036 assert_eq
!(it
.next(), Some((2, 2)));
2037 assert_eq
!(it
.next_back(), Some((4, 7)));
2038 assert_eq
!(it
.next_back(), Some((3, 3)));
2039 assert_eq
!(it
.next(), None
);
2043 fn test_double_ended_filter() {
2044 let xs
= [1, 2, 3, 4, 5, 6];
2045 let mut it
= xs
.iter().filter(|&x
| *x
& 1 == 0);
2046 assert_eq
!(it
.next_back().unwrap(), &6);
2047 assert_eq
!(it
.next_back().unwrap(), &4);
2048 assert_eq
!(it
.next().unwrap(), &2);
2049 assert_eq
!(it
.next_back(), None
);
2053 fn test_double_ended_filter_map() {
2054 let xs
= [1, 2, 3, 4, 5, 6];
2055 let mut it
= xs
.iter().filter_map(|&x
| if x
& 1 == 0 { Some(x * 2) }
else { None }
);
2056 assert_eq
!(it
.next_back().unwrap(), 12);
2057 assert_eq
!(it
.next_back().unwrap(), 8);
2058 assert_eq
!(it
.next().unwrap(), 4);
2059 assert_eq
!(it
.next_back(), None
);
2063 fn test_double_ended_chain() {
2064 let xs
= [1, 2, 3, 4, 5];
2065 let ys
= [7, 9, 11];
2066 let mut it
= xs
.iter().chain(&ys
).rev();
2067 assert_eq
!(it
.next().unwrap(), &11);
2068 assert_eq
!(it
.next().unwrap(), &9);
2069 assert_eq
!(it
.next_back().unwrap(), &1);
2070 assert_eq
!(it
.next_back().unwrap(), &2);
2071 assert_eq
!(it
.next_back().unwrap(), &3);
2072 assert_eq
!(it
.next_back().unwrap(), &4);
2073 assert_eq
!(it
.next_back().unwrap(), &5);
2074 assert_eq
!(it
.next_back().unwrap(), &7);
2075 assert_eq
!(it
.next_back(), None
);
2077 // test that .chain() is well behaved with an unfused iterator
2078 struct CrazyIterator(bool
);
2079 impl CrazyIterator
{
2080 fn new() -> CrazyIterator
{
2081 CrazyIterator(false)
2084 impl Iterator
for CrazyIterator
{
2086 fn next(&mut self) -> Option
<i32> {
2096 impl DoubleEndedIterator
for CrazyIterator
{
2097 fn next_back(&mut self) -> Option
<i32> {
2102 assert_eq
!(CrazyIterator
::new().chain(0..10).rev().last(), Some(0));
2103 assert
!((0..10).chain(CrazyIterator
::new()).rev().any(|i
| i
== 0));
2107 fn test_rposition() {
2108 fn f(xy
: &(isize, char)) -> bool
{
2112 fn g(xy
: &(isize, char)) -> bool
{
2116 let v
= [(0, 'a'
), (1, 'b'
), (2, 'c'
), (3, 'b'
)];
2118 assert_eq
!(v
.iter().rposition(f
), Some(3));
2119 assert
!(v
.iter().rposition(g
).is_none());
2123 fn test_rev_rposition() {
2124 let v
= [0, 0, 1, 1];
2125 assert_eq
!(v
.iter().rev().rposition(|&x
| x
== 1), Some(1));
2130 fn test_rposition_panic() {
2131 let v
: [(Box
<_
>, Box
<_
>); 4] = [(box 0, box 0), (box 0, box 0), (box 0, box 0), (box 0, box 0)];
2133 v
.iter().rposition(|_elt
| {
2143 fn test_double_ended_flat_map() {
2145 let v
= [5, 6, 7, 8];
2146 let mut it
= u
.iter().flat_map(|x
| &v
[*x
..v
.len()]);
2147 assert_eq
!(it
.next_back().unwrap(), &8);
2148 assert_eq
!(it
.next().unwrap(), &5);
2149 assert_eq
!(it
.next_back().unwrap(), &7);
2150 assert_eq
!(it
.next_back().unwrap(), &6);
2151 assert_eq
!(it
.next_back().unwrap(), &8);
2152 assert_eq
!(it
.next().unwrap(), &6);
2153 assert_eq
!(it
.next_back().unwrap(), &7);
2154 assert_eq
!(it
.next_back(), None
);
2155 assert_eq
!(it
.next(), None
);
2156 assert_eq
!(it
.next_back(), None
);
2160 fn test_double_ended_flatten() {
2162 let v
= [5, 6, 7, 8];
2163 let mut it
= u
.iter().map(|x
| &v
[*x
..v
.len()]).flatten();
2164 assert_eq
!(it
.next_back().unwrap(), &8);
2165 assert_eq
!(it
.next().unwrap(), &5);
2166 assert_eq
!(it
.next_back().unwrap(), &7);
2167 assert_eq
!(it
.next_back().unwrap(), &6);
2168 assert_eq
!(it
.next_back().unwrap(), &8);
2169 assert_eq
!(it
.next().unwrap(), &6);
2170 assert_eq
!(it
.next_back().unwrap(), &7);
2171 assert_eq
!(it
.next_back(), None
);
2172 assert_eq
!(it
.next(), None
);
2173 assert_eq
!(it
.next_back(), None
);
2177 fn test_double_ended_range() {
2178 assert_eq
!((11..14).rev().collect
::<Vec
<_
>>(), [13, 12, 11]);
2179 for _
in (10..0).rev() {
2180 panic
!("unreachable");
2183 assert_eq
!((11..14).rev().collect
::<Vec
<_
>>(), [13, 12, 11]);
2184 for _
in (10..0).rev() {
2185 panic
!("unreachable");
2191 assert_eq
!((0..5).collect
::<Vec
<_
>>(), [0, 1, 2, 3, 4]);
2192 assert_eq
!((-10..-1).collect
::<Vec
<_
>>(), [-10, -9, -8, -7, -6, -5, -4, -3, -2]);
2193 assert_eq
!((0..5).rev().collect
::<Vec
<_
>>(), [4, 3, 2, 1, 0]);
2194 assert_eq
!((200..-5).count(), 0);
2195 assert_eq
!((200..-5).rev().count(), 0);
2196 assert_eq
!((200..200).count(), 0);
2197 assert_eq
!((200..200).rev().count(), 0);
2199 assert_eq
!((0..100).size_hint(), (100, Some(100)));
2200 // this test is only meaningful when sizeof usize < sizeof u64
2201 assert_eq
!((usize::MAX
- 1..usize::MAX
).size_hint(), (1, Some(1)));
2202 assert_eq
!((-10..-1).size_hint(), (9, Some(9)));
2203 assert_eq
!((-1..-10).size_hint(), (0, Some(0)));
2205 assert_eq
!((-70..58).size_hint(), (128, Some(128)));
2206 assert_eq
!((-128..127).size_hint(), (255, Some(255)));
2208 (-2..isize::MAX
).size_hint(),
2209 (isize::MAX
as usize + 2, Some(isize::MAX
as usize + 2))
2214 fn test_char_range() {
2217 let from
= if cfg
!(miri
) { char::from_u32(0xD800 - 10).unwrap() }
else { '\0' }
;
2218 let to
= if cfg
!(miri
) { char::from_u32(0xDFFF + 10).unwrap() }
else { char::MAX }
;
2219 assert
!((from
..=to
).eq((from
as u32..=to
as u32).filter_map(char::from_u32
)));
2220 assert
!((from
..=to
).rev().eq((from
as u32..=to
as u32).filter_map(char::from_u32
).rev()));
2222 assert_eq
!(('
\u{D7FF}'
..='
\u{E000}'
).count(), 2);
2223 assert_eq
!(('
\u{D7FF}'
..='
\u{E000}'
).size_hint(), (2, Some(2)));
2224 assert_eq
!(('
\u{D7FF}'
..'
\u{E000}'
).count(), 1);
2225 assert_eq
!(('
\u{D7FF}'
..'
\u{E000}'
).size_hint(), (1, Some(1)));
2229 fn test_range_exhaustion() {
2231 assert
!(r
.is_empty());
2232 assert_eq
!(r
.next(), None
);
2233 assert_eq
!(r
.next_back(), None
);
2234 assert_eq
!(r
, 10..10);
2237 assert_eq
!(r
.next(), Some(10));
2238 assert_eq
!(r
.next(), Some(11));
2239 assert
!(r
.is_empty());
2240 assert_eq
!(r
, 12..12);
2241 assert_eq
!(r
.next(), None
);
2244 assert_eq
!(r
.next_back(), Some(11));
2245 assert_eq
!(r
.next_back(), Some(10));
2246 assert
!(r
.is_empty());
2247 assert_eq
!(r
, 10..10);
2248 assert_eq
!(r
.next_back(), None
);
2250 let mut r
= 100..10;
2251 assert
!(r
.is_empty());
2252 assert_eq
!(r
.next(), None
);
2253 assert_eq
!(r
.next_back(), None
);
2254 assert_eq
!(r
, 100..10);
2258 fn test_range_inclusive_exhaustion() {
2259 let mut r
= 10..=10;
2260 assert_eq
!(r
.next(), Some(10));
2261 assert
!(r
.is_empty());
2262 assert_eq
!(r
.next(), None
);
2263 assert_eq
!(r
.next(), None
);
2265 assert_eq
!(*r
.start(), 10);
2266 assert_eq
!(*r
.end(), 10);
2267 assert_ne
!(r
, 10..=10);
2269 let mut r
= 10..=10;
2270 assert_eq
!(r
.next_back(), Some(10));
2271 assert
!(r
.is_empty());
2272 assert_eq
!(r
.next_back(), None
);
2274 assert_eq
!(*r
.start(), 10);
2275 assert_eq
!(*r
.end(), 10);
2276 assert_ne
!(r
, 10..=10);
2278 let mut r
= 10..=12;
2279 assert_eq
!(r
.next(), Some(10));
2280 assert_eq
!(r
.next(), Some(11));
2281 assert_eq
!(r
.next(), Some(12));
2282 assert
!(r
.is_empty());
2283 assert_eq
!(r
.next(), None
);
2285 let mut r
= 10..=12;
2286 assert_eq
!(r
.next_back(), Some(12));
2287 assert_eq
!(r
.next_back(), Some(11));
2288 assert_eq
!(r
.next_back(), Some(10));
2289 assert
!(r
.is_empty());
2290 assert_eq
!(r
.next_back(), None
);
2292 let mut r
= 10..=12;
2293 assert_eq
!(r
.nth(2), Some(12));
2294 assert
!(r
.is_empty());
2295 assert_eq
!(r
.next(), None
);
2297 let mut r
= 10..=12;
2298 assert_eq
!(r
.nth(5), None
);
2299 assert
!(r
.is_empty());
2300 assert_eq
!(r
.next(), None
);
2302 let mut r
= 100..=10;
2303 assert_eq
!(r
.next(), None
);
2304 assert
!(r
.is_empty());
2305 assert_eq
!(r
.next(), None
);
2306 assert_eq
!(r
.next(), None
);
2307 assert_eq
!(r
, 100..=10);
2309 let mut r
= 100..=10;
2310 assert_eq
!(r
.next_back(), None
);
2311 assert
!(r
.is_empty());
2312 assert_eq
!(r
.next_back(), None
);
2313 assert_eq
!(r
.next_back(), None
);
2314 assert_eq
!(r
, 100..=10);
2318 fn test_range_nth() {
2319 assert_eq
!((10..15).nth(0), Some(10));
2320 assert_eq
!((10..15).nth(1), Some(11));
2321 assert_eq
!((10..15).nth(4), Some(14));
2322 assert_eq
!((10..15).nth(5), None
);
2325 assert_eq
!(r
.nth(2), Some(12));
2326 assert_eq
!(r
, 13..20);
2327 assert_eq
!(r
.nth(2), Some(15));
2328 assert_eq
!(r
, 16..20);
2329 assert_eq
!(r
.nth(10), None
);
2330 assert_eq
!(r
, 20..20);
2334 fn test_range_nth_back() {
2335 assert_eq
!((10..15).nth_back(0), Some(14));
2336 assert_eq
!((10..15).nth_back(1), Some(13));
2337 assert_eq
!((10..15).nth_back(4), Some(10));
2338 assert_eq
!((10..15).nth_back(5), None
);
2339 assert_eq
!((-120..80_i8).nth_back(199), Some(-120));
2342 assert_eq
!(r
.nth_back(2), Some(17));
2343 assert_eq
!(r
, 10..17);
2344 assert_eq
!(r
.nth_back(2), Some(14));
2345 assert_eq
!(r
, 10..14);
2346 assert_eq
!(r
.nth_back(10), None
);
2347 assert_eq
!(r
, 10..10);
2351 fn test_range_from_nth() {
2352 assert_eq
!((10..).nth(0), Some(10));
2353 assert_eq
!((10..).nth(1), Some(11));
2354 assert_eq
!((10..).nth(4), Some(14));
2357 assert_eq
!(r
.nth(2), Some(12));
2358 assert_eq
!(r
, 13..);
2359 assert_eq
!(r
.nth(2), Some(15));
2360 assert_eq
!(r
, 16..);
2361 assert_eq
!(r
.nth(10), Some(26));
2362 assert_eq
!(r
, 27..);
2364 assert_eq
!((0..).size_hint(), (usize::MAX
, None
));
2367 fn is_trusted_len
<I
: TrustedLen
>(_
: I
) {}
2370 fn test_range_from_take() {
2371 let mut it
= (0..).take(3);
2372 assert_eq
!(it
.next(), Some(0));
2373 assert_eq
!(it
.next(), Some(1));
2374 assert_eq
!(it
.next(), Some(2));
2375 assert_eq
!(it
.next(), None
);
2376 is_trusted_len((0..).take(3));
2377 assert_eq
!((0..).take(3).size_hint(), (3, Some(3)));
2378 assert_eq
!((0..).take(0).size_hint(), (0, Some(0)));
2379 assert_eq
!((0..).take(usize::MAX
).size_hint(), (usize::MAX
, Some(usize::MAX
)));
2383 fn test_range_from_take_collect() {
2384 let v
: Vec
<_
> = (0..).take(3).collect();
2385 assert_eq
!(v
, vec
![0, 1, 2]);
2389 fn test_range_inclusive_nth() {
2390 assert_eq
!((10..=15).nth(0), Some(10));
2391 assert_eq
!((10..=15).nth(1), Some(11));
2392 assert_eq
!((10..=15).nth(5), Some(15));
2393 assert_eq
!((10..=15).nth(6), None
);
2395 let mut exhausted_via_next
= 10_u8..=20;
2396 while exhausted_via_next
.next().is_some() {}
2398 let mut r
= 10_u8..=20;
2399 assert_eq
!(r
.nth(2), Some(12));
2400 assert_eq
!(r
, 13..=20);
2401 assert_eq
!(r
.nth(2), Some(15));
2402 assert_eq
!(r
, 16..=20);
2403 assert_eq
!(r
.is_empty(), false);
2404 assert_eq
!(ExactSizeIterator
::is_empty(&r
), false);
2405 assert_eq
!(r
.nth(10), None
);
2406 assert_eq
!(r
.is_empty(), true);
2407 assert_eq
!(r
, exhausted_via_next
);
2408 assert_eq
!(ExactSizeIterator
::is_empty(&r
), true);
2412 fn test_range_inclusive_nth_back() {
2413 assert_eq
!((10..=15).nth_back(0), Some(15));
2414 assert_eq
!((10..=15).nth_back(1), Some(14));
2415 assert_eq
!((10..=15).nth_back(5), Some(10));
2416 assert_eq
!((10..=15).nth_back(6), None
);
2417 assert_eq
!((-120..=80_i8).nth_back(200), Some(-120));
2419 let mut exhausted_via_next_back
= 10_u8..=20;
2420 while exhausted_via_next_back
.next_back().is_some() {}
2422 let mut r
= 10_u8..=20;
2423 assert_eq
!(r
.nth_back(2), Some(18));
2424 assert_eq
!(r
, 10..=17);
2425 assert_eq
!(r
.nth_back(2), Some(15));
2426 assert_eq
!(r
, 10..=14);
2427 assert_eq
!(r
.is_empty(), false);
2428 assert_eq
!(ExactSizeIterator
::is_empty(&r
), false);
2429 assert_eq
!(r
.nth_back(10), None
);
2430 assert_eq
!(r
.is_empty(), true);
2431 assert_eq
!(r
, exhausted_via_next_back
);
2432 assert_eq
!(ExactSizeIterator
::is_empty(&r
), true);
2436 fn test_range_len() {
2437 assert_eq
!((0..10_u8).len(), 10);
2438 assert_eq
!((9..10_u8).len(), 1);
2439 assert_eq
!((10..10_u8).len(), 0);
2440 assert_eq
!((11..10_u8).len(), 0);
2441 assert_eq
!((100..10_u8).len(), 0);
2445 fn test_range_inclusive_len() {
2446 assert_eq
!((0..=10_u8).len(), 11);
2447 assert_eq
!((9..=10_u8).len(), 2);
2448 assert_eq
!((10..=10_u8).len(), 1);
2449 assert_eq
!((11..=10_u8).len(), 0);
2450 assert_eq
!((100..=10_u8).len(), 0);
2454 fn test_range_step() {
2455 #![allow(deprecated)]
2457 assert_eq
!((0..20).step_by(5).collect
::<Vec
<isize>>(), [0, 5, 10, 15]);
2458 assert_eq
!((1..21).rev().step_by(5).collect
::<Vec
<isize>>(), [20, 15, 10, 5]);
2459 assert_eq
!((1..21).rev().step_by(6).collect
::<Vec
<isize>>(), [20, 14, 8, 2]);
2460 assert_eq
!((200..255).step_by(50).collect
::<Vec
<u8>>(), [200, 250]);
2461 assert_eq
!((200..-5).step_by(1).collect
::<Vec
<isize>>(), []);
2462 assert_eq
!((200..200).step_by(1).collect
::<Vec
<isize>>(), []);
2464 assert_eq
!((0..20).step_by(1).size_hint(), (20, Some(20)));
2465 assert_eq
!((0..20).step_by(21).size_hint(), (1, Some(1)));
2466 assert_eq
!((0..20).step_by(5).size_hint(), (4, Some(4)));
2467 assert_eq
!((1..21).rev().step_by(5).size_hint(), (4, Some(4)));
2468 assert_eq
!((1..21).rev().step_by(6).size_hint(), (4, Some(4)));
2469 assert_eq
!((20..-5).step_by(1).size_hint(), (0, Some(0)));
2470 assert_eq
!((20..20).step_by(1).size_hint(), (0, Some(0)));
2471 assert_eq
!((i8::MIN
..i8::MAX
).step_by(-(i8::MIN
as i32) as usize).size_hint(), (2, Some(2)));
2472 assert_eq
!((i16::MIN
..i16::MAX
).step_by(i16::MAX
as usize).size_hint(), (3, Some(3)));
2473 assert_eq
!((isize::MIN
..isize::MAX
).step_by(1).size_hint(), (usize::MAX
, Some(usize::MAX
)));
2477 fn test_step_by_skip() {
2478 assert_eq
!((0..640).step_by(128).skip(1).collect
::<Vec
<_
>>(), [128, 256, 384, 512]);
2479 assert_eq
!((0..=50).step_by(10).nth(3), Some(30));
2480 assert_eq
!((200..=255u8).step_by(10).nth(3), Some(230));
2484 fn test_range_inclusive_step() {
2485 assert_eq
!((0..=50).step_by(10).collect
::<Vec
<_
>>(), [0, 10, 20, 30, 40, 50]);
2486 assert_eq
!((0..=5).step_by(1).collect
::<Vec
<_
>>(), [0, 1, 2, 3, 4, 5]);
2487 assert_eq
!((200..=255u8).step_by(10).collect
::<Vec
<_
>>(), [200, 210, 220, 230, 240, 250]);
2488 assert_eq
!((250..=255u8).step_by(1).collect
::<Vec
<_
>>(), [250, 251, 252, 253, 254, 255]);
2492 fn test_range_last_max() {
2493 assert_eq
!((0..20).last(), Some(19));
2494 assert_eq
!((-20..0).last(), Some(-1));
2495 assert_eq
!((5..5).last(), None
);
2497 assert_eq
!((0..20).max(), Some(19));
2498 assert_eq
!((-20..0).max(), Some(-1));
2499 assert_eq
!((5..5).max(), None
);
2503 fn test_range_inclusive_last_max() {
2504 assert_eq
!((0..=20).last(), Some(20));
2505 assert_eq
!((-20..=0).last(), Some(0));
2506 assert_eq
!((5..=5).last(), Some(5));
2507 let mut r
= 10..=10;
2509 assert_eq
!(r
.last(), None
);
2511 assert_eq
!((0..=20).max(), Some(20));
2512 assert_eq
!((-20..=0).max(), Some(0));
2513 assert_eq
!((5..=5).max(), Some(5));
2514 let mut r
= 10..=10;
2516 assert_eq
!(r
.max(), None
);
2520 fn test_range_min() {
2521 assert_eq
!((0..20).min(), Some(0));
2522 assert_eq
!((-20..0).min(), Some(-20));
2523 assert_eq
!((5..5).min(), None
);
2527 fn test_range_inclusive_min() {
2528 assert_eq
!((0..=20).min(), Some(0));
2529 assert_eq
!((-20..=0).min(), Some(-20));
2530 assert_eq
!((5..=5).min(), Some(5));
2531 let mut r
= 10..=10;
2533 assert_eq
!(r
.min(), None
);
2537 fn test_range_inclusive_folds() {
2538 assert_eq
!((1..=10).sum
::<i32>(), 55);
2539 assert_eq
!((1..=10).rev().sum
::<i32>(), 55);
2541 let mut it
= 44..=50;
2542 assert_eq
!(it
.try_fold(0, i8::checked_add
), None
);
2543 assert_eq
!(it
, 47..=50);
2544 assert_eq
!(it
.try_fold(0, i8::checked_add
), None
);
2545 assert_eq
!(it
, 50..=50);
2546 assert_eq
!(it
.try_fold(0, i8::checked_add
), Some(50));
2547 assert
!(it
.is_empty());
2548 assert_eq
!(it
.try_fold(0, i8::checked_add
), Some(0));
2549 assert
!(it
.is_empty());
2551 let mut it
= 40..=47;
2552 assert_eq
!(it
.try_rfold(0, i8::checked_add
), None
);
2553 assert_eq
!(it
, 40..=44);
2554 assert_eq
!(it
.try_rfold(0, i8::checked_add
), None
);
2555 assert_eq
!(it
, 40..=41);
2556 assert_eq
!(it
.try_rfold(0, i8::checked_add
), Some(81));
2557 assert
!(it
.is_empty());
2558 assert_eq
!(it
.try_rfold(0, i8::checked_add
), Some(0));
2559 assert
!(it
.is_empty());
2561 let mut it
= 10..=20;
2562 assert_eq
!(it
.try_fold(0, |a
, b
| Some(a
+ b
)), Some(165));
2563 assert
!(it
.is_empty());
2564 assert_eq
!(it
.try_fold(0, |a
, b
| Some(a
+ b
)), Some(0));
2565 assert
!(it
.is_empty());
2567 let mut it
= 10..=20;
2568 assert_eq
!(it
.try_rfold(0, |a
, b
| Some(a
+ b
)), Some(165));
2569 assert
!(it
.is_empty());
2570 assert_eq
!(it
.try_rfold(0, |a
, b
| Some(a
+ b
)), Some(0));
2571 assert
!(it
.is_empty());
2575 fn test_range_size_hint() {
2576 assert_eq
!((0..0usize
).size_hint(), (0, Some(0)));
2577 assert_eq
!((0..100usize
).size_hint(), (100, Some(100)));
2578 assert_eq
!((0..usize::MAX
).size_hint(), (usize::MAX
, Some(usize::MAX
)));
2580 let umax
= u128
::try_from(usize::MAX
).unwrap();
2581 assert_eq
!((0..0u128).size_hint(), (0, Some(0)));
2582 assert_eq
!((0..100u128).size_hint(), (100, Some(100)));
2583 assert_eq
!((0..umax
).size_hint(), (usize::MAX
, Some(usize::MAX
)));
2584 assert_eq
!((0..umax
+ 1).size_hint(), (usize::MAX
, None
));
2586 assert_eq
!((0..0isize
).size_hint(), (0, Some(0)));
2587 assert_eq
!((-100..100isize
).size_hint(), (200, Some(200)));
2588 assert_eq
!((isize::MIN
..isize::MAX
).size_hint(), (usize::MAX
, Some(usize::MAX
)));
2590 let imin
= i128
::try_from(isize::MIN
).unwrap();
2591 let imax
= i128
::try_from(isize::MAX
).unwrap();
2592 assert_eq
!((0..0i128).size_hint(), (0, Some(0)));
2593 assert_eq
!((-100..100i128).size_hint(), (200, Some(200)));
2594 assert_eq
!((imin
..imax
).size_hint(), (usize::MAX
, Some(usize::MAX
)));
2595 assert_eq
!((imin
..imax
+ 1).size_hint(), (usize::MAX
, None
));
2599 fn test_range_inclusive_size_hint() {
2600 assert_eq
!((1..=0usize
).size_hint(), (0, Some(0)));
2601 assert_eq
!((0..=0usize
).size_hint(), (1, Some(1)));
2602 assert_eq
!((0..=100usize
).size_hint(), (101, Some(101)));
2603 assert_eq
!((0..=usize::MAX
- 1).size_hint(), (usize::MAX
, Some(usize::MAX
)));
2604 assert_eq
!((0..=usize::MAX
).size_hint(), (usize::MAX
, None
));
2606 let umax
= u128
::try_from(usize::MAX
).unwrap();
2607 assert_eq
!((1..=0u128).size_hint(), (0, Some(0)));
2608 assert_eq
!((0..=0u128).size_hint(), (1, Some(1)));
2609 assert_eq
!((0..=100u128).size_hint(), (101, Some(101)));
2610 assert_eq
!((0..=umax
- 1).size_hint(), (usize::MAX
, Some(usize::MAX
)));
2611 assert_eq
!((0..=umax
).size_hint(), (usize::MAX
, None
));
2612 assert_eq
!((0..=umax
+ 1).size_hint(), (usize::MAX
, None
));
2614 assert_eq
!((0..=-1isize
).size_hint(), (0, Some(0)));
2615 assert_eq
!((0..=0isize
).size_hint(), (1, Some(1)));
2616 assert_eq
!((-100..=100isize
).size_hint(), (201, Some(201)));
2617 assert_eq
!((isize::MIN
..=isize::MAX
- 1).size_hint(), (usize::MAX
, Some(usize::MAX
)));
2618 assert_eq
!((isize::MIN
..=isize::MAX
).size_hint(), (usize::MAX
, None
));
2620 let imin
= i128
::try_from(isize::MIN
).unwrap();
2621 let imax
= i128
::try_from(isize::MAX
).unwrap();
2622 assert_eq
!((0..=-1i128).size_hint(), (0, Some(0)));
2623 assert_eq
!((0..=0i128).size_hint(), (1, Some(1)));
2624 assert_eq
!((-100..=100i128).size_hint(), (201, Some(201)));
2625 assert_eq
!((imin
..=imax
- 1).size_hint(), (usize::MAX
, Some(usize::MAX
)));
2626 assert_eq
!((imin
..=imax
).size_hint(), (usize::MAX
, None
));
2627 assert_eq
!((imin
..=imax
+ 1).size_hint(), (usize::MAX
, None
));
2632 let mut it
= repeat(42);
2633 assert_eq
!(it
.next(), Some(42));
2634 assert_eq
!(it
.next(), Some(42));
2635 assert_eq
!(it
.next(), Some(42));
2636 assert_eq
!(repeat(42).size_hint(), (usize::MAX
, None
));
2640 fn test_repeat_take() {
2641 let mut it
= repeat(42).take(3);
2642 assert_eq
!(it
.next(), Some(42));
2643 assert_eq
!(it
.next(), Some(42));
2644 assert_eq
!(it
.next(), Some(42));
2645 assert_eq
!(it
.next(), None
);
2646 is_trusted_len(repeat(42).take(3));
2647 assert_eq
!(repeat(42).take(3).size_hint(), (3, Some(3)));
2648 assert_eq
!(repeat(42).take(0).size_hint(), (0, Some(0)));
2649 assert_eq
!(repeat(42).take(usize::MAX
).size_hint(), (usize::MAX
, Some(usize::MAX
)));
2653 fn test_repeat_take_collect() {
2654 let v
: Vec
<_
> = repeat(42).take(3).collect();
2655 assert_eq
!(v
, vec
![42, 42, 42]);
2659 fn test_repeat_with() {
2660 #[derive(PartialEq, Debug)]
2661 struct NotClone(usize);
2662 let mut it
= repeat_with(|| NotClone(42));
2663 assert_eq
!(it
.next(), Some(NotClone(42)));
2664 assert_eq
!(it
.next(), Some(NotClone(42)));
2665 assert_eq
!(it
.next(), Some(NotClone(42)));
2666 assert_eq
!(repeat_with(|| NotClone(42)).size_hint(), (usize::MAX
, None
));
2670 fn test_repeat_with_take() {
2671 let mut it
= repeat_with(|| 42).take(3);
2672 assert_eq
!(it
.next(), Some(42));
2673 assert_eq
!(it
.next(), Some(42));
2674 assert_eq
!(it
.next(), Some(42));
2675 assert_eq
!(it
.next(), None
);
2676 is_trusted_len(repeat_with(|| 42).take(3));
2677 assert_eq
!(repeat_with(|| 42).take(3).size_hint(), (3, Some(3)));
2678 assert_eq
!(repeat_with(|| 42).take(0).size_hint(), (0, Some(0)));
2679 assert_eq
!(repeat_with(|| 42).take(usize::MAX
).size_hint(), (usize::MAX
, Some(usize::MAX
)));
2683 fn test_repeat_with_take_collect() {
2685 let v
: Vec
<_
> = repeat_with(|| {
2692 assert_eq
!(v
, vec
![1, 2, 4, 8, 16]);
2696 fn test_successors() {
2697 let mut powers_of_10
= successors(Some(1_u16), |n
| n
.checked_mul(10));
2698 assert_eq
!(powers_of_10
.by_ref().collect
::<Vec
<_
>>(), &[1, 10, 100, 1_000, 10_000]);
2699 assert_eq
!(powers_of_10
.next(), None
);
2701 let mut empty
= successors(None
::<u32>, |_
| unimplemented
!());
2702 assert_eq
!(empty
.next(), None
);
2703 assert_eq
!(empty
.next(), None
);
2709 assert_eq
!(it
.len(), 3);
2710 assert_eq
!(it
.next(), Some(0));
2711 assert_eq
!(it
.len(), 2);
2712 assert_eq
!(it
.next(), Some(1));
2713 assert_eq
!(it
.len(), 1);
2714 assert_eq
!(it
.next(), Some(2));
2715 assert_eq
!(it
.len(), 0);
2716 assert_eq
!(it
.next(), None
);
2717 assert_eq
!(it
.len(), 0);
2718 assert_eq
!(it
.next(), None
);
2719 assert_eq
!(it
.len(), 0);
2720 assert_eq
!(it
.next(), None
);
2721 assert_eq
!(it
.len(), 0);
2725 fn test_fuse_nth() {
2727 let mut it
= xs
.iter();
2729 assert_eq
!(it
.len(), 3);
2730 assert_eq
!(it
.nth(2), Some(&2));
2731 assert_eq
!(it
.len(), 0);
2732 assert_eq
!(it
.nth(2), None
);
2733 assert_eq
!(it
.len(), 0);
2737 fn test_fuse_last() {
2741 assert_eq
!(it
.len(), 3);
2742 assert_eq
!(it
.last(), Some(&2));
2746 fn test_fuse_count() {
2750 assert_eq
!(it
.len(), 3);
2751 assert_eq
!(it
.count(), 3);
2752 // Can't check len now because count consumes.
2756 fn test_fuse_fold() {
2758 let it
= xs
.iter(); // `FusedIterator`
2759 let i
= it
.fuse().fold(0, |i
, &x
| {
2760 assert_eq
!(x
, xs
[i
]);
2763 assert_eq
!(i
, xs
.len());
2765 let it
= xs
.iter(); // `FusedIterator`
2766 let i
= it
.fuse().rfold(xs
.len(), |i
, &x
| {
2767 assert_eq
!(x
, xs
[i
- 1]);
2772 let it
= xs
.iter().scan((), |_
, &x
| Some(x
)); // `!FusedIterator`
2773 let i
= it
.fuse().fold(0, |i
, x
| {
2774 assert_eq
!(x
, xs
[i
]);
2777 assert_eq
!(i
, xs
.len());
2782 let mut it
= once(42);
2783 assert_eq
!(it
.next(), Some(42));
2784 assert_eq
!(it
.next(), None
);
2788 fn test_once_with() {
2789 let count
= Cell
::new(0);
2790 let mut it
= once_with(|| {
2791 count
.set(count
.get() + 1);
2795 assert_eq
!(count
.get(), 0);
2796 assert_eq
!(it
.next(), Some(42));
2797 assert_eq
!(count
.get(), 1);
2798 assert_eq
!(it
.next(), None
);
2799 assert_eq
!(count
.get(), 1);
2800 assert_eq
!(it
.next(), None
);
2801 assert_eq
!(count
.get(), 1);
2806 let mut it
= empty
::<i32>();
2807 assert_eq
!(it
.next(), None
);
2811 fn test_chain_fold() {
2815 let mut iter
= xs
.iter().chain(&ys
);
2817 let mut result
= Vec
::new();
2818 iter
.fold((), |(), &elt
| result
.push(elt
));
2819 assert_eq
!(&[2, 3, 1, 2, 0], &result
[..]);
2823 fn test_steps_between() {
2824 assert_eq
!(Step
::steps_between(&20_u8, &200_u8), Some(180_usize
));
2825 assert_eq
!(Step
::steps_between(&-20_i8, &80_i8), Some(100_usize
));
2826 assert_eq
!(Step
::steps_between(&-120_i8, &80_i8), Some(200_usize
));
2827 assert_eq
!(Step
::steps_between(&20_u32, &4_000_100_u32), Some(4_000_080_usize
));
2828 assert_eq
!(Step
::steps_between(&-20_i32, &80_i32), Some(100_usize
));
2829 assert_eq
!(Step
::steps_between(&-2_000_030_i32, &2_000_050_i32), Some(4_000_080_usize
));
2831 // Skip u64/i64 to avoid differences with 32-bit vs 64-bit platforms
2833 assert_eq
!(Step
::steps_between(&20_u128, &200_u128), Some(180_usize
));
2834 assert_eq
!(Step
::steps_between(&-20_i128, &80_i128), Some(100_usize
));
2835 if cfg
!(target_pointer_width
= "64") {
2836 assert_eq
!(Step
::steps_between(&10_u128, &0x1_0000_0000_0000_0009_u128), Some(usize::MAX
));
2838 assert_eq
!(Step
::steps_between(&10_u128, &0x1_0000_0000_0000_000a_u128), None
);
2839 assert_eq
!(Step
::steps_between(&10_i128, &0x1_0000_0000_0000_000a_i128), None
);
2841 Step
::steps_between(&-0x1_0000_0000_0000_0000_i128, &0x1_0000_0000_0000_0000_i128,),
2847 fn test_step_forward() {
2848 assert_eq
!(Step
::forward_checked(55_u8, 200_usize
), Some(255_u8));
2849 assert_eq
!(Step
::forward_checked(252_u8, 200_usize
), None
);
2850 assert_eq
!(Step
::forward_checked(0_u8, 256_usize
), None
);
2851 assert_eq
!(Step
::forward_checked(-110_i8, 200_usize
), Some(90_i8));
2852 assert_eq
!(Step
::forward_checked(-110_i8, 248_usize
), None
);
2853 assert_eq
!(Step
::forward_checked(-126_i8, 256_usize
), None
);
2855 assert_eq
!(Step
::forward_checked(35_u16, 100_usize
), Some(135_u16));
2856 assert_eq
!(Step
::forward_checked(35_u16, 65500_usize
), Some(u16::MAX
));
2857 assert_eq
!(Step
::forward_checked(36_u16, 65500_usize
), None
);
2858 assert_eq
!(Step
::forward_checked(-110_i16, 200_usize
), Some(90_i16));
2859 assert_eq
!(Step
::forward_checked(-20_030_i16, 50_050_usize
), Some(30_020_i16));
2860 assert_eq
!(Step
::forward_checked(-10_i16, 40_000_usize
), None
);
2861 assert_eq
!(Step
::forward_checked(-10_i16, 70_000_usize
), None
);
2863 assert_eq
!(Step
::forward_checked(10_u128, 70_000_usize
), Some(70_010_u128));
2864 assert_eq
!(Step
::forward_checked(10_i128, 70_030_usize
), Some(70_040_i128));
2866 Step
::forward_checked(0xffff_ffff_ffff_ffff__ffff_ffff_ffff_ff00_u128, 0xff_usize
),
2870 Step
::forward_checked(0xffff_ffff_ffff_ffff__ffff_ffff_ffff_ff00_u128, 0x100_usize
),
2874 Step
::forward_checked(0x7fff_ffff_ffff_ffff__ffff_ffff_ffff_ff00_i128, 0xff_usize
),
2878 Step
::forward_checked(0x7fff_ffff_ffff_ffff__ffff_ffff_ffff_ff00_i128, 0x100_usize
),
2884 fn test_step_backward() {
2885 assert_eq
!(Step
::backward_checked(255_u8, 200_usize
), Some(55_u8));
2886 assert_eq
!(Step
::backward_checked(100_u8, 200_usize
), None
);
2887 assert_eq
!(Step
::backward_checked(255_u8, 256_usize
), None
);
2888 assert_eq
!(Step
::backward_checked(90_i8, 200_usize
), Some(-110_i8));
2889 assert_eq
!(Step
::backward_checked(110_i8, 248_usize
), None
);
2890 assert_eq
!(Step
::backward_checked(127_i8, 256_usize
), None
);
2892 assert_eq
!(Step
::backward_checked(135_u16, 100_usize
), Some(35_u16));
2893 assert_eq
!(Step
::backward_checked(u16::MAX
, 65500_usize
), Some(35_u16));
2894 assert_eq
!(Step
::backward_checked(10_u16, 11_usize
), None
);
2895 assert_eq
!(Step
::backward_checked(90_i16, 200_usize
), Some(-110_i16));
2896 assert_eq
!(Step
::backward_checked(30_020_i16, 50_050_usize
), Some(-20_030_i16));
2897 assert_eq
!(Step
::backward_checked(-10_i16, 40_000_usize
), None
);
2898 assert_eq
!(Step
::backward_checked(-10_i16, 70_000_usize
), None
);
2900 assert_eq
!(Step
::backward_checked(70_010_u128, 70_000_usize
), Some(10_u128));
2901 assert_eq
!(Step
::backward_checked(70_020_i128, 70_030_usize
), Some(-10_i128));
2902 assert_eq
!(Step
::backward_checked(10_u128, 7_usize
), Some(3_u128));
2903 assert_eq
!(Step
::backward_checked(10_u128, 11_usize
), None
);
2905 Step
::backward_checked(-0x7fff_ffff_ffff_ffff__ffff_ffff_ffff_ff00_i128, 0x100_usize
),
2911 fn test_rev_try_folds() {
2912 let f
= &|acc
, x
| i32::checked_add(2 * acc
, x
);
2913 assert_eq
!((1..10).rev().try_fold(7, f
), (1..10).try_rfold(7, f
));
2914 assert_eq
!((1..10).rev().try_rfold(7, f
), (1..10).try_fold(7, f
));
2916 let a
= [10, 20, 30, 40, 100, 60, 70, 80, 90];
2917 let mut iter
= a
.iter().rev();
2918 assert_eq
!(iter
.try_fold(0_i8, |acc
, &x
| acc
.checked_add(x
)), None
);
2919 assert_eq
!(iter
.next(), Some(&70));
2920 let mut iter
= a
.iter().rev();
2921 assert_eq
!(iter
.try_rfold(0_i8, |acc
, &x
| acc
.checked_add(x
)), None
);
2922 assert_eq
!(iter
.next_back(), Some(&60));
2926 fn test_cloned_try_folds() {
2927 let a
= [1, 2, 3, 4, 5, 6, 7, 8, 9];
2928 let f
= &|acc
, x
| i32::checked_add(2 * acc
, x
);
2929 let f_ref
= &|acc
, &x
| i32::checked_add(2 * acc
, x
);
2930 assert_eq
!(a
.iter().cloned().try_fold(7, f
), a
.iter().try_fold(7, f_ref
));
2931 assert_eq
!(a
.iter().cloned().try_rfold(7, f
), a
.iter().try_rfold(7, f_ref
));
2933 let a
= [10, 20, 30, 40, 100, 60, 70, 80, 90];
2934 let mut iter
= a
.iter().cloned();
2935 assert_eq
!(iter
.try_fold(0_i8, |acc
, x
| acc
.checked_add(x
)), None
);
2936 assert_eq
!(iter
.next(), Some(60));
2937 let mut iter
= a
.iter().cloned();
2938 assert_eq
!(iter
.try_rfold(0_i8, |acc
, x
| acc
.checked_add(x
)), None
);
2939 assert_eq
!(iter
.next_back(), Some(70));
2943 fn test_chain_try_folds() {
2944 let c
= || (0..10).chain(10..20);
2946 let f
= &|acc
, x
| i32::checked_add(2 * acc
, x
);
2947 assert_eq
!(c().try_fold(7, f
), (0..20).try_fold(7, f
));
2948 assert_eq
!(c().try_rfold(7, f
), (0..20).rev().try_fold(7, f
));
2951 assert_eq
!(iter
.position(|x
| x
== 5), Some(5));
2952 assert_eq
!(iter
.next(), Some(6), "stopped in front, state Both");
2953 assert_eq
!(iter
.position(|x
| x
== 13), Some(6));
2954 assert_eq
!(iter
.next(), Some(14), "stopped in back, state Back");
2955 assert_eq
!(iter
.try_fold(0, |acc
, x
| Some(acc
+ x
)), Some((15..20).sum()));
2957 let mut iter
= c().rev(); // use rev to access try_rfold
2958 assert_eq
!(iter
.position(|x
| x
== 15), Some(4));
2959 assert_eq
!(iter
.next(), Some(14), "stopped in back, state Both");
2960 assert_eq
!(iter
.position(|x
| x
== 5), Some(8));
2961 assert_eq
!(iter
.next(), Some(4), "stopped in front, state Front");
2962 assert_eq
!(iter
.try_fold(0, |acc
, x
| Some(acc
+ x
)), Some((0..4).sum()));
2965 iter
.by_ref().rev().nth(14); // skip the last 15, ending in state Front
2966 assert_eq
!(iter
.try_fold(7, f
), (0..5).try_fold(7, f
));
2969 iter
.nth(14); // skip the first 15, ending in state Back
2970 assert_eq
!(iter
.try_rfold(7, f
), (15..20).try_rfold(7, f
));
2974 fn test_map_try_folds() {
2975 let f
= &|acc
, x
| i32::checked_add(2 * acc
, x
);
2976 assert_eq
!((0..10).map(|x
| x
+ 3).try_fold(7, f
), (3..13).try_fold(7, f
));
2977 assert_eq
!((0..10).map(|x
| x
+ 3).try_rfold(7, f
), (3..13).try_rfold(7, f
));
2979 let mut iter
= (0..40).map(|x
| x
+ 10);
2980 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
2981 assert_eq
!(iter
.next(), Some(20));
2982 assert_eq
!(iter
.try_rfold(0, i8::checked_add
), None
);
2983 assert_eq
!(iter
.next_back(), Some(46));
2987 fn test_filter_try_folds() {
2988 fn p(&x
: &i32) -> bool
{
2991 let f
= &|acc
, x
| i32::checked_add(2 * acc
, x
);
2992 assert_eq
!((-10..20).filter(p
).try_fold(7, f
), (0..10).try_fold(7, f
));
2993 assert_eq
!((-10..20).filter(p
).try_rfold(7, f
), (0..10).try_rfold(7, f
));
2995 let mut iter
= (0..40).filter(|&x
| x
% 2 == 1);
2996 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
2997 assert_eq
!(iter
.next(), Some(25));
2998 assert_eq
!(iter
.try_rfold(0, i8::checked_add
), None
);
2999 assert_eq
!(iter
.next_back(), Some(31));
3003 fn test_filter_map_try_folds() {
3004 let mp
= &|x
| if 0 <= x
&& x
< 10 { Some(x * 2) }
else { None }
;
3005 let f
= &|acc
, x
| i32::checked_add(2 * acc
, x
);
3006 assert_eq
!((-9..20).filter_map(mp
).try_fold(7, f
), (0..10).map(|x
| 2 * x
).try_fold(7, f
));
3007 assert_eq
!((-9..20).filter_map(mp
).try_rfold(7, f
), (0..10).map(|x
| 2 * x
).try_rfold(7, f
));
3009 let mut iter
= (0..40).filter_map(|x
| if x
% 2 == 1 { None }
else { Some(x * 2 + 10) }
);
3010 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
3011 assert_eq
!(iter
.next(), Some(38));
3012 assert_eq
!(iter
.try_rfold(0, i8::checked_add
), None
);
3013 assert_eq
!(iter
.next_back(), Some(78));
3017 fn test_enumerate_try_folds() {
3018 let f
= &|acc
, (i
, x
)| usize::checked_add(2 * acc
, x
/ (i
+ 1) + i
);
3019 assert_eq
!((9..18).enumerate().try_fold(7, f
), (0..9).map(|i
| (i
, i
+ 9)).try_fold(7, f
));
3020 assert_eq
!((9..18).enumerate().try_rfold(7, f
), (0..9).map(|i
| (i
, i
+ 9)).try_rfold(7, f
));
3022 let mut iter
= (100..200).enumerate();
3023 let f
= &|acc
, (i
, x
)| u8::checked_add(acc
, u8::checked_div(x
, i
as u8 + 1)?
);
3024 assert_eq
!(iter
.try_fold(0, f
), None
);
3025 assert_eq
!(iter
.next(), Some((7, 107)));
3026 assert_eq
!(iter
.try_rfold(0, f
), None
);
3027 assert_eq
!(iter
.next_back(), Some((11, 111)));
3031 fn test_peek_try_folds() {
3032 let f
= &|acc
, x
| i32::checked_add(2 * acc
, x
);
3034 assert_eq
!((1..20).peekable().try_fold(7, f
), (1..20).try_fold(7, f
));
3035 assert_eq
!((1..20).peekable().try_rfold(7, f
), (1..20).try_rfold(7, f
));
3037 let mut iter
= (1..20).peekable();
3038 assert_eq
!(iter
.peek(), Some(&1));
3039 assert_eq
!(iter
.try_fold(7, f
), (1..20).try_fold(7, f
));
3041 let mut iter
= (1..20).peekable();
3042 assert_eq
!(iter
.peek(), Some(&1));
3043 assert_eq
!(iter
.try_rfold(7, f
), (1..20).try_rfold(7, f
));
3045 let mut iter
= [100, 20, 30, 40, 50, 60, 70].iter().cloned().peekable();
3046 assert_eq
!(iter
.peek(), Some(&100));
3047 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
3048 assert_eq
!(iter
.peek(), Some(&40));
3050 let mut iter
= [100, 20, 30, 40, 50, 60, 70].iter().cloned().peekable();
3051 assert_eq
!(iter
.peek(), Some(&100));
3052 assert_eq
!(iter
.try_rfold(0, i8::checked_add
), None
);
3053 assert_eq
!(iter
.peek(), Some(&100));
3054 assert_eq
!(iter
.next_back(), Some(50));
3056 let mut iter
= (2..5).peekable();
3057 assert_eq
!(iter
.peek(), Some(&2));
3058 assert_eq
!(iter
.try_for_each(Err
), Err(2));
3059 assert_eq
!(iter
.peek(), Some(&3));
3060 assert_eq
!(iter
.try_for_each(Err
), Err(3));
3061 assert_eq
!(iter
.peek(), Some(&4));
3062 assert_eq
!(iter
.try_for_each(Err
), Err(4));
3063 assert_eq
!(iter
.peek(), None
);
3064 assert_eq
!(iter
.try_for_each(Err
), Ok(()));
3066 let mut iter
= (2..5).peekable();
3067 assert_eq
!(iter
.peek(), Some(&2));
3068 assert_eq
!(iter
.try_rfold((), |(), x
| Err(x
)), Err(4));
3069 assert_eq
!(iter
.peek(), Some(&2));
3070 assert_eq
!(iter
.try_rfold((), |(), x
| Err(x
)), Err(3));
3071 assert_eq
!(iter
.peek(), Some(&2));
3072 assert_eq
!(iter
.try_rfold((), |(), x
| Err(x
)), Err(2));
3073 assert_eq
!(iter
.peek(), None
);
3074 assert_eq
!(iter
.try_rfold((), |(), x
| Err(x
)), Ok(()));
3078 fn test_skip_while_try_fold() {
3079 let f
= &|acc
, x
| i32::checked_add(2 * acc
, x
);
3080 fn p(&x
: &i32) -> bool
{
3083 assert_eq
!((1..20).skip_while(p
).try_fold(7, f
), (6..20).try_fold(7, f
));
3084 let mut iter
= (1..20).skip_while(p
);
3085 assert_eq
!(iter
.nth(5), Some(11));
3086 assert_eq
!(iter
.try_fold(7, f
), (12..20).try_fold(7, f
));
3088 let mut iter
= (0..50).skip_while(|&x
| (x
% 20) < 15);
3089 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
3090 assert_eq
!(iter
.next(), Some(23));
3094 fn test_take_while_folds() {
3095 let f
= &|acc
, x
| i32::checked_add(2 * acc
, x
);
3096 assert_eq
!((1..20).take_while(|&x
| x
!= 10).try_fold(7, f
), (1..10).try_fold(7, f
));
3097 let mut iter
= (1..20).take_while(|&x
| x
!= 10);
3098 assert_eq
!(iter
.try_fold(0, |x
, y
| Some(x
+ y
)), Some((1..10).sum()));
3099 assert_eq
!(iter
.next(), None
, "flag should be set");
3100 let iter
= (1..20).take_while(|&x
| x
!= 10);
3101 assert_eq
!(iter
.fold(0, |x
, y
| x
+ y
), (1..10).sum());
3103 let mut iter
= (10..50).take_while(|&x
| x
!= 40);
3104 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
3105 assert_eq
!(iter
.next(), Some(20));
3109 fn test_skip_try_folds() {
3110 let f
= &|acc
, x
| i32::checked_add(2 * acc
, x
);
3111 assert_eq
!((1..20).skip(9).try_fold(7, f
), (10..20).try_fold(7, f
));
3112 assert_eq
!((1..20).skip(9).try_rfold(7, f
), (10..20).try_rfold(7, f
));
3114 let mut iter
= (0..30).skip(10);
3115 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
3116 assert_eq
!(iter
.next(), Some(20));
3117 assert_eq
!(iter
.try_rfold(0, i8::checked_add
), None
);
3118 assert_eq
!(iter
.next_back(), Some(24));
3122 fn test_skip_nth_back() {
3123 let xs
= [0, 1, 2, 3, 4, 5];
3124 let mut it
= xs
.iter().skip(2);
3125 assert_eq
!(it
.nth_back(0), Some(&5));
3126 assert_eq
!(it
.nth_back(1), Some(&3));
3127 assert_eq
!(it
.nth_back(0), Some(&2));
3128 assert_eq
!(it
.nth_back(0), None
);
3130 let ys
= [2, 3, 4, 5];
3131 let mut ity
= ys
.iter();
3132 let mut it
= xs
.iter().skip(2);
3133 assert_eq
!(it
.nth_back(1), ity
.nth_back(1));
3134 assert_eq
!(it
.clone().nth(0), ity
.clone().nth(0));
3135 assert_eq
!(it
.nth_back(0), ity
.nth_back(0));
3136 assert_eq
!(it
.clone().nth(0), ity
.clone().nth(0));
3137 assert_eq
!(it
.nth_back(0), ity
.nth_back(0));
3138 assert_eq
!(it
.clone().nth(0), ity
.clone().nth(0));
3139 assert_eq
!(it
.nth_back(0), ity
.nth_back(0));
3140 assert_eq
!(it
.clone().nth(0), ity
.clone().nth(0));
3142 let mut it
= xs
.iter().skip(2);
3143 assert_eq
!(it
.nth_back(4), None
);
3144 assert_eq
!(it
.nth_back(0), None
);
3146 let mut it
= xs
.iter();
3147 it
.by_ref().skip(2).nth_back(3);
3148 assert_eq
!(it
.next_back(), Some(&1));
3150 let mut it
= xs
.iter();
3151 it
.by_ref().skip(2).nth_back(10);
3152 assert_eq
!(it
.next_back(), Some(&1));
3156 fn test_take_try_folds() {
3157 let f
= &|acc
, x
| i32::checked_add(2 * acc
, x
);
3158 assert_eq
!((10..30).take(10).try_fold(7, f
), (10..20).try_fold(7, f
));
3159 assert_eq
!((10..30).take(10).try_rfold(7, f
), (10..20).try_rfold(7, f
));
3161 let mut iter
= (10..30).take(20);
3162 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
3163 assert_eq
!(iter
.next(), Some(20));
3164 assert_eq
!(iter
.try_rfold(0, i8::checked_add
), None
);
3165 assert_eq
!(iter
.next_back(), Some(24));
3167 let mut iter
= (2..20).take(3);
3168 assert_eq
!(iter
.try_for_each(Err
), Err(2));
3169 assert_eq
!(iter
.try_for_each(Err
), Err(3));
3170 assert_eq
!(iter
.try_for_each(Err
), Err(4));
3171 assert_eq
!(iter
.try_for_each(Err
), Ok(()));
3173 let mut iter
= (2..20).take(3).rev();
3174 assert_eq
!(iter
.try_for_each(Err
), Err(4));
3175 assert_eq
!(iter
.try_for_each(Err
), Err(3));
3176 assert_eq
!(iter
.try_for_each(Err
), Err(2));
3177 assert_eq
!(iter
.try_for_each(Err
), Ok(()));
3181 fn test_flat_map_try_folds() {
3182 let f
= &|acc
, x
| i32::checked_add(acc
* 2 / 3, x
);
3183 let mr
= &|x
| (5 * x
)..(5 * x
+ 5);
3184 assert_eq
!((0..10).flat_map(mr
).try_fold(7, f
), (0..50).try_fold(7, f
));
3185 assert_eq
!((0..10).flat_map(mr
).try_rfold(7, f
), (0..50).try_rfold(7, f
));
3186 let mut iter
= (0..10).flat_map(mr
);
3188 iter
.next_back(); // have front and back iters in progress
3189 assert_eq
!(iter
.try_rfold(7, f
), (1..49).try_rfold(7, f
));
3191 let mut iter
= (0..10).flat_map(|x
| (4 * x
)..(4 * x
+ 4));
3192 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
3193 assert_eq
!(iter
.next(), Some(17));
3194 assert_eq
!(iter
.try_rfold(0, i8::checked_add
), None
);
3195 assert_eq
!(iter
.next_back(), Some(35));
3199 fn test_flatten_try_folds() {
3200 let f
= &|acc
, x
| i32::checked_add(acc
* 2 / 3, x
);
3201 let mr
= &|x
| (5 * x
)..(5 * x
+ 5);
3202 assert_eq
!((0..10).map(mr
).flatten().try_fold(7, f
), (0..50).try_fold(7, f
));
3203 assert_eq
!((0..10).map(mr
).flatten().try_rfold(7, f
), (0..50).try_rfold(7, f
));
3204 let mut iter
= (0..10).map(mr
).flatten();
3206 iter
.next_back(); // have front and back iters in progress
3207 assert_eq
!(iter
.try_rfold(7, f
), (1..49).try_rfold(7, f
));
3209 let mut iter
= (0..10).map(|x
| (4 * x
)..(4 * x
+ 4)).flatten();
3210 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
3211 assert_eq
!(iter
.next(), Some(17));
3212 assert_eq
!(iter
.try_rfold(0, i8::checked_add
), None
);
3213 assert_eq
!(iter
.next_back(), Some(35));
3217 fn test_functor_laws() {
3219 fn identity
<T
>(x
: T
) -> T
{
3222 assert_eq
!((0..10).map(identity
).sum
::<usize>(), (0..10).sum());
3225 fn f(x
: usize) -> usize {
3228 fn g(x
: usize) -> usize {
3231 fn h(x
: usize) -> usize {
3234 assert_eq
!((0..10).map(f
).map(g
).sum
::<usize>(), (0..10).map(h
).sum());
3238 fn test_monad_laws_left_identity() {
3239 fn f(x
: usize) -> impl Iterator
<Item
= usize> {
3240 (0..10).map(move |y
| x
* y
)
3242 assert_eq
!(once(42).flat_map(f
.clone()).sum
::<usize>(), f(42).sum());
3246 fn test_monad_laws_right_identity() {
3247 assert_eq
!((0..10).flat_map(|x
| once(x
)).sum
::<usize>(), (0..10).sum());
3251 fn test_monad_laws_associativity() {
3252 fn f(x
: usize) -> impl Iterator
<Item
= usize> {
3255 fn g(x
: usize) -> impl Iterator
<Item
= usize> {
3259 (0..10).flat_map(f
).flat_map(g
).sum
::<usize>(),
3260 (0..10).flat_map(|x
| f(x
).flat_map(g
)).sum
::<usize>()
3265 fn test_is_sorted() {
3266 assert
!([1, 2, 2, 9].iter().is_sorted());
3267 assert
!(![1, 3, 2].iter().is_sorted());
3268 assert
!([0].iter().is_sorted());
3269 assert
!(std
::iter
::empty
::<i32>().is_sorted());
3270 assert
!(![0.0, 1.0, f32::NAN
].iter().is_sorted());
3271 assert
!([-2, -1, 0, 3].iter().is_sorted());
3272 assert
!(![-2i32, -1, 0, 3].iter().is_sorted_by_key(|n
| n
.abs()));
3273 assert
!(!["c", "bb", "aaa"].iter().is_sorted());
3274 assert
!(["c", "bb", "aaa"].iter().is_sorted_by_key(|s
| s
.len()));
3278 fn test_partition() {
3279 fn check(xs
: &mut [i32], ref p
: impl Fn(&i32) -> bool
, expected
: usize) {
3280 let i
= xs
.iter_mut().partition_in_place(p
);
3281 assert_eq
!(expected
, i
);
3282 assert
!(xs
[..i
].iter().all(p
));
3283 assert
!(!xs
[i
..].iter().any(p
));
3284 assert
!(xs
.iter().is_partitioned(p
));
3285 if i
== 0 || i
== xs
.len() {
3286 assert
!(xs
.iter().rev().is_partitioned(p
));
3288 assert
!(!xs
.iter().rev().is_partitioned(p
));
3292 check(&mut [], |_
| true, 0);
3293 check(&mut [], |_
| false, 0);
3295 check(&mut [0], |_
| true, 1);
3296 check(&mut [0], |_
| false, 0);
3298 check(&mut [-1, 1], |&x
| x
> 0, 1);
3299 check(&mut [-1, 1], |&x
| x
< 0, 1);
3301 let ref mut xs
= [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
3302 check(xs
, |_
| true, 10);
3303 check(xs
, |_
| false, 0);
3304 check(xs
, |&x
| x
% 2 == 0, 5); // evens
3305 check(xs
, |&x
| x
% 2 == 1, 5); // odds
3306 check(xs
, |&x
| x
% 3 == 0, 4); // multiple of 3
3307 check(xs
, |&x
| x
% 4 == 0, 3); // multiple of 4
3308 check(xs
, |&x
| x
% 5 == 0, 2); // multiple of 5
3309 check(xs
, |&x
| x
< 3, 3); // small
3310 check(xs
, |&x
| x
> 6, 3); // large
3313 /// An iterator that panics whenever `next` or next_back` is called
3314 /// after `None` has already been returned. This does not violate
3315 /// `Iterator`'s contract. Used to test that iterator adaptors don't
3316 /// poll their inner iterators after exhausting them.
3317 struct NonFused
<I
> {
3322 impl<I
> NonFused
<I
> {
3323 fn new(iter
: I
) -> Self {
3324 Self { iter, done: false }
3328 impl<I
> Iterator
for NonFused
<I
>
3332 type Item
= I
::Item
;
3334 fn next(&mut self) -> Option
<Self::Item
> {
3335 assert
!(!self.done
, "this iterator has already returned None");
3336 self.iter
.next().or_else(|| {
3343 impl<I
> DoubleEndedIterator
for NonFused
<I
>
3345 I
: DoubleEndedIterator
,
3347 fn next_back(&mut self) -> Option
<Self::Item
> {
3348 assert
!(!self.done
, "this iterator has already returned None");
3349 self.iter
.next_back().or_else(|| {
3357 fn test_peekable_non_fused() {
3358 let mut iter
= NonFused
::new(empty
::<i32>()).peekable();
3360 assert_eq
!(iter
.peek(), None
);
3361 assert_eq
!(iter
.next_back(), None
);
3365 fn test_flatten_non_fused_outer() {
3366 let mut iter
= NonFused
::new(once(0..2)).flatten();
3368 assert_eq
!(iter
.next_back(), Some(1));
3369 assert_eq
!(iter
.next(), Some(0));
3370 assert_eq
!(iter
.next(), None
);
3374 fn test_flatten_non_fused_inner() {
3375 let mut iter
= once(0..1).chain(once(1..3)).flat_map(NonFused
::new
);
3377 assert_eq
!(iter
.next_back(), Some(2));
3378 assert_eq
!(iter
.next(), Some(0));
3379 assert_eq
!(iter
.next(), Some(1));
3380 assert_eq
!(iter
.next(), None
);