2 use core
::convert
::TryFrom
;
4 use core
::{i8, i16, isize}
;
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()));
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() {
56 assert
!(xs
.iter().eq(ys
.iter().rev()));
57 assert
!(xs
.iter().lt(xs
.iter().skip(2)));
61 fn test_counter_from_iter() {
62 let it
= (0..).step_by(5).take(10);
63 let xs
: Vec
<isize> = FromIterator
::from_iter(it
);
64 assert_eq
!(xs
, [0, 5, 10, 15, 20, 25, 30, 35, 40, 45]);
68 fn test_iterator_chain() {
69 let xs
= [0, 1, 2, 3, 4, 5];
70 let ys
= [30, 40, 50, 60];
71 let expected
= [0, 1, 2, 3, 4, 5, 30, 40, 50, 60];
72 let it
= xs
.iter().chain(&ys
);
75 assert_eq
!(x
, expected
[i
]);
78 assert_eq
!(i
, expected
.len());
80 let ys
= (30..).step_by(10).take(4);
81 let it
= xs
.iter().cloned().chain(ys
);
84 assert_eq
!(x
, expected
[i
]);
87 assert_eq
!(i
, expected
.len());
91 fn test_iterator_chain_nth() {
92 let xs
= [0, 1, 2, 3, 4, 5];
93 let ys
= [30, 40, 50, 60];
95 let expected
= [0, 1, 2, 3, 4, 5, 30, 40, 50, 60];
96 for (i
, x
) in expected
.iter().enumerate() {
97 assert_eq
!(Some(x
), xs
.iter().chain(&ys
).nth(i
));
99 assert_eq
!(zs
.iter().chain(&xs
).nth(0), Some(&0));
101 let mut it
= xs
.iter().chain(&zs
);
102 assert_eq
!(it
.nth(5), Some(&5));
103 assert_eq
!(it
.next(), None
);
107 fn test_iterator_chain_last() {
108 let xs
= [0, 1, 2, 3, 4, 5];
109 let ys
= [30, 40, 50, 60];
111 assert_eq
!(xs
.iter().chain(&ys
).last(), Some(&60));
112 assert_eq
!(zs
.iter().chain(&ys
).last(), Some(&60));
113 assert_eq
!(ys
.iter().chain(&zs
).last(), Some(&60));
114 assert_eq
!(zs
.iter().chain(&zs
).last(), None
);
118 fn test_iterator_chain_count() {
119 let xs
= [0, 1, 2, 3, 4, 5];
120 let ys
= [30, 40, 50, 60];
122 assert_eq
!(xs
.iter().chain(&ys
).count(), 10);
123 assert_eq
!(zs
.iter().chain(&ys
).count(), 4);
127 fn test_iterator_chain_find() {
128 let xs
= [0, 1, 2, 3, 4, 5];
129 let ys
= [30, 40, 50, 60];
130 let mut iter
= xs
.iter().chain(&ys
);
131 assert_eq
!(iter
.find(|&&i
| i
== 4), Some(&4));
132 assert_eq
!(iter
.next(), Some(&5));
133 assert_eq
!(iter
.find(|&&i
| i
== 40), Some(&40));
134 assert_eq
!(iter
.next(), Some(&50));
135 assert_eq
!(iter
.find(|&&i
| i
== 100), None
);
136 assert_eq
!(iter
.next(), None
);
141 let xs
= [0, 1, 2, 4, 5];
142 let ys
= [10, 11, 12];
144 let mut it
= xs
.iter().zip(&ys
);
145 assert_eq
!(it
.nth(0), Some((&0, &10)));
146 assert_eq
!(it
.nth(1), Some((&2, &12)));
147 assert_eq
!(it
.nth(0), None
);
149 let mut it
= xs
.iter().zip(&ys
);
150 assert_eq
!(it
.nth(3), None
);
152 let mut it
= ys
.iter().zip(&xs
);
153 assert_eq
!(it
.nth(3), None
);
157 fn test_zip_nth_side_effects() {
158 let mut a
= Vec
::new();
159 let mut b
= Vec
::new();
160 let value
= [1, 2, 3, 4, 5, 6].iter().cloned()
165 .zip([2, 3, 4, 5, 6, 7, 8].iter().cloned().map(|n
| {
171 assert_eq
!(value
, Some((50, 6000)));
172 assert_eq
!(a
, vec
![1, 2, 3, 4, 5]);
173 assert_eq
!(b
, vec
![200, 300, 400, 500, 600]);
177 fn test_iterator_step_by() {
179 let mut it
= (0..).step_by(1).take(3);
180 assert_eq
!(it
.next(), Some(0));
181 assert_eq
!(it
.next(), Some(1));
182 assert_eq
!(it
.next(), Some(2));
183 assert_eq
!(it
.next(), None
);
185 let mut it
= (0..).step_by(3).take(4);
186 assert_eq
!(it
.next(), Some(0));
187 assert_eq
!(it
.next(), Some(3));
188 assert_eq
!(it
.next(), Some(6));
189 assert_eq
!(it
.next(), Some(9));
190 assert_eq
!(it
.next(), None
);
192 let mut it
= (0..3).step_by(1);
193 assert_eq
!(it
.next_back(), Some(2));
194 assert_eq
!(it
.next_back(), Some(1));
195 assert_eq
!(it
.next_back(), Some(0));
196 assert_eq
!(it
.next_back(), None
);
198 let mut it
= (0..11).step_by(3);
199 assert_eq
!(it
.next_back(), Some(9));
200 assert_eq
!(it
.next_back(), Some(6));
201 assert_eq
!(it
.next_back(), Some(3));
202 assert_eq
!(it
.next_back(), Some(0));
203 assert_eq
!(it
.next_back(), None
);
207 fn test_iterator_step_by_nth() {
208 let mut it
= (0..16).step_by(5);
209 assert_eq
!(it
.nth(0), Some(0));
210 assert_eq
!(it
.nth(0), Some(5));
211 assert_eq
!(it
.nth(0), Some(10));
212 assert_eq
!(it
.nth(0), Some(15));
213 assert_eq
!(it
.nth(0), None
);
215 let it
= (0..18).step_by(5);
216 assert_eq
!(it
.clone().nth(0), Some(0));
217 assert_eq
!(it
.clone().nth(1), Some(5));
218 assert_eq
!(it
.clone().nth(2), Some(10));
219 assert_eq
!(it
.clone().nth(3), Some(15));
220 assert_eq
!(it
.clone().nth(4), None
);
221 assert_eq
!(it
.clone().nth(42), None
);
225 fn test_iterator_step_by_nth_overflow() {
226 #[cfg(target_pointer_width = "8")]
228 #[cfg(target_pointer_width = "16")]
230 #[cfg(target_pointer_width = "32")]
232 #[cfg(target_pointer_width = "64")]
237 impl Iterator
for &mut Test
{
239 fn next(&mut self) -> Option
<Self::Item
> { Some(21) }
240 fn nth(&mut self, n
: usize) -> Option
<Self::Item
> {
241 self.0 += n
as Bigger
+ 1;
246 let mut it
= Test(0);
247 let root
= usize::MAX
>> (::std
::mem
::size_of
::<usize>() * 8 / 2);
249 (&mut it
).step_by(n
).nth(n
);
250 assert_eq
!(it
.0, n
as Bigger
* n
as Bigger
);
253 let mut it
= Test(0);
254 (&mut it
).step_by(usize::MAX
).nth(5);
255 assert_eq
!(it
.0, (usize::MAX
as Bigger
) * 5);
258 let mut it
= Test(0);
259 (&mut it
).step_by(2).nth(usize::MAX
);
260 assert_eq
!(it
.0, (usize::MAX
as Bigger
) * 2);
263 let mut it
= Test(0);
264 (&mut it
).step_by(1).nth(usize::MAX
);
265 assert_eq
!(it
.0, (usize::MAX
as Bigger
) * 1);
269 fn test_iterator_step_by_nth_back() {
270 let mut it
= (0..16).step_by(5);
271 assert_eq
!(it
.nth_back(0), Some(15));
272 assert_eq
!(it
.nth_back(0), Some(10));
273 assert_eq
!(it
.nth_back(0), Some(5));
274 assert_eq
!(it
.nth_back(0), Some(0));
275 assert_eq
!(it
.nth_back(0), None
);
277 let mut it
= (0..16).step_by(5);
278 assert_eq
!(it
.next(), Some(0)); // to set `first_take` to `false`
279 assert_eq
!(it
.nth_back(0), Some(15));
280 assert_eq
!(it
.nth_back(0), Some(10));
281 assert_eq
!(it
.nth_back(0), Some(5));
282 assert_eq
!(it
.nth_back(0), None
);
284 let it
= || (0..18).step_by(5);
285 assert_eq
!(it().nth_back(0), Some(15));
286 assert_eq
!(it().nth_back(1), Some(10));
287 assert_eq
!(it().nth_back(2), Some(5));
288 assert_eq
!(it().nth_back(3), Some(0));
289 assert_eq
!(it().nth_back(4), None
);
290 assert_eq
!(it().nth_back(42), None
);
295 fn test_iterator_step_by_zero() {
296 let mut it
= (0..).step_by(0);
301 fn test_iterator_step_by_size_hint() {
302 struct StubSizeHint(usize, Option
<usize>);
303 impl Iterator
for StubSizeHint
{
305 fn next(&mut self) -> Option
<()> {
307 if let Some(ref mut upper
) = self.1 {
312 fn size_hint(&self) -> (usize, Option
<usize>) {
317 // The two checks in each case are needed because the logic
318 // is different before the first call to `next()`.
320 let mut it
= StubSizeHint(10, Some(10)).step_by(1);
321 assert_eq
!(it
.size_hint(), (10, Some(10)));
323 assert_eq
!(it
.size_hint(), (9, Some(9)));
326 let mut it
= StubSizeHint(10, Some(10)).step_by(3);
327 assert_eq
!(it
.size_hint(), (4, Some(4)));
329 assert_eq
!(it
.size_hint(), (3, Some(3)));
331 // larger base range, but not enough to get another element
332 let mut it
= StubSizeHint(12, Some(12)).step_by(3);
333 assert_eq
!(it
.size_hint(), (4, Some(4)));
335 assert_eq
!(it
.size_hint(), (3, Some(3)));
337 // smaller base range, so fewer resulting elements
338 let mut it
= StubSizeHint(9, Some(9)).step_by(3);
339 assert_eq
!(it
.size_hint(), (3, Some(3)));
341 assert_eq
!(it
.size_hint(), (2, Some(2)));
343 // infinite upper bound
344 let mut it
= StubSizeHint(usize::MAX
, None
).step_by(1);
345 assert_eq
!(it
.size_hint(), (usize::MAX
, None
));
347 assert_eq
!(it
.size_hint(), (usize::MAX
-1, None
));
349 // still infinite with larger step
350 let mut it
= StubSizeHint(7, None
).step_by(3);
351 assert_eq
!(it
.size_hint(), (3, None
));
353 assert_eq
!(it
.size_hint(), (2, None
));
355 // propagates ExactSizeIterator
357 let it
= a
.iter().step_by(2);
358 assert_eq
!(it
.len(), 3);
360 // Cannot be TrustedLen as a step greater than one makes an iterator
361 // with (usize::MAX, None) no longer meet the safety requirements
362 trait TrustedLenCheck { fn test(self) -> bool; }
363 impl<T
:Iterator
> TrustedLenCheck
for T
{
364 default fn test(self) -> bool { false }
366 impl<T
:TrustedLen
> TrustedLenCheck
for T
{
367 fn test(self) -> bool { true }
369 assert
!(TrustedLenCheck
::test(a
.iter()));
370 assert
!(!TrustedLenCheck
::test(a
.iter().step_by(1)));
374 fn test_filter_map() {
375 let it
= (0..).step_by(1).take(10)
376 .filter_map(|x
| if x
% 2 == 0 { Some(x*x) }
else { None }
);
377 assert_eq
!(it
.collect
::<Vec
<usize>>(), [0*0, 2*2, 4*4, 6*6, 8*8]);
381 fn test_filter_map_fold() {
382 let xs
= [0, 1, 2, 3, 4, 5, 6, 7, 8];
383 let ys
= [0*0, 2*2, 4*4, 6*6, 8*8];
384 let it
= xs
.iter().filter_map(|&x
| if x
% 2 == 0 { Some(x*x) }
else { None }
);
385 let i
= it
.fold(0, |i
, x
| {
386 assert_eq
!(x
, ys
[i
]);
389 assert_eq
!(i
, ys
.len());
391 let it
= xs
.iter().filter_map(|&x
| if x
% 2 == 0 { Some(x*x) }
else { None }
);
392 let i
= it
.rfold(ys
.len(), |i
, x
| {
393 assert_eq
!(x
, ys
[i
- 1]);
400 fn test_iterator_enumerate() {
401 let xs
= [0, 1, 2, 3, 4, 5];
402 let it
= xs
.iter().enumerate();
409 fn test_iterator_enumerate_nth() {
410 let xs
= [0, 1, 2, 3, 4, 5];
411 for (i
, &x
) in xs
.iter().enumerate() {
415 let mut it
= xs
.iter().enumerate();
416 while let Some((i
, &x
)) = it
.nth(0) {
420 let mut it
= xs
.iter().enumerate();
421 while let Some((i
, &x
)) = it
.nth(1) {
425 let (i
, &x
) = xs
.iter().enumerate().nth(3).unwrap();
431 fn test_iterator_enumerate_nth_back() {
432 let xs
= [0, 1, 2, 3, 4, 5];
433 let mut it
= xs
.iter().enumerate();
434 while let Some((i
, &x
)) = it
.nth_back(0) {
438 let mut it
= xs
.iter().enumerate();
439 while let Some((i
, &x
)) = it
.nth_back(1) {
443 let (i
, &x
) = xs
.iter().enumerate().nth_back(3).unwrap();
449 fn test_iterator_enumerate_count() {
450 let xs
= [0, 1, 2, 3, 4, 5];
451 assert_eq
!(xs
.iter().enumerate().count(), 6);
455 fn test_iterator_enumerate_fold() {
456 let xs
= [0, 1, 2, 3, 4, 5];
457 let mut it
= xs
.iter().enumerate();
458 // steal a couple to get an interesting offset
459 assert_eq
!(it
.next(), Some((0, &0)));
460 assert_eq
!(it
.next(), Some((1, &1)));
461 let i
= it
.fold(2, |i
, (j
, &x
)| {
463 assert_eq
!(x
, xs
[j
]);
466 assert_eq
!(i
, xs
.len());
468 let mut it
= xs
.iter().enumerate();
469 assert_eq
!(it
.next(), Some((0, &0)));
470 let i
= it
.rfold(xs
.len() - 1, |i
, (j
, &x
)| {
472 assert_eq
!(x
, xs
[j
]);
479 fn test_iterator_filter_count() {
480 let xs
= [0, 1, 2, 3, 4, 5, 6, 7, 8];
481 assert_eq
!(xs
.iter().filter(|&&x
| x
% 2 == 0).count(), 5);
485 fn test_iterator_filter_fold() {
486 let xs
= [0, 1, 2, 3, 4, 5, 6, 7, 8];
487 let ys
= [0, 2, 4, 6, 8];
488 let it
= xs
.iter().filter(|&&x
| x
% 2 == 0);
489 let i
= it
.fold(0, |i
, &x
| {
490 assert_eq
!(x
, ys
[i
]);
493 assert_eq
!(i
, ys
.len());
495 let it
= xs
.iter().filter(|&&x
| x
% 2 == 0);
496 let i
= it
.rfold(ys
.len(), |i
, &x
| {
497 assert_eq
!(x
, ys
[i
- 1]);
504 fn test_iterator_peekable() {
505 let xs
= vec
![0, 1, 2, 3, 4, 5];
507 let mut it
= xs
.iter().cloned().peekable();
508 assert_eq
!(it
.len(), 6);
509 assert_eq
!(it
.peek().unwrap(), &0);
510 assert_eq
!(it
.len(), 6);
511 assert_eq
!(it
.next().unwrap(), 0);
512 assert_eq
!(it
.len(), 5);
513 assert_eq
!(it
.next().unwrap(), 1);
514 assert_eq
!(it
.len(), 4);
515 assert_eq
!(it
.next().unwrap(), 2);
516 assert_eq
!(it
.len(), 3);
517 assert_eq
!(it
.peek().unwrap(), &3);
518 assert_eq
!(it
.len(), 3);
519 assert_eq
!(it
.peek().unwrap(), &3);
520 assert_eq
!(it
.len(), 3);
521 assert_eq
!(it
.next().unwrap(), 3);
522 assert_eq
!(it
.len(), 2);
523 assert_eq
!(it
.next().unwrap(), 4);
524 assert_eq
!(it
.len(), 1);
525 assert_eq
!(it
.peek().unwrap(), &5);
526 assert_eq
!(it
.len(), 1);
527 assert_eq
!(it
.next().unwrap(), 5);
528 assert_eq
!(it
.len(), 0);
529 assert
!(it
.peek().is_none());
530 assert_eq
!(it
.len(), 0);
531 assert
!(it
.next().is_none());
532 assert_eq
!(it
.len(), 0);
534 let mut it
= xs
.iter().cloned().peekable();
535 assert_eq
!(it
.len(), 6);
536 assert_eq
!(it
.peek().unwrap(), &0);
537 assert_eq
!(it
.len(), 6);
538 assert_eq
!(it
.next_back().unwrap(), 5);
539 assert_eq
!(it
.len(), 5);
540 assert_eq
!(it
.next_back().unwrap(), 4);
541 assert_eq
!(it
.len(), 4);
542 assert_eq
!(it
.next_back().unwrap(), 3);
543 assert_eq
!(it
.len(), 3);
544 assert_eq
!(it
.peek().unwrap(), &0);
545 assert_eq
!(it
.len(), 3);
546 assert_eq
!(it
.peek().unwrap(), &0);
547 assert_eq
!(it
.len(), 3);
548 assert_eq
!(it
.next_back().unwrap(), 2);
549 assert_eq
!(it
.len(), 2);
550 assert_eq
!(it
.next_back().unwrap(), 1);
551 assert_eq
!(it
.len(), 1);
552 assert_eq
!(it
.peek().unwrap(), &0);
553 assert_eq
!(it
.len(), 1);
554 assert_eq
!(it
.next_back().unwrap(), 0);
555 assert_eq
!(it
.len(), 0);
556 assert
!(it
.peek().is_none());
557 assert_eq
!(it
.len(), 0);
558 assert
!(it
.next_back().is_none());
559 assert_eq
!(it
.len(), 0);
563 fn test_iterator_peekable_count() {
564 let xs
= [0, 1, 2, 3, 4, 5];
566 let zs
: [i32; 0] = [];
568 assert_eq
!(xs
.iter().peekable().count(), 6);
570 let mut it
= xs
.iter().peekable();
571 assert_eq
!(it
.peek(), Some(&&0));
572 assert_eq
!(it
.count(), 6);
574 assert_eq
!(ys
.iter().peekable().count(), 1);
576 let mut it
= ys
.iter().peekable();
577 assert_eq
!(it
.peek(), Some(&&10));
578 assert_eq
!(it
.count(), 1);
580 assert_eq
!(zs
.iter().peekable().count(), 0);
582 let mut it
= zs
.iter().peekable();
583 assert_eq
!(it
.peek(), None
);
588 fn test_iterator_peekable_nth() {
589 let xs
= [0, 1, 2, 3, 4, 5];
590 let mut it
= xs
.iter().peekable();
592 assert_eq
!(it
.peek(), Some(&&0));
593 assert_eq
!(it
.nth(0), Some(&0));
594 assert_eq
!(it
.peek(), Some(&&1));
595 assert_eq
!(it
.nth(1), Some(&2));
596 assert_eq
!(it
.peek(), Some(&&3));
597 assert_eq
!(it
.nth(2), Some(&5));
598 assert_eq
!(it
.next(), None
);
602 fn test_iterator_peekable_last() {
603 let xs
= [0, 1, 2, 3, 4, 5];
606 let mut it
= xs
.iter().peekable();
607 assert_eq
!(it
.peek(), Some(&&0));
608 assert_eq
!(it
.last(), Some(&5));
610 let mut it
= ys
.iter().peekable();
611 assert_eq
!(it
.peek(), Some(&&0));
612 assert_eq
!(it
.last(), Some(&0));
614 let mut it
= ys
.iter().peekable();
615 assert_eq
!(it
.next(), Some(&0));
616 assert_eq
!(it
.peek(), None
);
617 assert_eq
!(it
.last(), None
);
621 fn test_iterator_peekable_fold() {
622 let xs
= [0, 1, 2, 3, 4, 5];
623 let mut it
= xs
.iter().peekable();
624 assert_eq
!(it
.peek(), Some(&&0));
625 let i
= it
.fold(0, |i
, &x
| {
626 assert_eq
!(x
, xs
[i
]);
629 assert_eq
!(i
, xs
.len());
633 fn test_iterator_peekable_rfold() {
634 let xs
= [0, 1, 2, 3, 4, 5];
635 let mut it
= xs
.iter().peekable();
636 assert_eq
!(it
.peek(), Some(&&0));
637 let i
= it
.rfold(0, |i
, &x
| {
638 assert_eq
!(x
, xs
[xs
.len() - 1 - i
]);
641 assert_eq
!(i
, xs
.len());
644 /// This is an iterator that follows the Iterator contract,
645 /// but it is not fused. After having returned None once, it will start
646 /// producing elements if .next() is called again.
647 pub struct CycleIter
<'a
, T
> {
652 pub fn cycle
<T
>(data
: &[T
]) -> CycleIter
<'_
, T
> {
659 impl<'a
, T
> Iterator
for CycleIter
<'a
, T
> {
661 fn next(&mut self) -> Option
<Self::Item
> {
662 let elt
= self.data
.get(self.index
);
664 self.index
%= 1 + self.data
.len();
670 fn test_iterator_peekable_remember_peek_none_1() {
671 // Check that the loop using .peek() terminates
672 let data
= [1, 2, 3];
673 let mut iter
= cycle(&data
).peekable();
676 while let Some(_
) = iter
.next() {
677 let is_the_last
= iter
.peek().is_none();
678 assert_eq
!(is_the_last
, n
== data
.len() - 1);
680 if n
> data
.len() { break; }
682 assert_eq
!(n
, data
.len());
686 fn test_iterator_peekable_remember_peek_none_2() {
688 let mut iter
= cycle(&data
).peekable();
690 assert_eq
!(iter
.peek(), None
);
691 assert_eq
!(iter
.last(), None
);
695 fn test_iterator_peekable_remember_peek_none_3() {
697 let mut iter
= cycle(&data
).peekable();
699 assert_eq
!(iter
.nth(0), Some(&0));
701 let mut iter
= cycle(&data
).peekable();
703 assert_eq
!(iter
.peek(), None
);
704 assert_eq
!(iter
.nth(0), None
);
708 fn test_iterator_take_while() {
709 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19];
710 let ys
= [0, 1, 2, 3, 5, 13];
711 let it
= xs
.iter().take_while(|&x
| *x
< 15);
714 assert_eq
!(*x
, ys
[i
]);
717 assert_eq
!(i
, ys
.len());
721 fn test_iterator_skip_while() {
722 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19];
723 let ys
= [15, 16, 17, 19];
724 let it
= xs
.iter().skip_while(|&x
| *x
< 15);
727 assert_eq
!(*x
, ys
[i
]);
730 assert_eq
!(i
, ys
.len());
734 fn test_iterator_skip_while_fold() {
735 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19];
736 let ys
= [15, 16, 17, 19];
737 let it
= xs
.iter().skip_while(|&x
| *x
< 15);
738 let i
= it
.fold(0, |i
, &x
| {
739 assert_eq
!(x
, ys
[i
]);
742 assert_eq
!(i
, ys
.len());
744 let mut it
= xs
.iter().skip_while(|&x
| *x
< 15);
745 assert_eq
!(it
.next(), Some(&ys
[0])); // process skips before folding
746 let i
= it
.fold(1, |i
, &x
| {
747 assert_eq
!(x
, ys
[i
]);
750 assert_eq
!(i
, ys
.len());
754 fn test_iterator_skip() {
755 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
756 let ys
= [13, 15, 16, 17, 19, 20, 30];
757 let mut it
= xs
.iter().skip(5);
759 while let Some(&x
) = it
.next() {
760 assert_eq
!(x
, ys
[i
]);
762 assert_eq
!(it
.len(), xs
.len()-5-i
);
764 assert_eq
!(i
, ys
.len());
765 assert_eq
!(it
.len(), 0);
769 fn test_iterator_skip_doubleended() {
770 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
771 let mut it
= xs
.iter().rev().skip(5);
772 assert_eq
!(it
.next(), Some(&15));
773 assert_eq
!(it
.by_ref().rev().next(), Some(&0));
774 assert_eq
!(it
.next(), Some(&13));
775 assert_eq
!(it
.by_ref().rev().next(), Some(&1));
776 assert_eq
!(it
.next(), Some(&5));
777 assert_eq
!(it
.by_ref().rev().next(), Some(&2));
778 assert_eq
!(it
.next(), Some(&3));
779 assert_eq
!(it
.next(), None
);
780 let mut it
= xs
.iter().rev().skip(5).rev();
781 assert_eq
!(it
.next(), Some(&0));
782 assert_eq
!(it
.rev().next(), Some(&15));
783 let mut it_base
= xs
.iter();
785 let mut it
= it_base
.by_ref().skip(5).rev();
786 assert_eq
!(it
.next(), Some(&30));
787 assert_eq
!(it
.next(), Some(&20));
788 assert_eq
!(it
.next(), Some(&19));
789 assert_eq
!(it
.next(), Some(&17));
790 assert_eq
!(it
.next(), Some(&16));
791 assert_eq
!(it
.next(), Some(&15));
792 assert_eq
!(it
.next(), Some(&13));
793 assert_eq
!(it
.next(), None
);
795 // make sure the skipped parts have not been consumed
796 assert_eq
!(it_base
.next(), Some(&0));
797 assert_eq
!(it_base
.next(), Some(&1));
798 assert_eq
!(it_base
.next(), Some(&2));
799 assert_eq
!(it_base
.next(), Some(&3));
800 assert_eq
!(it_base
.next(), Some(&5));
801 assert_eq
!(it_base
.next(), None
);
802 let it
= xs
.iter().skip(5).rev();
803 assert_eq
!(it
.last(), Some(&13));
807 fn test_iterator_skip_nth() {
808 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
810 let mut it
= xs
.iter().skip(0);
811 assert_eq
!(it
.nth(0), Some(&0));
812 assert_eq
!(it
.nth(1), Some(&2));
814 let mut it
= xs
.iter().skip(5);
815 assert_eq
!(it
.nth(0), Some(&13));
816 assert_eq
!(it
.nth(1), Some(&16));
818 let mut it
= xs
.iter().skip(12);
819 assert_eq
!(it
.nth(0), None
);
824 fn test_iterator_skip_count() {
825 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
827 assert_eq
!(xs
.iter().skip(0).count(), 12);
828 assert_eq
!(xs
.iter().skip(1).count(), 11);
829 assert_eq
!(xs
.iter().skip(11).count(), 1);
830 assert_eq
!(xs
.iter().skip(12).count(), 0);
831 assert_eq
!(xs
.iter().skip(13).count(), 0);
835 fn test_iterator_skip_last() {
836 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
838 assert_eq
!(xs
.iter().skip(0).last(), Some(&30));
839 assert_eq
!(xs
.iter().skip(1).last(), Some(&30));
840 assert_eq
!(xs
.iter().skip(11).last(), Some(&30));
841 assert_eq
!(xs
.iter().skip(12).last(), None
);
842 assert_eq
!(xs
.iter().skip(13).last(), None
);
844 let mut it
= xs
.iter().skip(5);
845 assert_eq
!(it
.next(), Some(&13));
846 assert_eq
!(it
.last(), Some(&30));
850 fn test_iterator_skip_fold() {
851 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
852 let ys
= [13, 15, 16, 17, 19, 20, 30];
854 let it
= xs
.iter().skip(5);
855 let i
= it
.fold(0, |i
, &x
| {
856 assert_eq
!(x
, ys
[i
]);
859 assert_eq
!(i
, ys
.len());
861 let mut it
= xs
.iter().skip(5);
862 assert_eq
!(it
.next(), Some(&ys
[0])); // process skips before folding
863 let i
= it
.fold(1, |i
, &x
| {
864 assert_eq
!(x
, ys
[i
]);
867 assert_eq
!(i
, ys
.len());
869 let it
= xs
.iter().skip(5);
870 let i
= it
.rfold(ys
.len(), |i
, &x
| {
872 assert_eq
!(x
, ys
[i
]);
877 let mut it
= xs
.iter().skip(5);
878 assert_eq
!(it
.next(), Some(&ys
[0])); // process skips before folding
879 let i
= it
.rfold(ys
.len(), |i
, &x
| {
881 assert_eq
!(x
, ys
[i
]);
889 fn test_iterator_take() {
890 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19];
891 let ys
= [0, 1, 2, 3, 5];
893 let mut it
= xs
.iter().take(ys
.len());
895 assert_eq
!(it
.len(), ys
.len());
896 while let Some(&x
) = it
.next() {
897 assert_eq
!(x
, ys
[i
]);
899 assert_eq
!(it
.len(), ys
.len() - i
);
901 assert_eq
!(i
, ys
.len());
902 assert_eq
!(it
.len(), 0);
904 let mut it
= xs
.iter().take(ys
.len());
906 assert_eq
!(it
.len(), ys
.len());
907 while let Some(&x
) = it
.next_back() {
909 assert_eq
!(x
, ys
[ys
.len() - i
]);
910 assert_eq
!(it
.len(), ys
.len() - i
);
912 assert_eq
!(i
, ys
.len());
913 assert_eq
!(it
.len(), 0);
917 fn test_iterator_take_nth() {
918 let xs
= [0, 1, 2, 4, 5];
919 let mut it
= xs
.iter();
921 let mut take
= it
.by_ref().take(3);
923 while let Some(&x
) = take
.nth(0) {
928 assert_eq
!(it
.nth(1), Some(&5));
929 assert_eq
!(it
.nth(0), None
);
931 let xs
= [0, 1, 2, 3, 4];
932 let mut it
= xs
.iter().take(7);
934 while let Some(&x
) = it
.nth(1) {
941 fn test_iterator_take_nth_back() {
942 let xs
= [0, 1, 2, 4, 5];
943 let mut it
= xs
.iter();
945 let mut take
= it
.by_ref().take(3);
947 while let Some(&x
) = take
.nth_back(0) {
949 assert_eq
!(x
, 3 - i
);
952 assert_eq
!(it
.nth_back(0), None
);
954 let xs
= [0, 1, 2, 3, 4];
955 let mut it
= xs
.iter().take(7);
956 assert_eq
!(it
.nth_back(1), Some(&3));
957 assert_eq
!(it
.nth_back(1), Some(&1));
958 assert_eq
!(it
.nth_back(1), None
);
962 fn test_iterator_take_short() {
963 let xs
= [0, 1, 2, 3];
965 let mut it
= xs
.iter().take(5);
967 assert_eq
!(it
.len(), xs
.len());
968 while let Some(&x
) = it
.next() {
969 assert_eq
!(x
, xs
[i
]);
971 assert_eq
!(it
.len(), xs
.len() - i
);
973 assert_eq
!(i
, xs
.len());
974 assert_eq
!(it
.len(), 0);
976 let mut it
= xs
.iter().take(5);
978 assert_eq
!(it
.len(), xs
.len());
979 while let Some(&x
) = it
.next_back() {
981 assert_eq
!(x
, xs
[xs
.len() - i
]);
982 assert_eq
!(it
.len(), xs
.len() - i
);
984 assert_eq
!(i
, xs
.len());
985 assert_eq
!(it
.len(), 0);
989 fn test_iterator_scan() {
990 // test the type inference
991 fn add(old
: &mut isize, new
: &usize) -> Option
<f64> {
992 *old
+= *new
as isize;
995 let xs
= [0, 1, 2, 3, 4];
996 let ys
= [0f64, 1.0, 3.0, 6.0, 10.0];
998 let it
= xs
.iter().scan(0, add
);
1001 assert_eq
!(x
, ys
[i
]);
1004 assert_eq
!(i
, ys
.len());
1008 fn test_iterator_flat_map() {
1010 let ys
= [0, 1, 2, 3, 4, 5, 6, 7, 8];
1011 let it
= xs
.iter().flat_map(|&x
| (x
..).step_by(1).take(3));
1014 assert_eq
!(x
, ys
[i
]);
1017 assert_eq
!(i
, ys
.len());
1020 /// Tests `FlatMap::fold` with items already picked off the front and back,
1021 /// to make sure all parts of the `FlatMap` are folded correctly.
1023 fn test_iterator_flat_map_fold() {
1025 let ys
= [1, 2, 3, 4, 5, 6, 7];
1026 let mut it
= xs
.iter().flat_map(|&x
| x
..x
+3);
1027 assert_eq
!(it
.next(), Some(0));
1028 assert_eq
!(it
.next_back(), Some(8));
1029 let i
= it
.fold(0, |i
, x
| {
1030 assert_eq
!(x
, ys
[i
]);
1033 assert_eq
!(i
, ys
.len());
1035 let mut it
= xs
.iter().flat_map(|&x
| x
..x
+3);
1036 assert_eq
!(it
.next(), Some(0));
1037 assert_eq
!(it
.next_back(), Some(8));
1038 let i
= it
.rfold(ys
.len(), |i
, x
| {
1039 assert_eq
!(x
, ys
[i
- 1]);
1046 fn test_iterator_flatten() {
1048 let ys
= [0, 1, 2, 3, 4, 5, 6, 7, 8];
1049 let it
= xs
.iter().map(|&x
| (x
..).step_by(1).take(3)).flatten();
1052 assert_eq
!(x
, ys
[i
]);
1055 assert_eq
!(i
, ys
.len());
1058 /// Tests `Flatten::fold` with items already picked off the front and back,
1059 /// to make sure all parts of the `Flatten` are folded correctly.
1061 fn test_iterator_flatten_fold() {
1063 let ys
= [1, 2, 3, 4, 5, 6, 7];
1064 let mut it
= xs
.iter().map(|&x
| x
..x
+3).flatten();
1065 assert_eq
!(it
.next(), Some(0));
1066 assert_eq
!(it
.next_back(), Some(8));
1067 let i
= it
.fold(0, |i
, x
| {
1068 assert_eq
!(x
, ys
[i
]);
1071 assert_eq
!(i
, ys
.len());
1073 let mut it
= xs
.iter().map(|&x
| x
..x
+3).flatten();
1074 assert_eq
!(it
.next(), Some(0));
1075 assert_eq
!(it
.next_back(), Some(8));
1076 let i
= it
.rfold(ys
.len(), |i
, x
| {
1077 assert_eq
!(x
, ys
[i
- 1]);
1085 let xs
= [1, 2, 3, 4];
1090 .inspect(|_
| n
+= 1)
1091 .collect
::<Vec
<usize>>();
1093 assert_eq
!(n
, xs
.len());
1094 assert_eq
!(&xs
[..], &ys
[..]);
1098 fn test_inspect_fold() {
1099 let xs
= [1, 2, 3, 4];
1102 let it
= xs
.iter().inspect(|_
| n
+= 1);
1103 let i
= it
.fold(0, |i
, &x
| {
1104 assert_eq
!(x
, xs
[i
]);
1107 assert_eq
!(i
, xs
.len());
1109 assert_eq
!(n
, xs
.len());
1113 let it
= xs
.iter().inspect(|_
| n
+= 1);
1114 let i
= it
.rfold(xs
.len(), |i
, &x
| {
1115 assert_eq
!(x
, xs
[i
- 1]);
1120 assert_eq
!(n
, xs
.len());
1126 let it
= (0..).step_by(1).take(cycle_len
).cycle();
1127 assert_eq
!(it
.size_hint(), (usize::MAX
, None
));
1128 for (i
, x
) in it
.take(100).enumerate() {
1129 assert_eq
!(i
% cycle_len
, x
);
1132 let mut it
= (0..).step_by(1).take(0).cycle();
1133 assert_eq
!(it
.size_hint(), (0, Some(0)));
1134 assert_eq
!(it
.next(), None
);
1136 assert_eq
!(empty
::<i32>().cycle().fold(0, |acc
, x
| acc
+ x
), 0);
1138 assert_eq
!(once(1).cycle().skip(1).take(4).fold(0, |acc
, x
| acc
+ x
), 4);
1142 fn test_iterator_nth() {
1143 let v
: &[_
] = &[0, 1, 2, 3, 4];
1144 for i
in 0..v
.len() {
1145 assert_eq
!(v
.iter().nth(i
).unwrap(), &v
[i
]);
1147 assert_eq
!(v
.iter().nth(v
.len()), None
);
1151 fn test_iterator_nth_back() {
1152 let v
: &[_
] = &[0, 1, 2, 3, 4];
1153 for i
in 0..v
.len() {
1154 assert_eq
!(v
.iter().nth_back(i
).unwrap(), &v
[v
.len() - 1 - i
]);
1156 assert_eq
!(v
.iter().nth_back(v
.len()), None
);
1160 fn test_iterator_rev_nth_back() {
1161 let v
: &[_
] = &[0, 1, 2, 3, 4];
1162 for i
in 0..v
.len() {
1163 assert_eq
!(v
.iter().rev().nth_back(i
).unwrap(), &v
[i
]);
1165 assert_eq
!(v
.iter().rev().nth_back(v
.len()), None
);
1169 fn test_iterator_rev_nth() {
1170 let v
: &[_
] = &[0, 1, 2, 3, 4];
1171 for i
in 0..v
.len() {
1172 assert_eq
!(v
.iter().rev().nth(i
).unwrap(), &v
[v
.len() - 1 - i
]);
1174 assert_eq
!(v
.iter().rev().nth(v
.len()), None
);
1178 fn test_iterator_last() {
1179 let v
: &[_
] = &[0, 1, 2, 3, 4];
1180 assert_eq
!(v
.iter().last().unwrap(), &4);
1181 assert_eq
!(v
[..1].iter().last().unwrap(), &0);
1185 fn test_iterator_len() {
1186 let v
: &[_
] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1187 assert_eq
!(v
[..4].iter().count(), 4);
1188 assert_eq
!(v
[..10].iter().count(), 10);
1189 assert_eq
!(v
[..0].iter().count(), 0);
1193 fn test_iterator_sum() {
1194 let v
: &[i32] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1195 assert_eq
!(v
[..4].iter().cloned().sum
::<i32>(), 6);
1196 assert_eq
!(v
.iter().cloned().sum
::<i32>(), 55);
1197 assert_eq
!(v
[..0].iter().cloned().sum
::<i32>(), 0);
1201 fn test_iterator_sum_result() {
1202 let v
: &[Result
<i32, ()>] = &[Ok(1), Ok(2), Ok(3), Ok(4)];
1203 assert_eq
!(v
.iter().cloned().sum
::<Result
<i32, _
>>(), Ok(10));
1204 let v
: &[Result
<i32, ()>] = &[Ok(1), Err(()), Ok(3), Ok(4)];
1205 assert_eq
!(v
.iter().cloned().sum
::<Result
<i32, _
>>(), Err(()));
1207 #[derive(PartialEq, Debug)]
1208 struct S(Result
<i32, ()>);
1210 impl Sum
<Result
<i32, ()>> for S
{
1211 fn sum
<I
: Iterator
<Item
= Result
<i32, ()>>>(mut iter
: I
) -> Self {
1212 // takes the sum by repeatedly calling `next` on `iter`,
1213 // thus testing that repeated calls to `ResultShunt::try_fold`
1214 // produce the expected results
1215 Self(iter
.by_ref().sum())
1219 let v
: &[Result
<i32, ()>] = &[Ok(1), Ok(2), Ok(3), Ok(4)];
1220 assert_eq
!(v
.iter().cloned().sum
::<S
>(), S(Ok(10)));
1221 let v
: &[Result
<i32, ()>] = &[Ok(1), Err(()), Ok(3), Ok(4)];
1222 assert_eq
!(v
.iter().cloned().sum
::<S
>(), S(Err(())));
1226 fn test_iterator_sum_option() {
1227 let v
: &[Option
<i32>] = &[Some(1), Some(2), Some(3), Some(4)];
1228 assert_eq
!(v
.iter().cloned().sum
::<Option
<i32>>(), Some(10));
1229 let v
: &[Option
<i32>] = &[Some(1), None
, Some(3), Some(4)];
1230 assert_eq
!(v
.iter().cloned().sum
::<Option
<i32>>(), None
);
1234 fn test_iterator_product() {
1235 let v
: &[i32] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1236 assert_eq
!(v
[..4].iter().cloned().product
::<i32>(), 0);
1237 assert_eq
!(v
[1..5].iter().cloned().product
::<i32>(), 24);
1238 assert_eq
!(v
[..0].iter().cloned().product
::<i32>(), 1);
1242 fn test_iterator_product_result() {
1243 let v
: &[Result
<i32, ()>] = &[Ok(1), Ok(2), Ok(3), Ok(4)];
1244 assert_eq
!(v
.iter().cloned().product
::<Result
<i32, _
>>(), Ok(24));
1245 let v
: &[Result
<i32, ()>] = &[Ok(1), Err(()), Ok(3), Ok(4)];
1246 assert_eq
!(v
.iter().cloned().product
::<Result
<i32, _
>>(), Err(()));
1249 /// A wrapper struct that implements `Eq` and `Ord` based on the wrapped
1250 /// integer modulo 3. Used to test that `Iterator::max` and `Iterator::min`
1251 /// return the correct element if some of them are equal.
1255 impl PartialEq
for Mod3
{
1256 fn eq(&self, other
: &Self) -> bool
{
1257 self.0 % 3 == other
.0 % 3
1263 impl PartialOrd
for Mod3
{
1264 fn partial_cmp(&self, other
: &Self) -> Option
<core
::cmp
::Ordering
> {
1265 Some(self.cmp(other
))
1270 fn cmp(&self, other
: &Self) -> core
::cmp
::Ordering
{
1271 (self.0 % 3).cmp(&(other
.0 % 3))
1276 fn test_iterator_product_option() {
1277 let v
: &[Option
<i32>] = &[Some(1), Some(2), Some(3), Some(4)];
1278 assert_eq
!(v
.iter().cloned().product
::<Option
<i32>>(), Some(24));
1279 let v
: &[Option
<i32>] = &[Some(1), None
, Some(3), Some(4)];
1280 assert_eq
!(v
.iter().cloned().product
::<Option
<i32>>(), None
);
1284 fn test_iterator_max() {
1285 let v
: &[_
] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1286 assert_eq
!(v
[..4].iter().cloned().max(), Some(3));
1287 assert_eq
!(v
.iter().cloned().max(), Some(10));
1288 assert_eq
!(v
[..0].iter().cloned().max(), None
);
1289 assert_eq
!(v
.iter().cloned().map(Mod3
).max().map(|x
| x
.0), Some(8));
1293 fn test_iterator_min() {
1294 let v
: &[_
] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1295 assert_eq
!(v
[..4].iter().cloned().min(), Some(0));
1296 assert_eq
!(v
.iter().cloned().min(), Some(0));
1297 assert_eq
!(v
[..0].iter().cloned().min(), None
);
1298 assert_eq
!(v
.iter().cloned().map(Mod3
).min().map(|x
| x
.0), Some(0));
1302 fn test_iterator_size_hint() {
1303 let c
= (0..).step_by(1);
1304 let v
: &[_
] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
1305 let v2
= &[10, 11, 12];
1308 assert_eq
!((0..).size_hint(), (usize::MAX
, None
));
1309 assert_eq
!(c
.size_hint(), (usize::MAX
, None
));
1310 assert_eq
!(vi
.clone().size_hint(), (10, Some(10)));
1312 assert_eq
!(c
.clone().take(5).size_hint(), (5, Some(5)));
1313 assert_eq
!(c
.clone().skip(5).size_hint().1, None
);
1314 assert_eq
!(c
.clone().take_while(|_
| false).size_hint(), (0, None
));
1315 assert_eq
!(c
.clone().skip_while(|_
| false).size_hint(), (0, None
));
1316 assert_eq
!(c
.clone().enumerate().size_hint(), (usize::MAX
, None
));
1317 assert_eq
!(c
.clone().chain(vi
.clone().cloned()).size_hint(), (usize::MAX
, None
));
1318 assert_eq
!(c
.clone().zip(vi
.clone()).size_hint(), (10, Some(10)));
1319 assert_eq
!(c
.clone().scan(0, |_
,_
| Some(0)).size_hint(), (0, None
));
1320 assert_eq
!(c
.clone().filter(|_
| false).size_hint(), (0, None
));
1321 assert_eq
!(c
.clone().map(|_
| 0).size_hint(), (usize::MAX
, None
));
1322 assert_eq
!(c
.filter_map(|_
| Some(0)).size_hint(), (0, None
));
1324 assert_eq
!(vi
.clone().take(5).size_hint(), (5, Some(5)));
1325 assert_eq
!(vi
.clone().take(12).size_hint(), (10, Some(10)));
1326 assert_eq
!(vi
.clone().skip(3).size_hint(), (7, Some(7)));
1327 assert_eq
!(vi
.clone().skip(12).size_hint(), (0, Some(0)));
1328 assert_eq
!(vi
.clone().take_while(|_
| false).size_hint(), (0, Some(10)));
1329 assert_eq
!(vi
.clone().skip_while(|_
| false).size_hint(), (0, Some(10)));
1330 assert_eq
!(vi
.clone().enumerate().size_hint(), (10, Some(10)));
1331 assert_eq
!(vi
.clone().chain(v2
).size_hint(), (13, Some(13)));
1332 assert_eq
!(vi
.clone().zip(v2
).size_hint(), (3, Some(3)));
1333 assert_eq
!(vi
.clone().scan(0, |_
,_
| Some(0)).size_hint(), (0, Some(10)));
1334 assert_eq
!(vi
.clone().filter(|_
| false).size_hint(), (0, Some(10)));
1335 assert_eq
!(vi
.clone().map(|&i
| i
+1).size_hint(), (10, Some(10)));
1336 assert_eq
!(vi
.filter_map(|_
| Some(0)).size_hint(), (0, Some(10)));
1341 let a
= vec
![1, 2, 3, 4, 5];
1342 let b
: Vec
<isize> = a
.iter().cloned().collect();
1348 let v
: Box
<[isize]> = Box
::new([1, 2, 3, 4, 5]);
1349 assert
!(v
.iter().all(|&x
| x
< 10));
1350 assert
!(!v
.iter().all(|&x
| x
% 2 == 0));
1351 assert
!(!v
.iter().all(|&x
| x
> 100));
1352 assert
!(v
[..0].iter().all(|_
| panic
!()));
1357 let v
: Box
<[isize]> = Box
::new([1, 2, 3, 4, 5]);
1358 assert
!(v
.iter().any(|&x
| x
< 10));
1359 assert
!(v
.iter().any(|&x
| x
% 2 == 0));
1360 assert
!(!v
.iter().any(|&x
| x
> 100));
1361 assert
!(!v
[..0].iter().any(|_
| panic
!()));
1366 let v
: &[isize] = &[1, 3, 9, 27, 103, 14, 11];
1367 assert_eq
!(*v
.iter().find(|&&x
| x
& 1 == 0).unwrap(), 14);
1368 assert_eq
!(*v
.iter().find(|&&x
| x
% 3 == 0).unwrap(), 3);
1369 assert
!(v
.iter().find(|&&x
| x
% 12 == 0).is_none());
1373 fn test_find_map() {
1374 let xs
: &[isize] = &[];
1375 assert_eq
!(xs
.iter().find_map(half_if_even
), None
);
1376 let xs
: &[isize] = &[3, 5];
1377 assert_eq
!(xs
.iter().find_map(half_if_even
), None
);
1378 let xs
: &[isize] = &[4, 5];
1379 assert_eq
!(xs
.iter().find_map(half_if_even
), Some(2));
1380 let xs
: &[isize] = &[3, 6];
1381 assert_eq
!(xs
.iter().find_map(half_if_even
), Some(3));
1383 let xs
: &[isize] = &[1, 2, 3, 4, 5, 6, 7];
1384 let mut iter
= xs
.iter();
1385 assert_eq
!(iter
.find_map(half_if_even
), Some(1));
1386 assert_eq
!(iter
.find_map(half_if_even
), Some(2));
1387 assert_eq
!(iter
.find_map(half_if_even
), Some(3));
1388 assert_eq
!(iter
.next(), Some(&7));
1390 fn half_if_even(x
: &isize) -> Option
<isize> {
1400 fn test_position() {
1401 let v
= &[1, 3, 9, 27, 103, 14, 11];
1402 assert_eq
!(v
.iter().position(|x
| *x
& 1 == 0).unwrap(), 5);
1403 assert_eq
!(v
.iter().position(|x
| *x
% 3 == 0).unwrap(), 1);
1404 assert
!(v
.iter().position(|x
| *x
% 12 == 0).is_none());
1409 let xs
= &[1, 2, 2, 1, 5, 9, 0, 2];
1410 assert_eq
!(xs
.iter().filter(|x
| **x
== 2).count(), 3);
1411 assert_eq
!(xs
.iter().filter(|x
| **x
== 5).count(), 1);
1412 assert_eq
!(xs
.iter().filter(|x
| **x
== 95).count(), 0);
1416 fn test_max_by_key() {
1417 let xs
: &[isize] = &[-3, 0, 1, 5, -10];
1418 assert_eq
!(*xs
.iter().max_by_key(|x
| x
.abs()).unwrap(), -10);
1423 let xs
: &[isize] = &[-3, 0, 1, 5, -10];
1424 assert_eq
!(*xs
.iter().max_by(|x
, y
| x
.abs().cmp(&y
.abs())).unwrap(), -10);
1428 fn test_min_by_key() {
1429 let xs
: &[isize] = &[-3, 0, 1, 5, -10];
1430 assert_eq
!(*xs
.iter().min_by_key(|x
| x
.abs()).unwrap(), 0);
1435 let xs
: &[isize] = &[-3, 0, 1, 5, -10];
1436 assert_eq
!(*xs
.iter().min_by(|x
, y
| x
.abs().cmp(&y
.abs())).unwrap(), 0);
1442 // sum the first five values
1443 let partial_sum
= xs
.by_ref().take(5).fold(0, |a
, b
| a
+ b
);
1444 assert_eq
!(partial_sum
, 10);
1445 assert_eq
!(xs
.next(), Some(5));
1450 let xs
= [2, 4, 6, 8, 10, 12, 14, 16];
1451 let mut it
= xs
.iter();
1454 assert
!(it
.rev().cloned().collect
::<Vec
<isize>>() ==
1455 vec
![16, 14, 12, 10, 8, 6]);
1460 let xs
= [2, 4, 6, 8];
1462 let mut it
= xs
.iter().copied();
1463 assert_eq
!(it
.len(), 4);
1464 assert_eq
!(it
.next(), Some(2));
1465 assert_eq
!(it
.len(), 3);
1466 assert_eq
!(it
.next(), Some(4));
1467 assert_eq
!(it
.len(), 2);
1468 assert_eq
!(it
.next_back(), Some(8));
1469 assert_eq
!(it
.len(), 1);
1470 assert_eq
!(it
.next_back(), Some(6));
1471 assert_eq
!(it
.len(), 0);
1472 assert_eq
!(it
.next_back(), None
);
1477 let xs
= [2, 4, 6, 8];
1479 let mut it
= xs
.iter().cloned();
1480 assert_eq
!(it
.len(), 4);
1481 assert_eq
!(it
.next(), Some(2));
1482 assert_eq
!(it
.len(), 3);
1483 assert_eq
!(it
.next(), Some(4));
1484 assert_eq
!(it
.len(), 2);
1485 assert_eq
!(it
.next_back(), Some(8));
1486 assert_eq
!(it
.len(), 1);
1487 assert_eq
!(it
.next_back(), Some(6));
1488 assert_eq
!(it
.len(), 0);
1489 assert_eq
!(it
.next_back(), None
);
1493 fn test_cloned_side_effects() {
1496 let iter
= [1, 2, 3]
1506 assert_eq
!(count
, 2);
1510 fn test_double_ended_map() {
1511 let xs
= [1, 2, 3, 4, 5, 6];
1512 let mut it
= xs
.iter().map(|&x
| x
* -1);
1513 assert_eq
!(it
.next(), Some(-1));
1514 assert_eq
!(it
.next(), Some(-2));
1515 assert_eq
!(it
.next_back(), Some(-6));
1516 assert_eq
!(it
.next_back(), Some(-5));
1517 assert_eq
!(it
.next(), Some(-3));
1518 assert_eq
!(it
.next_back(), Some(-4));
1519 assert_eq
!(it
.next(), None
);
1523 fn test_double_ended_enumerate() {
1524 let xs
= [1, 2, 3, 4, 5, 6];
1525 let mut it
= xs
.iter().cloned().enumerate();
1526 assert_eq
!(it
.next(), Some((0, 1)));
1527 assert_eq
!(it
.next(), Some((1, 2)));
1528 assert_eq
!(it
.next_back(), Some((5, 6)));
1529 assert_eq
!(it
.next_back(), Some((4, 5)));
1530 assert_eq
!(it
.next_back(), Some((3, 4)));
1531 assert_eq
!(it
.next_back(), Some((2, 3)));
1532 assert_eq
!(it
.next(), None
);
1536 fn test_double_ended_zip() {
1537 let xs
= [1, 2, 3, 4, 5, 6];
1538 let ys
= [1, 2, 3, 7];
1539 let a
= xs
.iter().cloned();
1540 let b
= ys
.iter().cloned();
1541 let mut it
= a
.zip(b
);
1542 assert_eq
!(it
.next(), Some((1, 1)));
1543 assert_eq
!(it
.next(), Some((2, 2)));
1544 assert_eq
!(it
.next_back(), Some((4, 7)));
1545 assert_eq
!(it
.next_back(), Some((3, 3)));
1546 assert_eq
!(it
.next(), None
);
1550 fn test_double_ended_filter() {
1551 let xs
= [1, 2, 3, 4, 5, 6];
1552 let mut it
= xs
.iter().filter(|&x
| *x
& 1 == 0);
1553 assert_eq
!(it
.next_back().unwrap(), &6);
1554 assert_eq
!(it
.next_back().unwrap(), &4);
1555 assert_eq
!(it
.next().unwrap(), &2);
1556 assert_eq
!(it
.next_back(), None
);
1560 fn test_double_ended_filter_map() {
1561 let xs
= [1, 2, 3, 4, 5, 6];
1562 let mut it
= xs
.iter().filter_map(|&x
| if x
& 1 == 0 { Some(x * 2) }
else { None }
);
1563 assert_eq
!(it
.next_back().unwrap(), 12);
1564 assert_eq
!(it
.next_back().unwrap(), 8);
1565 assert_eq
!(it
.next().unwrap(), 4);
1566 assert_eq
!(it
.next_back(), None
);
1570 fn test_double_ended_chain() {
1571 let xs
= [1, 2, 3, 4, 5];
1572 let ys
= [7, 9, 11];
1573 let mut it
= xs
.iter().chain(&ys
).rev();
1574 assert_eq
!(it
.next().unwrap(), &11);
1575 assert_eq
!(it
.next().unwrap(), &9);
1576 assert_eq
!(it
.next_back().unwrap(), &1);
1577 assert_eq
!(it
.next_back().unwrap(), &2);
1578 assert_eq
!(it
.next_back().unwrap(), &3);
1579 assert_eq
!(it
.next_back().unwrap(), &4);
1580 assert_eq
!(it
.next_back().unwrap(), &5);
1581 assert_eq
!(it
.next_back().unwrap(), &7);
1582 assert_eq
!(it
.next_back(), None
);
1585 // test that .chain() is well behaved with an unfused iterator
1586 struct CrazyIterator(bool
);
1587 impl CrazyIterator { fn new() -> CrazyIterator { CrazyIterator(false) }
}
1588 impl Iterator
for CrazyIterator
{
1590 fn next(&mut self) -> Option
<i32> {
1591 if self.0 { Some(99) }
else { self.0 = true; None }
1595 impl DoubleEndedIterator
for CrazyIterator
{
1596 fn next_back(&mut self) -> Option
<i32> {
1601 assert_eq
!(CrazyIterator
::new().chain(0..10).rev().last(), Some(0));
1602 assert
!((0..10).chain(CrazyIterator
::new()).rev().any(|i
| i
== 0));
1606 fn test_rposition() {
1607 fn f(xy
: &(isize, char)) -> bool { let (_x, y) = *xy; y == 'b' }
1608 fn g(xy
: &(isize, char)) -> bool { let (_x, y) = *xy; y == 'd' }
1609 let v
= [(0, 'a'
), (1, 'b'
), (2, 'c'
), (3, 'b'
)];
1611 assert_eq
!(v
.iter().rposition(f
), Some(3));
1612 assert
!(v
.iter().rposition(g
).is_none());
1617 fn test_rposition_panic() {
1618 let v
: [(Box
<_
>, Box
<_
>); 4] =
1619 [(box 0, box 0), (box 0, box 0),
1620 (box 0, box 0), (box 0, box 0)];
1622 v
.iter().rposition(|_elt
| {
1633 fn test_double_ended_flat_map() {
1636 let mut it
= u
.iter().flat_map(|x
| &v
[*x
..v
.len()]);
1637 assert_eq
!(it
.next_back().unwrap(), &8);
1638 assert_eq
!(it
.next().unwrap(), &5);
1639 assert_eq
!(it
.next_back().unwrap(), &7);
1640 assert_eq
!(it
.next_back().unwrap(), &6);
1641 assert_eq
!(it
.next_back().unwrap(), &8);
1642 assert_eq
!(it
.next().unwrap(), &6);
1643 assert_eq
!(it
.next_back().unwrap(), &7);
1644 assert_eq
!(it
.next_back(), None
);
1645 assert_eq
!(it
.next(), None
);
1646 assert_eq
!(it
.next_back(), None
);
1650 fn test_double_ended_flatten() {
1653 let mut it
= u
.iter().map(|x
| &v
[*x
..v
.len()]).flatten();
1654 assert_eq
!(it
.next_back().unwrap(), &8);
1655 assert_eq
!(it
.next().unwrap(), &5);
1656 assert_eq
!(it
.next_back().unwrap(), &7);
1657 assert_eq
!(it
.next_back().unwrap(), &6);
1658 assert_eq
!(it
.next_back().unwrap(), &8);
1659 assert_eq
!(it
.next().unwrap(), &6);
1660 assert_eq
!(it
.next_back().unwrap(), &7);
1661 assert_eq
!(it
.next_back(), None
);
1662 assert_eq
!(it
.next(), None
);
1663 assert_eq
!(it
.next_back(), None
);
1667 fn test_double_ended_range() {
1668 assert_eq
!((11..14).rev().collect
::<Vec
<_
>>(), [13, 12, 11]);
1669 for _
in (10..0).rev() {
1670 panic
!("unreachable");
1673 assert_eq
!((11..14).rev().collect
::<Vec
<_
>>(), [13, 12, 11]);
1674 for _
in (10..0).rev() {
1675 panic
!("unreachable");
1681 assert_eq
!((0..5).collect
::<Vec
<_
>>(), [0, 1, 2, 3, 4]);
1682 assert_eq
!((-10..-1).collect
::<Vec
<_
>>(), [-10, -9, -8, -7, -6, -5, -4, -3, -2]);
1683 assert_eq
!((0..5).rev().collect
::<Vec
<_
>>(), [4, 3, 2, 1, 0]);
1684 assert_eq
!((200..-5).count(), 0);
1685 assert_eq
!((200..-5).rev().count(), 0);
1686 assert_eq
!((200..200).count(), 0);
1687 assert_eq
!((200..200).rev().count(), 0);
1689 assert_eq
!((0..100).size_hint(), (100, Some(100)));
1690 // this test is only meaningful when sizeof usize < sizeof u64
1691 assert_eq
!((usize::MAX
- 1..usize::MAX
).size_hint(), (1, Some(1)));
1692 assert_eq
!((-10..-1).size_hint(), (9, Some(9)));
1693 assert_eq
!((-1..-10).size_hint(), (0, Some(0)));
1695 assert_eq
!((-70..58).size_hint(), (128, Some(128)));
1696 assert_eq
!((-128..127).size_hint(), (255, Some(255)));
1697 assert_eq
!((-2..isize::MAX
).size_hint(),
1698 (isize::MAX
as usize + 2, Some(isize::MAX
as usize + 2)));
1702 fn test_range_exhaustion() {
1704 assert
!(r
.is_empty());
1705 assert_eq
!(r
.next(), None
);
1706 assert_eq
!(r
.next_back(), None
);
1707 assert_eq
!(r
, 10..10);
1710 assert_eq
!(r
.next(), Some(10));
1711 assert_eq
!(r
.next(), Some(11));
1712 assert
!(r
.is_empty());
1713 assert_eq
!(r
, 12..12);
1714 assert_eq
!(r
.next(), None
);
1717 assert_eq
!(r
.next_back(), Some(11));
1718 assert_eq
!(r
.next_back(), Some(10));
1719 assert
!(r
.is_empty());
1720 assert_eq
!(r
, 10..10);
1721 assert_eq
!(r
.next_back(), None
);
1723 let mut r
= 100..10;
1724 assert
!(r
.is_empty());
1725 assert_eq
!(r
.next(), None
);
1726 assert_eq
!(r
.next_back(), None
);
1727 assert_eq
!(r
, 100..10);
1731 fn test_range_inclusive_exhaustion() {
1732 let mut r
= 10..=10;
1733 assert_eq
!(r
.next(), Some(10));
1734 assert
!(r
.is_empty());
1735 assert_eq
!(r
.next(), None
);
1736 assert_eq
!(r
.next(), None
);
1738 let mut r
= 10..=10;
1739 assert_eq
!(r
.next_back(), Some(10));
1740 assert
!(r
.is_empty());
1741 assert_eq
!(r
.next_back(), None
);
1743 let mut r
= 10..=12;
1744 assert_eq
!(r
.next(), Some(10));
1745 assert_eq
!(r
.next(), Some(11));
1746 assert_eq
!(r
.next(), Some(12));
1747 assert
!(r
.is_empty());
1748 assert_eq
!(r
.next(), None
);
1750 let mut r
= 10..=12;
1751 assert_eq
!(r
.next_back(), Some(12));
1752 assert_eq
!(r
.next_back(), Some(11));
1753 assert_eq
!(r
.next_back(), Some(10));
1754 assert
!(r
.is_empty());
1755 assert_eq
!(r
.next_back(), None
);
1757 let mut r
= 10..=12;
1758 assert_eq
!(r
.nth(2), Some(12));
1759 assert
!(r
.is_empty());
1760 assert_eq
!(r
.next(), None
);
1762 let mut r
= 10..=12;
1763 assert_eq
!(r
.nth(5), None
);
1764 assert
!(r
.is_empty());
1765 assert_eq
!(r
.next(), None
);
1767 let mut r
= 100..=10;
1768 assert_eq
!(r
.next(), None
);
1769 assert
!(r
.is_empty());
1770 assert_eq
!(r
.next(), None
);
1771 assert_eq
!(r
.next(), None
);
1772 assert_eq
!(r
, 100..=10);
1774 let mut r
= 100..=10;
1775 assert_eq
!(r
.next_back(), None
);
1776 assert
!(r
.is_empty());
1777 assert_eq
!(r
.next_back(), None
);
1778 assert_eq
!(r
.next_back(), None
);
1779 assert_eq
!(r
, 100..=10);
1783 fn test_range_nth() {
1784 assert_eq
!((10..15).nth(0), Some(10));
1785 assert_eq
!((10..15).nth(1), Some(11));
1786 assert_eq
!((10..15).nth(4), Some(14));
1787 assert_eq
!((10..15).nth(5), None
);
1790 assert_eq
!(r
.nth(2), Some(12));
1791 assert_eq
!(r
, 13..20);
1792 assert_eq
!(r
.nth(2), Some(15));
1793 assert_eq
!(r
, 16..20);
1794 assert_eq
!(r
.nth(10), None
);
1795 assert_eq
!(r
, 20..20);
1799 fn test_range_nth_back() {
1800 assert_eq
!((10..15).nth_back(0), Some(14));
1801 assert_eq
!((10..15).nth_back(1), Some(13));
1802 assert_eq
!((10..15).nth_back(4), Some(10));
1803 assert_eq
!((10..15).nth_back(5), None
);
1804 assert_eq
!((-120..80_i8).nth_back(199), Some(-120));
1807 assert_eq
!(r
.nth_back(2), Some(17));
1808 assert_eq
!(r
, 10..17);
1809 assert_eq
!(r
.nth_back(2), Some(14));
1810 assert_eq
!(r
, 10..14);
1811 assert_eq
!(r
.nth_back(10), None
);
1812 assert_eq
!(r
, 10..10);
1816 fn test_range_from_nth() {
1817 assert_eq
!((10..).nth(0), Some(10));
1818 assert_eq
!((10..).nth(1), Some(11));
1819 assert_eq
!((10..).nth(4), Some(14));
1822 assert_eq
!(r
.nth(2), Some(12));
1823 assert_eq
!(r
, 13..);
1824 assert_eq
!(r
.nth(2), Some(15));
1825 assert_eq
!(r
, 16..);
1826 assert_eq
!(r
.nth(10), Some(26));
1827 assert_eq
!(r
, 27..);
1829 assert_eq
!((0..).size_hint(), (usize::MAX
, None
));
1832 fn is_trusted_len
<I
: TrustedLen
>(_
: I
) {}
1835 fn test_range_from_take() {
1836 let mut it
= (0..).take(3);
1837 assert_eq
!(it
.next(), Some(0));
1838 assert_eq
!(it
.next(), Some(1));
1839 assert_eq
!(it
.next(), Some(2));
1840 assert_eq
!(it
.next(), None
);
1841 is_trusted_len((0..).take(3));
1842 assert_eq
!((0..).take(3).size_hint(), (3, Some(3)));
1843 assert_eq
!((0..).take(0).size_hint(), (0, Some(0)));
1844 assert_eq
!((0..).take(usize::MAX
).size_hint(), (usize::MAX
, Some(usize::MAX
)));
1848 fn test_range_from_take_collect() {
1849 let v
: Vec
<_
> = (0..).take(3).collect();
1850 assert_eq
!(v
, vec
![0, 1, 2]);
1854 fn test_range_inclusive_nth() {
1855 assert_eq
!((10..=15).nth(0), Some(10));
1856 assert_eq
!((10..=15).nth(1), Some(11));
1857 assert_eq
!((10..=15).nth(5), Some(15));
1858 assert_eq
!((10..=15).nth(6), None
);
1860 let mut r
= 10_u8..=20;
1861 assert_eq
!(r
.nth(2), Some(12));
1862 assert_eq
!(r
, 13..=20);
1863 assert_eq
!(r
.nth(2), Some(15));
1864 assert_eq
!(r
, 16..=20);
1865 assert_eq
!(r
.is_empty(), false);
1866 assert_eq
!(ExactSizeIterator
::is_empty(&r
), false);
1867 assert_eq
!(r
.nth(10), None
);
1868 assert_eq
!(r
.is_empty(), true);
1869 assert_eq
!(ExactSizeIterator
::is_empty(&r
), true);
1873 fn test_range_inclusive_nth_back() {
1874 assert_eq
!((10..=15).nth_back(0), Some(15));
1875 assert_eq
!((10..=15).nth_back(1), Some(14));
1876 assert_eq
!((10..=15).nth_back(5), Some(10));
1877 assert_eq
!((10..=15).nth_back(6), None
);
1878 assert_eq
!((-120..=80_i8).nth_back(200), Some(-120));
1880 let mut r
= 10_u8..=20;
1881 assert_eq
!(r
.nth_back(2), Some(18));
1882 assert_eq
!(r
, 10..=17);
1883 assert_eq
!(r
.nth_back(2), Some(15));
1884 assert_eq
!(r
, 10..=14);
1885 assert_eq
!(r
.is_empty(), false);
1886 assert_eq
!(ExactSizeIterator
::is_empty(&r
), false);
1887 assert_eq
!(r
.nth_back(10), None
);
1888 assert_eq
!(r
.is_empty(), true);
1889 assert_eq
!(ExactSizeIterator
::is_empty(&r
), true);
1893 fn test_range_step() {
1894 #![allow(deprecated)]
1896 assert_eq
!((0..20).step_by(5).collect
::<Vec
<isize>>(), [0, 5, 10, 15]);
1897 assert_eq
!((1..21).rev().step_by(5).collect
::<Vec
<isize>>(), [20, 15, 10, 5]);
1898 assert_eq
!((1..21).rev().step_by(6).collect
::<Vec
<isize>>(), [20, 14, 8, 2]);
1899 assert_eq
!((200..255).step_by(50).collect
::<Vec
<u8>>(), [200, 250]);
1900 assert_eq
!((200..-5).step_by(1).collect
::<Vec
<isize>>(), []);
1901 assert_eq
!((200..200).step_by(1).collect
::<Vec
<isize>>(), []);
1903 assert_eq
!((0..20).step_by(1).size_hint(), (20, Some(20)));
1904 assert_eq
!((0..20).step_by(21).size_hint(), (1, Some(1)));
1905 assert_eq
!((0..20).step_by(5).size_hint(), (4, Some(4)));
1906 assert_eq
!((1..21).rev().step_by(5).size_hint(), (4, Some(4)));
1907 assert_eq
!((1..21).rev().step_by(6).size_hint(), (4, Some(4)));
1908 assert_eq
!((20..-5).step_by(1).size_hint(), (0, Some(0)));
1909 assert_eq
!((20..20).step_by(1).size_hint(), (0, Some(0)));
1910 assert_eq
!((i8::MIN
..i8::MAX
).step_by(-(i8::MIN
as i32) as usize).size_hint(), (2, Some(2)));
1911 assert_eq
!((i16::MIN
..i16::MAX
).step_by(i16::MAX
as usize).size_hint(), (3, Some(3)));
1912 assert_eq
!((isize::MIN
..isize::MAX
).step_by(1).size_hint(), (usize::MAX
, Some(usize::MAX
)));
1916 fn test_step_by_skip() {
1917 assert_eq
!((0..640).step_by(128).skip(1).collect
::<Vec
<_
>>(), [128, 256, 384, 512]);
1918 assert_eq
!((0..=50).step_by(10).nth(3), Some(30));
1919 assert_eq
!((200..=255u8).step_by(10).nth(3), Some(230));
1923 fn test_range_inclusive_step() {
1924 assert_eq
!((0..=50).step_by(10).collect
::<Vec
<_
>>(), [0, 10, 20, 30, 40, 50]);
1925 assert_eq
!((0..=5).step_by(1).collect
::<Vec
<_
>>(), [0, 1, 2, 3, 4, 5]);
1926 assert_eq
!((200..=255u8).step_by(10).collect
::<Vec
<_
>>(), [200, 210, 220, 230, 240, 250]);
1927 assert_eq
!((250..=255u8).step_by(1).collect
::<Vec
<_
>>(), [250, 251, 252, 253, 254, 255]);
1931 fn test_range_last_max() {
1932 assert_eq
!((0..20).last(), Some(19));
1933 assert_eq
!((-20..0).last(), Some(-1));
1934 assert_eq
!((5..5).last(), None
);
1936 assert_eq
!((0..20).max(), Some(19));
1937 assert_eq
!((-20..0).max(), Some(-1));
1938 assert_eq
!((5..5).max(), None
);
1942 fn test_range_inclusive_last_max() {
1943 assert_eq
!((0..=20).last(), Some(20));
1944 assert_eq
!((-20..=0).last(), Some(0));
1945 assert_eq
!((5..=5).last(), Some(5));
1946 let mut r
= 10..=10;
1948 assert_eq
!(r
.last(), None
);
1950 assert_eq
!((0..=20).max(), Some(20));
1951 assert_eq
!((-20..=0).max(), Some(0));
1952 assert_eq
!((5..=5).max(), Some(5));
1953 let mut r
= 10..=10;
1955 assert_eq
!(r
.max(), None
);
1959 fn test_range_min() {
1960 assert_eq
!((0..20).min(), Some(0));
1961 assert_eq
!((-20..0).min(), Some(-20));
1962 assert_eq
!((5..5).min(), None
);
1966 fn test_range_inclusive_min() {
1967 assert_eq
!((0..=20).min(), Some(0));
1968 assert_eq
!((-20..=0).min(), Some(-20));
1969 assert_eq
!((5..=5).min(), Some(5));
1970 let mut r
= 10..=10;
1972 assert_eq
!(r
.min(), None
);
1976 fn test_range_inclusive_folds() {
1977 assert_eq
!((1..=10).sum
::<i32>(), 55);
1978 assert_eq
!((1..=10).rev().sum
::<i32>(), 55);
1980 let mut it
= 44..=50;
1981 assert_eq
!(it
.try_fold(0, i8::checked_add
), None
);
1982 assert_eq
!(it
, 47..=50);
1983 assert_eq
!(it
.try_fold(0, i8::checked_add
), None
);
1984 assert_eq
!(it
, 50..=50);
1985 assert_eq
!(it
.try_fold(0, i8::checked_add
), Some(50));
1986 assert
!(it
.is_empty());
1987 assert_eq
!(it
.try_fold(0, i8::checked_add
), Some(0));
1988 assert
!(it
.is_empty());
1990 let mut it
= 40..=47;
1991 assert_eq
!(it
.try_rfold(0, i8::checked_add
), None
);
1992 assert_eq
!(it
, 40..=44);
1993 assert_eq
!(it
.try_rfold(0, i8::checked_add
), None
);
1994 assert_eq
!(it
, 40..=41);
1995 assert_eq
!(it
.try_rfold(0, i8::checked_add
), Some(81));
1996 assert
!(it
.is_empty());
1997 assert_eq
!(it
.try_rfold(0, i8::checked_add
), Some(0));
1998 assert
!(it
.is_empty());
2000 let mut it
= 10..=20;
2001 assert_eq
!(it
.try_fold(0, |a
,b
| Some(a
+b
)), Some(165));
2002 assert
!(it
.is_empty());
2003 assert_eq
!(it
.try_fold(0, |a
,b
| Some(a
+b
)), Some(0));
2004 assert
!(it
.is_empty());
2006 let mut it
= 10..=20;
2007 assert_eq
!(it
.try_rfold(0, |a
,b
| Some(a
+b
)), Some(165));
2008 assert
!(it
.is_empty());
2009 assert_eq
!(it
.try_rfold(0, |a
,b
| Some(a
+b
)), Some(0));
2010 assert
!(it
.is_empty());
2014 fn test_range_size_hint() {
2015 use core
::usize::MAX
as UMAX
;
2016 assert_eq
!((0..0usize
).size_hint(), (0, Some(0)));
2017 assert_eq
!((0..100usize
).size_hint(), (100, Some(100)));
2018 assert_eq
!((0..UMAX
).size_hint(), (UMAX
, Some(UMAX
)));
2020 let umax
= u128
::try_from(UMAX
).unwrap();
2021 assert_eq
!((0..0u128).size_hint(), (0, Some(0)));
2022 assert_eq
!((0..100u128).size_hint(), (100, Some(100)));
2023 assert_eq
!((0..umax
).size_hint(), (UMAX
, Some(UMAX
)));
2024 assert_eq
!((0..umax
+ 1).size_hint(), (UMAX
, None
));
2026 use core
::isize::{MAX as IMAX, MIN as IMIN}
;
2027 assert_eq
!((0..0isize
).size_hint(), (0, Some(0)));
2028 assert_eq
!((-100..100isize
).size_hint(), (200, Some(200)));
2029 assert_eq
!((IMIN
..IMAX
).size_hint(), (UMAX
, Some(UMAX
)));
2031 let imin
= i128
::try_from(IMIN
).unwrap();
2032 let imax
= i128
::try_from(IMAX
).unwrap();
2033 assert_eq
!((0..0i128).size_hint(), (0, Some(0)));
2034 assert_eq
!((-100..100i128).size_hint(), (200, Some(200)));
2035 assert_eq
!((imin
..imax
).size_hint(), (UMAX
, Some(UMAX
)));
2036 assert_eq
!((imin
..imax
+ 1).size_hint(), (UMAX
, None
));
2040 fn test_range_inclusive_size_hint() {
2041 use core
::usize::MAX
as UMAX
;
2042 assert_eq
!((1..=0usize
).size_hint(), (0, Some(0)));
2043 assert_eq
!((0..=0usize
).size_hint(), (1, Some(1)));
2044 assert_eq
!((0..=100usize
).size_hint(), (101, Some(101)));
2045 assert_eq
!((0..=UMAX
- 1).size_hint(), (UMAX
, Some(UMAX
)));
2046 assert_eq
!((0..=UMAX
).size_hint(), (UMAX
, None
));
2048 let umax
= u128
::try_from(UMAX
).unwrap();
2049 assert_eq
!((1..=0u128).size_hint(), (0, Some(0)));
2050 assert_eq
!((0..=0u128).size_hint(), (1, Some(1)));
2051 assert_eq
!((0..=100u128).size_hint(), (101, Some(101)));
2052 assert_eq
!((0..=umax
- 1).size_hint(), (UMAX
, Some(UMAX
)));
2053 assert_eq
!((0..=umax
).size_hint(), (UMAX
, None
));
2054 assert_eq
!((0..=umax
+ 1).size_hint(), (UMAX
, None
));
2056 use core
::isize::{MAX as IMAX, MIN as IMIN}
;
2057 assert_eq
!((0..=-1isize
).size_hint(), (0, Some(0)));
2058 assert_eq
!((0..=0isize
).size_hint(), (1, Some(1)));
2059 assert_eq
!((-100..=100isize
).size_hint(), (201, Some(201)));
2060 assert_eq
!((IMIN
..=IMAX
- 1).size_hint(), (UMAX
, Some(UMAX
)));
2061 assert_eq
!((IMIN
..=IMAX
).size_hint(), (UMAX
, None
));
2063 let imin
= i128
::try_from(IMIN
).unwrap();
2064 let imax
= i128
::try_from(IMAX
).unwrap();
2065 assert_eq
!((0..=-1i128).size_hint(), (0, Some(0)));
2066 assert_eq
!((0..=0i128).size_hint(), (1, Some(1)));
2067 assert_eq
!((-100..=100i128).size_hint(), (201, Some(201)));
2068 assert_eq
!((imin
..=imax
- 1).size_hint(), (UMAX
, Some(UMAX
)));
2069 assert_eq
!((imin
..=imax
).size_hint(), (UMAX
, None
));
2070 assert_eq
!((imin
..=imax
+ 1).size_hint(), (UMAX
, None
));
2075 let mut it
= repeat(42);
2076 assert_eq
!(it
.next(), Some(42));
2077 assert_eq
!(it
.next(), Some(42));
2078 assert_eq
!(it
.next(), Some(42));
2079 assert_eq
!(repeat(42).size_hint(), (usize::MAX
, None
));
2083 fn test_repeat_take() {
2084 let mut it
= repeat(42).take(3);
2085 assert_eq
!(it
.next(), Some(42));
2086 assert_eq
!(it
.next(), Some(42));
2087 assert_eq
!(it
.next(), Some(42));
2088 assert_eq
!(it
.next(), None
);
2089 is_trusted_len(repeat(42).take(3));
2090 assert_eq
!(repeat(42).take(3).size_hint(), (3, Some(3)));
2091 assert_eq
!(repeat(42).take(0).size_hint(), (0, Some(0)));
2092 assert_eq
!(repeat(42).take(usize::MAX
).size_hint(), (usize::MAX
, Some(usize::MAX
)));
2096 fn test_repeat_take_collect() {
2097 let v
: Vec
<_
> = repeat(42).take(3).collect();
2098 assert_eq
!(v
, vec
![42, 42, 42]);
2102 fn test_repeat_with() {
2103 #[derive(PartialEq, Debug)]
2104 struct NotClone(usize);
2105 let mut it
= repeat_with(|| NotClone(42));
2106 assert_eq
!(it
.next(), Some(NotClone(42)));
2107 assert_eq
!(it
.next(), Some(NotClone(42)));
2108 assert_eq
!(it
.next(), Some(NotClone(42)));
2109 assert_eq
!(repeat_with(|| NotClone(42)).size_hint(), (usize::MAX
, None
));
2113 fn test_repeat_with_take() {
2114 let mut it
= repeat_with(|| 42).take(3);
2115 assert_eq
!(it
.next(), Some(42));
2116 assert_eq
!(it
.next(), Some(42));
2117 assert_eq
!(it
.next(), Some(42));
2118 assert_eq
!(it
.next(), None
);
2119 is_trusted_len(repeat_with(|| 42).take(3));
2120 assert_eq
!(repeat_with(|| 42).take(3).size_hint(), (3, Some(3)));
2121 assert_eq
!(repeat_with(|| 42).take(0).size_hint(), (0, Some(0)));
2122 assert_eq
!(repeat_with(|| 42).take(usize::MAX
).size_hint(),
2123 (usize::MAX
, Some(usize::MAX
)));
2127 fn test_repeat_with_take_collect() {
2129 let v
: Vec
<_
> = repeat_with(|| { let tmp = curr; curr *= 2; tmp }
)
2131 assert_eq
!(v
, vec
![1, 2, 4, 8, 16]);
2135 fn test_successors() {
2136 let mut powers_of_10
= successors(Some(1_u16), |n
| n
.checked_mul(10));
2137 assert_eq
!(powers_of_10
.by_ref().collect
::<Vec
<_
>>(), &[1, 10, 100, 1_000, 10_000]);
2138 assert_eq
!(powers_of_10
.next(), None
);
2140 let mut empty
= successors(None
::<u32>, |_
| unimplemented
!());
2141 assert_eq
!(empty
.next(), None
);
2142 assert_eq
!(empty
.next(), None
);
2148 assert_eq
!(it
.len(), 3);
2149 assert_eq
!(it
.next(), Some(0));
2150 assert_eq
!(it
.len(), 2);
2151 assert_eq
!(it
.next(), Some(1));
2152 assert_eq
!(it
.len(), 1);
2153 assert_eq
!(it
.next(), Some(2));
2154 assert_eq
!(it
.len(), 0);
2155 assert_eq
!(it
.next(), None
);
2156 assert_eq
!(it
.len(), 0);
2157 assert_eq
!(it
.next(), None
);
2158 assert_eq
!(it
.len(), 0);
2159 assert_eq
!(it
.next(), None
);
2160 assert_eq
!(it
.len(), 0);
2164 fn test_fuse_nth() {
2166 let mut it
= xs
.iter();
2168 assert_eq
!(it
.len(), 3);
2169 assert_eq
!(it
.nth(2), Some(&2));
2170 assert_eq
!(it
.len(), 0);
2171 assert_eq
!(it
.nth(2), None
);
2172 assert_eq
!(it
.len(), 0);
2176 fn test_fuse_last() {
2180 assert_eq
!(it
.len(), 3);
2181 assert_eq
!(it
.last(), Some(&2));
2185 fn test_fuse_count() {
2189 assert_eq
!(it
.len(), 3);
2190 assert_eq
!(it
.count(), 3);
2191 // Can't check len now because count consumes.
2195 fn test_fuse_fold() {
2197 let it
= xs
.iter(); // `FusedIterator`
2198 let i
= it
.fuse().fold(0, |i
, &x
| {
2199 assert_eq
!(x
, xs
[i
]);
2202 assert_eq
!(i
, xs
.len());
2204 let it
= xs
.iter(); // `FusedIterator`
2205 let i
= it
.fuse().rfold(xs
.len(), |i
, &x
| {
2206 assert_eq
!(x
, xs
[i
- 1]);
2211 let it
= xs
.iter().scan((), |_
, &x
| Some(x
)); // `!FusedIterator`
2212 let i
= it
.fuse().fold(0, |i
, x
| {
2213 assert_eq
!(x
, xs
[i
]);
2216 assert_eq
!(i
, xs
.len());
2221 let mut it
= once(42);
2222 assert_eq
!(it
.next(), Some(42));
2223 assert_eq
!(it
.next(), None
);
2227 fn test_once_with() {
2228 let count
= Cell
::new(0);
2229 let mut it
= once_with(|| {
2230 count
.set(count
.get() + 1);
2234 assert_eq
!(count
.get(), 0);
2235 assert_eq
!(it
.next(), Some(42));
2236 assert_eq
!(count
.get(), 1);
2237 assert_eq
!(it
.next(), None
);
2238 assert_eq
!(count
.get(), 1);
2239 assert_eq
!(it
.next(), None
);
2240 assert_eq
!(count
.get(), 1);
2245 let mut it
= empty
::<i32>();
2246 assert_eq
!(it
.next(), None
);
2250 fn test_chain_fold() {
2254 let mut iter
= xs
.iter().chain(&ys
);
2256 let mut result
= Vec
::new();
2257 iter
.fold((), |(), &elt
| result
.push(elt
));
2258 assert_eq
!(&[2, 3, 1, 2, 0], &result
[..]);
2262 fn test_step_replace_unsigned() {
2264 let y
= x
.replace_zero();
2269 let y
= x
.replace_one();
2275 fn test_step_replace_signed() {
2277 let y
= x
.replace_zero();
2282 let y
= x
.replace_one();
2288 fn test_step_replace_no_between() {
2290 let y
= x
.replace_zero();
2295 let y
= x
.replace_one();
2301 fn test_rev_try_folds() {
2302 let f
= &|acc
, x
| i32::checked_add(2*acc
, x
);
2303 assert_eq
!((1..10).rev().try_fold(7, f
), (1..10).try_rfold(7, f
));
2304 assert_eq
!((1..10).rev().try_rfold(7, f
), (1..10).try_fold(7, f
));
2306 let a
= [10, 20, 30, 40, 100, 60, 70, 80, 90];
2307 let mut iter
= a
.iter().rev();
2308 assert_eq
!(iter
.try_fold(0_i8, |acc
, &x
| acc
.checked_add(x
)), None
);
2309 assert_eq
!(iter
.next(), Some(&70));
2310 let mut iter
= a
.iter().rev();
2311 assert_eq
!(iter
.try_rfold(0_i8, |acc
, &x
| acc
.checked_add(x
)), None
);
2312 assert_eq
!(iter
.next_back(), Some(&60));
2316 fn test_cloned_try_folds() {
2317 let a
= [1, 2, 3, 4, 5, 6, 7, 8, 9];
2318 let f
= &|acc
, x
| i32::checked_add(2*acc
, x
);
2319 let f_ref
= &|acc
, &x
| i32::checked_add(2*acc
, x
);
2320 assert_eq
!(a
.iter().cloned().try_fold(7, f
), a
.iter().try_fold(7, f_ref
));
2321 assert_eq
!(a
.iter().cloned().try_rfold(7, f
), a
.iter().try_rfold(7, f_ref
));
2323 let a
= [10, 20, 30, 40, 100, 60, 70, 80, 90];
2324 let mut iter
= a
.iter().cloned();
2325 assert_eq
!(iter
.try_fold(0_i8, |acc
, x
| acc
.checked_add(x
)), None
);
2326 assert_eq
!(iter
.next(), Some(60));
2327 let mut iter
= a
.iter().cloned();
2328 assert_eq
!(iter
.try_rfold(0_i8, |acc
, x
| acc
.checked_add(x
)), None
);
2329 assert_eq
!(iter
.next_back(), Some(70));
2333 fn test_chain_try_folds() {
2334 let c
= || (0..10).chain(10..20);
2336 let f
= &|acc
, x
| i32::checked_add(2*acc
, x
);
2337 assert_eq
!(c().try_fold(7, f
), (0..20).try_fold(7, f
));
2338 assert_eq
!(c().try_rfold(7, f
), (0..20).rev().try_fold(7, f
));
2341 assert_eq
!(iter
.position(|x
| x
== 5), Some(5));
2342 assert_eq
!(iter
.next(), Some(6), "stopped in front, state Both");
2343 assert_eq
!(iter
.position(|x
| x
== 13), Some(6));
2344 assert_eq
!(iter
.next(), Some(14), "stopped in back, state Back");
2345 assert_eq
!(iter
.try_fold(0, |acc
, x
| Some(acc
+x
)), Some((15..20).sum()));
2347 let mut iter
= c().rev(); // use rev to access try_rfold
2348 assert_eq
!(iter
.position(|x
| x
== 15), Some(4));
2349 assert_eq
!(iter
.next(), Some(14), "stopped in back, state Both");
2350 assert_eq
!(iter
.position(|x
| x
== 5), Some(8));
2351 assert_eq
!(iter
.next(), Some(4), "stopped in front, state Front");
2352 assert_eq
!(iter
.try_fold(0, |acc
, x
| Some(acc
+x
)), Some((0..4).sum()));
2355 iter
.by_ref().rev().nth(14); // skip the last 15, ending in state Front
2356 assert_eq
!(iter
.try_fold(7, f
), (0..5).try_fold(7, f
));
2359 iter
.nth(14); // skip the first 15, ending in state Back
2360 assert_eq
!(iter
.try_rfold(7, f
), (15..20).try_rfold(7, f
));
2364 fn test_map_try_folds() {
2365 let f
= &|acc
, x
| i32::checked_add(2*acc
, x
);
2366 assert_eq
!((0..10).map(|x
| x
+3).try_fold(7, f
), (3..13).try_fold(7, f
));
2367 assert_eq
!((0..10).map(|x
| x
+3).try_rfold(7, f
), (3..13).try_rfold(7, f
));
2369 let mut iter
= (0..40).map(|x
| x
+10);
2370 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
2371 assert_eq
!(iter
.next(), Some(20));
2372 assert_eq
!(iter
.try_rfold(0, i8::checked_add
), None
);
2373 assert_eq
!(iter
.next_back(), Some(46));
2377 fn test_filter_try_folds() {
2378 fn p(&x
: &i32) -> bool { 0 <= x && x < 10 }
2379 let f
= &|acc
, x
| i32::checked_add(2*acc
, x
);
2380 assert_eq
!((-10..20).filter(p
).try_fold(7, f
), (0..10).try_fold(7, f
));
2381 assert_eq
!((-10..20).filter(p
).try_rfold(7, f
), (0..10).try_rfold(7, f
));
2383 let mut iter
= (0..40).filter(|&x
| x
% 2 == 1);
2384 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
2385 assert_eq
!(iter
.next(), Some(25));
2386 assert_eq
!(iter
.try_rfold(0, i8::checked_add
), None
);
2387 assert_eq
!(iter
.next_back(), Some(31));
2391 fn test_filter_map_try_folds() {
2392 let mp
= &|x
| if 0 <= x
&& x
< 10 { Some(x*2) }
else { None }
;
2393 let f
= &|acc
, x
| i32::checked_add(2*acc
, x
);
2394 assert_eq
!((-9..20).filter_map(mp
).try_fold(7, f
), (0..10).map(|x
| 2*x
).try_fold(7, f
));
2395 assert_eq
!((-9..20).filter_map(mp
).try_rfold(7, f
), (0..10).map(|x
| 2*x
).try_rfold(7, f
));
2397 let mut iter
= (0..40).filter_map(|x
| if x
%2 == 1 { None }
else { Some(x*2 + 10) }
);
2398 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
2399 assert_eq
!(iter
.next(), Some(38));
2400 assert_eq
!(iter
.try_rfold(0, i8::checked_add
), None
);
2401 assert_eq
!(iter
.next_back(), Some(78));
2405 fn test_enumerate_try_folds() {
2406 let f
= &|acc
, (i
, x
)| usize::checked_add(2*acc
, x
/(i
+1) + i
);
2407 assert_eq
!((9..18).enumerate().try_fold(7, f
), (0..9).map(|i
| (i
, i
+9)).try_fold(7, f
));
2408 assert_eq
!((9..18).enumerate().try_rfold(7, f
), (0..9).map(|i
| (i
, i
+9)).try_rfold(7, f
));
2410 let mut iter
= (100..200).enumerate();
2411 let f
= &|acc
, (i
, x
)| u8::checked_add(acc
, u8::checked_div(x
, i
as u8 + 1)?
);
2412 assert_eq
!(iter
.try_fold(0, f
), None
);
2413 assert_eq
!(iter
.next(), Some((7, 107)));
2414 assert_eq
!(iter
.try_rfold(0, f
), None
);
2415 assert_eq
!(iter
.next_back(), Some((11, 111)));
2419 fn test_peek_try_folds() {
2420 let f
= &|acc
, x
| i32::checked_add(2*acc
, x
);
2422 assert_eq
!((1..20).peekable().try_fold(7, f
), (1..20).try_fold(7, f
));
2423 assert_eq
!((1..20).peekable().try_rfold(7, f
), (1..20).try_rfold(7, f
));
2425 let mut iter
= (1..20).peekable();
2426 assert_eq
!(iter
.peek(), Some(&1));
2427 assert_eq
!(iter
.try_fold(7, f
), (1..20).try_fold(7, f
));
2429 let mut iter
= (1..20).peekable();
2430 assert_eq
!(iter
.peek(), Some(&1));
2431 assert_eq
!(iter
.try_rfold(7, f
), (1..20).try_rfold(7, f
));
2433 let mut iter
= [100, 20, 30, 40, 50, 60, 70].iter().cloned().peekable();
2434 assert_eq
!(iter
.peek(), Some(&100));
2435 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
2436 assert_eq
!(iter
.peek(), Some(&40));
2438 let mut iter
= [100, 20, 30, 40, 50, 60, 70].iter().cloned().peekable();
2439 assert_eq
!(iter
.peek(), Some(&100));
2440 assert_eq
!(iter
.try_rfold(0, i8::checked_add
), None
);
2441 assert_eq
!(iter
.peek(), Some(&100));
2442 assert_eq
!(iter
.next_back(), Some(50));
2444 let mut iter
= (2..5).peekable();
2445 assert_eq
!(iter
.peek(), Some(&2));
2446 assert_eq
!(iter
.try_for_each(Err
), Err(2));
2447 assert_eq
!(iter
.peek(), Some(&3));
2448 assert_eq
!(iter
.try_for_each(Err
), Err(3));
2449 assert_eq
!(iter
.peek(), Some(&4));
2450 assert_eq
!(iter
.try_for_each(Err
), Err(4));
2451 assert_eq
!(iter
.peek(), None
);
2452 assert_eq
!(iter
.try_for_each(Err
), Ok(()));
2454 let mut iter
= (2..5).peekable();
2455 assert_eq
!(iter
.peek(), Some(&2));
2456 assert_eq
!(iter
.try_rfold((), |(), x
| Err(x
)), Err(4));
2457 assert_eq
!(iter
.peek(), Some(&2));
2458 assert_eq
!(iter
.try_rfold((), |(), x
| Err(x
)), Err(3));
2459 assert_eq
!(iter
.peek(), Some(&2));
2460 assert_eq
!(iter
.try_rfold((), |(), x
| Err(x
)), Err(2));
2461 assert_eq
!(iter
.peek(), None
);
2462 assert_eq
!(iter
.try_rfold((), |(), x
| Err(x
)), Ok(()));
2466 fn test_skip_while_try_fold() {
2467 let f
= &|acc
, x
| i32::checked_add(2*acc
, x
);
2468 fn p(&x
: &i32) -> bool { (x % 10) <= 5 }
2469 assert_eq
!((1..20).skip_while(p
).try_fold(7, f
), (6..20).try_fold(7, f
));
2470 let mut iter
= (1..20).skip_while(p
);
2471 assert_eq
!(iter
.nth(5), Some(11));
2472 assert_eq
!(iter
.try_fold(7, f
), (12..20).try_fold(7, f
));
2474 let mut iter
= (0..50).skip_while(|&x
| (x
% 20) < 15);
2475 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
2476 assert_eq
!(iter
.next(), Some(23));
2480 fn test_take_while_folds() {
2481 let f
= &|acc
, x
| i32::checked_add(2*acc
, x
);
2482 assert_eq
!((1..20).take_while(|&x
| x
!= 10).try_fold(7, f
), (1..10).try_fold(7, f
));
2483 let mut iter
= (1..20).take_while(|&x
| x
!= 10);
2484 assert_eq
!(iter
.try_fold(0, |x
, y
| Some(x
+y
)), Some((1..10).sum()));
2485 assert_eq
!(iter
.next(), None
, "flag should be set");
2486 let iter
= (1..20).take_while(|&x
| x
!= 10);
2487 assert_eq
!(iter
.fold(0, |x
, y
| x
+y
), (1..10).sum());
2489 let mut iter
= (10..50).take_while(|&x
| x
!= 40);
2490 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
2491 assert_eq
!(iter
.next(), Some(20));
2495 fn test_skip_try_folds() {
2496 let f
= &|acc
, x
| i32::checked_add(2*acc
, x
);
2497 assert_eq
!((1..20).skip(9).try_fold(7, f
), (10..20).try_fold(7, f
));
2498 assert_eq
!((1..20).skip(9).try_rfold(7, f
), (10..20).try_rfold(7, f
));
2500 let mut iter
= (0..30).skip(10);
2501 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
2502 assert_eq
!(iter
.next(), Some(20));
2503 assert_eq
!(iter
.try_rfold(0, i8::checked_add
), None
);
2504 assert_eq
!(iter
.next_back(), Some(24));
2508 fn test_skip_nth_back() {
2509 let xs
= [0, 1, 2, 3, 4, 5];
2510 let mut it
= xs
.iter().skip(2);
2511 assert_eq
!(it
.nth_back(0), Some(&5));
2512 assert_eq
!(it
.nth_back(1), Some(&3));
2513 assert_eq
!(it
.nth_back(0), Some(&2));
2514 assert_eq
!(it
.nth_back(0), None
);
2516 let ys
= [2, 3, 4, 5];
2517 let mut ity
= ys
.iter();
2518 let mut it
= xs
.iter().skip(2);
2519 assert_eq
!(it
.nth_back(1), ity
.nth_back(1));
2520 assert_eq
!(it
.clone().nth(0), ity
.clone().nth(0));
2521 assert_eq
!(it
.nth_back(0), ity
.nth_back(0));
2522 assert_eq
!(it
.clone().nth(0), ity
.clone().nth(0));
2523 assert_eq
!(it
.nth_back(0), ity
.nth_back(0));
2524 assert_eq
!(it
.clone().nth(0), ity
.clone().nth(0));
2525 assert_eq
!(it
.nth_back(0), ity
.nth_back(0));
2526 assert_eq
!(it
.clone().nth(0), ity
.clone().nth(0));
2528 let mut it
= xs
.iter().skip(2);
2529 assert_eq
!(it
.nth_back(4), None
);
2530 assert_eq
!(it
.nth_back(0), None
);
2532 let mut it
= xs
.iter();
2533 it
.by_ref().skip(2).nth_back(3);
2534 assert_eq
!(it
.next_back(), Some(&1));
2536 let mut it
= xs
.iter();
2537 it
.by_ref().skip(2).nth_back(10);
2538 assert_eq
!(it
.next_back(), Some(&1));
2542 fn test_take_try_folds() {
2543 let f
= &|acc
, x
| i32::checked_add(2*acc
, x
);
2544 assert_eq
!((10..30).take(10).try_fold(7, f
), (10..20).try_fold(7, f
));
2545 assert_eq
!((10..30).take(10).try_rfold(7, f
), (10..20).try_rfold(7, f
));
2547 let mut iter
= (10..30).take(20);
2548 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
2549 assert_eq
!(iter
.next(), Some(20));
2550 assert_eq
!(iter
.try_rfold(0, i8::checked_add
), None
);
2551 assert_eq
!(iter
.next_back(), Some(24));
2553 let mut iter
= (2..20).take(3);
2554 assert_eq
!(iter
.try_for_each(Err
), Err(2));
2555 assert_eq
!(iter
.try_for_each(Err
), Err(3));
2556 assert_eq
!(iter
.try_for_each(Err
), Err(4));
2557 assert_eq
!(iter
.try_for_each(Err
), Ok(()));
2559 let mut iter
= (2..20).take(3).rev();
2560 assert_eq
!(iter
.try_for_each(Err
), Err(4));
2561 assert_eq
!(iter
.try_for_each(Err
), Err(3));
2562 assert_eq
!(iter
.try_for_each(Err
), Err(2));
2563 assert_eq
!(iter
.try_for_each(Err
), Ok(()));
2567 fn test_flat_map_try_folds() {
2568 let f
= &|acc
, x
| i32::checked_add(acc
*2/3, x
);
2569 let mr
= &|x
| (5*x
)..(5*x
+ 5);
2570 assert_eq
!((0..10).flat_map(mr
).try_fold(7, f
), (0..50).try_fold(7, f
));
2571 assert_eq
!((0..10).flat_map(mr
).try_rfold(7, f
), (0..50).try_rfold(7, f
));
2572 let mut iter
= (0..10).flat_map(mr
);
2573 iter
.next(); iter
.next_back(); // have front and back iters in progress
2574 assert_eq
!(iter
.try_rfold(7, f
), (1..49).try_rfold(7, f
));
2576 let mut iter
= (0..10).flat_map(|x
| (4*x
)..(4*x
+ 4));
2577 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
2578 assert_eq
!(iter
.next(), Some(17));
2579 assert_eq
!(iter
.try_rfold(0, i8::checked_add
), None
);
2580 assert_eq
!(iter
.next_back(), Some(35));
2584 fn test_flatten_try_folds() {
2585 let f
= &|acc
, x
| i32::checked_add(acc
*2/3, x
);
2586 let mr
= &|x
| (5*x
)..(5*x
+ 5);
2587 assert_eq
!((0..10).map(mr
).flatten().try_fold(7, f
), (0..50).try_fold(7, f
));
2588 assert_eq
!((0..10).map(mr
).flatten().try_rfold(7, f
), (0..50).try_rfold(7, f
));
2589 let mut iter
= (0..10).map(mr
).flatten();
2590 iter
.next(); iter
.next_back(); // have front and back iters in progress
2591 assert_eq
!(iter
.try_rfold(7, f
), (1..49).try_rfold(7, f
));
2593 let mut iter
= (0..10).map(|x
| (4*x
)..(4*x
+ 4)).flatten();
2594 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
2595 assert_eq
!(iter
.next(), Some(17));
2596 assert_eq
!(iter
.try_rfold(0, i8::checked_add
), None
);
2597 assert_eq
!(iter
.next_back(), Some(35));
2601 fn test_functor_laws() {
2603 fn identity
<T
>(x
: T
) -> T { x }
2604 assert_eq
!((0..10).map(identity
).sum
::<usize>(), (0..10).sum());
2607 fn f(x
: usize) -> usize { x + 3 }
2608 fn g(x
: usize) -> usize { x * 2 }
2609 fn h(x
: usize) -> usize { g(f(x)) }
2610 assert_eq
!((0..10).map(f
).map(g
).sum
::<usize>(), (0..10).map(h
).sum());
2614 fn test_monad_laws_left_identity() {
2615 fn f(x
: usize) -> impl Iterator
<Item
= usize> {
2616 (0..10).map(move |y
| x
* y
)
2618 assert_eq
!(once(42).flat_map(f
.clone()).sum
::<usize>(), f(42).sum());
2622 fn test_monad_laws_right_identity() {
2623 assert_eq
!((0..10).flat_map(|x
| once(x
)).sum
::<usize>(), (0..10).sum());
2627 fn test_monad_laws_associativity() {
2628 fn f(x
: usize) -> impl Iterator
<Item
= usize> { 0..x }
2629 fn g(x
: usize) -> impl Iterator
<Item
= usize> { (0..x).rev() }
2630 assert_eq
!((0..10).flat_map(f
).flat_map(g
).sum
::<usize>(),
2631 (0..10).flat_map(|x
| f(x
).flat_map(g
)).sum
::<usize>());
2635 fn test_is_sorted() {
2636 assert
!([1, 2, 2, 9].iter().is_sorted());
2637 assert
!(![1, 3, 2].iter().is_sorted());
2638 assert
!([0].iter().is_sorted());
2639 assert
!(std
::iter
::empty
::<i32>().is_sorted());
2640 assert
!(![0.0, 1.0, std
::f32::NAN
].iter().is_sorted());
2641 assert
!([-2, -1, 0, 3].iter().is_sorted());
2642 assert
!(![-2i32, -1, 0, 3].iter().is_sorted_by_key(|n
| n
.abs()));
2643 assert
!(!["c", "bb", "aaa"].iter().is_sorted());
2644 assert
!(["c", "bb", "aaa"].iter().is_sorted_by_key(|s
| s
.len()));
2648 fn test_partition() {
2649 fn check(xs
: &mut [i32], ref p
: impl Fn(&i32) -> bool
, expected
: usize) {
2650 let i
= xs
.iter_mut().partition_in_place(p
);
2651 assert_eq
!(expected
, i
);
2652 assert
!(xs
[..i
].iter().all(p
));
2653 assert
!(!xs
[i
..].iter().any(p
));
2654 assert
!(xs
.iter().is_partitioned(p
));
2655 if i
== 0 || i
== xs
.len() {
2656 assert
!(xs
.iter().rev().is_partitioned(p
));
2658 assert
!(!xs
.iter().rev().is_partitioned(p
));
2662 check(&mut [], |_
| true, 0);
2663 check(&mut [], |_
| false, 0);
2665 check(&mut [0], |_
| true, 1);
2666 check(&mut [0], |_
| false, 0);
2668 check(&mut [-1, 1], |&x
| x
> 0, 1);
2669 check(&mut [-1, 1], |&x
| x
< 0, 1);
2671 let ref mut xs
= [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
2672 check(xs
, |_
| true, 10);
2673 check(xs
, |_
| false, 0);
2674 check(xs
, |&x
| x
% 2 == 0, 5); // evens
2675 check(xs
, |&x
| x
% 2 == 1, 5); // odds
2676 check(xs
, |&x
| x
% 3 == 0, 4); // multiple of 3
2677 check(xs
, |&x
| x
% 4 == 0, 3); // multiple of 4
2678 check(xs
, |&x
| x
% 5 == 0, 2); // multiple of 5
2679 check(xs
, |&x
| x
< 3, 3); // small
2680 check(xs
, |&x
| x
> 6, 3); // large