src/libcore/tests/iter.rs

   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.
   4 //
   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.
  10
  11 use core::iter::*;
  12 use core::{i8, i16, isize};
  13 use core::usize;
  14
  15 // FIXME #27741: This is here to simplify calling Iterator::step_by. Remove
  16 // once Range::step_by is completely gone (not just deprecated).
  17 trait IterEx: Sized {
  18     fn iter_step_by(self, n: usize) -> StepBy<Self>;
  19 }
  20 impl<I:Iterator> IterEx for I {
  21     fn iter_step_by(self, n: usize) -> StepBy<Self> { self.step_by(n) }
  22 }
  23
  24 #[test]
  25 fn test_lt() {
  26     let empty: [isize; 0] = [];
  27     let xs = [1,2,3];
  28     let ys = [1,2,0];
  29
  30     assert!(!xs.iter().lt(ys.iter()));
  31     assert!(!xs.iter().le(ys.iter()));
  32     assert!( xs.iter().gt(ys.iter()));
  33     assert!( xs.iter().ge(ys.iter()));
  34
  35     assert!( ys.iter().lt(xs.iter()));
  36     assert!( ys.iter().le(xs.iter()));
  37     assert!(!ys.iter().gt(xs.iter()));
  38     assert!(!ys.iter().ge(xs.iter()));
  39
  40     assert!( empty.iter().lt(xs.iter()));
  41     assert!( empty.iter().le(xs.iter()));
  42     assert!(!empty.iter().gt(xs.iter()));
  43     assert!(!empty.iter().ge(xs.iter()));
  44
  45     // Sequence with NaN
  46     let u = [1.0f64, 2.0];
  47     let v = [0.0f64/0.0, 3.0];
  48
  49     assert!(!u.iter().lt(v.iter()));
  50     assert!(!u.iter().le(v.iter()));
  51     assert!(!u.iter().gt(v.iter()));
  52     assert!(!u.iter().ge(v.iter()));
  53
  54     let a = [0.0f64/0.0];
  55     let b = [1.0f64];
  56     let c = [2.0f64];
  57
  58     assert!(a.iter().lt(b.iter()) == (a[0] <  b[0]));
  59     assert!(a.iter().le(b.iter()) == (a[0] <= b[0]));
  60     assert!(a.iter().gt(b.iter()) == (a[0] >  b[0]));
  61     assert!(a.iter().ge(b.iter()) == (a[0] >= b[0]));
  62
  63     assert!(c.iter().lt(b.iter()) == (c[0] <  b[0]));
  64     assert!(c.iter().le(b.iter()) == (c[0] <= b[0]));
  65     assert!(c.iter().gt(b.iter()) == (c[0] >  b[0]));
  66     assert!(c.iter().ge(b.iter()) == (c[0] >= b[0]));
  67 }
  68
  69 #[test]
  70 fn test_multi_iter() {
  71     let xs = [1,2,3,4];
  72     let ys = [4,3,2,1];
  73     assert!(xs.iter().eq(ys.iter().rev()));
  74     assert!(xs.iter().lt(xs.iter().skip(2)));
  75 }
  76
  77 #[test]
  78 fn test_counter_from_iter() {
  79     let it = (0..).iter_step_by(5).take(10);
  80     let xs: Vec<isize> = FromIterator::from_iter(it);
  81     assert_eq!(xs, [0, 5, 10, 15, 20, 25, 30, 35, 40, 45]);
  82 }
  83
  84 #[test]
  85 fn test_iterator_chain() {
  86     let xs = [0, 1, 2, 3, 4, 5];
  87     let ys = [30, 40, 50, 60];
  88     let expected = [0, 1, 2, 3, 4, 5, 30, 40, 50, 60];
  89     let it = xs.iter().chain(&ys);
  90     let mut i = 0;
  91     for &x in it {
  92         assert_eq!(x, expected[i]);
  93         i += 1;
  94     }
  95     assert_eq!(i, expected.len());
  96
  97     let ys = (30..).iter_step_by(10).take(4);
  98     let it = xs.iter().cloned().chain(ys);
  99     let mut i = 0;
 100     for x in it {
 101         assert_eq!(x, expected[i]);
 102         i += 1;
 103     }
 104     assert_eq!(i, expected.len());
 105 }
 106
 107 #[test]
 108 fn test_iterator_chain_nth() {
 109     let xs = [0, 1, 2, 3, 4, 5];
 110     let ys = [30, 40, 50, 60];
 111     let zs = [];
 112     let expected = [0, 1, 2, 3, 4, 5, 30, 40, 50, 60];
 113     for (i, x) in expected.iter().enumerate() {
 114         assert_eq!(Some(x), xs.iter().chain(&ys).nth(i));
 115     }
 116     assert_eq!(zs.iter().chain(&xs).nth(0), Some(&0));
 117
 118     let mut it = xs.iter().chain(&zs);
 119     assert_eq!(it.nth(5), Some(&5));
 120     assert_eq!(it.next(), None);
 121 }
 122
 123 #[test]
 124 fn test_iterator_chain_last() {
 125     let xs = [0, 1, 2, 3, 4, 5];
 126     let ys = [30, 40, 50, 60];
 127     let zs = [];
 128     assert_eq!(xs.iter().chain(&ys).last(), Some(&60));
 129     assert_eq!(zs.iter().chain(&ys).last(), Some(&60));
 130     assert_eq!(ys.iter().chain(&zs).last(), Some(&60));
 131     assert_eq!(zs.iter().chain(&zs).last(), None);
 132 }
 133
 134 #[test]
 135 fn test_iterator_chain_count() {
 136     let xs = [0, 1, 2, 3, 4, 5];
 137     let ys = [30, 40, 50, 60];
 138     let zs = [];
 139     assert_eq!(xs.iter().chain(&ys).count(), 10);
 140     assert_eq!(zs.iter().chain(&ys).count(), 4);
 141 }
 142
 143 #[test]
 144 fn test_iterator_chain_find() {
 145     let xs = [0, 1, 2, 3, 4, 5];
 146     let ys = [30, 40, 50, 60];
 147     let mut iter = xs.iter().chain(&ys);
 148     assert_eq!(iter.find(|&&i| i == 4), Some(&4));
 149     assert_eq!(iter.next(), Some(&5));
 150     assert_eq!(iter.find(|&&i| i == 40), Some(&40));
 151     assert_eq!(iter.next(), Some(&50));
 152     assert_eq!(iter.find(|&&i| i == 100), None);
 153     assert_eq!(iter.next(), None);
 154 }
 155
 156 #[test]
 157 fn test_iterator_step_by() {
 158     // Identity
 159     let mut it = (0..).iter_step_by(1).take(3);
 160     assert_eq!(it.next(), Some(0));
 161     assert_eq!(it.next(), Some(1));
 162     assert_eq!(it.next(), Some(2));
 163     assert_eq!(it.next(), None);
 164
 165     let mut it = (0..).iter_step_by(3).take(4);
 166     assert_eq!(it.next(), Some(0));
 167     assert_eq!(it.next(), Some(3));
 168     assert_eq!(it.next(), Some(6));
 169     assert_eq!(it.next(), Some(9));
 170     assert_eq!(it.next(), None);
 171 }
 172
 173 #[test]
 174 #[should_panic]
 175 fn test_iterator_step_by_zero() {
 176     let mut it = (0..).iter_step_by(0);
 177     it.next();
 178 }
 179
 180 #[test]
 181 fn test_iterator_step_by_size_hint() {
 182     struct StubSizeHint(usize, Option<usize>);
 183     impl Iterator for StubSizeHint {
 184         type Item = ();
 185         fn next(&mut self) -> Option<()> {
 186             self.0 -= 1;
 187             if let Some(ref mut upper) = self.1 {
 188                 *upper -= 1;
 189             }
 190             Some(())
 191         }
 192         fn size_hint(&self) -> (usize, Option<usize>) {
 193             (self.0, self.1)
 194         }
 195     }
 196
 197     // The two checks in each case are needed because the logic
 198     // is different before the first call to `next()`.
 199
 200     let mut it = StubSizeHint(10, Some(10)).step_by(1);
 201     assert_eq!(it.size_hint(), (10, Some(10)));
 202     it.next();
 203     assert_eq!(it.size_hint(), (9, Some(9)));
 204
 205     // exact multiple
 206     let mut it = StubSizeHint(10, Some(10)).step_by(3);
 207     assert_eq!(it.size_hint(), (4, Some(4)));
 208     it.next();
 209     assert_eq!(it.size_hint(), (3, Some(3)));
 210
 211     // larger base range, but not enough to get another element
 212     let mut it = StubSizeHint(12, Some(12)).step_by(3);
 213     assert_eq!(it.size_hint(), (4, Some(4)));
 214     it.next();
 215     assert_eq!(it.size_hint(), (3, Some(3)));
 216
 217     // smaller base range, so fewer resulting elements
 218     let mut it = StubSizeHint(9, Some(9)).step_by(3);
 219     assert_eq!(it.size_hint(), (3, Some(3)));
 220     it.next();
 221     assert_eq!(it.size_hint(), (2, Some(2)));
 222
 223     // infinite upper bound
 224     let mut it = StubSizeHint(usize::MAX, None).step_by(1);
 225     assert_eq!(it.size_hint(), (usize::MAX, None));
 226     it.next();
 227     assert_eq!(it.size_hint(), (usize::MAX-1, None));
 228
 229     // still infinite with larger step
 230     let mut it = StubSizeHint(7, None).step_by(3);
 231     assert_eq!(it.size_hint(), (3, None));
 232     it.next();
 233     assert_eq!(it.size_hint(), (2, None));
 234
 235     // propagates ExactSizeIterator
 236     let a = [1,2,3,4,5];
 237     let it = a.iter().step_by(2);
 238     assert_eq!(it.len(), 3);
 239
 240     // Cannot be TrustedLen as a step greater than one makes an iterator
 241     // with (usize::MAX, None) no longer meet the safety requirements
 242     trait TrustedLenCheck { fn test(self) -> bool; }
 243     impl<T:Iterator> TrustedLenCheck for T {
 244         default fn test(self) -> bool { false }
 245     }
 246     impl<T:TrustedLen> TrustedLenCheck for T {
 247         fn test(self) -> bool { true }
 248     }
 249     assert!(TrustedLenCheck::test(a.iter()));
 250     assert!(!TrustedLenCheck::test(a.iter().step_by(1)));
 251 }
 252
 253 #[test]
 254 fn test_filter_map() {
 255     let it = (0..).iter_step_by(1).take(10)
 256         .filter_map(|x| if x % 2 == 0 { Some(x*x) } else { None });
 257     assert_eq!(it.collect::<Vec<usize>>(), [0*0, 2*2, 4*4, 6*6, 8*8]);
 258 }
 259
 260 #[test]
 261 fn test_iterator_enumerate() {
 262     let xs = [0, 1, 2, 3, 4, 5];
 263     let it = xs.iter().enumerate();
 264     for (i, &x) in it {
 265         assert_eq!(i, x);
 266     }
 267 }
 268
 269 #[test]
 270 fn test_iterator_enumerate_nth() {
 271     let xs = [0, 1, 2, 3, 4, 5];
 272     for (i, &x) in xs.iter().enumerate() {
 273         assert_eq!(i, x);
 274     }
 275
 276     let mut it = xs.iter().enumerate();
 277     while let Some((i, &x)) = it.nth(0) {
 278         assert_eq!(i, x);
 279     }
 280
 281     let mut it = xs.iter().enumerate();
 282     while let Some((i, &x)) = it.nth(1) {
 283         assert_eq!(i, x);
 284     }
 285
 286     let (i, &x) = xs.iter().enumerate().nth(3).unwrap();
 287     assert_eq!(i, x);
 288     assert_eq!(i, 3);
 289 }
 290
 291 #[test]
 292 fn test_iterator_enumerate_count() {
 293     let xs = [0, 1, 2, 3, 4, 5];
 294     assert_eq!(xs.iter().count(), 6);
 295 }
 296
 297 #[test]
 298 fn test_iterator_filter_count() {
 299     let xs = [0, 1, 2, 3, 4, 5, 6, 7, 8];
 300     assert_eq!(xs.iter().filter(|&&x| x % 2 == 0).count(), 5);
 301 }
 302
 303 #[test]
 304 fn test_iterator_peekable() {
 305     let xs = vec![0, 1, 2, 3, 4, 5];
 306     let mut it = xs.iter().cloned().peekable();
 307
 308     assert_eq!(it.len(), 6);
 309     assert_eq!(it.peek().unwrap(), &0);
 310     assert_eq!(it.len(), 6);
 311     assert_eq!(it.next().unwrap(), 0);
 312     assert_eq!(it.len(), 5);
 313     assert_eq!(it.next().unwrap(), 1);
 314     assert_eq!(it.len(), 4);
 315     assert_eq!(it.next().unwrap(), 2);
 316     assert_eq!(it.len(), 3);
 317     assert_eq!(it.peek().unwrap(), &3);
 318     assert_eq!(it.len(), 3);
 319     assert_eq!(it.peek().unwrap(), &3);
 320     assert_eq!(it.len(), 3);
 321     assert_eq!(it.next().unwrap(), 3);
 322     assert_eq!(it.len(), 2);
 323     assert_eq!(it.next().unwrap(), 4);
 324     assert_eq!(it.len(), 1);
 325     assert_eq!(it.peek().unwrap(), &5);
 326     assert_eq!(it.len(), 1);
 327     assert_eq!(it.next().unwrap(), 5);
 328     assert_eq!(it.len(), 0);
 329     assert!(it.peek().is_none());
 330     assert_eq!(it.len(), 0);
 331     assert!(it.next().is_none());
 332     assert_eq!(it.len(), 0);
 333 }
 334
 335 #[test]
 336 fn test_iterator_peekable_count() {
 337     let xs = [0, 1, 2, 3, 4, 5];
 338     let ys = [10];
 339     let zs: [i32; 0] = [];
 340
 341     assert_eq!(xs.iter().peekable().count(), 6);
 342
 343     let mut it = xs.iter().peekable();
 344     assert_eq!(it.peek(), Some(&&0));
 345     assert_eq!(it.count(), 6);
 346
 347     assert_eq!(ys.iter().peekable().count(), 1);
 348
 349     let mut it = ys.iter().peekable();
 350     assert_eq!(it.peek(), Some(&&10));
 351     assert_eq!(it.count(), 1);
 352
 353     assert_eq!(zs.iter().peekable().count(), 0);
 354
 355     let mut it = zs.iter().peekable();
 356     assert_eq!(it.peek(), None);
 357
 358 }
 359
 360 #[test]
 361 fn test_iterator_peekable_nth() {
 362     let xs = [0, 1, 2, 3, 4, 5];
 363     let mut it = xs.iter().peekable();
 364
 365     assert_eq!(it.peek(), Some(&&0));
 366     assert_eq!(it.nth(0), Some(&0));
 367     assert_eq!(it.peek(), Some(&&1));
 368     assert_eq!(it.nth(1), Some(&2));
 369     assert_eq!(it.peek(), Some(&&3));
 370     assert_eq!(it.nth(2), Some(&5));
 371     assert_eq!(it.next(), None);
 372 }
 373
 374 #[test]
 375 fn test_iterator_peekable_last() {
 376     let xs = [0, 1, 2, 3, 4, 5];
 377     let ys = [0];
 378
 379     let mut it = xs.iter().peekable();
 380     assert_eq!(it.peek(), Some(&&0));
 381     assert_eq!(it.last(), Some(&5));
 382
 383     let mut it = ys.iter().peekable();
 384     assert_eq!(it.peek(), Some(&&0));
 385     assert_eq!(it.last(), Some(&0));
 386
 387     let mut it = ys.iter().peekable();
 388     assert_eq!(it.next(), Some(&0));
 389     assert_eq!(it.peek(), None);
 390     assert_eq!(it.last(), None);
 391 }
 392
 393 /// This is an iterator that follows the Iterator contract,
 394 /// but it is not fused. After having returned None once, it will start
 395 /// producing elements if .next() is called again.
 396 pub struct CycleIter<'a, T: 'a> {
 397     index: usize,
 398     data: &'a [T],
 399 }
 400
 401 pub fn cycle<T>(data: &[T]) -> CycleIter<T> {
 402     CycleIter {
 403         index: 0,
 404         data: data,
 405     }
 406 }
 407
 408 impl<'a, T> Iterator for CycleIter<'a, T> {
 409     type Item = &'a T;
 410     fn next(&mut self) -> Option<Self::Item> {
 411         let elt = self.data.get(self.index);
 412         self.index += 1;
 413         self.index %= 1 + self.data.len();
 414         elt
 415     }
 416 }
 417
 418 #[test]
 419 fn test_iterator_peekable_remember_peek_none_1() {
 420     // Check that the loop using .peek() terminates
 421     let data = [1, 2, 3];
 422     let mut iter = cycle(&data).peekable();
 423
 424     let mut n = 0;
 425     while let Some(_) = iter.next() {
 426         let is_the_last = iter.peek().is_none();
 427         assert_eq!(is_the_last, n == data.len() - 1);
 428         n += 1;
 429         if n > data.len() { break; }
 430     }
 431     assert_eq!(n, data.len());
 432 }
 433
 434 #[test]
 435 fn test_iterator_peekable_remember_peek_none_2() {
 436     let data = [0];
 437     let mut iter = cycle(&data).peekable();
 438     iter.next();
 439     assert_eq!(iter.peek(), None);
 440     assert_eq!(iter.last(), None);
 441 }
 442
 443 #[test]
 444 fn test_iterator_peekable_remember_peek_none_3() {
 445     let data = [0];
 446     let mut iter = cycle(&data).peekable();
 447     iter.peek();
 448     assert_eq!(iter.nth(0), Some(&0));
 449
 450     let mut iter = cycle(&data).peekable();
 451     iter.next();
 452     assert_eq!(iter.peek(), None);
 453     assert_eq!(iter.nth(0), None);
 454 }
 455
 456 #[test]
 457 fn test_iterator_take_while() {
 458     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19];
 459     let ys = [0, 1, 2, 3, 5, 13];
 460     let it = xs.iter().take_while(|&x| *x < 15);
 461     let mut i = 0;
 462     for x in it {
 463         assert_eq!(*x, ys[i]);
 464         i += 1;
 465     }
 466     assert_eq!(i, ys.len());
 467 }
 468
 469 #[test]
 470 fn test_iterator_skip_while() {
 471     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19];
 472     let ys = [15, 16, 17, 19];
 473     let it = xs.iter().skip_while(|&x| *x < 15);
 474     let mut i = 0;
 475     for x in it {
 476         assert_eq!(*x, ys[i]);
 477         i += 1;
 478     }
 479     assert_eq!(i, ys.len());
 480 }
 481
 482 #[test]
 483 fn test_iterator_skip() {
 484     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
 485     let ys = [13, 15, 16, 17, 19, 20, 30];
 486     let mut it = xs.iter().skip(5);
 487     let mut i = 0;
 488     while let Some(&x) = it.next() {
 489         assert_eq!(x, ys[i]);
 490         i += 1;
 491         assert_eq!(it.len(), xs.len()-5-i);
 492     }
 493     assert_eq!(i, ys.len());
 494     assert_eq!(it.len(), 0);
 495 }
 496
 497 #[test]
 498 fn test_iterator_skip_doubleended() {
 499     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
 500     let mut it = xs.iter().rev().skip(5);
 501     assert_eq!(it.next(), Some(&15));
 502     assert_eq!(it.by_ref().rev().next(), Some(&0));
 503     assert_eq!(it.next(), Some(&13));
 504     assert_eq!(it.by_ref().rev().next(), Some(&1));
 505     assert_eq!(it.next(), Some(&5));
 506     assert_eq!(it.by_ref().rev().next(), Some(&2));
 507     assert_eq!(it.next(), Some(&3));
 508     assert_eq!(it.next(), None);
 509     let mut it = xs.iter().rev().skip(5).rev();
 510     assert_eq!(it.next(), Some(&0));
 511     assert_eq!(it.rev().next(), Some(&15));
 512     let mut it_base = xs.iter();
 513     {
 514         let mut it = it_base.by_ref().skip(5).rev();
 515         assert_eq!(it.next(), Some(&30));
 516         assert_eq!(it.next(), Some(&20));
 517         assert_eq!(it.next(), Some(&19));
 518         assert_eq!(it.next(), Some(&17));
 519         assert_eq!(it.next(), Some(&16));
 520         assert_eq!(it.next(), Some(&15));
 521         assert_eq!(it.next(), Some(&13));
 522         assert_eq!(it.next(), None);
 523     }
 524     // make sure the skipped parts have not been consumed
 525     assert_eq!(it_base.next(), Some(&0));
 526     assert_eq!(it_base.next(), Some(&1));
 527     assert_eq!(it_base.next(), Some(&2));
 528     assert_eq!(it_base.next(), Some(&3));
 529     assert_eq!(it_base.next(), Some(&5));
 530     assert_eq!(it_base.next(), None);
 531     let it = xs.iter().skip(5).rev();
 532     assert_eq!(it.last(), Some(&13));
 533 }
 534
 535 #[test]
 536 fn test_iterator_skip_nth() {
 537     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
 538
 539     let mut it = xs.iter().skip(0);
 540     assert_eq!(it.nth(0), Some(&0));
 541     assert_eq!(it.nth(1), Some(&2));
 542
 543     let mut it = xs.iter().skip(5);
 544     assert_eq!(it.nth(0), Some(&13));
 545     assert_eq!(it.nth(1), Some(&16));
 546
 547     let mut it = xs.iter().skip(12);
 548     assert_eq!(it.nth(0), None);
 549
 550 }
 551
 552 #[test]
 553 fn test_iterator_skip_count() {
 554     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
 555
 556     assert_eq!(xs.iter().skip(0).count(), 12);
 557     assert_eq!(xs.iter().skip(1).count(), 11);
 558     assert_eq!(xs.iter().skip(11).count(), 1);
 559     assert_eq!(xs.iter().skip(12).count(), 0);
 560     assert_eq!(xs.iter().skip(13).count(), 0);
 561 }
 562
 563 #[test]
 564 fn test_iterator_skip_last() {
 565     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
 566
 567     assert_eq!(xs.iter().skip(0).last(), Some(&30));
 568     assert_eq!(xs.iter().skip(1).last(), Some(&30));
 569     assert_eq!(xs.iter().skip(11).last(), Some(&30));
 570     assert_eq!(xs.iter().skip(12).last(), None);
 571     assert_eq!(xs.iter().skip(13).last(), None);
 572
 573     let mut it = xs.iter().skip(5);
 574     assert_eq!(it.next(), Some(&13));
 575     assert_eq!(it.last(), Some(&30));
 576 }
 577
 578 #[test]
 579 fn test_iterator_take() {
 580     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19];
 581     let ys = [0, 1, 2, 3, 5];
 582     let mut it = xs.iter().take(5);
 583     let mut i = 0;
 584     assert_eq!(it.len(), 5);
 585     while let Some(&x) = it.next() {
 586         assert_eq!(x, ys[i]);
 587         i += 1;
 588         assert_eq!(it.len(), 5-i);
 589     }
 590     assert_eq!(i, ys.len());
 591     assert_eq!(it.len(), 0);
 592 }
 593
 594 #[test]
 595 fn test_iterator_take_nth() {
 596     let xs = [0, 1, 2, 4, 5];
 597     let mut it = xs.iter();
 598     {
 599         let mut take = it.by_ref().take(3);
 600         let mut i = 0;
 601         while let Some(&x) = take.nth(0) {
 602             assert_eq!(x, i);
 603             i += 1;
 604         }
 605     }
 606     assert_eq!(it.nth(1), Some(&5));
 607     assert_eq!(it.nth(0), None);
 608
 609     let xs = [0, 1, 2, 3, 4];
 610     let mut it = xs.iter().take(7);
 611     let mut i = 1;
 612     while let Some(&x) = it.nth(1) {
 613         assert_eq!(x, i);
 614         i += 2;
 615     }
 616 }
 617
 618 #[test]
 619 fn test_iterator_take_short() {
 620     let xs = [0, 1, 2, 3];
 621     let ys = [0, 1, 2, 3];
 622     let mut it = xs.iter().take(5);
 623     let mut i = 0;
 624     assert_eq!(it.len(), 4);
 625     while let Some(&x) = it.next() {
 626         assert_eq!(x, ys[i]);
 627         i += 1;
 628         assert_eq!(it.len(), 4-i);
 629     }
 630     assert_eq!(i, ys.len());
 631     assert_eq!(it.len(), 0);
 632 }
 633
 634 #[test]
 635 fn test_iterator_scan() {
 636     // test the type inference
 637     fn add(old: &mut isize, new: &usize) -> Option<f64> {
 638         *old += *new as isize;
 639         Some(*old as f64)
 640     }
 641     let xs = [0, 1, 2, 3, 4];
 642     let ys = [0f64, 1.0, 3.0, 6.0, 10.0];
 643
 644     let it = xs.iter().scan(0, add);
 645     let mut i = 0;
 646     for x in it {
 647         assert_eq!(x, ys[i]);
 648         i += 1;
 649     }
 650     assert_eq!(i, ys.len());
 651 }
 652
 653 #[test]
 654 fn test_iterator_flat_map() {
 655     let xs = [0, 3, 6];
 656     let ys = [0, 1, 2, 3, 4, 5, 6, 7, 8];
 657     let it = xs.iter().flat_map(|&x| (x..).iter_step_by(1).take(3));
 658     let mut i = 0;
 659     for x in it {
 660         assert_eq!(x, ys[i]);
 661         i += 1;
 662     }
 663     assert_eq!(i, ys.len());
 664 }
 665
 666 #[test]
 667 fn test_inspect() {
 668     let xs = [1, 2, 3, 4];
 669     let mut n = 0;
 670
 671     let ys = xs.iter()
 672                .cloned()
 673                .inspect(|_| n += 1)
 674                .collect::<Vec<usize>>();
 675
 676     assert_eq!(n, xs.len());
 677     assert_eq!(&xs[..], &ys[..]);
 678 }
 679
 680 #[test]
 681 fn test_cycle() {
 682     let cycle_len = 3;
 683     let it = (0..).iter_step_by(1).take(cycle_len).cycle();
 684     assert_eq!(it.size_hint(), (usize::MAX, None));
 685     for (i, x) in it.take(100).enumerate() {
 686         assert_eq!(i % cycle_len, x);
 687     }
 688
 689     let mut it = (0..).iter_step_by(1).take(0).cycle();
 690     assert_eq!(it.size_hint(), (0, Some(0)));
 691     assert_eq!(it.next(), None);
 692 }
 693
 694 #[test]
 695 fn test_iterator_nth() {
 696     let v: &[_] = &[0, 1, 2, 3, 4];
 697     for i in 0..v.len() {
 698         assert_eq!(v.iter().nth(i).unwrap(), &v[i]);
 699     }
 700     assert_eq!(v.iter().nth(v.len()), None);
 701 }
 702
 703 #[test]
 704 fn test_iterator_last() {
 705     let v: &[_] = &[0, 1, 2, 3, 4];
 706     assert_eq!(v.iter().last().unwrap(), &4);
 707     assert_eq!(v[..1].iter().last().unwrap(), &0);
 708 }
 709
 710 #[test]
 711 fn test_iterator_len() {
 712     let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 713     assert_eq!(v[..4].iter().count(), 4);
 714     assert_eq!(v[..10].iter().count(), 10);
 715     assert_eq!(v[..0].iter().count(), 0);
 716 }
 717
 718 #[test]
 719 fn test_iterator_sum() {
 720     let v: &[i32] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 721     assert_eq!(v[..4].iter().cloned().sum::<i32>(), 6);
 722     assert_eq!(v.iter().cloned().sum::<i32>(), 55);
 723     assert_eq!(v[..0].iter().cloned().sum::<i32>(), 0);
 724 }
 725
 726 #[test]
 727 fn test_iterator_sum_result() {
 728     let v: &[Result<i32, ()>] = &[Ok(1), Ok(2), Ok(3), Ok(4)];
 729     assert_eq!(v.iter().cloned().sum::<Result<i32, _>>(), Ok(10));
 730     let v: &[Result<i32, ()>] = &[Ok(1), Err(()), Ok(3), Ok(4)];
 731     assert_eq!(v.iter().cloned().sum::<Result<i32, _>>(), Err(()));
 732 }
 733
 734 #[test]
 735 fn test_iterator_product() {
 736     let v: &[i32] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 737     assert_eq!(v[..4].iter().cloned().product::<i32>(), 0);
 738     assert_eq!(v[1..5].iter().cloned().product::<i32>(), 24);
 739     assert_eq!(v[..0].iter().cloned().product::<i32>(), 1);
 740 }
 741
 742 #[test]
 743 fn test_iterator_product_result() {
 744     let v: &[Result<i32, ()>] = &[Ok(1), Ok(2), Ok(3), Ok(4)];
 745     assert_eq!(v.iter().cloned().product::<Result<i32, _>>(), Ok(24));
 746     let v: &[Result<i32, ()>] = &[Ok(1), Err(()), Ok(3), Ok(4)];
 747     assert_eq!(v.iter().cloned().product::<Result<i32, _>>(), Err(()));
 748 }
 749
 750 #[test]
 751 fn test_iterator_max() {
 752     let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 753     assert_eq!(v[..4].iter().cloned().max(), Some(3));
 754     assert_eq!(v.iter().cloned().max(), Some(10));
 755     assert_eq!(v[..0].iter().cloned().max(), None);
 756 }
 757
 758 #[test]
 759 fn test_iterator_min() {
 760     let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 761     assert_eq!(v[..4].iter().cloned().min(), Some(0));
 762     assert_eq!(v.iter().cloned().min(), Some(0));
 763     assert_eq!(v[..0].iter().cloned().min(), None);
 764 }
 765
 766 #[test]
 767 fn test_iterator_size_hint() {
 768     let c = (0..).iter_step_by(1);
 769     let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
 770     let v2 = &[10, 11, 12];
 771     let vi = v.iter();
 772
 773     assert_eq!((0..).size_hint(), (usize::MAX, None));
 774     assert_eq!(c.size_hint(), (usize::MAX, None));
 775     assert_eq!(vi.clone().size_hint(), (10, Some(10)));
 776
 777     assert_eq!(c.clone().take(5).size_hint(), (5, Some(5)));
 778     assert_eq!(c.clone().skip(5).size_hint().1, None);
 779     assert_eq!(c.clone().take_while(|_| false).size_hint(), (0, None));
 780     assert_eq!(c.clone().skip_while(|_| false).size_hint(), (0, None));
 781     assert_eq!(c.clone().enumerate().size_hint(), (usize::MAX, None));
 782     assert_eq!(c.clone().chain(vi.clone().cloned()).size_hint(), (usize::MAX, None));
 783     assert_eq!(c.clone().zip(vi.clone()).size_hint(), (10, Some(10)));
 784     assert_eq!(c.clone().scan(0, |_,_| Some(0)).size_hint(), (0, None));
 785     assert_eq!(c.clone().filter(|_| false).size_hint(), (0, None));
 786     assert_eq!(c.clone().map(|_| 0).size_hint(), (usize::MAX, None));
 787     assert_eq!(c.filter_map(|_| Some(0)).size_hint(), (0, None));
 788
 789     assert_eq!(vi.clone().take(5).size_hint(), (5, Some(5)));
 790     assert_eq!(vi.clone().take(12).size_hint(), (10, Some(10)));
 791     assert_eq!(vi.clone().skip(3).size_hint(), (7, Some(7)));
 792     assert_eq!(vi.clone().skip(12).size_hint(), (0, Some(0)));
 793     assert_eq!(vi.clone().take_while(|_| false).size_hint(), (0, Some(10)));
 794     assert_eq!(vi.clone().skip_while(|_| false).size_hint(), (0, Some(10)));
 795     assert_eq!(vi.clone().enumerate().size_hint(), (10, Some(10)));
 796     assert_eq!(vi.clone().chain(v2).size_hint(), (13, Some(13)));
 797     assert_eq!(vi.clone().zip(v2).size_hint(), (3, Some(3)));
 798     assert_eq!(vi.clone().scan(0, |_,_| Some(0)).size_hint(), (0, Some(10)));
 799     assert_eq!(vi.clone().filter(|_| false).size_hint(), (0, Some(10)));
 800     assert_eq!(vi.clone().map(|&i| i+1).size_hint(), (10, Some(10)));
 801     assert_eq!(vi.filter_map(|_| Some(0)).size_hint(), (0, Some(10)));
 802 }
 803
 804 #[test]
 805 fn test_collect() {
 806     let a = vec![1, 2, 3, 4, 5];
 807     let b: Vec<isize> = a.iter().cloned().collect();
 808     assert!(a == b);
 809 }
 810
 811 #[test]
 812 fn test_all() {
 813     let v: Box<[isize]> = Box::new([1, 2, 3, 4, 5]);
 814     assert!(v.iter().all(|&x| x < 10));
 815     assert!(!v.iter().all(|&x| x % 2 == 0));
 816     assert!(!v.iter().all(|&x| x > 100));
 817     assert!(v[..0].iter().all(|_| panic!()));
 818 }
 819
 820 #[test]
 821 fn test_any() {
 822     let v: Box<[isize]> = Box::new([1, 2, 3, 4, 5]);
 823     assert!(v.iter().any(|&x| x < 10));
 824     assert!(v.iter().any(|&x| x % 2 == 0));
 825     assert!(!v.iter().any(|&x| x > 100));
 826     assert!(!v[..0].iter().any(|_| panic!()));
 827 }
 828
 829 #[test]
 830 fn test_find() {
 831     let v: &[isize] = &[1, 3, 9, 27, 103, 14, 11];
 832     assert_eq!(*v.iter().find(|&&x| x & 1 == 0).unwrap(), 14);
 833     assert_eq!(*v.iter().find(|&&x| x % 3 == 0).unwrap(), 3);
 834     assert!(v.iter().find(|&&x| x % 12 == 0).is_none());
 835 }
 836
 837 #[test]
 838 fn test_position() {
 839     let v = &[1, 3, 9, 27, 103, 14, 11];
 840     assert_eq!(v.iter().position(|x| *x & 1 == 0).unwrap(), 5);
 841     assert_eq!(v.iter().position(|x| *x % 3 == 0).unwrap(), 1);
 842     assert!(v.iter().position(|x| *x % 12 == 0).is_none());
 843 }
 844
 845 #[test]
 846 fn test_count() {
 847     let xs = &[1, 2, 2, 1, 5, 9, 0, 2];
 848     assert_eq!(xs.iter().filter(|x| **x == 2).count(), 3);
 849     assert_eq!(xs.iter().filter(|x| **x == 5).count(), 1);
 850     assert_eq!(xs.iter().filter(|x| **x == 95).count(), 0);
 851 }
 852
 853 #[test]
 854 fn test_max_by_key() {
 855     let xs: &[isize] = &[-3, 0, 1, 5, -10];
 856     assert_eq!(*xs.iter().max_by_key(|x| x.abs()).unwrap(), -10);
 857 }
 858
 859 #[test]
 860 fn test_max_by() {
 861     let xs: &[isize] = &[-3, 0, 1, 5, -10];
 862     assert_eq!(*xs.iter().max_by(|x, y| x.abs().cmp(&y.abs())).unwrap(), -10);
 863 }
 864
 865 #[test]
 866 fn test_min_by_key() {
 867     let xs: &[isize] = &[-3, 0, 1, 5, -10];
 868     assert_eq!(*xs.iter().min_by_key(|x| x.abs()).unwrap(), 0);
 869 }
 870
 871 #[test]
 872 fn test_min_by() {
 873     let xs: &[isize] = &[-3, 0, 1, 5, -10];
 874     assert_eq!(*xs.iter().min_by(|x, y| x.abs().cmp(&y.abs())).unwrap(), 0);
 875 }
 876
 877 #[test]
 878 fn test_by_ref() {
 879     let mut xs = 0..10;
 880     // sum the first five values
 881     let partial_sum = xs.by_ref().take(5).fold(0, |a, b| a + b);
 882     assert_eq!(partial_sum, 10);
 883     assert_eq!(xs.next(), Some(5));
 884 }
 885
 886 #[test]
 887 fn test_rev() {
 888     let xs = [2, 4, 6, 8, 10, 12, 14, 16];
 889     let mut it = xs.iter();
 890     it.next();
 891     it.next();
 892     assert!(it.rev().cloned().collect::<Vec<isize>>() ==
 893             vec![16, 14, 12, 10, 8, 6]);
 894 }
 895
 896 #[test]
 897 fn test_cloned() {
 898     let xs = [2, 4, 6, 8];
 899
 900     let mut it = xs.iter().cloned();
 901     assert_eq!(it.len(), 4);
 902     assert_eq!(it.next(), Some(2));
 903     assert_eq!(it.len(), 3);
 904     assert_eq!(it.next(), Some(4));
 905     assert_eq!(it.len(), 2);
 906     assert_eq!(it.next_back(), Some(8));
 907     assert_eq!(it.len(), 1);
 908     assert_eq!(it.next_back(), Some(6));
 909     assert_eq!(it.len(), 0);
 910     assert_eq!(it.next_back(), None);
 911 }
 912
 913 #[test]
 914 fn test_double_ended_map() {
 915     let xs = [1, 2, 3, 4, 5, 6];
 916     let mut it = xs.iter().map(|&x| x * -1);
 917     assert_eq!(it.next(), Some(-1));
 918     assert_eq!(it.next(), Some(-2));
 919     assert_eq!(it.next_back(), Some(-6));
 920     assert_eq!(it.next_back(), Some(-5));
 921     assert_eq!(it.next(), Some(-3));
 922     assert_eq!(it.next_back(), Some(-4));
 923     assert_eq!(it.next(), None);
 924 }
 925
 926 #[test]
 927 fn test_double_ended_enumerate() {
 928     let xs = [1, 2, 3, 4, 5, 6];
 929     let mut it = xs.iter().cloned().enumerate();
 930     assert_eq!(it.next(), Some((0, 1)));
 931     assert_eq!(it.next(), Some((1, 2)));
 932     assert_eq!(it.next_back(), Some((5, 6)));
 933     assert_eq!(it.next_back(), Some((4, 5)));
 934     assert_eq!(it.next_back(), Some((3, 4)));
 935     assert_eq!(it.next_back(), Some((2, 3)));
 936     assert_eq!(it.next(), None);
 937 }
 938
 939 #[test]
 940 fn test_double_ended_zip() {
 941     let xs = [1, 2, 3, 4, 5, 6];
 942     let ys = [1, 2, 3, 7];
 943     let a = xs.iter().cloned();
 944     let b = ys.iter().cloned();
 945     let mut it = a.zip(b);
 946     assert_eq!(it.next(), Some((1, 1)));
 947     assert_eq!(it.next(), Some((2, 2)));
 948     assert_eq!(it.next_back(), Some((4, 7)));
 949     assert_eq!(it.next_back(), Some((3, 3)));
 950     assert_eq!(it.next(), None);
 951 }
 952
 953 #[test]
 954 fn test_double_ended_filter() {
 955     let xs = [1, 2, 3, 4, 5, 6];
 956     let mut it = xs.iter().filter(|&x| *x & 1 == 0);
 957     assert_eq!(it.next_back().unwrap(), &6);
 958     assert_eq!(it.next_back().unwrap(), &4);
 959     assert_eq!(it.next().unwrap(), &2);
 960     assert_eq!(it.next_back(), None);
 961 }
 962
 963 #[test]
 964 fn test_double_ended_filter_map() {
 965     let xs = [1, 2, 3, 4, 5, 6];
 966     let mut it = xs.iter().filter_map(|&x| if x & 1 == 0 { Some(x * 2) } else { None });
 967     assert_eq!(it.next_back().unwrap(), 12);
 968     assert_eq!(it.next_back().unwrap(), 8);
 969     assert_eq!(it.next().unwrap(), 4);
 970     assert_eq!(it.next_back(), None);
 971 }
 972
 973 #[test]
 974 fn test_double_ended_chain() {
 975     let xs = [1, 2, 3, 4, 5];
 976     let ys = [7, 9, 11];
 977     let mut it = xs.iter().chain(&ys).rev();
 978     assert_eq!(it.next().unwrap(), &11);
 979     assert_eq!(it.next().unwrap(), &9);
 980     assert_eq!(it.next_back().unwrap(), &1);
 981     assert_eq!(it.next_back().unwrap(), &2);
 982     assert_eq!(it.next_back().unwrap(), &3);
 983     assert_eq!(it.next_back().unwrap(), &4);
 984     assert_eq!(it.next_back().unwrap(), &5);
 985     assert_eq!(it.next_back().unwrap(), &7);
 986     assert_eq!(it.next_back(), None);
 987
 988
 989     // test that .chain() is well behaved with an unfused iterator
 990     struct CrazyIterator(bool);
 991     impl CrazyIterator { fn new() -> CrazyIterator { CrazyIterator(false) } }
 992     impl Iterator for CrazyIterator {
 993         type Item = i32;
 994         fn next(&mut self) -> Option<i32> {
 995             if self.0 { Some(99) } else { self.0 = true; None }
 996         }
 997     }
 998
 999     impl DoubleEndedIterator for CrazyIterator {
1000         fn next_back(&mut self) -> Option<i32> {
1001             self.next()
1002         }
1003     }
1004
1005     assert_eq!(CrazyIterator::new().chain(0..10).rev().last(), Some(0));
1006     assert!((0..10).chain(CrazyIterator::new()).rev().any(|i| i == 0));
1007 }
1008
1009 #[test]
1010 fn test_rposition() {
1011     fn f(xy: &(isize, char)) -> bool { let (_x, y) = *xy; y == 'b' }
1012     fn g(xy: &(isize, char)) -> bool { let (_x, y) = *xy; y == 'd' }
1013     let v = [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
1014
1015     assert_eq!(v.iter().rposition(f), Some(3));
1016     assert!(v.iter().rposition(g).is_none());
1017 }
1018
1019 #[test]
1020 #[should_panic]
1021 fn test_rposition_panic() {
1022     let v: [(Box<_>, Box<_>); 4] =
1023         [(box 0, box 0), (box 0, box 0),
1024          (box 0, box 0), (box 0, box 0)];
1025     let mut i = 0;
1026     v.iter().rposition(|_elt| {
1027         if i == 2 {
1028             panic!()
1029         }
1030         i += 1;
1031         false
1032     });
1033 }
1034
1035
1036 #[test]
1037 fn test_double_ended_flat_map() {
1038     let u = [0,1];
1039     let v = [5,6,7,8];
1040     let mut it = u.iter().flat_map(|x| &v[*x..v.len()]);
1041     assert_eq!(it.next_back().unwrap(), &8);
1042     assert_eq!(it.next().unwrap(),      &5);
1043     assert_eq!(it.next_back().unwrap(), &7);
1044     assert_eq!(it.next_back().unwrap(), &6);
1045     assert_eq!(it.next_back().unwrap(), &8);
1046     assert_eq!(it.next().unwrap(),      &6);
1047     assert_eq!(it.next_back().unwrap(), &7);
1048     assert_eq!(it.next_back(), None);
1049     assert_eq!(it.next(),      None);
1050     assert_eq!(it.next_back(), None);
1051 }
1052
1053 #[test]
1054 fn test_double_ended_range() {
1055     assert_eq!((11..14).rev().collect::<Vec<_>>(), [13, 12, 11]);
1056     for _ in (10..0).rev() {
1057         panic!("unreachable");
1058     }
1059
1060     assert_eq!((11..14).rev().collect::<Vec<_>>(), [13, 12, 11]);
1061     for _ in (10..0).rev() {
1062         panic!("unreachable");
1063     }
1064 }
1065
1066 #[test]
1067 fn test_range() {
1068     assert_eq!((0..5).collect::<Vec<_>>(), [0, 1, 2, 3, 4]);
1069     assert_eq!((-10..-1).collect::<Vec<_>>(), [-10, -9, -8, -7, -6, -5, -4, -3, -2]);
1070     assert_eq!((0..5).rev().collect::<Vec<_>>(), [4, 3, 2, 1, 0]);
1071     assert_eq!((200..-5).count(), 0);
1072     assert_eq!((200..-5).rev().count(), 0);
1073     assert_eq!((200..200).count(), 0);
1074     assert_eq!((200..200).rev().count(), 0);
1075
1076     assert_eq!((0..100).size_hint(), (100, Some(100)));
1077     // this test is only meaningful when sizeof usize < sizeof u64
1078     assert_eq!((usize::MAX - 1..usize::MAX).size_hint(), (1, Some(1)));
1079     assert_eq!((-10..-1).size_hint(), (9, Some(9)));
1080     assert_eq!((-1..-10).size_hint(), (0, Some(0)));
1081
1082     assert_eq!((-70..58).size_hint(), (128, Some(128)));
1083     assert_eq!((-128..127).size_hint(), (255, Some(255)));
1084     assert_eq!((-2..isize::MAX).size_hint(),
1085                (isize::MAX as usize + 2, Some(isize::MAX as usize + 2)));
1086 }
1087
1088 #[test]
1089 fn test_range_step() {
1090     #![allow(deprecated)]
1091
1092     assert_eq!((0..20).step_by(5).collect::<Vec<isize>>(), [0, 5, 10, 15]);
1093     assert_eq!((20..0).step_by(-5).collect::<Vec<isize>>(), [20, 15, 10, 5]);
1094     assert_eq!((20..0).step_by(-6).collect::<Vec<isize>>(), [20, 14, 8, 2]);
1095     assert_eq!((200..255).step_by(50).collect::<Vec<u8>>(), [200, 250]);
1096     assert_eq!((200..-5).step_by(1).collect::<Vec<isize>>(), []);
1097     assert_eq!((200..200).step_by(1).collect::<Vec<isize>>(), []);
1098
1099     assert_eq!((0..20).step_by(1).size_hint(), (20, Some(20)));
1100     assert_eq!((0..20).step_by(21).size_hint(), (1, Some(1)));
1101     assert_eq!((0..20).step_by(5).size_hint(), (4, Some(4)));
1102     assert_eq!((20..0).step_by(-5).size_hint(), (4, Some(4)));
1103     assert_eq!((20..0).step_by(-6).size_hint(), (4, Some(4)));
1104     assert_eq!((20..-5).step_by(1).size_hint(), (0, Some(0)));
1105     assert_eq!((20..20).step_by(1).size_hint(), (0, Some(0)));
1106     assert_eq!((0..1).step_by(0).size_hint(), (0, None));
1107     assert_eq!((i8::MAX..i8::MIN).step_by(i8::MIN).size_hint(), (2, Some(2)));
1108     assert_eq!((i16::MIN..i16::MAX).step_by(i16::MAX).size_hint(), (3, Some(3)));
1109     assert_eq!((isize::MIN..isize::MAX).step_by(1).size_hint(), (usize::MAX, Some(usize::MAX)));
1110 }
1111
1112 #[test]
1113 fn test_repeat() {
1114     let mut it = repeat(42);
1115     assert_eq!(it.next(), Some(42));
1116     assert_eq!(it.next(), Some(42));
1117     assert_eq!(it.next(), Some(42));
1118 }
1119
1120 #[test]
1121 fn test_fuse() {
1122     let mut it = 0..3;
1123     assert_eq!(it.len(), 3);
1124     assert_eq!(it.next(), Some(0));
1125     assert_eq!(it.len(), 2);
1126     assert_eq!(it.next(), Some(1));
1127     assert_eq!(it.len(), 1);
1128     assert_eq!(it.next(), Some(2));
1129     assert_eq!(it.len(), 0);
1130     assert_eq!(it.next(), None);
1131     assert_eq!(it.len(), 0);
1132     assert_eq!(it.next(), None);
1133     assert_eq!(it.len(), 0);
1134     assert_eq!(it.next(), None);
1135     assert_eq!(it.len(), 0);
1136 }
1137
1138 #[test]
1139 fn test_fuse_nth() {
1140     let xs = [0, 1, 2];
1141     let mut it = xs.iter();
1142
1143     assert_eq!(it.len(), 3);
1144     assert_eq!(it.nth(2), Some(&2));
1145     assert_eq!(it.len(), 0);
1146     assert_eq!(it.nth(2), None);
1147     assert_eq!(it.len(), 0);
1148 }
1149
1150 #[test]
1151 fn test_fuse_last() {
1152     let xs = [0, 1, 2];
1153     let it = xs.iter();
1154
1155     assert_eq!(it.len(), 3);
1156     assert_eq!(it.last(), Some(&2));
1157 }
1158
1159 #[test]
1160 fn test_fuse_count() {
1161     let xs = [0, 1, 2];
1162     let it = xs.iter();
1163
1164     assert_eq!(it.len(), 3);
1165     assert_eq!(it.count(), 3);
1166     // Can't check len now because count consumes.
1167 }
1168
1169 #[test]
1170 fn test_once() {
1171     let mut it = once(42);
1172     assert_eq!(it.next(), Some(42));
1173     assert_eq!(it.next(), None);
1174 }
1175
1176 #[test]
1177 fn test_empty() {
1178     let mut it = empty::<i32>();
1179     assert_eq!(it.next(), None);
1180 }
1181
1182 #[test]
1183 fn test_chain_fold() {
1184     let xs = [1, 2, 3];
1185     let ys = [1, 2, 0];
1186
1187     let mut iter = xs.iter().chain(&ys);
1188     iter.next();
1189     let mut result = Vec::new();
1190     iter.fold((), |(), &elt| result.push(elt));
1191     assert_eq!(&[2, 3, 1, 2, 0], &result[..]);
1192 }
1193
1194 #[test]
1195 fn test_step_replace_unsigned() {
1196     let mut x = 4u32;
1197     let y = x.replace_zero();
1198     assert_eq!(x, 0);
1199     assert_eq!(y, 4);
1200
1201     x = 5;
1202     let y = x.replace_one();
1203     assert_eq!(x, 1);
1204     assert_eq!(y, 5);
1205 }
1206
1207 #[test]
1208 fn test_step_replace_signed() {
1209     let mut x = 4i32;
1210     let y = x.replace_zero();
1211     assert_eq!(x, 0);
1212     assert_eq!(y, 4);
1213
1214     x = 5;
1215     let y = x.replace_one();
1216     assert_eq!(x, 1);
1217     assert_eq!(y, 5);
1218 }
1219
1220 #[test]
1221 fn test_step_replace_no_between() {
1222     let mut x = 4u128;
1223     let y = x.replace_zero();
1224     assert_eq!(x, 0);
1225     assert_eq!(y, 4);
1226
1227     x = 5;
1228     let y = x.replace_one();
1229     assert_eq!(x, 1);
1230     assert_eq!(y, 5);
1231 }