]> git.proxmox.com Git - rustc.git/blame - src/libcore/tests/iter.rs
projects / rustc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
New upstream version 1.38.0+dfsg1
[rustc.git] / src / libcore / tests / iter.rs
CommitLineData
0731742a 1use core::cell::Cell;
532ac7d7 2use core::convert::TryFrom;
1a4d82fc 3use core::iter::*;
d9579d0f 4use core::{i8, i16, isize};
c34b1796 5use core::usize;
1a4d82fc 6
1a4d82fc
JJ		 7#[test]
8fn test_lt() {
c34b1796 9 let empty: [isize; 0] = [];
85aaf69f
SL		 10 let xs = [1,2,3];
11 let ys = [1,2,0];
1a4d82fc 12
e9174d1e
SL		 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()));
1a4d82fc 17
e9174d1e
SL		 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()));
1a4d82fc 22
e9174d1e
SL		 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()));
1a4d82fc
JJ		 27
28 // Sequence with NaN
29 let u = [1.0f64, 2.0];
30 let v = [0.0f64/0.0, 3.0];
31
e9174d1e
SL		 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()));
1a4d82fc
JJ		 36
37 let a = [0.0f64/0.0];
38 let b = [1.0f64];
39 let c = [2.0f64];
40
e9174d1e
SL		 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]));
1a4d82fc 45
e9174d1e
SL		 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]));
1a4d82fc
JJ		 50}
51
52#[test]
53fn test_multi_iter() {
85aaf69f
SL		 54 let xs = [1,2,3,4];
55 let ys = [4,3,2,1];
e9174d1e
SL		 56 assert!(xs.iter().eq(ys.iter().rev()));
57 assert!(xs.iter().lt(xs.iter().skip(2)));
1a4d82fc
JJ		 58}
59
60#[test]
61fn test_counter_from_iter() {
041b39d2 62 let it = (0..).step_by(5).take(10);
c34b1796
AL		 63 let xs: Vec<isize> = FromIterator::from_iter(it);
64 assert_eq!(xs, [0, 5, 10, 15, 20, 25, 30, 35, 40, 45]);
1a4d82fc
JJ		 65}
66
67#[test]
68fn test_iterator_chain() {
85aaf69f
SL		 69 let xs = [0, 1, 2, 3, 4, 5];
70 let ys = [30, 40, 50, 60];
1a4d82fc 71 let expected = [0, 1, 2, 3, 4, 5, 30, 40, 50, 60];
62682a34 72 let it = xs.iter().chain(&ys);
1a4d82fc
JJ		 73 let mut i = 0;
74 for &x in it {
75 assert_eq!(x, expected[i]);
76 i += 1;
77 }
78 assert_eq!(i, expected.len());
79
041b39d2 80 let ys = (30..).step_by(10).take(4);
c34b1796 81 let it = xs.iter().cloned().chain(ys);
1a4d82fc
JJ		 82 let mut i = 0;
83 for x in it {
84 assert_eq!(x, expected[i]);
85 i += 1;
86 }
87 assert_eq!(i, expected.len());
88}
89
d9579d0f
AL		 90#[test]
91fn test_iterator_chain_nth() {
92 let xs = [0, 1, 2, 3, 4, 5];
93 let ys = [30, 40, 50, 60];
94 let zs = [];
95 let expected = [0, 1, 2, 3, 4, 5, 30, 40, 50, 60];
96 for (i, x) in expected.iter().enumerate() {
62682a34 97 assert_eq!(Some(x), xs.iter().chain(&ys).nth(i));
d9579d0f 98 }
62682a34 99 assert_eq!(zs.iter().chain(&xs).nth(0), Some(&0));
d9579d0f 100
62682a34 101 let mut it = xs.iter().chain(&zs);
d9579d0f
AL		 102 assert_eq!(it.nth(5), Some(&5));
103 assert_eq!(it.next(), None);
104}
105
106#[test]
107fn test_iterator_chain_last() {
108 let xs = [0, 1, 2, 3, 4, 5];
109 let ys = [30, 40, 50, 60];
110 let zs = [];
62682a34
SL		 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);
d9579d0f
AL		 115}
116
117#[test]
118fn test_iterator_chain_count() {
119 let xs = [0, 1, 2, 3, 4, 5];
120 let ys = [30, 40, 50, 60];
121 let zs = [];
62682a34
SL		 122 assert_eq!(xs.iter().chain(&ys).count(), 10);
123 assert_eq!(zs.iter().chain(&ys).count(), 4);
d9579d0f
AL		 124}
125
a7813a04
XL		 126#[test]
127fn 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);
137}
138
0531ce1d
XL		 139#[test]
140fn test_zip_nth() {
141 let xs = [0, 1, 2, 4, 5];
142 let ys = [10, 11, 12];
143
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);
148
149 let mut it = xs.iter().zip(&ys);
150 assert_eq!(it.nth(3), None);
151
152 let mut it = ys.iter().zip(&xs);
153 assert_eq!(it.nth(3), None);
154}
155
156#[test]
157fn 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()
161 .map(|n| {
162 a.push(n);
163 n * 10
164 })
165 .zip([2, 3, 4, 5, 6, 7, 8].iter().cloned().map(|n| {
166 b.push(n * 100);
167 n * 1000
168 }))
169 .skip(1)
170 .nth(3);
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]);
174}
175
7cac9316
XL		 176#[test]
177fn test_iterator_step_by() {
178 // Identity
041b39d2 179 let mut it = (0..).step_by(1).take(3);
7cac9316
XL		 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);
184
041b39d2 185 let mut it = (0..).step_by(3).take(4);
7cac9316
XL		 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);
416331ca
XL		 191
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);
197
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);
7cac9316
XL		 204}
205
2c00a5a8
XL		 206#[test]
207fn 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);
214
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);
222}
223
224#[test]
225fn test_iterator_step_by_nth_overflow() {
226 #[cfg(target_pointer_width = "8")]
227 type Bigger = u16;
228 #[cfg(target_pointer_width = "16")]
229 type Bigger = u32;
230 #[cfg(target_pointer_width = "32")]
231 type Bigger = u64;
232 #[cfg(target_pointer_width = "64")]
233 type Bigger = u128;
234
235 #[derive(Clone)]
236 struct Test(Bigger);
0bf4aa26 237 impl Iterator for &mut Test {
2c00a5a8
XL		 238 type Item = i32;
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;
242 Some(42)
243 }
244 }
245
246 let mut it = Test(0);
247 let root = usize::MAX >> (::std::mem::size_of::<usize>() * 8 / 2);
248 let n = root + 20;
249 (&mut it).step_by(n).nth(n);
250 assert_eq!(it.0, n as Bigger * n as Bigger);
251
252 // large step
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);
256
257 // n + 1 overflows
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);
261
262 // n + 1 overflows
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);
266}
267
416331ca
XL		 268#[test]
269fn 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);
276
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);
283
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);
291}
292
7cac9316
XL		 293#[test]
294#[should_panic]
295fn test_iterator_step_by_zero() {
041b39d2 296 let mut it = (0..).step_by(0);
7cac9316
XL		 297 it.next();
298}
299
300#[test]
301fn test_iterator_step_by_size_hint() {
302 struct StubSizeHint(usize, Option<usize>);
303 impl Iterator for StubSizeHint {
304 type Item = ();
305 fn next(&mut self) -> Option<()> {
306 self.0 -= 1;
307 if let Some(ref mut upper) = self.1 {
308 *upper -= 1;
309 }
310 Some(())
311 }
312 fn size_hint(&self) -> (usize, Option<usize>) {
313 (self.0, self.1)
314 }
315 }
316
317 // The two checks in each case are needed because the logic
318 // is different before the first call to `next()`.
319
320 let mut it = StubSizeHint(10, Some(10)).step_by(1);
321 assert_eq!(it.size_hint(), (10, Some(10)));
322 it.next();
323 assert_eq!(it.size_hint(), (9, Some(9)));
324
325 // exact multiple
326 let mut it = StubSizeHint(10, Some(10)).step_by(3);
327 assert_eq!(it.size_hint(), (4, Some(4)));
328 it.next();
329 assert_eq!(it.size_hint(), (3, Some(3)));
330
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)));
334 it.next();
335 assert_eq!(it.size_hint(), (3, Some(3)));
336
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)));
340 it.next();
341 assert_eq!(it.size_hint(), (2, Some(2)));
342
343 // infinite upper bound
344 let mut it = StubSizeHint(usize::MAX, None).step_by(1);
345 assert_eq!(it.size_hint(), (usize::MAX, None));
346 it.next();
347 assert_eq!(it.size_hint(), (usize::MAX-1, None));
348
349 // still infinite with larger step
350 let mut it = StubSizeHint(7, None).step_by(3);
351 assert_eq!(it.size_hint(), (3, None));
352 it.next();
353 assert_eq!(it.size_hint(), (2, None));
354
355 // propagates ExactSizeIterator
356 let a = [1,2,3,4,5];
357 let it = a.iter().step_by(2);
358 assert_eq!(it.len(), 3);
359
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 }
365 }
366 impl<T:TrustedLen> TrustedLenCheck for T {
367 fn test(self) -> bool { true }
368 }
369 assert!(TrustedLenCheck::test(a.iter()));
370 assert!(!TrustedLenCheck::test(a.iter().step_by(1)));
371}
372
1a4d82fc
JJ		 373#[test]
374fn test_filter_map() {
041b39d2 375 let it = (0..).step_by(1).take(10)
1a4d82fc 376 .filter_map(|x| if x % 2 == 0 { Some(x*x) } else { None });
c34b1796 377 assert_eq!(it.collect::<Vec<usize>>(), [0*0, 2*2, 4*4, 6*6, 8*8]);
1a4d82fc
JJ		 378}
379
ea8adc8c
XL		 380#[test]
381fn 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]);
387 i + 1
388 });
389 assert_eq!(i, ys.len());
390
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]);
394 i - 1
395 });
396 assert_eq!(i, 0);
397}
398
1a4d82fc
JJ		 399#[test]
400fn test_iterator_enumerate() {
85aaf69f 401 let xs = [0, 1, 2, 3, 4, 5];
c34b1796 402 let it = xs.iter().enumerate();
1a4d82fc
JJ		 403 for (i, &x) in it {
404 assert_eq!(i, x);
405 }
406}
407
d9579d0f
AL		 408#[test]
409fn test_iterator_enumerate_nth() {
410 let xs = [0, 1, 2, 3, 4, 5];
411 for (i, &x) in xs.iter().enumerate() {
412 assert_eq!(i, x);
413 }
414
415 let mut it = xs.iter().enumerate();
416 while let Some((i, &x)) = it.nth(0) {
417 assert_eq!(i, x);
418 }
419
420 let mut it = xs.iter().enumerate();
421 while let Some((i, &x)) = it.nth(1) {
422 assert_eq!(i, x);
423 }
424
425 let (i, &x) = xs.iter().enumerate().nth(3).unwrap();
426 assert_eq!(i, x);
427 assert_eq!(i, 3);
428}
429
48663c56
XL		 430#[test]
431fn 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) {
435 assert_eq!(i, x);
436 }
437
438 let mut it = xs.iter().enumerate();
439 while let Some((i, &x)) = it.nth_back(1) {
440 assert_eq!(i, x);
441 }
442
443 let (i, &x) = xs.iter().enumerate().nth_back(3).unwrap();
444 assert_eq!(i, x);
445 assert_eq!(i, 2);
446}
447
d9579d0f
AL		 448#[test]
449fn test_iterator_enumerate_count() {
450 let xs = [0, 1, 2, 3, 4, 5];
ea8adc8c
XL		 451 assert_eq!(xs.iter().enumerate().count(), 6);
452}
453
454#[test]
455fn 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)| {
462 assert_eq!(i, j);
463 assert_eq!(x, xs[j]);
464 i + 1
465 });
466 assert_eq!(i, xs.len());
467
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)| {
471 assert_eq!(i, j);
472 assert_eq!(x, xs[j]);
473 i - 1
474 });
475 assert_eq!(i, 0);
d9579d0f
AL		 476}
477
8bb4bdeb
XL		 478#[test]
479fn 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);
482}
483
ea8adc8c
XL		 484#[test]
485fn 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]);
491 i + 1
492 });
493 assert_eq!(i, ys.len());
494
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]);
498 i - 1
499 });
500 assert_eq!(i, 0);
501}
502
1a4d82fc
JJ		 503#[test]
504fn test_iterator_peekable() {
85aaf69f 505 let xs = vec![0, 1, 2, 3, 4, 5];
85aaf69f 506
416331ca 507 let mut it = xs.iter().cloned().peekable();
85aaf69f 508 assert_eq!(it.len(), 6);
1a4d82fc 509 assert_eq!(it.peek().unwrap(), &0);
85aaf69f 510 assert_eq!(it.len(), 6);
1a4d82fc 511 assert_eq!(it.next().unwrap(), 0);
85aaf69f 512 assert_eq!(it.len(), 5);
1a4d82fc 513 assert_eq!(it.next().unwrap(), 1);
85aaf69f 514 assert_eq!(it.len(), 4);
1a4d82fc 515 assert_eq!(it.next().unwrap(), 2);
85aaf69f 516 assert_eq!(it.len(), 3);
1a4d82fc 517 assert_eq!(it.peek().unwrap(), &3);
85aaf69f 518 assert_eq!(it.len(), 3);
1a4d82fc 519 assert_eq!(it.peek().unwrap(), &3);
85aaf69f 520 assert_eq!(it.len(), 3);
1a4d82fc 521 assert_eq!(it.next().unwrap(), 3);
85aaf69f 522 assert_eq!(it.len(), 2);
1a4d82fc 523 assert_eq!(it.next().unwrap(), 4);
85aaf69f 524 assert_eq!(it.len(), 1);
1a4d82fc 525 assert_eq!(it.peek().unwrap(), &5);
85aaf69f 526 assert_eq!(it.len(), 1);
1a4d82fc 527 assert_eq!(it.next().unwrap(), 5);
85aaf69f 528 assert_eq!(it.len(), 0);
1a4d82fc 529 assert!(it.peek().is_none());
85aaf69f 530 assert_eq!(it.len(), 0);
1a4d82fc 531 assert!(it.next().is_none());
85aaf69f 532 assert_eq!(it.len(), 0);
416331ca
XL		 533
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);
1a4d82fc
JJ		 560}
561
d9579d0f
AL		 562#[test]
563fn test_iterator_peekable_count() {
564 let xs = [0, 1, 2, 3, 4, 5];
565 let ys = [10];
566 let zs: [i32; 0] = [];
567
568 assert_eq!(xs.iter().peekable().count(), 6);
569
570 let mut it = xs.iter().peekable();
571 assert_eq!(it.peek(), Some(&&0));
572 assert_eq!(it.count(), 6);
573
574 assert_eq!(ys.iter().peekable().count(), 1);
575
576 let mut it = ys.iter().peekable();
577 assert_eq!(it.peek(), Some(&&10));
578 assert_eq!(it.count(), 1);
579
580 assert_eq!(zs.iter().peekable().count(), 0);
581
582 let mut it = zs.iter().peekable();
583 assert_eq!(it.peek(), None);
584
585}
586
587#[test]
588fn test_iterator_peekable_nth() {
589 let xs = [0, 1, 2, 3, 4, 5];
590 let mut it = xs.iter().peekable();
591
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);
599}
600
601#[test]
602fn test_iterator_peekable_last() {
603 let xs = [0, 1, 2, 3, 4, 5];
604 let ys = [0];
605
606 let mut it = xs.iter().peekable();
607 assert_eq!(it.peek(), Some(&&0));
608 assert_eq!(it.last(), Some(&5));
609
610 let mut it = ys.iter().peekable();
611 assert_eq!(it.peek(), Some(&&0));
612 assert_eq!(it.last(), Some(&0));
476ff2be
SL		 613
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);
618}
619
ea8adc8c
XL		 620#[test]
621fn 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]);
627 i + 1
628 });
629 assert_eq!(i, xs.len());
630}
631
416331ca
XL		 632#[test]
633fn 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]);
639 i + 1
640 });
641 assert_eq!(i, xs.len());
642}
643
476ff2be
SL		 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.
48663c56 647pub struct CycleIter<'a, T> {
476ff2be
SL		 648 index: usize,
649 data: &'a [T],
650}
651
48663c56 652pub fn cycle<T>(data: &[T]) -> CycleIter<'_, T> {
476ff2be
SL		 653 CycleIter {
654 index: 0,
3b2f2976 655 data,
476ff2be
SL		 656 }
657}
658
659impl<'a, T> Iterator for CycleIter<'a, T> {
660 type Item = &'a T;
661 fn next(&mut self) -> Option<Self::Item> {
662 let elt = self.data.get(self.index);
663 self.index += 1;
664 self.index %= 1 + self.data.len();
665 elt
666 }
667}
668
669#[test]
670fn 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();
674
675 let mut n = 0;
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);
679 n += 1;
680 if n > data.len() { break; }
681 }
682 assert_eq!(n, data.len());
683}
684
685#[test]
686fn test_iterator_peekable_remember_peek_none_2() {
687 let data = [0];
688 let mut iter = cycle(&data).peekable();
689 iter.next();
690 assert_eq!(iter.peek(), None);
691 assert_eq!(iter.last(), None);
692}
693
694#[test]
695fn test_iterator_peekable_remember_peek_none_3() {
696 let data = [0];
697 let mut iter = cycle(&data).peekable();
698 iter.peek();
699 assert_eq!(iter.nth(0), Some(&0));
700
701 let mut iter = cycle(&data).peekable();
702 iter.next();
703 assert_eq!(iter.peek(), None);
704 assert_eq!(iter.nth(0), None);
d9579d0f
AL		 705}
706
1a4d82fc
JJ		 707#[test]
708fn test_iterator_take_while() {
85aaf69f
SL		 709 let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19];
710 let ys = [0, 1, 2, 3, 5, 13];
c34b1796 711 let it = xs.iter().take_while(|&x| *x < 15);
1a4d82fc
JJ		 712 let mut i = 0;
713 for x in it {
714 assert_eq!(*x, ys[i]);
715 i += 1;
716 }
717 assert_eq!(i, ys.len());
718}
719
720#[test]
721fn test_iterator_skip_while() {
85aaf69f 722 let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19];
1a4d82fc 723 let ys = [15, 16, 17, 19];
c34b1796 724 let it = xs.iter().skip_while(|&x| *x < 15);
1a4d82fc
JJ		 725 let mut i = 0;
726 for x in it {
727 assert_eq!(*x, ys[i]);
728 i += 1;
729 }
730 assert_eq!(i, ys.len());
731}
732
ea8adc8c
XL		 733#[test]
734fn 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]);
740 i + 1
741 });
742 assert_eq!(i, ys.len());
743
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]);
748 i + 1
749 });
750 assert_eq!(i, ys.len());
751}
752
1a4d82fc
JJ		 753#[test]
754fn test_iterator_skip() {
85aaf69f 755 let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
1a4d82fc
JJ		 756 let ys = [13, 15, 16, 17, 19, 20, 30];
757 let mut it = xs.iter().skip(5);
758 let mut i = 0;
85aaf69f 759 while let Some(&x) = it.next() {
1a4d82fc
JJ		 760 assert_eq!(x, ys[i]);
761 i += 1;
85aaf69f 762 assert_eq!(it.len(), xs.len()-5-i);
1a4d82fc
JJ		 763 }
764 assert_eq!(i, ys.len());
85aaf69f 765 assert_eq!(it.len(), 0);
1a4d82fc
JJ		 766}
767
54a0048b
SL		 768#[test]
769fn 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();
784 {
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);
794 }
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));
804}
805
d9579d0f
AL		 806#[test]
807fn test_iterator_skip_nth() {
808 let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
809
810 let mut it = xs.iter().skip(0);
811 assert_eq!(it.nth(0), Some(&0));
812 assert_eq!(it.nth(1), Some(&2));
813
814 let mut it = xs.iter().skip(5);
815 assert_eq!(it.nth(0), Some(&13));
816 assert_eq!(it.nth(1), Some(&16));
817
818 let mut it = xs.iter().skip(12);
819 assert_eq!(it.nth(0), None);
820
821}
822
823#[test]
824fn test_iterator_skip_count() {
825 let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
826
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);
832}
833
834#[test]
835fn test_iterator_skip_last() {
836 let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
837
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);
843
844 let mut it = xs.iter().skip(5);
845 assert_eq!(it.next(), Some(&13));
846 assert_eq!(it.last(), Some(&30));
847}
848
ea8adc8c
XL		 849#[test]
850fn 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];
abe05a73 853
ea8adc8c
XL		 854 let it = xs.iter().skip(5);
855 let i = it.fold(0, |i, &x| {
856 assert_eq!(x, ys[i]);
857 i + 1
858 });
859 assert_eq!(i, ys.len());
860
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]);
865 i + 1
866 });
867 assert_eq!(i, ys.len());
abe05a73
XL		 868
869 let it = xs.iter().skip(5);
870 let i = it.rfold(ys.len(), |i, &x| {
871 let i = i - 1;
872 assert_eq!(x, ys[i]);
873 i
874 });
875 assert_eq!(i, 0);
876
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| {
880 let i = i - 1;
881 assert_eq!(x, ys[i]);
882 i
883 });
884 assert_eq!(i, 1);
885
ea8adc8c
XL		 886}
887
1a4d82fc
JJ		 888#[test]
889fn test_iterator_take() {
85aaf69f
SL		 890 let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19];
891 let ys = [0, 1, 2, 3, 5];
416331ca
XL		 892
893 let mut it = xs.iter().take(ys.len());
1a4d82fc 894 let mut i = 0;
416331ca 895 assert_eq!(it.len(), ys.len());
85aaf69f
SL		 896 while let Some(&x) = it.next() {
897 assert_eq!(x, ys[i]);
898 i += 1;
416331ca
XL		 899 assert_eq!(it.len(), ys.len() - i);
900 }
901 assert_eq!(i, ys.len());
902 assert_eq!(it.len(), 0);
903
904 let mut it = xs.iter().take(ys.len());
905 let mut i = 0;
906 assert_eq!(it.len(), ys.len());
907 while let Some(&x) = it.next_back() {
908 i += 1;
909 assert_eq!(x, ys[ys.len() - i]);
910 assert_eq!(it.len(), ys.len() - i);
85aaf69f
SL		 911 }
912 assert_eq!(i, ys.len());
913 assert_eq!(it.len(), 0);
914}
915
d9579d0f
AL		 916#[test]
917fn test_iterator_take_nth() {
918 let xs = [0, 1, 2, 4, 5];
919 let mut it = xs.iter();
920 {
921 let mut take = it.by_ref().take(3);
922 let mut i = 0;
923 while let Some(&x) = take.nth(0) {
924 assert_eq!(x, i);
925 i += 1;
926 }
927 }
928 assert_eq!(it.nth(1), Some(&5));
929 assert_eq!(it.nth(0), None);
930
931 let xs = [0, 1, 2, 3, 4];
932 let mut it = xs.iter().take(7);
933 let mut i = 1;
934 while let Some(&x) = it.nth(1) {
935 assert_eq!(x, i);
936 i += 2;
937 }
938}
939
416331ca
XL		 940#[test]
941fn test_iterator_take_nth_back() {
942 let xs = [0, 1, 2, 4, 5];
943 let mut it = xs.iter();
944 {
945 let mut take = it.by_ref().take(3);
946 let mut i = 0;
947 while let Some(&x) = take.nth_back(0) {
948 i += 1;
949 assert_eq!(x, 3 - i);
950 }
951 }
952 assert_eq!(it.nth_back(0), None);
953
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);
959}
960
85aaf69f
SL		 961#[test]
962fn test_iterator_take_short() {
963 let xs = [0, 1, 2, 3];
416331ca 964
85aaf69f
SL		 965 let mut it = xs.iter().take(5);
966 let mut i = 0;
416331ca 967 assert_eq!(it.len(), xs.len());
85aaf69f 968 while let Some(&x) = it.next() {
416331ca 969 assert_eq!(x, xs[i]);
1a4d82fc 970 i += 1;
416331ca 971 assert_eq!(it.len(), xs.len() - i);
1a4d82fc 972 }
416331ca
XL		 973 assert_eq!(i, xs.len());
974 assert_eq!(it.len(), 0);
975
976 let mut it = xs.iter().take(5);
977 let mut i = 0;
978 assert_eq!(it.len(), xs.len());
979 while let Some(&x) = it.next_back() {
980 i += 1;
981 assert_eq!(x, xs[xs.len() - i]);
982 assert_eq!(it.len(), xs.len() - i);
983 }
984 assert_eq!(i, xs.len());
85aaf69f 985 assert_eq!(it.len(), 0);
1a4d82fc
JJ		 986}
987
988#[test]
989fn test_iterator_scan() {
990 // test the type inference
c34b1796
AL		 991 fn add(old: &mut isize, new: &usize) -> Option<f64> {
992 *old += *new as isize;
1a4d82fc
JJ		 993 Some(*old as f64)
994 }
85aaf69f 995 let xs = [0, 1, 2, 3, 4];
1a4d82fc
JJ		 996 let ys = [0f64, 1.0, 3.0, 6.0, 10.0];
997
c34b1796 998 let it = xs.iter().scan(0, add);
1a4d82fc
JJ		 999 let mut i = 0;
1000 for x in it {
1001 assert_eq!(x, ys[i]);
1002 i += 1;
1003 }
1004 assert_eq!(i, ys.len());
1005}
1006
1007#[test]
1008fn test_iterator_flat_map() {
85aaf69f
SL		 1009 let xs = [0, 3, 6];
1010 let ys = [0, 1, 2, 3, 4, 5, 6, 7, 8];
041b39d2 1011 let it = xs.iter().flat_map(|&x| (x..).step_by(1).take(3));
1a4d82fc
JJ		 1012 let mut i = 0;
1013 for x in it {
1014 assert_eq!(x, ys[i]);
1015 i += 1;
1016 }
1017 assert_eq!(i, ys.len());
1018}
1019
9fa01778 1020/// Tests `FlatMap::fold` with items already picked off the front and back,
ea8adc8c
XL		 1021/// to make sure all parts of the `FlatMap` are folded correctly.
1022#[test]
1023fn test_iterator_flat_map_fold() {
1024 let xs = [0, 3, 6];
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]);
1031 i + 1
1032 });
1033 assert_eq!(i, ys.len());
1034
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]);
1040 i - 1
1041 });
1042 assert_eq!(i, 0);
1043}
1044
0531ce1d
XL		 1045#[test]
1046fn test_iterator_flatten() {
1047 let xs = [0, 3, 6];
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();
1050 let mut i = 0;
1051 for x in it {
1052 assert_eq!(x, ys[i]);
1053 i += 1;
1054 }
1055 assert_eq!(i, ys.len());
1056}
1057
9fa01778 1058/// Tests `Flatten::fold` with items already picked off the front and back,
0531ce1d
XL		 1059/// to make sure all parts of the `Flatten` are folded correctly.
1060#[test]
1061fn test_iterator_flatten_fold() {
1062 let xs = [0, 3, 6];
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]);
1069 i + 1
1070 });
1071 assert_eq!(i, ys.len());
1072
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]);
1078 i - 1
1079 });
1080 assert_eq!(i, 0);
1081}
1082
1a4d82fc
JJ		 1083#[test]
1084fn test_inspect() {
85aaf69f
SL		 1085 let xs = [1, 2, 3, 4];
1086 let mut n = 0;
1a4d82fc
JJ		 1087
1088 let ys = xs.iter()
85aaf69f 1089 .cloned()
1a4d82fc 1090 .inspect(|_| n += 1)
c34b1796 1091 .collect::<Vec<usize>>();
1a4d82fc
JJ		 1092
1093 assert_eq!(n, xs.len());
85aaf69f 1094 assert_eq!(&xs[..], &ys[..]);
1a4d82fc
JJ		 1095}
1096
ea8adc8c
XL		 1097#[test]
1098fn test_inspect_fold() {
1099 let xs = [1, 2, 3, 4];
1100 let mut n = 0;
1101 {
1102 let it = xs.iter().inspect(|_| n += 1);
1103 let i = it.fold(0, |i, &x| {
1104 assert_eq!(x, xs[i]);
1105 i + 1
1106 });
1107 assert_eq!(i, xs.len());
1108 }
1109 assert_eq!(n, xs.len());
1110
1111 let mut n = 0;
1112 {
1113 let it = xs.iter().inspect(|_| n += 1);
1114 let i = it.rfold(xs.len(), |i, &x| {
1115 assert_eq!(x, xs[i - 1]);
1116 i - 1
1117 });
1118 assert_eq!(i, 0);
1119 }
1120 assert_eq!(n, xs.len());
1121}
1122
1a4d82fc
JJ		 1123#[test]
1124fn test_cycle() {
1125 let cycle_len = 3;
041b39d2 1126 let it = (0..).step_by(1).take(cycle_len).cycle();
c34b1796 1127 assert_eq!(it.size_hint(), (usize::MAX, None));
1a4d82fc
JJ		 1128 for (i, x) in it.take(100).enumerate() {
1129 assert_eq!(i % cycle_len, x);
1130 }
1131
041b39d2 1132 let mut it = (0..).step_by(1).take(0).cycle();
1a4d82fc
JJ		 1133 assert_eq!(it.size_hint(), (0, Some(0)));
1134 assert_eq!(it.next(), None);
0731742a
XL		 1135
1136 assert_eq!(empty::<i32>().cycle().fold(0, |acc, x| acc + x), 0);
1137
1138 assert_eq!(once(1).cycle().skip(1).take(4).fold(0, |acc, x| acc + x), 4);
1a4d82fc
JJ		 1139}
1140
1141#[test]
1142fn test_iterator_nth() {
85aaf69f
SL		 1143 let v: &[_] = &[0, 1, 2, 3, 4];
1144 for i in 0..v.len() {
1a4d82fc
JJ		 1145 assert_eq!(v.iter().nth(i).unwrap(), &v[i]);
1146 }
1147 assert_eq!(v.iter().nth(v.len()), None);
1148}
1149
0731742a
XL		 1150#[test]
1151fn 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]);
1155 }
1156 assert_eq!(v.iter().nth_back(v.len()), None);
1157}
1158
1159#[test]
1160fn 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]);
1164 }
1165 assert_eq!(v.iter().rev().nth_back(v.len()), None);
1166}
1167
1168#[test]
1169fn 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]);
1173 }
1174 assert_eq!(v.iter().rev().nth(v.len()), None);
1175}
1176
1a4d82fc
JJ		 1177#[test]
1178fn test_iterator_last() {
85aaf69f 1179 let v: &[_] = &[0, 1, 2, 3, 4];
1a4d82fc
JJ		 1180 assert_eq!(v.iter().last().unwrap(), &4);
1181 assert_eq!(v[..1].iter().last().unwrap(), &0);
1182}
1183
1184#[test]
1185fn test_iterator_len() {
85aaf69f 1186 let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1a4d82fc
JJ		 1187 assert_eq!(v[..4].iter().count(), 4);
1188 assert_eq!(v[..10].iter().count(), 10);
85aaf69f 1189 assert_eq!(v[..0].iter().count(), 0);
1a4d82fc
JJ		 1190}
1191
1192#[test]
1193fn test_iterator_sum() {
85aaf69f 1194 let v: &[i32] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
9346a6ac
AL		 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);
1a4d82fc
JJ		 1198}
1199
32a655c1
SL		 1200#[test]
1201fn 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(()));
416331ca
XL		 1206
1207 #[derive(PartialEq, Debug)]
1208 struct S(Result<i32, ()>);
1209
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())
1216 }
1217 }
1218
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(())));
32a655c1
SL		 1223}
1224
dc9dc135
XL		 1225#[test]
1226fn 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);
1231}
1232
1a4d82fc
JJ		 1233#[test]
1234fn test_iterator_product() {
85aaf69f 1235 let v: &[i32] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
9346a6ac
AL		 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);
1a4d82fc
JJ		 1239}
1240
32a655c1
SL		 1241#[test]
1242fn 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(()));
1247}
1248
532ac7d7
XL		 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.
1252#[derive(Debug)]
1253struct Mod3(i32);
1254
1255impl PartialEq for Mod3 {
1256 fn eq(&self, other: &Self) -> bool {
1257 self.0 % 3 == other.0 % 3
1258 }
1259}
1260
1261impl Eq for Mod3 {}
1262
1263impl PartialOrd for Mod3 {
1264 fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
1265 Some(self.cmp(other))
1266 }
1267}
1268
1269impl Ord for Mod3 {
1270 fn cmp(&self, other: &Self) -> core::cmp::Ordering {
1271 (self.0 % 3).cmp(&(other.0 % 3))
1272 }
1273}
1274
dc9dc135
XL		 1275#[test]
1276fn 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);
1281}
1282
1a4d82fc
JJ		 1283#[test]
1284fn test_iterator_max() {
85aaf69f
SL		 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);
532ac7d7 1289 assert_eq!(v.iter().cloned().map(Mod3).max().map(|x| x.0), Some(8));
1a4d82fc
JJ		 1290}
1291
1292#[test]
1293fn test_iterator_min() {
85aaf69f
SL		 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);
532ac7d7 1298 assert_eq!(v.iter().cloned().map(Mod3).min().map(|x| x.0), Some(0));
1a4d82fc
JJ		 1299}
1300
1301#[test]
1302fn test_iterator_size_hint() {
041b39d2 1303 let c = (0..).step_by(1);
85aaf69f
SL		 1304 let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
1305 let v2 = &[10, 11, 12];
1a4d82fc
JJ		 1306 let vi = v.iter();
1307
7cac9316 1308 assert_eq!((0..).size_hint(), (usize::MAX, None));
c34b1796 1309 assert_eq!(c.size_hint(), (usize::MAX, None));
85aaf69f
SL		 1310 assert_eq!(vi.clone().size_hint(), (10, Some(10)));
1311
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));
c34b1796
AL		 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));
85aaf69f
SL		 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));
c34b1796 1321 assert_eq!(c.clone().map(|_| 0).size_hint(), (usize::MAX, None));
85aaf69f
SL		 1322 assert_eq!(c.filter_map(|_| Some(0)).size_hint(), (0, None));
1323
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)));
62682a34
SL		 1331 assert_eq!(vi.clone().chain(v2).size_hint(), (13, Some(13)));
1332 assert_eq!(vi.clone().zip(v2).size_hint(), (3, Some(3)));
85aaf69f
SL		 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)));
1a4d82fc
JJ		 1337}
1338
1339#[test]
1340fn test_collect() {
85aaf69f 1341 let a = vec![1, 2, 3, 4, 5];
c34b1796 1342 let b: Vec<isize> = a.iter().cloned().collect();
1a4d82fc
JJ		 1343 assert!(a == b);
1344}
1345
1346#[test]
1347fn test_all() {
c34b1796 1348 let v: Box<[isize]> = Box::new([1, 2, 3, 4, 5]);
1a4d82fc
JJ		 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));
85aaf69f 1352 assert!(v[..0].iter().all(|_| panic!()));
1a4d82fc
JJ		 1353}
1354
1355#[test]
1356fn test_any() {
c34b1796 1357 let v: Box<[isize]> = Box::new([1, 2, 3, 4, 5]);
1a4d82fc
JJ		 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));
85aaf69f 1361 assert!(!v[..0].iter().any(|_| panic!()));
1a4d82fc
JJ		 1362}
1363
1364#[test]
1365fn test_find() {
c34b1796 1366 let v: &[isize] = &[1, 3, 9, 27, 103, 14, 11];
1a4d82fc
JJ		 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());
1370}
1371
83c7162d
XL		 1372#[test]
1373fn 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));
1382
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));
1389
1390 fn half_if_even(x: &isize) -> Option<isize> {
1391 if x % 2 == 0 {
1392 Some(x / 2)
1393 } else {
1394 None
1395 }
1396 }
1397}
1398
1a4d82fc
JJ		 1399#[test]
1400fn test_position() {
85aaf69f 1401 let v = &[1, 3, 9, 27, 103, 14, 11];
1a4d82fc
JJ		 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());
1405}
1406
1407#[test]
1408fn test_count() {
85aaf69f 1409 let xs = &[1, 2, 2, 1, 5, 9, 0, 2];
1a4d82fc
JJ		 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);
1413}
1414
1415#[test]
7453a54e 1416fn test_max_by_key() {
c34b1796 1417 let xs: &[isize] = &[-3, 0, 1, 5, -10];
7453a54e 1418 assert_eq!(*xs.iter().max_by_key(|x| x.abs()).unwrap(), -10);
1a4d82fc
JJ		 1419}
1420
9e0c209e
SL		 1421#[test]
1422fn test_max_by() {
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);
1425}
1426
1a4d82fc 1427#[test]
7453a54e 1428fn test_min_by_key() {
c34b1796 1429 let xs: &[isize] = &[-3, 0, 1, 5, -10];
7453a54e 1430 assert_eq!(*xs.iter().min_by_key(|x| x.abs()).unwrap(), 0);
1a4d82fc
JJ		 1431}
1432
9e0c209e
SL		 1433#[test]
1434fn test_min_by() {
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);
1437}
1438
1a4d82fc
JJ		 1439#[test]
1440fn test_by_ref() {
85aaf69f 1441 let mut xs = 0..10;
1a4d82fc
JJ		 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));
1446}
1447
1448#[test]
1449fn test_rev() {
85aaf69f 1450 let xs = [2, 4, 6, 8, 10, 12, 14, 16];
1a4d82fc
JJ		 1451 let mut it = xs.iter();
1452 it.next();
1453 it.next();
c34b1796 1454 assert!(it.rev().cloned().collect::<Vec<isize>>() ==
1a4d82fc
JJ		 1455 vec![16, 14, 12, 10, 8, 6]);
1456}
1457
0731742a
XL		 1458#[test]
1459fn test_copied() {
1460 let xs = [2, 4, 6, 8];
1461
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);
1473}
1474
1a4d82fc
JJ		 1475#[test]
1476fn test_cloned() {
54a0048b 1477 let xs = [2, 4, 6, 8];
1a4d82fc
JJ		 1478
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);
1490}
1491
0731742a
XL		 1492#[test]
1493fn test_cloned_side_effects() {
1494 let mut count = 0;
1495 {
1496 let iter = [1, 2, 3]
1497 .iter()
1498 .map(|x| {
1499 count += 1;
1500 x
1501 })
1502 .cloned()
1503 .zip(&[1]);
1504 for _ in iter {}
1505 }
1506 assert_eq!(count, 2);
1507}
1508
1a4d82fc
JJ		 1509#[test]
1510fn test_double_ended_map() {
85aaf69f 1511 let xs = [1, 2, 3, 4, 5, 6];
1a4d82fc
JJ		 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);
1520}
1521
1522#[test]
1523fn test_double_ended_enumerate() {
85aaf69f
SL		 1524 let xs = [1, 2, 3, 4, 5, 6];
1525 let mut it = xs.iter().cloned().enumerate();
1a4d82fc
JJ		 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);
1533}
1534
1535#[test]
1536fn test_double_ended_zip() {
85aaf69f
SL		 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();
1a4d82fc
JJ		 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);
1547}
1548
1549#[test]
1550fn test_double_ended_filter() {
85aaf69f 1551 let xs = [1, 2, 3, 4, 5, 6];
1a4d82fc
JJ		 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);
1557}
1558
1559#[test]
1560fn test_double_ended_filter_map() {
85aaf69f 1561 let xs = [1, 2, 3, 4, 5, 6];
1a4d82fc
JJ		 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);
1567}
1568
1569#[test]
1570fn test_double_ended_chain() {
85aaf69f
SL		 1571 let xs = [1, 2, 3, 4, 5];
1572 let ys = [7, 9, 11];
62682a34 1573 let mut it = xs.iter().chain(&ys).rev();
1a4d82fc
JJ		 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);
e9174d1e
SL		 1583
1584
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 {
1589 type Item = i32;
1590 fn next(&mut self) -> Option<i32> {
1591 if self.0 { Some(99) } else { self.0 = true; None }
1592 }
1593 }
1594
1595 impl DoubleEndedIterator for CrazyIterator {
1596 fn next_back(&mut self) -> Option<i32> {
1597 self.next()
1598 }
1599 }
1600
1601 assert_eq!(CrazyIterator::new().chain(0..10).rev().last(), Some(0));
1602 assert!((0..10).chain(CrazyIterator::new()).rev().any(|i| i == 0));
1a4d82fc
JJ		 1603}
1604
1605#[test]
1606fn test_rposition() {
c34b1796
AL		 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' }
85aaf69f 1609 let v = [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
1a4d82fc 1610
85aaf69f 1611 assert_eq!(v.iter().rposition(f), Some(3));
1a4d82fc
JJ		 1612 assert!(v.iter().rposition(g).is_none());
1613}
1614
1615#[test]
c34b1796 1616#[should_panic]
1a4d82fc 1617fn test_rposition_panic() {
c34b1796
AL		 1618 let v: [(Box<_>, Box<_>); 4] =
1619 [(box 0, box 0), (box 0, box 0),
1620 (box 0, box 0), (box 0, box 0)];
85aaf69f 1621 let mut i = 0;
1a4d82fc
JJ		 1622 v.iter().rposition(|_elt| {
1623 if i == 2 {
1624 panic!()
1625 }
1626 i += 1;
1627 false
1628 });
1629}
1630
1631
1a4d82fc
JJ		 1632#[test]
1633fn test_double_ended_flat_map() {
85aaf69f
SL		 1634 let u = [0,1];
1635 let v = [5,6,7,8];
62682a34 1636 let mut it = u.iter().flat_map(|x| &v[*x..v.len()]);
1a4d82fc
JJ		 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);
1647}
1648
0531ce1d
XL		 1649#[test]
1650fn test_double_ended_flatten() {
1651 let u = [0,1];
1652 let v = [5,6,7,8];
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);
1664}
1665
1a4d82fc
JJ		 1666#[test]
1667fn test_double_ended_range() {
c34b1796 1668 assert_eq!((11..14).rev().collect::<Vec<_>>(), [13, 12, 11]);
85aaf69f 1669 for _ in (10..0).rev() {
1a4d82fc
JJ		 1670 panic!("unreachable");
1671 }
1672
c34b1796 1673 assert_eq!((11..14).rev().collect::<Vec<_>>(), [13, 12, 11]);
85aaf69f 1674 for _ in (10..0).rev() {
1a4d82fc
JJ		 1675 panic!("unreachable");
1676 }
1677}
1678
1679#[test]
1680fn test_range() {
c34b1796
AL		 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]);
85aaf69f
SL		 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);
1a4d82fc 1688
85aaf69f 1689 assert_eq!((0..100).size_hint(), (100, Some(100)));
c34b1796
AL		 1690 // this test is only meaningful when sizeof usize < sizeof u64
1691 assert_eq!((usize::MAX - 1..usize::MAX).size_hint(), (1, Some(1)));
85aaf69f
SL		 1692 assert_eq!((-10..-1).size_hint(), (9, Some(9)));
1693 assert_eq!((-1..-10).size_hint(), (0, Some(0)));
d9579d0f 1694
54a0048b
SL		 1695 assert_eq!((-70..58).size_hint(), (128, Some(128)));
1696 assert_eq!((-128..127).size_hint(), (255, Some(255)));
d9579d0f
AL		 1697 assert_eq!((-2..isize::MAX).size_hint(),
1698 (isize::MAX as usize + 2, Some(isize::MAX as usize + 2)));
1a4d82fc
JJ		 1699}
1700
0531ce1d
XL		 1701#[test]
1702fn test_range_exhaustion() {
1703 let mut r = 10..10;
1704 assert!(r.is_empty());
1705 assert_eq!(r.next(), None);
1706 assert_eq!(r.next_back(), None);
1707 assert_eq!(r, 10..10);
1708
1709 let mut r = 10..12;
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);
1715
1716 let mut r = 10..12;
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);
1722
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);
1728}
1729
041b39d2
XL		 1730#[test]
1731fn test_range_inclusive_exhaustion() {
ea8adc8c 1732 let mut r = 10..=10;
041b39d2 1733 assert_eq!(r.next(), Some(10));
0531ce1d
XL		 1734 assert!(r.is_empty());
1735 assert_eq!(r.next(), None);
1736 assert_eq!(r.next(), None);
041b39d2 1737
ea8adc8c 1738 let mut r = 10..=10;
041b39d2 1739 assert_eq!(r.next_back(), Some(10));
0531ce1d
XL		 1740 assert!(r.is_empty());
1741 assert_eq!(r.next_back(), None);
041b39d2 1742
2c00a5a8
XL		 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));
0531ce1d
XL		 1747 assert!(r.is_empty());
1748 assert_eq!(r.next(), None);
2c00a5a8
XL		 1749
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));
0531ce1d
XL		 1754 assert!(r.is_empty());
1755 assert_eq!(r.next_back(), None);
2c00a5a8 1756
ea8adc8c 1757 let mut r = 10..=12;
041b39d2 1758 assert_eq!(r.nth(2), Some(12));
0531ce1d
XL		 1759 assert!(r.is_empty());
1760 assert_eq!(r.next(), None);
041b39d2 1761
ea8adc8c 1762 let mut r = 10..=12;
041b39d2 1763 assert_eq!(r.nth(5), None);
0531ce1d
XL		 1764 assert!(r.is_empty());
1765 assert_eq!(r.next(), None);
041b39d2 1766
2c00a5a8
XL		 1767 let mut r = 100..=10;
1768 assert_eq!(r.next(), None);
0531ce1d
XL		 1769 assert!(r.is_empty());
1770 assert_eq!(r.next(), None);
1771 assert_eq!(r.next(), None);
2c00a5a8
XL		 1772 assert_eq!(r, 100..=10);
1773
1774 let mut r = 100..=10;
1775 assert_eq!(r.next_back(), None);
0531ce1d
XL		 1776 assert!(r.is_empty());
1777 assert_eq!(r.next_back(), None);
1778 assert_eq!(r.next_back(), None);
2c00a5a8 1779 assert_eq!(r, 100..=10);
041b39d2
XL		 1780}
1781
1782#[test]
1783fn 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);
1788
1789 let mut r = 10..20;
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);
1796}
1797
dc9dc135
XL		 1798#[test]
1799fn 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));
1805
1806 let mut r = 10..20;
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);
1813}
1814
041b39d2
XL		 1815#[test]
1816fn 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));
1820
1821 let mut r = 10..;
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..);
2c00a5a8
XL		 1828
1829 assert_eq!((0..).size_hint(), (usize::MAX, None));
1830}
1831
1832fn is_trusted_len<I: TrustedLen>(_: I) {}
1833
1834#[test]
1835fn 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)));
1845}
1846
1847#[test]
1848fn test_range_from_take_collect() {
1849 let v: Vec<_> = (0..).take(3).collect();
1850 assert_eq!(v, vec![0, 1, 2]);
041b39d2
XL		 1851}
1852
1853#[test]
1854fn test_range_inclusive_nth() {
ea8adc8c
XL		 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);
041b39d2 1859
ea8adc8c 1860 let mut r = 10_u8..=20;
041b39d2 1861 assert_eq!(r.nth(2), Some(12));
ea8adc8c 1862 assert_eq!(r, 13..=20);
041b39d2 1863 assert_eq!(r.nth(2), Some(15));
ea8adc8c 1864 assert_eq!(r, 16..=20);
041b39d2 1865 assert_eq!(r.is_empty(), false);
0531ce1d 1866 assert_eq!(ExactSizeIterator::is_empty(&r), false);
041b39d2
XL		 1867 assert_eq!(r.nth(10), None);
1868 assert_eq!(r.is_empty(), true);
0531ce1d 1869 assert_eq!(ExactSizeIterator::is_empty(&r), true);
041b39d2
XL		 1870}
1871
dc9dc135
XL		 1872#[test]
1873fn 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));
1879
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);
1890}
1891
1a4d82fc 1892#[test]
1a4d82fc 1893fn test_range_step() {
7cac9316
XL		 1894 #![allow(deprecated)]
1895
c34b1796 1896 assert_eq!((0..20).step_by(5).collect::<Vec<isize>>(), [0, 5, 10, 15]);
041b39d2
XL		 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]);
c34b1796
AL		 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>>(), []);
d9579d0f
AL		 1902
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)));
041b39d2
XL		 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)));
d9579d0f
AL		 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)));
041b39d2
XL		 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)));
d9579d0f 1912 assert_eq!((isize::MIN..isize::MAX).step_by(1).size_hint(), (usize::MAX, Some(usize::MAX)));
1a4d82fc
JJ		 1913}
1914
13cf67c4
XL		 1915#[test]
1916fn 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));
1920}
1921
8faf50e0
XL		 1922#[test]
1923fn 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]);
1928}
1929
2c00a5a8
XL		 1930#[test]
1931fn 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);
1935
1936 assert_eq!((0..20).max(), Some(19));
1937 assert_eq!((-20..0).max(), Some(-1));
1938 assert_eq!((5..5).max(), None);
1939}
1940
1941#[test]
1942fn 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;
1947 r.next();
1948 assert_eq!(r.last(), None);
1949
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;
1954 r.next();
1955 assert_eq!(r.max(), None);
1956}
1957
1958#[test]
1959fn 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);
1963}
1964
1965#[test]
1966fn 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;
1971 r.next();
1972 assert_eq!(r.min(), None);
1973}
1974
1975#[test]
1976fn test_range_inclusive_folds() {
1977 assert_eq!((1..=10).sum::<i32>(), 55);
1978 assert_eq!((1..=10).rev().sum::<i32>(), 55);
1979
9fa01778 1980 let mut it = 44..=50;
2c00a5a8 1981 assert_eq!(it.try_fold(0, i8::checked_add), None);
9fa01778
XL		 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());
1989
1990 let mut it = 40..=47;
1991 assert_eq!(it.try_rfold(0, i8::checked_add), None);
1992 assert_eq!(it, 40..=44);
2c00a5a8 1993 assert_eq!(it.try_rfold(0, i8::checked_add), None);
9fa01778
XL		 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());
2c00a5a8
XL		 1999
2000 let mut it = 10..=20;
2001 assert_eq!(it.try_fold(0, |a,b| Some(a+b)), Some(165));
0531ce1d 2002 assert!(it.is_empty());
9fa01778
XL		 2003 assert_eq!(it.try_fold(0, |a,b| Some(a+b)), Some(0));
2004 assert!(it.is_empty());
2c00a5a8
XL		 2005
2006 let mut it = 10..=20;
2007 assert_eq!(it.try_rfold(0, |a,b| Some(a+b)), Some(165));
0531ce1d 2008 assert!(it.is_empty());
9fa01778
XL		 2009 assert_eq!(it.try_rfold(0, |a,b| Some(a+b)), Some(0));
2010 assert!(it.is_empty());
2c00a5a8
XL		 2011}
2012
532ac7d7
XL		 2013#[test]
2014fn 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)));
2019
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));
2025
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)));
2030
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));
2037}
2038
2039#[test]
2040fn 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));
2047
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));
2055
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));
2062
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));
2071}
2072
1a4d82fc
JJ		 2073#[test]
2074fn test_repeat() {
85aaf69f
SL		 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));
2c00a5a8
XL		 2079 assert_eq!(repeat(42).size_hint(), (usize::MAX, None));
2080}
2081
2082#[test]
2083fn 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)));
2093}
2094
2095#[test]
2096fn test_repeat_take_collect() {
2097 let v: Vec<_> = repeat(42).take(3).collect();
2098 assert_eq!(v, vec![42, 42, 42]);
85aaf69f
SL		 2099}
2100
0531ce1d
XL		 2101#[test]
2102fn 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));
2110}
2111
0531ce1d
XL		 2112#[test]
2113fn 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)));
2124}
2125
2126#[test]
2127fn test_repeat_with_take_collect() {
2128 let mut curr = 1;
2129 let v: Vec<_> = repeat_with(|| { let tmp = curr; curr *= 2; tmp })
2130 .take(5).collect();
2131 assert_eq!(v, vec![1, 2, 4, 8, 16]);
2132}
2133
a1dfa0c6
XL		 2134#[test]
2135fn 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);
2139
2140 let mut empty = successors(None::<u32>, |_| unimplemented!());
2141 assert_eq!(empty.next(), None);
2142 assert_eq!(empty.next(), None);
2143}
2144
85aaf69f
SL		 2145#[test]
2146fn test_fuse() {
2147 let mut it = 0..3;
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);
1a4d82fc
JJ		 2161}
2162
d9579d0f
AL		 2163#[test]
2164fn test_fuse_nth() {
2165 let xs = [0, 1, 2];
2166 let mut it = xs.iter();
2167
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);
2173}
2174
2175#[test]
2176fn test_fuse_last() {
2177 let xs = [0, 1, 2];
2178 let it = xs.iter();
2179
2180 assert_eq!(it.len(), 3);
2181 assert_eq!(it.last(), Some(&2));
2182}
2183
2184#[test]
2185fn test_fuse_count() {
2186 let xs = [0, 1, 2];
2187 let it = xs.iter();
2188
2189 assert_eq!(it.len(), 3);
2190 assert_eq!(it.count(), 3);
2191 // Can't check len now because count consumes.
2192}
2193
ea8adc8c
XL		 2194#[test]
2195fn test_fuse_fold() {
2196 let xs = [0, 1, 2];
2197 let it = xs.iter(); // `FusedIterator`
2198 let i = it.fuse().fold(0, |i, &x| {
2199 assert_eq!(x, xs[i]);
2200 i + 1
2201 });
2202 assert_eq!(i, xs.len());
2203
2204 let it = xs.iter(); // `FusedIterator`
2205 let i = it.fuse().rfold(xs.len(), |i, &x| {
2206 assert_eq!(x, xs[i - 1]);
2207 i - 1
2208 });
2209 assert_eq!(i, 0);
2210
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]);
2214 i + 1
2215 });
2216 assert_eq!(i, xs.len());
2217}
2218
62682a34
SL		 2219#[test]
2220fn test_once() {
2221 let mut it = once(42);
2222 assert_eq!(it.next(), Some(42));
2223 assert_eq!(it.next(), None);
2224}
2225
0731742a
XL		 2226#[test]
2227fn test_once_with() {
2228 let count = Cell::new(0);
2229 let mut it = once_with(|| {
2230 count.set(count.get() + 1);
2231 42
2232 });
2233
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);
2241}
2242
62682a34
SL		 2243#[test]
2244fn test_empty() {
2245 let mut it = empty::<i32>();
2246 assert_eq!(it.next(), None);
2247}
2248
c30ab7b3
SL		 2249#[test]
2250fn test_chain_fold() {
2251 let xs = [1, 2, 3];
2252 let ys = [1, 2, 0];
2253
2254 let mut iter = xs.iter().chain(&ys);
2255 iter.next();
2256 let mut result = Vec::new();
2257 iter.fold((), |(), &elt| result.push(elt));
2258 assert_eq!(&[2, 3, 1, 2, 0], &result[..]);
2259}
2260
7cac9316
XL		 2261#[test]
2262fn test_step_replace_unsigned() {
2263 let mut x = 4u32;
2264 let y = x.replace_zero();
2265 assert_eq!(x, 0);
2266 assert_eq!(y, 4);
2267
2268 x = 5;
2269 let y = x.replace_one();
2270 assert_eq!(x, 1);
2271 assert_eq!(y, 5);
2272}
2273
2274#[test]
2275fn test_step_replace_signed() {
2276 let mut x = 4i32;
2277 let y = x.replace_zero();
2278 assert_eq!(x, 0);
2279 assert_eq!(y, 4);
2280
2281 x = 5;
2282 let y = x.replace_one();
2283 assert_eq!(x, 1);
2284 assert_eq!(y, 5);
2285}
2286
2287#[test]
2288fn test_step_replace_no_between() {
2289 let mut x = 4u128;
2290 let y = x.replace_zero();
2291 assert_eq!(x, 0);
2292 assert_eq!(y, 4);
2293
2294 x = 5;
2295 let y = x.replace_one();
2296 assert_eq!(x, 1);
2297 assert_eq!(y, 5);
2298}
abe05a73
XL		 2299
2300#[test]
2301fn 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));
2305
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));
2313}
2314
2315#[test]
2316fn 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));
2322
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));
2330}
2331
2332#[test]
2333fn test_chain_try_folds() {
2334 let c = || (0..10).chain(10..20);
2335
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));
2339
2340 let mut iter = c();
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()));
2346
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()));
2353
2354 let mut iter = c();
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));
2357
2358 let mut iter = c();
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));
2361}
2362
2363#[test]
2364fn 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));
2368
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));
2374}
2375
2376#[test]
2377fn 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));
2382
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));
2388}
2389
2390#[test]
2391fn 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));
2396
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));
2402}
2403
2404#[test]
2405fn 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));
2409
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)));
2416}
2417
2418#[test]
416331ca 2419fn test_peek_try_folds() {
abe05a73 2420 let f = &|acc, x| i32::checked_add(2*acc, x);
416331ca 2421
abe05a73 2422 assert_eq!((1..20).peekable().try_fold(7, f), (1..20).try_fold(7, f));
416331ca
XL		 2423 assert_eq!((1..20).peekable().try_rfold(7, f), (1..20).try_rfold(7, f));
2424
abe05a73
XL		 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));
2428
416331ca
XL		 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));
2432
abe05a73
XL		 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));
416331ca
XL		 2437
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));
2443
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(()));
2453
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(()));
abe05a73
XL		 2463}
2464
2465#[test]
2466fn 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));
2473
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));
2477}
2478
2479#[test]
2480fn 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());
2488
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));
2492}
2493
2494#[test]
2495fn 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));
2499
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));
2505}
2506
dc9dc135
XL		 2507#[test]
2508fn 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);
2515
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));
2527
2528 let mut it = xs.iter().skip(2);
2529 assert_eq!(it.nth_back(4), None);
2530 assert_eq!(it.nth_back(0), None);
2531
2532 let mut it = xs.iter();
2533 it.by_ref().skip(2).nth_back(3);
2534 assert_eq!(it.next_back(), Some(&1));
2535
2536 let mut it = xs.iter();
2537 it.by_ref().skip(2).nth_back(10);
2538 assert_eq!(it.next_back(), Some(&1));
2539}
2540
abe05a73
XL		 2541#[test]
2542fn 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));
416331ca 2545 assert_eq!((10..30).take(10).try_rfold(7, f), (10..20).try_rfold(7, f));
abe05a73
XL		 2546
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));
416331ca
XL		 2550 assert_eq!(iter.try_rfold(0, i8::checked_add), None);
2551 assert_eq!(iter.next_back(), Some(24));
2552
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(()));
2558
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(()));
abe05a73
XL		 2564}
2565
2566#[test]
2567fn 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));
2575
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));
2581}
0531ce1d
XL		 2582
2583#[test]
2584fn 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));
2592
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));
2598}
2599
2600#[test]
2601fn test_functor_laws() {
2602 // identity:
2603 fn identity<T>(x: T) -> T { x }
2604 assert_eq!((0..10).map(identity).sum::<usize>(), (0..10).sum());
2605
2606 // composition:
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());
2611}
2612
2613#[test]
2614fn test_monad_laws_left_identity() {
2615 fn f(x: usize) -> impl Iterator<Item = usize> {
2616 (0..10).map(move |y| x * y)
2617 }
2618 assert_eq!(once(42).flat_map(f.clone()).sum::<usize>(), f(42).sum());
2619}
2620
2621#[test]
2622fn test_monad_laws_right_identity() {
2623 assert_eq!((0..10).flat_map(|x| once(x)).sum::<usize>(), (0..10).sum());
2624}
2625
2626#[test]
2627fn 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>());
2632}
9fa01778
XL		 2633
2634#[test]
2635fn 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()));
2645}
416331ca
XL		 2646
2647#[test]
2648fn 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));
2657 } else {
2658 assert!(!xs.iter().rev().is_partitioned(p));
2659 }
2660 }
2661
2662 check(&mut [], |_| true, 0);
2663 check(&mut [], |_| false, 0);
2664
2665 check(&mut [0], |_| true, 1);
2666 check(&mut [0], |_| false, 0);
2667
2668 check(&mut [-1, 1], |&x| x > 0, 1);
2669 check(&mut [-1, 1], |&x| x < 0, 1);
2670
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
2681}
backport for Debian buster