1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
12 use core
::{i8, i16, isize}
;
17 let empty
: [isize; 0] = [];
21 assert
!(!xs
.iter().lt(ys
.iter()));
22 assert
!(!xs
.iter().le(ys
.iter()));
23 assert
!( xs
.iter().gt(ys
.iter()));
24 assert
!( xs
.iter().ge(ys
.iter()));
26 assert
!( ys
.iter().lt(xs
.iter()));
27 assert
!( ys
.iter().le(xs
.iter()));
28 assert
!(!ys
.iter().gt(xs
.iter()));
29 assert
!(!ys
.iter().ge(xs
.iter()));
31 assert
!( empty
.iter().lt(xs
.iter()));
32 assert
!( empty
.iter().le(xs
.iter()));
33 assert
!(!empty
.iter().gt(xs
.iter()));
34 assert
!(!empty
.iter().ge(xs
.iter()));
37 let u
= [1.0f64, 2.0];
38 let v
= [0.0f64/0.0, 3.0];
40 assert
!(!u
.iter().lt(v
.iter()));
41 assert
!(!u
.iter().le(v
.iter()));
42 assert
!(!u
.iter().gt(v
.iter()));
43 assert
!(!u
.iter().ge(v
.iter()));
49 assert
!(a
.iter().lt(b
.iter()) == (a
[0] < b
[0]));
50 assert
!(a
.iter().le(b
.iter()) == (a
[0] <= b
[0]));
51 assert
!(a
.iter().gt(b
.iter()) == (a
[0] > b
[0]));
52 assert
!(a
.iter().ge(b
.iter()) == (a
[0] >= b
[0]));
54 assert
!(c
.iter().lt(b
.iter()) == (c
[0] < b
[0]));
55 assert
!(c
.iter().le(b
.iter()) == (c
[0] <= b
[0]));
56 assert
!(c
.iter().gt(b
.iter()) == (c
[0] > b
[0]));
57 assert
!(c
.iter().ge(b
.iter()) == (c
[0] >= b
[0]));
61 fn test_multi_iter() {
64 assert
!(xs
.iter().eq(ys
.iter().rev()));
65 assert
!(xs
.iter().lt(xs
.iter().skip(2)));
69 fn test_counter_from_iter() {
70 let it
= (0..).step_by(5).take(10);
71 let xs
: Vec
<isize> = FromIterator
::from_iter(it
);
72 assert_eq
!(xs
, [0, 5, 10, 15, 20, 25, 30, 35, 40, 45]);
76 fn test_iterator_chain() {
77 let xs
= [0, 1, 2, 3, 4, 5];
78 let ys
= [30, 40, 50, 60];
79 let expected
= [0, 1, 2, 3, 4, 5, 30, 40, 50, 60];
80 let it
= xs
.iter().chain(&ys
);
83 assert_eq
!(x
, expected
[i
]);
86 assert_eq
!(i
, expected
.len());
88 let ys
= (30..).step_by(10).take(4);
89 let it
= xs
.iter().cloned().chain(ys
);
92 assert_eq
!(x
, expected
[i
]);
95 assert_eq
!(i
, expected
.len());
99 fn test_iterator_chain_nth() {
100 let xs
= [0, 1, 2, 3, 4, 5];
101 let ys
= [30, 40, 50, 60];
103 let expected
= [0, 1, 2, 3, 4, 5, 30, 40, 50, 60];
104 for (i
, x
) in expected
.iter().enumerate() {
105 assert_eq
!(Some(x
), xs
.iter().chain(&ys
).nth(i
));
107 assert_eq
!(zs
.iter().chain(&xs
).nth(0), Some(&0));
109 let mut it
= xs
.iter().chain(&zs
);
110 assert_eq
!(it
.nth(5), Some(&5));
111 assert_eq
!(it
.next(), None
);
115 fn test_iterator_chain_last() {
116 let xs
= [0, 1, 2, 3, 4, 5];
117 let ys
= [30, 40, 50, 60];
119 assert_eq
!(xs
.iter().chain(&ys
).last(), Some(&60));
120 assert_eq
!(zs
.iter().chain(&ys
).last(), Some(&60));
121 assert_eq
!(ys
.iter().chain(&zs
).last(), Some(&60));
122 assert_eq
!(zs
.iter().chain(&zs
).last(), None
);
126 fn test_iterator_chain_count() {
127 let xs
= [0, 1, 2, 3, 4, 5];
128 let ys
= [30, 40, 50, 60];
130 assert_eq
!(xs
.iter().chain(&ys
).count(), 10);
131 assert_eq
!(zs
.iter().chain(&ys
).count(), 4);
135 fn test_iterator_chain_find() {
136 let xs
= [0, 1, 2, 3, 4, 5];
137 let ys
= [30, 40, 50, 60];
138 let mut iter
= xs
.iter().chain(&ys
);
139 assert_eq
!(iter
.find(|&&i
| i
== 4), Some(&4));
140 assert_eq
!(iter
.next(), Some(&5));
141 assert_eq
!(iter
.find(|&&i
| i
== 40), Some(&40));
142 assert_eq
!(iter
.next(), Some(&50));
143 assert_eq
!(iter
.find(|&&i
| i
== 100), None
);
144 assert_eq
!(iter
.next(), None
);
148 fn test_iterator_step_by() {
150 let mut it
= (0..).step_by(1).take(3);
151 assert_eq
!(it
.next(), Some(0));
152 assert_eq
!(it
.next(), Some(1));
153 assert_eq
!(it
.next(), Some(2));
154 assert_eq
!(it
.next(), None
);
156 let mut it
= (0..).step_by(3).take(4);
157 assert_eq
!(it
.next(), Some(0));
158 assert_eq
!(it
.next(), Some(3));
159 assert_eq
!(it
.next(), Some(6));
160 assert_eq
!(it
.next(), Some(9));
161 assert_eq
!(it
.next(), None
);
166 fn test_iterator_step_by_zero() {
167 let mut it
= (0..).step_by(0);
172 fn test_iterator_step_by_size_hint() {
173 struct StubSizeHint(usize, Option
<usize>);
174 impl Iterator
for StubSizeHint
{
176 fn next(&mut self) -> Option
<()> {
178 if let Some(ref mut upper
) = self.1 {
183 fn size_hint(&self) -> (usize, Option
<usize>) {
188 // The two checks in each case are needed because the logic
189 // is different before the first call to `next()`.
191 let mut it
= StubSizeHint(10, Some(10)).step_by(1);
192 assert_eq
!(it
.size_hint(), (10, Some(10)));
194 assert_eq
!(it
.size_hint(), (9, Some(9)));
197 let mut it
= StubSizeHint(10, Some(10)).step_by(3);
198 assert_eq
!(it
.size_hint(), (4, Some(4)));
200 assert_eq
!(it
.size_hint(), (3, Some(3)));
202 // larger base range, but not enough to get another element
203 let mut it
= StubSizeHint(12, Some(12)).step_by(3);
204 assert_eq
!(it
.size_hint(), (4, Some(4)));
206 assert_eq
!(it
.size_hint(), (3, Some(3)));
208 // smaller base range, so fewer resulting elements
209 let mut it
= StubSizeHint(9, Some(9)).step_by(3);
210 assert_eq
!(it
.size_hint(), (3, Some(3)));
212 assert_eq
!(it
.size_hint(), (2, Some(2)));
214 // infinite upper bound
215 let mut it
= StubSizeHint(usize::MAX
, None
).step_by(1);
216 assert_eq
!(it
.size_hint(), (usize::MAX
, None
));
218 assert_eq
!(it
.size_hint(), (usize::MAX
-1, None
));
220 // still infinite with larger step
221 let mut it
= StubSizeHint(7, None
).step_by(3);
222 assert_eq
!(it
.size_hint(), (3, None
));
224 assert_eq
!(it
.size_hint(), (2, None
));
226 // propagates ExactSizeIterator
228 let it
= a
.iter().step_by(2);
229 assert_eq
!(it
.len(), 3);
231 // Cannot be TrustedLen as a step greater than one makes an iterator
232 // with (usize::MAX, None) no longer meet the safety requirements
233 trait TrustedLenCheck { fn test(self) -> bool; }
234 impl<T
:Iterator
> TrustedLenCheck
for T
{
235 default fn test(self) -> bool { false }
237 impl<T
:TrustedLen
> TrustedLenCheck
for T
{
238 fn test(self) -> bool { true }
240 assert
!(TrustedLenCheck
::test(a
.iter()));
241 assert
!(!TrustedLenCheck
::test(a
.iter().step_by(1)));
245 fn test_filter_map() {
246 let it
= (0..).step_by(1).take(10)
247 .filter_map(|x
| if x
% 2 == 0 { Some(x*x) }
else { None }
);
248 assert_eq
!(it
.collect
::<Vec
<usize>>(), [0*0, 2*2, 4*4, 6*6, 8*8]);
252 fn test_filter_map_fold() {
253 let xs
= [0, 1, 2, 3, 4, 5, 6, 7, 8];
254 let ys
= [0*0, 2*2, 4*4, 6*6, 8*8];
255 let it
= xs
.iter().filter_map(|&x
| if x
% 2 == 0 { Some(x*x) }
else { None }
);
256 let i
= it
.fold(0, |i
, x
| {
257 assert_eq
!(x
, ys
[i
]);
260 assert_eq
!(i
, ys
.len());
262 let it
= xs
.iter().filter_map(|&x
| if x
% 2 == 0 { Some(x*x) }
else { None }
);
263 let i
= it
.rfold(ys
.len(), |i
, x
| {
264 assert_eq
!(x
, ys
[i
- 1]);
271 fn test_iterator_enumerate() {
272 let xs
= [0, 1, 2, 3, 4, 5];
273 let it
= xs
.iter().enumerate();
280 fn test_iterator_enumerate_nth() {
281 let xs
= [0, 1, 2, 3, 4, 5];
282 for (i
, &x
) in xs
.iter().enumerate() {
286 let mut it
= xs
.iter().enumerate();
287 while let Some((i
, &x
)) = it
.nth(0) {
291 let mut it
= xs
.iter().enumerate();
292 while let Some((i
, &x
)) = it
.nth(1) {
296 let (i
, &x
) = xs
.iter().enumerate().nth(3).unwrap();
302 fn test_iterator_enumerate_count() {
303 let xs
= [0, 1, 2, 3, 4, 5];
304 assert_eq
!(xs
.iter().enumerate().count(), 6);
308 fn test_iterator_enumerate_fold() {
309 let xs
= [0, 1, 2, 3, 4, 5];
310 let mut it
= xs
.iter().enumerate();
311 // steal a couple to get an interesting offset
312 assert_eq
!(it
.next(), Some((0, &0)));
313 assert_eq
!(it
.next(), Some((1, &1)));
314 let i
= it
.fold(2, |i
, (j
, &x
)| {
316 assert_eq
!(x
, xs
[j
]);
319 assert_eq
!(i
, xs
.len());
321 let mut it
= xs
.iter().enumerate();
322 assert_eq
!(it
.next(), Some((0, &0)));
323 let i
= it
.rfold(xs
.len() - 1, |i
, (j
, &x
)| {
325 assert_eq
!(x
, xs
[j
]);
332 fn test_iterator_filter_count() {
333 let xs
= [0, 1, 2, 3, 4, 5, 6, 7, 8];
334 assert_eq
!(xs
.iter().filter(|&&x
| x
% 2 == 0).count(), 5);
338 fn test_iterator_filter_fold() {
339 let xs
= [0, 1, 2, 3, 4, 5, 6, 7, 8];
340 let ys
= [0, 2, 4, 6, 8];
341 let it
= xs
.iter().filter(|&&x
| x
% 2 == 0);
342 let i
= it
.fold(0, |i
, &x
| {
343 assert_eq
!(x
, ys
[i
]);
346 assert_eq
!(i
, ys
.len());
348 let it
= xs
.iter().filter(|&&x
| x
% 2 == 0);
349 let i
= it
.rfold(ys
.len(), |i
, &x
| {
350 assert_eq
!(x
, ys
[i
- 1]);
357 fn test_iterator_peekable() {
358 let xs
= vec
![0, 1, 2, 3, 4, 5];
359 let mut it
= xs
.iter().cloned().peekable();
361 assert_eq
!(it
.len(), 6);
362 assert_eq
!(it
.peek().unwrap(), &0);
363 assert_eq
!(it
.len(), 6);
364 assert_eq
!(it
.next().unwrap(), 0);
365 assert_eq
!(it
.len(), 5);
366 assert_eq
!(it
.next().unwrap(), 1);
367 assert_eq
!(it
.len(), 4);
368 assert_eq
!(it
.next().unwrap(), 2);
369 assert_eq
!(it
.len(), 3);
370 assert_eq
!(it
.peek().unwrap(), &3);
371 assert_eq
!(it
.len(), 3);
372 assert_eq
!(it
.peek().unwrap(), &3);
373 assert_eq
!(it
.len(), 3);
374 assert_eq
!(it
.next().unwrap(), 3);
375 assert_eq
!(it
.len(), 2);
376 assert_eq
!(it
.next().unwrap(), 4);
377 assert_eq
!(it
.len(), 1);
378 assert_eq
!(it
.peek().unwrap(), &5);
379 assert_eq
!(it
.len(), 1);
380 assert_eq
!(it
.next().unwrap(), 5);
381 assert_eq
!(it
.len(), 0);
382 assert
!(it
.peek().is_none());
383 assert_eq
!(it
.len(), 0);
384 assert
!(it
.next().is_none());
385 assert_eq
!(it
.len(), 0);
389 fn test_iterator_peekable_count() {
390 let xs
= [0, 1, 2, 3, 4, 5];
392 let zs
: [i32; 0] = [];
394 assert_eq
!(xs
.iter().peekable().count(), 6);
396 let mut it
= xs
.iter().peekable();
397 assert_eq
!(it
.peek(), Some(&&0));
398 assert_eq
!(it
.count(), 6);
400 assert_eq
!(ys
.iter().peekable().count(), 1);
402 let mut it
= ys
.iter().peekable();
403 assert_eq
!(it
.peek(), Some(&&10));
404 assert_eq
!(it
.count(), 1);
406 assert_eq
!(zs
.iter().peekable().count(), 0);
408 let mut it
= zs
.iter().peekable();
409 assert_eq
!(it
.peek(), None
);
414 fn test_iterator_peekable_nth() {
415 let xs
= [0, 1, 2, 3, 4, 5];
416 let mut it
= xs
.iter().peekable();
418 assert_eq
!(it
.peek(), Some(&&0));
419 assert_eq
!(it
.nth(0), Some(&0));
420 assert_eq
!(it
.peek(), Some(&&1));
421 assert_eq
!(it
.nth(1), Some(&2));
422 assert_eq
!(it
.peek(), Some(&&3));
423 assert_eq
!(it
.nth(2), Some(&5));
424 assert_eq
!(it
.next(), None
);
428 fn test_iterator_peekable_last() {
429 let xs
= [0, 1, 2, 3, 4, 5];
432 let mut it
= xs
.iter().peekable();
433 assert_eq
!(it
.peek(), Some(&&0));
434 assert_eq
!(it
.last(), Some(&5));
436 let mut it
= ys
.iter().peekable();
437 assert_eq
!(it
.peek(), Some(&&0));
438 assert_eq
!(it
.last(), Some(&0));
440 let mut it
= ys
.iter().peekable();
441 assert_eq
!(it
.next(), Some(&0));
442 assert_eq
!(it
.peek(), None
);
443 assert_eq
!(it
.last(), None
);
447 fn test_iterator_peekable_fold() {
448 let xs
= [0, 1, 2, 3, 4, 5];
449 let mut it
= xs
.iter().peekable();
450 assert_eq
!(it
.peek(), Some(&&0));
451 let i
= it
.fold(0, |i
, &x
| {
452 assert_eq
!(x
, xs
[i
]);
455 assert_eq
!(i
, xs
.len());
458 /// This is an iterator that follows the Iterator contract,
459 /// but it is not fused. After having returned None once, it will start
460 /// producing elements if .next() is called again.
461 pub struct CycleIter
<'a
, T
: 'a
> {
466 pub fn cycle
<T
>(data
: &[T
]) -> CycleIter
<T
> {
473 impl<'a
, T
> Iterator
for CycleIter
<'a
, T
> {
475 fn next(&mut self) -> Option
<Self::Item
> {
476 let elt
= self.data
.get(self.index
);
478 self.index
%= 1 + self.data
.len();
484 fn test_iterator_peekable_remember_peek_none_1() {
485 // Check that the loop using .peek() terminates
486 let data
= [1, 2, 3];
487 let mut iter
= cycle(&data
).peekable();
490 while let Some(_
) = iter
.next() {
491 let is_the_last
= iter
.peek().is_none();
492 assert_eq
!(is_the_last
, n
== data
.len() - 1);
494 if n
> data
.len() { break; }
496 assert_eq
!(n
, data
.len());
500 fn test_iterator_peekable_remember_peek_none_2() {
502 let mut iter
= cycle(&data
).peekable();
504 assert_eq
!(iter
.peek(), None
);
505 assert_eq
!(iter
.last(), None
);
509 fn test_iterator_peekable_remember_peek_none_3() {
511 let mut iter
= cycle(&data
).peekable();
513 assert_eq
!(iter
.nth(0), Some(&0));
515 let mut iter
= cycle(&data
).peekable();
517 assert_eq
!(iter
.peek(), None
);
518 assert_eq
!(iter
.nth(0), None
);
522 fn test_iterator_take_while() {
523 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19];
524 let ys
= [0, 1, 2, 3, 5, 13];
525 let it
= xs
.iter().take_while(|&x
| *x
< 15);
528 assert_eq
!(*x
, ys
[i
]);
531 assert_eq
!(i
, ys
.len());
535 fn test_iterator_skip_while() {
536 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19];
537 let ys
= [15, 16, 17, 19];
538 let it
= xs
.iter().skip_while(|&x
| *x
< 15);
541 assert_eq
!(*x
, ys
[i
]);
544 assert_eq
!(i
, ys
.len());
548 fn test_iterator_skip_while_fold() {
549 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19];
550 let ys
= [15, 16, 17, 19];
551 let it
= xs
.iter().skip_while(|&x
| *x
< 15);
552 let i
= it
.fold(0, |i
, &x
| {
553 assert_eq
!(x
, ys
[i
]);
556 assert_eq
!(i
, ys
.len());
558 let mut it
= xs
.iter().skip_while(|&x
| *x
< 15);
559 assert_eq
!(it
.next(), Some(&ys
[0])); // process skips before folding
560 let i
= it
.fold(1, |i
, &x
| {
561 assert_eq
!(x
, ys
[i
]);
564 assert_eq
!(i
, ys
.len());
568 fn test_iterator_skip() {
569 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
570 let ys
= [13, 15, 16, 17, 19, 20, 30];
571 let mut it
= xs
.iter().skip(5);
573 while let Some(&x
) = it
.next() {
574 assert_eq
!(x
, ys
[i
]);
576 assert_eq
!(it
.len(), xs
.len()-5-i
);
578 assert_eq
!(i
, ys
.len());
579 assert_eq
!(it
.len(), 0);
583 fn test_iterator_skip_doubleended() {
584 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
585 let mut it
= xs
.iter().rev().skip(5);
586 assert_eq
!(it
.next(), Some(&15));
587 assert_eq
!(it
.by_ref().rev().next(), Some(&0));
588 assert_eq
!(it
.next(), Some(&13));
589 assert_eq
!(it
.by_ref().rev().next(), Some(&1));
590 assert_eq
!(it
.next(), Some(&5));
591 assert_eq
!(it
.by_ref().rev().next(), Some(&2));
592 assert_eq
!(it
.next(), Some(&3));
593 assert_eq
!(it
.next(), None
);
594 let mut it
= xs
.iter().rev().skip(5).rev();
595 assert_eq
!(it
.next(), Some(&0));
596 assert_eq
!(it
.rev().next(), Some(&15));
597 let mut it_base
= xs
.iter();
599 let mut it
= it_base
.by_ref().skip(5).rev();
600 assert_eq
!(it
.next(), Some(&30));
601 assert_eq
!(it
.next(), Some(&20));
602 assert_eq
!(it
.next(), Some(&19));
603 assert_eq
!(it
.next(), Some(&17));
604 assert_eq
!(it
.next(), Some(&16));
605 assert_eq
!(it
.next(), Some(&15));
606 assert_eq
!(it
.next(), Some(&13));
607 assert_eq
!(it
.next(), None
);
609 // make sure the skipped parts have not been consumed
610 assert_eq
!(it_base
.next(), Some(&0));
611 assert_eq
!(it_base
.next(), Some(&1));
612 assert_eq
!(it_base
.next(), Some(&2));
613 assert_eq
!(it_base
.next(), Some(&3));
614 assert_eq
!(it_base
.next(), Some(&5));
615 assert_eq
!(it_base
.next(), None
);
616 let it
= xs
.iter().skip(5).rev();
617 assert_eq
!(it
.last(), Some(&13));
621 fn test_iterator_skip_nth() {
622 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
624 let mut it
= xs
.iter().skip(0);
625 assert_eq
!(it
.nth(0), Some(&0));
626 assert_eq
!(it
.nth(1), Some(&2));
628 let mut it
= xs
.iter().skip(5);
629 assert_eq
!(it
.nth(0), Some(&13));
630 assert_eq
!(it
.nth(1), Some(&16));
632 let mut it
= xs
.iter().skip(12);
633 assert_eq
!(it
.nth(0), None
);
638 fn test_iterator_skip_count() {
639 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
641 assert_eq
!(xs
.iter().skip(0).count(), 12);
642 assert_eq
!(xs
.iter().skip(1).count(), 11);
643 assert_eq
!(xs
.iter().skip(11).count(), 1);
644 assert_eq
!(xs
.iter().skip(12).count(), 0);
645 assert_eq
!(xs
.iter().skip(13).count(), 0);
649 fn test_iterator_skip_last() {
650 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
652 assert_eq
!(xs
.iter().skip(0).last(), Some(&30));
653 assert_eq
!(xs
.iter().skip(1).last(), Some(&30));
654 assert_eq
!(xs
.iter().skip(11).last(), Some(&30));
655 assert_eq
!(xs
.iter().skip(12).last(), None
);
656 assert_eq
!(xs
.iter().skip(13).last(), None
);
658 let mut it
= xs
.iter().skip(5);
659 assert_eq
!(it
.next(), Some(&13));
660 assert_eq
!(it
.last(), Some(&30));
664 fn test_iterator_skip_fold() {
665 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
666 let ys
= [13, 15, 16, 17, 19, 20, 30];
668 let it
= xs
.iter().skip(5);
669 let i
= it
.fold(0, |i
, &x
| {
670 assert_eq
!(x
, ys
[i
]);
673 assert_eq
!(i
, ys
.len());
675 let mut it
= xs
.iter().skip(5);
676 assert_eq
!(it
.next(), Some(&ys
[0])); // process skips before folding
677 let i
= it
.fold(1, |i
, &x
| {
678 assert_eq
!(x
, ys
[i
]);
681 assert_eq
!(i
, ys
.len());
683 let it
= xs
.iter().skip(5);
684 let i
= it
.rfold(ys
.len(), |i
, &x
| {
686 assert_eq
!(x
, ys
[i
]);
691 let mut it
= xs
.iter().skip(5);
692 assert_eq
!(it
.next(), Some(&ys
[0])); // process skips before folding
693 let i
= it
.rfold(ys
.len(), |i
, &x
| {
695 assert_eq
!(x
, ys
[i
]);
703 fn test_iterator_take() {
704 let xs
= [0, 1, 2, 3, 5, 13, 15, 16, 17, 19];
705 let ys
= [0, 1, 2, 3, 5];
706 let mut it
= xs
.iter().take(5);
708 assert_eq
!(it
.len(), 5);
709 while let Some(&x
) = it
.next() {
710 assert_eq
!(x
, ys
[i
]);
712 assert_eq
!(it
.len(), 5-i
);
714 assert_eq
!(i
, ys
.len());
715 assert_eq
!(it
.len(), 0);
719 fn test_iterator_take_nth() {
720 let xs
= [0, 1, 2, 4, 5];
721 let mut it
= xs
.iter();
723 let mut take
= it
.by_ref().take(3);
725 while let Some(&x
) = take
.nth(0) {
730 assert_eq
!(it
.nth(1), Some(&5));
731 assert_eq
!(it
.nth(0), None
);
733 let xs
= [0, 1, 2, 3, 4];
734 let mut it
= xs
.iter().take(7);
736 while let Some(&x
) = it
.nth(1) {
743 fn test_iterator_take_short() {
744 let xs
= [0, 1, 2, 3];
745 let ys
= [0, 1, 2, 3];
746 let mut it
= xs
.iter().take(5);
748 assert_eq
!(it
.len(), 4);
749 while let Some(&x
) = it
.next() {
750 assert_eq
!(x
, ys
[i
]);
752 assert_eq
!(it
.len(), 4-i
);
754 assert_eq
!(i
, ys
.len());
755 assert_eq
!(it
.len(), 0);
759 fn test_iterator_scan() {
760 // test the type inference
761 fn add(old
: &mut isize, new
: &usize) -> Option
<f64> {
762 *old
+= *new
as isize;
765 let xs
= [0, 1, 2, 3, 4];
766 let ys
= [0f64, 1.0, 3.0, 6.0, 10.0];
768 let it
= xs
.iter().scan(0, add
);
771 assert_eq
!(x
, ys
[i
]);
774 assert_eq
!(i
, ys
.len());
778 fn test_iterator_flat_map() {
780 let ys
= [0, 1, 2, 3, 4, 5, 6, 7, 8];
781 let it
= xs
.iter().flat_map(|&x
| (x
..).step_by(1).take(3));
784 assert_eq
!(x
, ys
[i
]);
787 assert_eq
!(i
, ys
.len());
790 /// Test `FlatMap::fold` with items already picked off the front and back,
791 /// to make sure all parts of the `FlatMap` are folded correctly.
793 fn test_iterator_flat_map_fold() {
795 let ys
= [1, 2, 3, 4, 5, 6, 7];
796 let mut it
= xs
.iter().flat_map(|&x
| x
..x
+3);
797 assert_eq
!(it
.next(), Some(0));
798 assert_eq
!(it
.next_back(), Some(8));
799 let i
= it
.fold(0, |i
, x
| {
800 assert_eq
!(x
, ys
[i
]);
803 assert_eq
!(i
, ys
.len());
805 let mut it
= xs
.iter().flat_map(|&x
| x
..x
+3);
806 assert_eq
!(it
.next(), Some(0));
807 assert_eq
!(it
.next_back(), Some(8));
808 let i
= it
.rfold(ys
.len(), |i
, x
| {
809 assert_eq
!(x
, ys
[i
- 1]);
817 let xs
= [1, 2, 3, 4];
823 .collect
::<Vec
<usize>>();
825 assert_eq
!(n
, xs
.len());
826 assert_eq
!(&xs
[..], &ys
[..]);
830 fn test_inspect_fold() {
831 let xs
= [1, 2, 3, 4];
834 let it
= xs
.iter().inspect(|_
| n
+= 1);
835 let i
= it
.fold(0, |i
, &x
| {
836 assert_eq
!(x
, xs
[i
]);
839 assert_eq
!(i
, xs
.len());
841 assert_eq
!(n
, xs
.len());
845 let it
= xs
.iter().inspect(|_
| n
+= 1);
846 let i
= it
.rfold(xs
.len(), |i
, &x
| {
847 assert_eq
!(x
, xs
[i
- 1]);
852 assert_eq
!(n
, xs
.len());
858 let it
= (0..).step_by(1).take(cycle_len
).cycle();
859 assert_eq
!(it
.size_hint(), (usize::MAX
, None
));
860 for (i
, x
) in it
.take(100).enumerate() {
861 assert_eq
!(i
% cycle_len
, x
);
864 let mut it
= (0..).step_by(1).take(0).cycle();
865 assert_eq
!(it
.size_hint(), (0, Some(0)));
866 assert_eq
!(it
.next(), None
);
870 fn test_iterator_nth() {
871 let v
: &[_
] = &[0, 1, 2, 3, 4];
872 for i
in 0..v
.len() {
873 assert_eq
!(v
.iter().nth(i
).unwrap(), &v
[i
]);
875 assert_eq
!(v
.iter().nth(v
.len()), None
);
879 fn test_iterator_last() {
880 let v
: &[_
] = &[0, 1, 2, 3, 4];
881 assert_eq
!(v
.iter().last().unwrap(), &4);
882 assert_eq
!(v
[..1].iter().last().unwrap(), &0);
886 fn test_iterator_len() {
887 let v
: &[_
] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
888 assert_eq
!(v
[..4].iter().count(), 4);
889 assert_eq
!(v
[..10].iter().count(), 10);
890 assert_eq
!(v
[..0].iter().count(), 0);
894 fn test_iterator_sum() {
895 let v
: &[i32] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
896 assert_eq
!(v
[..4].iter().cloned().sum
::<i32>(), 6);
897 assert_eq
!(v
.iter().cloned().sum
::<i32>(), 55);
898 assert_eq
!(v
[..0].iter().cloned().sum
::<i32>(), 0);
902 fn test_iterator_sum_result() {
903 let v
: &[Result
<i32, ()>] = &[Ok(1), Ok(2), Ok(3), Ok(4)];
904 assert_eq
!(v
.iter().cloned().sum
::<Result
<i32, _
>>(), Ok(10));
905 let v
: &[Result
<i32, ()>] = &[Ok(1), Err(()), Ok(3), Ok(4)];
906 assert_eq
!(v
.iter().cloned().sum
::<Result
<i32, _
>>(), Err(()));
910 fn test_iterator_product() {
911 let v
: &[i32] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
912 assert_eq
!(v
[..4].iter().cloned().product
::<i32>(), 0);
913 assert_eq
!(v
[1..5].iter().cloned().product
::<i32>(), 24);
914 assert_eq
!(v
[..0].iter().cloned().product
::<i32>(), 1);
918 fn test_iterator_product_result() {
919 let v
: &[Result
<i32, ()>] = &[Ok(1), Ok(2), Ok(3), Ok(4)];
920 assert_eq
!(v
.iter().cloned().product
::<Result
<i32, _
>>(), Ok(24));
921 let v
: &[Result
<i32, ()>] = &[Ok(1), Err(()), Ok(3), Ok(4)];
922 assert_eq
!(v
.iter().cloned().product
::<Result
<i32, _
>>(), Err(()));
926 fn test_iterator_max() {
927 let v
: &[_
] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
928 assert_eq
!(v
[..4].iter().cloned().max(), Some(3));
929 assert_eq
!(v
.iter().cloned().max(), Some(10));
930 assert_eq
!(v
[..0].iter().cloned().max(), None
);
934 fn test_iterator_min() {
935 let v
: &[_
] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
936 assert_eq
!(v
[..4].iter().cloned().min(), Some(0));
937 assert_eq
!(v
.iter().cloned().min(), Some(0));
938 assert_eq
!(v
[..0].iter().cloned().min(), None
);
942 fn test_iterator_size_hint() {
943 let c
= (0..).step_by(1);
944 let v
: &[_
] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
945 let v2
= &[10, 11, 12];
948 assert_eq
!((0..).size_hint(), (usize::MAX
, None
));
949 assert_eq
!(c
.size_hint(), (usize::MAX
, None
));
950 assert_eq
!(vi
.clone().size_hint(), (10, Some(10)));
952 assert_eq
!(c
.clone().take(5).size_hint(), (5, Some(5)));
953 assert_eq
!(c
.clone().skip(5).size_hint().1, None
);
954 assert_eq
!(c
.clone().take_while(|_
| false).size_hint(), (0, None
));
955 assert_eq
!(c
.clone().skip_while(|_
| false).size_hint(), (0, None
));
956 assert_eq
!(c
.clone().enumerate().size_hint(), (usize::MAX
, None
));
957 assert_eq
!(c
.clone().chain(vi
.clone().cloned()).size_hint(), (usize::MAX
, None
));
958 assert_eq
!(c
.clone().zip(vi
.clone()).size_hint(), (10, Some(10)));
959 assert_eq
!(c
.clone().scan(0, |_
,_
| Some(0)).size_hint(), (0, None
));
960 assert_eq
!(c
.clone().filter(|_
| false).size_hint(), (0, None
));
961 assert_eq
!(c
.clone().map(|_
| 0).size_hint(), (usize::MAX
, None
));
962 assert_eq
!(c
.filter_map(|_
| Some(0)).size_hint(), (0, None
));
964 assert_eq
!(vi
.clone().take(5).size_hint(), (5, Some(5)));
965 assert_eq
!(vi
.clone().take(12).size_hint(), (10, Some(10)));
966 assert_eq
!(vi
.clone().skip(3).size_hint(), (7, Some(7)));
967 assert_eq
!(vi
.clone().skip(12).size_hint(), (0, Some(0)));
968 assert_eq
!(vi
.clone().take_while(|_
| false).size_hint(), (0, Some(10)));
969 assert_eq
!(vi
.clone().skip_while(|_
| false).size_hint(), (0, Some(10)));
970 assert_eq
!(vi
.clone().enumerate().size_hint(), (10, Some(10)));
971 assert_eq
!(vi
.clone().chain(v2
).size_hint(), (13, Some(13)));
972 assert_eq
!(vi
.clone().zip(v2
).size_hint(), (3, Some(3)));
973 assert_eq
!(vi
.clone().scan(0, |_
,_
| Some(0)).size_hint(), (0, Some(10)));
974 assert_eq
!(vi
.clone().filter(|_
| false).size_hint(), (0, Some(10)));
975 assert_eq
!(vi
.clone().map(|&i
| i
+1).size_hint(), (10, Some(10)));
976 assert_eq
!(vi
.filter_map(|_
| Some(0)).size_hint(), (0, Some(10)));
981 let a
= vec
![1, 2, 3, 4, 5];
982 let b
: Vec
<isize> = a
.iter().cloned().collect();
988 let v
: Box
<[isize]> = Box
::new([1, 2, 3, 4, 5]);
989 assert
!(v
.iter().all(|&x
| x
< 10));
990 assert
!(!v
.iter().all(|&x
| x
% 2 == 0));
991 assert
!(!v
.iter().all(|&x
| x
> 100));
992 assert
!(v
[..0].iter().all(|_
| panic
!()));
997 let v
: Box
<[isize]> = Box
::new([1, 2, 3, 4, 5]);
998 assert
!(v
.iter().any(|&x
| x
< 10));
999 assert
!(v
.iter().any(|&x
| x
% 2 == 0));
1000 assert
!(!v
.iter().any(|&x
| x
> 100));
1001 assert
!(!v
[..0].iter().any(|_
| panic
!()));
1006 let v
: &[isize] = &[1, 3, 9, 27, 103, 14, 11];
1007 assert_eq
!(*v
.iter().find(|&&x
| x
& 1 == 0).unwrap(), 14);
1008 assert_eq
!(*v
.iter().find(|&&x
| x
% 3 == 0).unwrap(), 3);
1009 assert
!(v
.iter().find(|&&x
| x
% 12 == 0).is_none());
1013 fn test_position() {
1014 let v
= &[1, 3, 9, 27, 103, 14, 11];
1015 assert_eq
!(v
.iter().position(|x
| *x
& 1 == 0).unwrap(), 5);
1016 assert_eq
!(v
.iter().position(|x
| *x
% 3 == 0).unwrap(), 1);
1017 assert
!(v
.iter().position(|x
| *x
% 12 == 0).is_none());
1022 let xs
= &[1, 2, 2, 1, 5, 9, 0, 2];
1023 assert_eq
!(xs
.iter().filter(|x
| **x
== 2).count(), 3);
1024 assert_eq
!(xs
.iter().filter(|x
| **x
== 5).count(), 1);
1025 assert_eq
!(xs
.iter().filter(|x
| **x
== 95).count(), 0);
1029 fn test_max_by_key() {
1030 let xs
: &[isize] = &[-3, 0, 1, 5, -10];
1031 assert_eq
!(*xs
.iter().max_by_key(|x
| x
.abs()).unwrap(), -10);
1036 let xs
: &[isize] = &[-3, 0, 1, 5, -10];
1037 assert_eq
!(*xs
.iter().max_by(|x
, y
| x
.abs().cmp(&y
.abs())).unwrap(), -10);
1041 fn test_min_by_key() {
1042 let xs
: &[isize] = &[-3, 0, 1, 5, -10];
1043 assert_eq
!(*xs
.iter().min_by_key(|x
| x
.abs()).unwrap(), 0);
1048 let xs
: &[isize] = &[-3, 0, 1, 5, -10];
1049 assert_eq
!(*xs
.iter().min_by(|x
, y
| x
.abs().cmp(&y
.abs())).unwrap(), 0);
1055 // sum the first five values
1056 let partial_sum
= xs
.by_ref().take(5).fold(0, |a
, b
| a
+ b
);
1057 assert_eq
!(partial_sum
, 10);
1058 assert_eq
!(xs
.next(), Some(5));
1063 let xs
= [2, 4, 6, 8, 10, 12, 14, 16];
1064 let mut it
= xs
.iter();
1067 assert
!(it
.rev().cloned().collect
::<Vec
<isize>>() ==
1068 vec
![16, 14, 12, 10, 8, 6]);
1073 let xs
= [2, 4, 6, 8];
1075 let mut it
= xs
.iter().cloned();
1076 assert_eq
!(it
.len(), 4);
1077 assert_eq
!(it
.next(), Some(2));
1078 assert_eq
!(it
.len(), 3);
1079 assert_eq
!(it
.next(), Some(4));
1080 assert_eq
!(it
.len(), 2);
1081 assert_eq
!(it
.next_back(), Some(8));
1082 assert_eq
!(it
.len(), 1);
1083 assert_eq
!(it
.next_back(), Some(6));
1084 assert_eq
!(it
.len(), 0);
1085 assert_eq
!(it
.next_back(), None
);
1089 fn test_double_ended_map() {
1090 let xs
= [1, 2, 3, 4, 5, 6];
1091 let mut it
= xs
.iter().map(|&x
| x
* -1);
1092 assert_eq
!(it
.next(), Some(-1));
1093 assert_eq
!(it
.next(), Some(-2));
1094 assert_eq
!(it
.next_back(), Some(-6));
1095 assert_eq
!(it
.next_back(), Some(-5));
1096 assert_eq
!(it
.next(), Some(-3));
1097 assert_eq
!(it
.next_back(), Some(-4));
1098 assert_eq
!(it
.next(), None
);
1102 fn test_double_ended_enumerate() {
1103 let xs
= [1, 2, 3, 4, 5, 6];
1104 let mut it
= xs
.iter().cloned().enumerate();
1105 assert_eq
!(it
.next(), Some((0, 1)));
1106 assert_eq
!(it
.next(), Some((1, 2)));
1107 assert_eq
!(it
.next_back(), Some((5, 6)));
1108 assert_eq
!(it
.next_back(), Some((4, 5)));
1109 assert_eq
!(it
.next_back(), Some((3, 4)));
1110 assert_eq
!(it
.next_back(), Some((2, 3)));
1111 assert_eq
!(it
.next(), None
);
1115 fn test_double_ended_zip() {
1116 let xs
= [1, 2, 3, 4, 5, 6];
1117 let ys
= [1, 2, 3, 7];
1118 let a
= xs
.iter().cloned();
1119 let b
= ys
.iter().cloned();
1120 let mut it
= a
.zip(b
);
1121 assert_eq
!(it
.next(), Some((1, 1)));
1122 assert_eq
!(it
.next(), Some((2, 2)));
1123 assert_eq
!(it
.next_back(), Some((4, 7)));
1124 assert_eq
!(it
.next_back(), Some((3, 3)));
1125 assert_eq
!(it
.next(), None
);
1129 fn test_double_ended_filter() {
1130 let xs
= [1, 2, 3, 4, 5, 6];
1131 let mut it
= xs
.iter().filter(|&x
| *x
& 1 == 0);
1132 assert_eq
!(it
.next_back().unwrap(), &6);
1133 assert_eq
!(it
.next_back().unwrap(), &4);
1134 assert_eq
!(it
.next().unwrap(), &2);
1135 assert_eq
!(it
.next_back(), None
);
1139 fn test_double_ended_filter_map() {
1140 let xs
= [1, 2, 3, 4, 5, 6];
1141 let mut it
= xs
.iter().filter_map(|&x
| if x
& 1 == 0 { Some(x * 2) }
else { None }
);
1142 assert_eq
!(it
.next_back().unwrap(), 12);
1143 assert_eq
!(it
.next_back().unwrap(), 8);
1144 assert_eq
!(it
.next().unwrap(), 4);
1145 assert_eq
!(it
.next_back(), None
);
1149 fn test_double_ended_chain() {
1150 let xs
= [1, 2, 3, 4, 5];
1151 let ys
= [7, 9, 11];
1152 let mut it
= xs
.iter().chain(&ys
).rev();
1153 assert_eq
!(it
.next().unwrap(), &11);
1154 assert_eq
!(it
.next().unwrap(), &9);
1155 assert_eq
!(it
.next_back().unwrap(), &1);
1156 assert_eq
!(it
.next_back().unwrap(), &2);
1157 assert_eq
!(it
.next_back().unwrap(), &3);
1158 assert_eq
!(it
.next_back().unwrap(), &4);
1159 assert_eq
!(it
.next_back().unwrap(), &5);
1160 assert_eq
!(it
.next_back().unwrap(), &7);
1161 assert_eq
!(it
.next_back(), None
);
1164 // test that .chain() is well behaved with an unfused iterator
1165 struct CrazyIterator(bool
);
1166 impl CrazyIterator { fn new() -> CrazyIterator { CrazyIterator(false) }
}
1167 impl Iterator
for CrazyIterator
{
1169 fn next(&mut self) -> Option
<i32> {
1170 if self.0 { Some(99) }
else { self.0 = true; None }
1174 impl DoubleEndedIterator
for CrazyIterator
{
1175 fn next_back(&mut self) -> Option
<i32> {
1180 assert_eq
!(CrazyIterator
::new().chain(0..10).rev().last(), Some(0));
1181 assert
!((0..10).chain(CrazyIterator
::new()).rev().any(|i
| i
== 0));
1185 fn test_rposition() {
1186 fn f(xy
: &(isize, char)) -> bool { let (_x, y) = *xy; y == 'b' }
1187 fn g(xy
: &(isize, char)) -> bool { let (_x, y) = *xy; y == 'd' }
1188 let v
= [(0, 'a'
), (1, 'b'
), (2, 'c'
), (3, 'b'
)];
1190 assert_eq
!(v
.iter().rposition(f
), Some(3));
1191 assert
!(v
.iter().rposition(g
).is_none());
1196 fn test_rposition_panic() {
1197 let v
: [(Box
<_
>, Box
<_
>); 4] =
1198 [(box 0, box 0), (box 0, box 0),
1199 (box 0, box 0), (box 0, box 0)];
1201 v
.iter().rposition(|_elt
| {
1212 fn test_double_ended_flat_map() {
1215 let mut it
= u
.iter().flat_map(|x
| &v
[*x
..v
.len()]);
1216 assert_eq
!(it
.next_back().unwrap(), &8);
1217 assert_eq
!(it
.next().unwrap(), &5);
1218 assert_eq
!(it
.next_back().unwrap(), &7);
1219 assert_eq
!(it
.next_back().unwrap(), &6);
1220 assert_eq
!(it
.next_back().unwrap(), &8);
1221 assert_eq
!(it
.next().unwrap(), &6);
1222 assert_eq
!(it
.next_back().unwrap(), &7);
1223 assert_eq
!(it
.next_back(), None
);
1224 assert_eq
!(it
.next(), None
);
1225 assert_eq
!(it
.next_back(), None
);
1229 fn test_double_ended_range() {
1230 assert_eq
!((11..14).rev().collect
::<Vec
<_
>>(), [13, 12, 11]);
1231 for _
in (10..0).rev() {
1232 panic
!("unreachable");
1235 assert_eq
!((11..14).rev().collect
::<Vec
<_
>>(), [13, 12, 11]);
1236 for _
in (10..0).rev() {
1237 panic
!("unreachable");
1243 assert_eq
!((0..5).collect
::<Vec
<_
>>(), [0, 1, 2, 3, 4]);
1244 assert_eq
!((-10..-1).collect
::<Vec
<_
>>(), [-10, -9, -8, -7, -6, -5, -4, -3, -2]);
1245 assert_eq
!((0..5).rev().collect
::<Vec
<_
>>(), [4, 3, 2, 1, 0]);
1246 assert_eq
!((200..-5).count(), 0);
1247 assert_eq
!((200..-5).rev().count(), 0);
1248 assert_eq
!((200..200).count(), 0);
1249 assert_eq
!((200..200).rev().count(), 0);
1251 assert_eq
!((0..100).size_hint(), (100, Some(100)));
1252 // this test is only meaningful when sizeof usize < sizeof u64
1253 assert_eq
!((usize::MAX
- 1..usize::MAX
).size_hint(), (1, Some(1)));
1254 assert_eq
!((-10..-1).size_hint(), (9, Some(9)));
1255 assert_eq
!((-1..-10).size_hint(), (0, Some(0)));
1257 assert_eq
!((-70..58).size_hint(), (128, Some(128)));
1258 assert_eq
!((-128..127).size_hint(), (255, Some(255)));
1259 assert_eq
!((-2..isize::MAX
).size_hint(),
1260 (isize::MAX
as usize + 2, Some(isize::MAX
as usize + 2)));
1264 fn test_range_inclusive_exhaustion() {
1265 let mut r
= 10..=10;
1266 assert_eq
!(r
.next(), Some(10));
1267 assert_eq
!(r
, 1..=0);
1269 let mut r
= 10..=10;
1270 assert_eq
!(r
.next_back(), Some(10));
1271 assert_eq
!(r
, 1..=0);
1273 let mut r
= 10..=12;
1274 assert_eq
!(r
.nth(2), Some(12));
1275 assert_eq
!(r
, 1..=0);
1277 let mut r
= 10..=12;
1278 assert_eq
!(r
.nth(5), None
);
1279 assert_eq
!(r
, 1..=0);
1284 fn test_range_nth() {
1285 assert_eq
!((10..15).nth(0), Some(10));
1286 assert_eq
!((10..15).nth(1), Some(11));
1287 assert_eq
!((10..15).nth(4), Some(14));
1288 assert_eq
!((10..15).nth(5), None
);
1291 assert_eq
!(r
.nth(2), Some(12));
1292 assert_eq
!(r
, 13..20);
1293 assert_eq
!(r
.nth(2), Some(15));
1294 assert_eq
!(r
, 16..20);
1295 assert_eq
!(r
.nth(10), None
);
1296 assert_eq
!(r
, 20..20);
1300 fn test_range_from_nth() {
1301 assert_eq
!((10..).nth(0), Some(10));
1302 assert_eq
!((10..).nth(1), Some(11));
1303 assert_eq
!((10..).nth(4), Some(14));
1306 assert_eq
!(r
.nth(2), Some(12));
1307 assert_eq
!(r
, 13..);
1308 assert_eq
!(r
.nth(2), Some(15));
1309 assert_eq
!(r
, 16..);
1310 assert_eq
!(r
.nth(10), Some(26));
1311 assert_eq
!(r
, 27..);
1315 fn test_range_inclusive_nth() {
1316 assert_eq
!((10..=15).nth(0), Some(10));
1317 assert_eq
!((10..=15).nth(1), Some(11));
1318 assert_eq
!((10..=15).nth(5), Some(15));
1319 assert_eq
!((10..=15).nth(6), None
);
1321 let mut r
= 10_u8..=20;
1322 assert_eq
!(r
.nth(2), Some(12));
1323 assert_eq
!(r
, 13..=20);
1324 assert_eq
!(r
.nth(2), Some(15));
1325 assert_eq
!(r
, 16..=20);
1326 assert_eq
!(r
.is_empty(), false);
1327 assert_eq
!(r
.nth(10), None
);
1328 assert_eq
!(r
.is_empty(), true);
1329 assert_eq
!(r
, 1..=0); // We may not want to document/promise this detail
1333 fn test_range_step() {
1334 #![allow(deprecated)]
1336 assert_eq
!((0..20).step_by(5).collect
::<Vec
<isize>>(), [0, 5, 10, 15]);
1337 assert_eq
!((1..21).rev().step_by(5).collect
::<Vec
<isize>>(), [20, 15, 10, 5]);
1338 assert_eq
!((1..21).rev().step_by(6).collect
::<Vec
<isize>>(), [20, 14, 8, 2]);
1339 assert_eq
!((200..255).step_by(50).collect
::<Vec
<u8>>(), [200, 250]);
1340 assert_eq
!((200..-5).step_by(1).collect
::<Vec
<isize>>(), []);
1341 assert_eq
!((200..200).step_by(1).collect
::<Vec
<isize>>(), []);
1343 assert_eq
!((0..20).step_by(1).size_hint(), (20, Some(20)));
1344 assert_eq
!((0..20).step_by(21).size_hint(), (1, Some(1)));
1345 assert_eq
!((0..20).step_by(5).size_hint(), (4, Some(4)));
1346 assert_eq
!((1..21).rev().step_by(5).size_hint(), (4, Some(4)));
1347 assert_eq
!((1..21).rev().step_by(6).size_hint(), (4, Some(4)));
1348 assert_eq
!((20..-5).step_by(1).size_hint(), (0, Some(0)));
1349 assert_eq
!((20..20).step_by(1).size_hint(), (0, Some(0)));
1350 assert_eq
!((i8::MIN
..i8::MAX
).step_by(-(i8::MIN
as i32) as usize).size_hint(), (2, Some(2)));
1351 assert_eq
!((i16::MIN
..i16::MAX
).step_by(i16::MAX
as usize).size_hint(), (3, Some(3)));
1352 assert_eq
!((isize::MIN
..isize::MAX
).step_by(1).size_hint(), (usize::MAX
, Some(usize::MAX
)));
1357 let mut it
= repeat(42);
1358 assert_eq
!(it
.next(), Some(42));
1359 assert_eq
!(it
.next(), Some(42));
1360 assert_eq
!(it
.next(), Some(42));
1366 assert_eq
!(it
.len(), 3);
1367 assert_eq
!(it
.next(), Some(0));
1368 assert_eq
!(it
.len(), 2);
1369 assert_eq
!(it
.next(), Some(1));
1370 assert_eq
!(it
.len(), 1);
1371 assert_eq
!(it
.next(), Some(2));
1372 assert_eq
!(it
.len(), 0);
1373 assert_eq
!(it
.next(), None
);
1374 assert_eq
!(it
.len(), 0);
1375 assert_eq
!(it
.next(), None
);
1376 assert_eq
!(it
.len(), 0);
1377 assert_eq
!(it
.next(), None
);
1378 assert_eq
!(it
.len(), 0);
1382 fn test_fuse_nth() {
1384 let mut it
= xs
.iter();
1386 assert_eq
!(it
.len(), 3);
1387 assert_eq
!(it
.nth(2), Some(&2));
1388 assert_eq
!(it
.len(), 0);
1389 assert_eq
!(it
.nth(2), None
);
1390 assert_eq
!(it
.len(), 0);
1394 fn test_fuse_last() {
1398 assert_eq
!(it
.len(), 3);
1399 assert_eq
!(it
.last(), Some(&2));
1403 fn test_fuse_count() {
1407 assert_eq
!(it
.len(), 3);
1408 assert_eq
!(it
.count(), 3);
1409 // Can't check len now because count consumes.
1413 fn test_fuse_fold() {
1415 let it
= xs
.iter(); // `FusedIterator`
1416 let i
= it
.fuse().fold(0, |i
, &x
| {
1417 assert_eq
!(x
, xs
[i
]);
1420 assert_eq
!(i
, xs
.len());
1422 let it
= xs
.iter(); // `FusedIterator`
1423 let i
= it
.fuse().rfold(xs
.len(), |i
, &x
| {
1424 assert_eq
!(x
, xs
[i
- 1]);
1429 let it
= xs
.iter().scan((), |_
, &x
| Some(x
)); // `!FusedIterator`
1430 let i
= it
.fuse().fold(0, |i
, x
| {
1431 assert_eq
!(x
, xs
[i
]);
1434 assert_eq
!(i
, xs
.len());
1439 let mut it
= once(42);
1440 assert_eq
!(it
.next(), Some(42));
1441 assert_eq
!(it
.next(), None
);
1446 let mut it
= empty
::<i32>();
1447 assert_eq
!(it
.next(), None
);
1451 fn test_chain_fold() {
1455 let mut iter
= xs
.iter().chain(&ys
);
1457 let mut result
= Vec
::new();
1458 iter
.fold((), |(), &elt
| result
.push(elt
));
1459 assert_eq
!(&[2, 3, 1, 2, 0], &result
[..]);
1463 fn test_step_replace_unsigned() {
1465 let y
= x
.replace_zero();
1470 let y
= x
.replace_one();
1476 fn test_step_replace_signed() {
1478 let y
= x
.replace_zero();
1483 let y
= x
.replace_one();
1489 fn test_step_replace_no_between() {
1491 let y
= x
.replace_zero();
1496 let y
= x
.replace_one();
1502 fn test_rev_try_folds() {
1503 let f
= &|acc
, x
| i32::checked_add(2*acc
, x
);
1504 assert_eq
!((1..10).rev().try_fold(7, f
), (1..10).try_rfold(7, f
));
1505 assert_eq
!((1..10).rev().try_rfold(7, f
), (1..10).try_fold(7, f
));
1507 let a
= [10, 20, 30, 40, 100, 60, 70, 80, 90];
1508 let mut iter
= a
.iter().rev();
1509 assert_eq
!(iter
.try_fold(0_i8, |acc
, &x
| acc
.checked_add(x
)), None
);
1510 assert_eq
!(iter
.next(), Some(&70));
1511 let mut iter
= a
.iter().rev();
1512 assert_eq
!(iter
.try_rfold(0_i8, |acc
, &x
| acc
.checked_add(x
)), None
);
1513 assert_eq
!(iter
.next_back(), Some(&60));
1517 fn test_cloned_try_folds() {
1518 let a
= [1, 2, 3, 4, 5, 6, 7, 8, 9];
1519 let f
= &|acc
, x
| i32::checked_add(2*acc
, x
);
1520 let f_ref
= &|acc
, &x
| i32::checked_add(2*acc
, x
);
1521 assert_eq
!(a
.iter().cloned().try_fold(7, f
), a
.iter().try_fold(7, f_ref
));
1522 assert_eq
!(a
.iter().cloned().try_rfold(7, f
), a
.iter().try_rfold(7, f_ref
));
1524 let a
= [10, 20, 30, 40, 100, 60, 70, 80, 90];
1525 let mut iter
= a
.iter().cloned();
1526 assert_eq
!(iter
.try_fold(0_i8, |acc
, x
| acc
.checked_add(x
)), None
);
1527 assert_eq
!(iter
.next(), Some(60));
1528 let mut iter
= a
.iter().cloned();
1529 assert_eq
!(iter
.try_rfold(0_i8, |acc
, x
| acc
.checked_add(x
)), None
);
1530 assert_eq
!(iter
.next_back(), Some(70));
1534 fn test_chain_try_folds() {
1535 let c
= || (0..10).chain(10..20);
1537 let f
= &|acc
, x
| i32::checked_add(2*acc
, x
);
1538 assert_eq
!(c().try_fold(7, f
), (0..20).try_fold(7, f
));
1539 assert_eq
!(c().try_rfold(7, f
), (0..20).rev().try_fold(7, f
));
1542 assert_eq
!(iter
.position(|x
| x
== 5), Some(5));
1543 assert_eq
!(iter
.next(), Some(6), "stopped in front, state Both");
1544 assert_eq
!(iter
.position(|x
| x
== 13), Some(6));
1545 assert_eq
!(iter
.next(), Some(14), "stopped in back, state Back");
1546 assert_eq
!(iter
.try_fold(0, |acc
, x
| Some(acc
+x
)), Some((15..20).sum()));
1548 let mut iter
= c().rev(); // use rev to access try_rfold
1549 assert_eq
!(iter
.position(|x
| x
== 15), Some(4));
1550 assert_eq
!(iter
.next(), Some(14), "stopped in back, state Both");
1551 assert_eq
!(iter
.position(|x
| x
== 5), Some(8));
1552 assert_eq
!(iter
.next(), Some(4), "stopped in front, state Front");
1553 assert_eq
!(iter
.try_fold(0, |acc
, x
| Some(acc
+x
)), Some((0..4).sum()));
1556 iter
.by_ref().rev().nth(14); // skip the last 15, ending in state Front
1557 assert_eq
!(iter
.try_fold(7, f
), (0..5).try_fold(7, f
));
1560 iter
.nth(14); // skip the first 15, ending in state Back
1561 assert_eq
!(iter
.try_rfold(7, f
), (15..20).try_rfold(7, f
));
1565 fn test_map_try_folds() {
1566 let f
= &|acc
, x
| i32::checked_add(2*acc
, x
);
1567 assert_eq
!((0..10).map(|x
| x
+3).try_fold(7, f
), (3..13).try_fold(7, f
));
1568 assert_eq
!((0..10).map(|x
| x
+3).try_rfold(7, f
), (3..13).try_rfold(7, f
));
1570 let mut iter
= (0..40).map(|x
| x
+10);
1571 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
1572 assert_eq
!(iter
.next(), Some(20));
1573 assert_eq
!(iter
.try_rfold(0, i8::checked_add
), None
);
1574 assert_eq
!(iter
.next_back(), Some(46));
1578 fn test_filter_try_folds() {
1579 fn p(&x
: &i32) -> bool { 0 <= x && x < 10 }
1580 let f
= &|acc
, x
| i32::checked_add(2*acc
, x
);
1581 assert_eq
!((-10..20).filter(p
).try_fold(7, f
), (0..10).try_fold(7, f
));
1582 assert_eq
!((-10..20).filter(p
).try_rfold(7, f
), (0..10).try_rfold(7, f
));
1584 let mut iter
= (0..40).filter(|&x
| x
% 2 == 1);
1585 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
1586 assert_eq
!(iter
.next(), Some(25));
1587 assert_eq
!(iter
.try_rfold(0, i8::checked_add
), None
);
1588 assert_eq
!(iter
.next_back(), Some(31));
1592 fn test_filter_map_try_folds() {
1593 let mp
= &|x
| if 0 <= x
&& x
< 10 { Some(x*2) }
else { None }
;
1594 let f
= &|acc
, x
| i32::checked_add(2*acc
, x
);
1595 assert_eq
!((-9..20).filter_map(mp
).try_fold(7, f
), (0..10).map(|x
| 2*x
).try_fold(7, f
));
1596 assert_eq
!((-9..20).filter_map(mp
).try_rfold(7, f
), (0..10).map(|x
| 2*x
).try_rfold(7, f
));
1598 let mut iter
= (0..40).filter_map(|x
| if x
%2 == 1 { None }
else { Some(x*2 + 10) }
);
1599 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
1600 assert_eq
!(iter
.next(), Some(38));
1601 assert_eq
!(iter
.try_rfold(0, i8::checked_add
), None
);
1602 assert_eq
!(iter
.next_back(), Some(78));
1606 fn test_enumerate_try_folds() {
1607 let f
= &|acc
, (i
, x
)| usize::checked_add(2*acc
, x
/(i
+1) + i
);
1608 assert_eq
!((9..18).enumerate().try_fold(7, f
), (0..9).map(|i
| (i
, i
+9)).try_fold(7, f
));
1609 assert_eq
!((9..18).enumerate().try_rfold(7, f
), (0..9).map(|i
| (i
, i
+9)).try_rfold(7, f
));
1611 let mut iter
= (100..200).enumerate();
1612 let f
= &|acc
, (i
, x
)| u8::checked_add(acc
, u8::checked_div(x
, i
as u8 + 1)?
);
1613 assert_eq
!(iter
.try_fold(0, f
), None
);
1614 assert_eq
!(iter
.next(), Some((7, 107)));
1615 assert_eq
!(iter
.try_rfold(0, f
), None
);
1616 assert_eq
!(iter
.next_back(), Some((11, 111)));
1620 fn test_peek_try_fold() {
1621 let f
= &|acc
, x
| i32::checked_add(2*acc
, x
);
1622 assert_eq
!((1..20).peekable().try_fold(7, f
), (1..20).try_fold(7, f
));
1623 let mut iter
= (1..20).peekable();
1624 assert_eq
!(iter
.peek(), Some(&1));
1625 assert_eq
!(iter
.try_fold(7, f
), (1..20).try_fold(7, f
));
1627 let mut iter
= [100, 20, 30, 40, 50, 60, 70].iter().cloned().peekable();
1628 assert_eq
!(iter
.peek(), Some(&100));
1629 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
1630 assert_eq
!(iter
.peek(), Some(&40));
1634 fn test_skip_while_try_fold() {
1635 let f
= &|acc
, x
| i32::checked_add(2*acc
, x
);
1636 fn p(&x
: &i32) -> bool { (x % 10) <= 5 }
1637 assert_eq
!((1..20).skip_while(p
).try_fold(7, f
), (6..20).try_fold(7, f
));
1638 let mut iter
= (1..20).skip_while(p
);
1639 assert_eq
!(iter
.nth(5), Some(11));
1640 assert_eq
!(iter
.try_fold(7, f
), (12..20).try_fold(7, f
));
1642 let mut iter
= (0..50).skip_while(|&x
| (x
% 20) < 15);
1643 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
1644 assert_eq
!(iter
.next(), Some(23));
1648 fn test_take_while_folds() {
1649 let f
= &|acc
, x
| i32::checked_add(2*acc
, x
);
1650 assert_eq
!((1..20).take_while(|&x
| x
!= 10).try_fold(7, f
), (1..10).try_fold(7, f
));
1651 let mut iter
= (1..20).take_while(|&x
| x
!= 10);
1652 assert_eq
!(iter
.try_fold(0, |x
, y
| Some(x
+y
)), Some((1..10).sum()));
1653 assert_eq
!(iter
.next(), None
, "flag should be set");
1654 let iter
= (1..20).take_while(|&x
| x
!= 10);
1655 assert_eq
!(iter
.fold(0, |x
, y
| x
+y
), (1..10).sum());
1657 let mut iter
= (10..50).take_while(|&x
| x
!= 40);
1658 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
1659 assert_eq
!(iter
.next(), Some(20));
1663 fn test_skip_try_folds() {
1664 let f
= &|acc
, x
| i32::checked_add(2*acc
, x
);
1665 assert_eq
!((1..20).skip(9).try_fold(7, f
), (10..20).try_fold(7, f
));
1666 assert_eq
!((1..20).skip(9).try_rfold(7, f
), (10..20).try_rfold(7, f
));
1668 let mut iter
= (0..30).skip(10);
1669 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
1670 assert_eq
!(iter
.next(), Some(20));
1671 assert_eq
!(iter
.try_rfold(0, i8::checked_add
), None
);
1672 assert_eq
!(iter
.next_back(), Some(24));
1676 fn test_take_try_folds() {
1677 let f
= &|acc
, x
| i32::checked_add(2*acc
, x
);
1678 assert_eq
!((10..30).take(10).try_fold(7, f
), (10..20).try_fold(7, f
));
1679 //assert_eq!((10..30).take(10).try_rfold(7, f), (10..20).try_rfold(7, f));
1681 let mut iter
= (10..30).take(20);
1682 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
1683 assert_eq
!(iter
.next(), Some(20));
1684 //assert_eq!(iter.try_rfold(0, i8::checked_add), None);
1685 //assert_eq!(iter.next_back(), Some(24));
1689 fn test_flat_map_try_folds() {
1690 let f
= &|acc
, x
| i32::checked_add(acc
*2/3, x
);
1691 let mr
= &|x
| (5*x
)..(5*x
+ 5);
1692 assert_eq
!((0..10).flat_map(mr
).try_fold(7, f
), (0..50).try_fold(7, f
));
1693 assert_eq
!((0..10).flat_map(mr
).try_rfold(7, f
), (0..50).try_rfold(7, f
));
1694 let mut iter
= (0..10).flat_map(mr
);
1695 iter
.next(); iter
.next_back(); // have front and back iters in progress
1696 assert_eq
!(iter
.try_rfold(7, f
), (1..49).try_rfold(7, f
));
1698 let mut iter
= (0..10).flat_map(|x
| (4*x
)..(4*x
+ 4));
1699 assert_eq
!(iter
.try_fold(0, i8::checked_add
), None
);
1700 assert_eq
!(iter
.next(), Some(17));
1701 assert_eq
!(iter
.try_rfold(0, i8::checked_add
), None
);
1702 assert_eq
!(iter
.next_back(), Some(35));