src/libcoretest/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::iter::order::*;
  13 use core::{i8, i16, isize};
  14 use core::usize;
  15
  16 use test::Bencher;
  17
  18 #[test]
  19 fn test_lt() {
  20     let empty: [isize; 0] = [];
  21     let xs = [1,2,3];
  22     let ys = [1,2,0];
  23
  24     assert!(!lt(xs.iter(), ys.iter()));
  25     assert!(!le(xs.iter(), ys.iter()));
  26     assert!( gt(xs.iter(), ys.iter()));
  27     assert!( ge(xs.iter(), ys.iter()));
  28
  29     assert!( lt(ys.iter(), xs.iter()));
  30     assert!( le(ys.iter(), xs.iter()));
  31     assert!(!gt(ys.iter(), xs.iter()));
  32     assert!(!ge(ys.iter(), xs.iter()));
  33
  34     assert!( lt(empty.iter(), xs.iter()));
  35     assert!( le(empty.iter(), xs.iter()));
  36     assert!(!gt(empty.iter(), xs.iter()));
  37     assert!(!ge(empty.iter(), xs.iter()));
  38
  39     // Sequence with NaN
  40     let u = [1.0f64, 2.0];
  41     let v = [0.0f64/0.0, 3.0];
  42
  43     assert!(!lt(u.iter(), v.iter()));
  44     assert!(!le(u.iter(), v.iter()));
  45     assert!(!gt(u.iter(), v.iter()));
  46     assert!(!ge(u.iter(), v.iter()));
  47
  48     let a = [0.0f64/0.0];
  49     let b = [1.0f64];
  50     let c = [2.0f64];
  51
  52     assert!(lt(a.iter(), b.iter()) == (a[0] <  b[0]));
  53     assert!(le(a.iter(), b.iter()) == (a[0] <= b[0]));
  54     assert!(gt(a.iter(), b.iter()) == (a[0] >  b[0]));
  55     assert!(ge(a.iter(), b.iter()) == (a[0] >= b[0]));
  56
  57     assert!(lt(c.iter(), b.iter()) == (c[0] <  b[0]));
  58     assert!(le(c.iter(), b.iter()) == (c[0] <= b[0]));
  59     assert!(gt(c.iter(), b.iter()) == (c[0] >  b[0]));
  60     assert!(ge(c.iter(), b.iter()) == (c[0] >= b[0]));
  61 }
  62
  63 #[test]
  64 fn test_multi_iter() {
  65     let xs = [1,2,3,4];
  66     let ys = [4,3,2,1];
  67     assert!(eq(xs.iter(), ys.iter().rev()));
  68     assert!(lt(xs.iter(), xs.iter().skip(2)));
  69 }
  70
  71 #[test]
  72 fn test_counter_from_iter() {
  73     let it = (0..).step_by(5).take(10);
  74     let xs: Vec<isize> = FromIterator::from_iter(it);
  75     assert_eq!(xs, [0, 5, 10, 15, 20, 25, 30, 35, 40, 45]);
  76 }
  77
  78 #[test]
  79 fn test_iterator_chain() {
  80     let xs = [0, 1, 2, 3, 4, 5];
  81     let ys = [30, 40, 50, 60];
  82     let expected = [0, 1, 2, 3, 4, 5, 30, 40, 50, 60];
  83     let it = xs.iter().chain(&ys);
  84     let mut i = 0;
  85     for &x in it {
  86         assert_eq!(x, expected[i]);
  87         i += 1;
  88     }
  89     assert_eq!(i, expected.len());
  90
  91     let ys = (30..).step_by(10).take(4);
  92     let it = xs.iter().cloned().chain(ys);
  93     let mut i = 0;
  94     for x in it {
  95         assert_eq!(x, expected[i]);
  96         i += 1;
  97     }
  98     assert_eq!(i, expected.len());
  99 }
 100
 101 #[test]
 102 fn test_iterator_chain_nth() {
 103     let xs = [0, 1, 2, 3, 4, 5];
 104     let ys = [30, 40, 50, 60];
 105     let zs = [];
 106     let expected = [0, 1, 2, 3, 4, 5, 30, 40, 50, 60];
 107     for (i, x) in expected.iter().enumerate() {
 108         assert_eq!(Some(x), xs.iter().chain(&ys).nth(i));
 109     }
 110     assert_eq!(zs.iter().chain(&xs).nth(0), Some(&0));
 111
 112     let mut it = xs.iter().chain(&zs);
 113     assert_eq!(it.nth(5), Some(&5));
 114     assert_eq!(it.next(), None);
 115 }
 116
 117 #[test]
 118 fn test_iterator_chain_last() {
 119     let xs = [0, 1, 2, 3, 4, 5];
 120     let ys = [30, 40, 50, 60];
 121     let zs = [];
 122     assert_eq!(xs.iter().chain(&ys).last(), Some(&60));
 123     assert_eq!(zs.iter().chain(&ys).last(), Some(&60));
 124     assert_eq!(ys.iter().chain(&zs).last(), Some(&60));
 125     assert_eq!(zs.iter().chain(&zs).last(), None);
 126 }
 127
 128 #[test]
 129 fn test_iterator_chain_count() {
 130     let xs = [0, 1, 2, 3, 4, 5];
 131     let ys = [30, 40, 50, 60];
 132     let zs = [];
 133     assert_eq!(xs.iter().chain(&ys).count(), 10);
 134     assert_eq!(zs.iter().chain(&ys).count(), 4);
 135 }
 136
 137 #[test]
 138 fn test_filter_map() {
 139     let it = (0..).step_by(1).take(10)
 140         .filter_map(|x| if x % 2 == 0 { Some(x*x) } else { None });
 141     assert_eq!(it.collect::<Vec<usize>>(), [0*0, 2*2, 4*4, 6*6, 8*8]);
 142 }
 143
 144 #[test]
 145 fn test_iterator_enumerate() {
 146     let xs = [0, 1, 2, 3, 4, 5];
 147     let it = xs.iter().enumerate();
 148     for (i, &x) in it {
 149         assert_eq!(i, x);
 150     }
 151 }
 152
 153 #[test]
 154 fn test_iterator_enumerate_nth() {
 155     let xs = [0, 1, 2, 3, 4, 5];
 156     for (i, &x) in xs.iter().enumerate() {
 157         assert_eq!(i, x);
 158     }
 159
 160     let mut it = xs.iter().enumerate();
 161     while let Some((i, &x)) = it.nth(0) {
 162         assert_eq!(i, x);
 163     }
 164
 165     let mut it = xs.iter().enumerate();
 166     while let Some((i, &x)) = it.nth(1) {
 167         assert_eq!(i, x);
 168     }
 169
 170     let (i, &x) = xs.iter().enumerate().nth(3).unwrap();
 171     assert_eq!(i, x);
 172     assert_eq!(i, 3);
 173 }
 174
 175 #[test]
 176 fn test_iterator_enumerate_count() {
 177     let xs = [0, 1, 2, 3, 4, 5];
 178     assert_eq!(xs.iter().count(), 6);
 179 }
 180
 181 #[test]
 182 fn test_iterator_peekable() {
 183     let xs = vec![0, 1, 2, 3, 4, 5];
 184     let mut it = xs.iter().cloned().peekable();
 185
 186     assert_eq!(it.len(), 6);
 187     assert_eq!(it.peek().unwrap(), &0);
 188     assert_eq!(it.len(), 6);
 189     assert_eq!(it.next().unwrap(), 0);
 190     assert_eq!(it.len(), 5);
 191     assert_eq!(it.next().unwrap(), 1);
 192     assert_eq!(it.len(), 4);
 193     assert_eq!(it.next().unwrap(), 2);
 194     assert_eq!(it.len(), 3);
 195     assert_eq!(it.peek().unwrap(), &3);
 196     assert_eq!(it.len(), 3);
 197     assert_eq!(it.peek().unwrap(), &3);
 198     assert_eq!(it.len(), 3);
 199     assert_eq!(it.next().unwrap(), 3);
 200     assert_eq!(it.len(), 2);
 201     assert_eq!(it.next().unwrap(), 4);
 202     assert_eq!(it.len(), 1);
 203     assert_eq!(it.peek().unwrap(), &5);
 204     assert_eq!(it.len(), 1);
 205     assert_eq!(it.next().unwrap(), 5);
 206     assert_eq!(it.len(), 0);
 207     assert!(it.peek().is_none());
 208     assert_eq!(it.len(), 0);
 209     assert!(it.next().is_none());
 210     assert_eq!(it.len(), 0);
 211 }
 212
 213 #[test]
 214 fn test_iterator_peekable_count() {
 215     let xs = [0, 1, 2, 3, 4, 5];
 216     let ys = [10];
 217     let zs: [i32; 0] = [];
 218
 219     assert_eq!(xs.iter().peekable().count(), 6);
 220
 221     let mut it = xs.iter().peekable();
 222     assert_eq!(it.peek(), Some(&&0));
 223     assert_eq!(it.count(), 6);
 224
 225     assert_eq!(ys.iter().peekable().count(), 1);
 226
 227     let mut it = ys.iter().peekable();
 228     assert_eq!(it.peek(), Some(&&10));
 229     assert_eq!(it.count(), 1);
 230
 231     assert_eq!(zs.iter().peekable().count(), 0);
 232
 233     let mut it = zs.iter().peekable();
 234     assert_eq!(it.peek(), None);
 235
 236 }
 237
 238 #[test]
 239 fn test_iterator_peekable_nth() {
 240     let xs = [0, 1, 2, 3, 4, 5];
 241     let mut it = xs.iter().peekable();
 242
 243     assert_eq!(it.peek(), Some(&&0));
 244     assert_eq!(it.nth(0), Some(&0));
 245     assert_eq!(it.peek(), Some(&&1));
 246     assert_eq!(it.nth(1), Some(&2));
 247     assert_eq!(it.peek(), Some(&&3));
 248     assert_eq!(it.nth(2), Some(&5));
 249     assert_eq!(it.next(), None);
 250 }
 251
 252 #[test]
 253 fn test_iterator_peekable_last() {
 254     let xs = [0, 1, 2, 3, 4, 5];
 255     let ys = [0];
 256
 257     let mut it = xs.iter().peekable();
 258     assert_eq!(it.peek(), Some(&&0));
 259     assert_eq!(it.last(), Some(&5));
 260
 261     let mut it = ys.iter().peekable();
 262     assert_eq!(it.peek(), Some(&&0));
 263     assert_eq!(it.last(), Some(&0));
 264 }
 265
 266 #[test]
 267 fn test_iterator_take_while() {
 268     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19];
 269     let ys = [0, 1, 2, 3, 5, 13];
 270     let it = xs.iter().take_while(|&x| *x < 15);
 271     let mut i = 0;
 272     for x in it {
 273         assert_eq!(*x, ys[i]);
 274         i += 1;
 275     }
 276     assert_eq!(i, ys.len());
 277 }
 278
 279 #[test]
 280 fn test_iterator_skip_while() {
 281     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19];
 282     let ys = [15, 16, 17, 19];
 283     let it = xs.iter().skip_while(|&x| *x < 15);
 284     let mut i = 0;
 285     for x in it {
 286         assert_eq!(*x, ys[i]);
 287         i += 1;
 288     }
 289     assert_eq!(i, ys.len());
 290 }
 291
 292 #[test]
 293 fn test_iterator_skip() {
 294     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
 295     let ys = [13, 15, 16, 17, 19, 20, 30];
 296     let mut it = xs.iter().skip(5);
 297     let mut i = 0;
 298     while let Some(&x) = it.next() {
 299         assert_eq!(x, ys[i]);
 300         i += 1;
 301         assert_eq!(it.len(), xs.len()-5-i);
 302     }
 303     assert_eq!(i, ys.len());
 304     assert_eq!(it.len(), 0);
 305 }
 306
 307 #[test]
 308 fn test_iterator_skip_nth() {
 309     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
 310
 311     let mut it = xs.iter().skip(0);
 312     assert_eq!(it.nth(0), Some(&0));
 313     assert_eq!(it.nth(1), Some(&2));
 314
 315     let mut it = xs.iter().skip(5);
 316     assert_eq!(it.nth(0), Some(&13));
 317     assert_eq!(it.nth(1), Some(&16));
 318
 319     let mut it = xs.iter().skip(12);
 320     assert_eq!(it.nth(0), None);
 321
 322 }
 323
 324 #[test]
 325 fn test_iterator_skip_count() {
 326     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
 327
 328     assert_eq!(xs.iter().skip(0).count(), 12);
 329     assert_eq!(xs.iter().skip(1).count(), 11);
 330     assert_eq!(xs.iter().skip(11).count(), 1);
 331     assert_eq!(xs.iter().skip(12).count(), 0);
 332     assert_eq!(xs.iter().skip(13).count(), 0);
 333 }
 334
 335 #[test]
 336 fn test_iterator_skip_last() {
 337     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
 338
 339     assert_eq!(xs.iter().skip(0).last(), Some(&30));
 340     assert_eq!(xs.iter().skip(1).last(), Some(&30));
 341     assert_eq!(xs.iter().skip(11).last(), Some(&30));
 342     assert_eq!(xs.iter().skip(12).last(), None);
 343     assert_eq!(xs.iter().skip(13).last(), None);
 344
 345     let mut it = xs.iter().skip(5);
 346     assert_eq!(it.next(), Some(&13));
 347     assert_eq!(it.last(), Some(&30));
 348 }
 349
 350 #[test]
 351 fn test_iterator_take() {
 352     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19];
 353     let ys = [0, 1, 2, 3, 5];
 354     let mut it = xs.iter().take(5);
 355     let mut i = 0;
 356     assert_eq!(it.len(), 5);
 357     while let Some(&x) = it.next() {
 358         assert_eq!(x, ys[i]);
 359         i += 1;
 360         assert_eq!(it.len(), 5-i);
 361     }
 362     assert_eq!(i, ys.len());
 363     assert_eq!(it.len(), 0);
 364 }
 365
 366 #[test]
 367 fn test_iterator_take_nth() {
 368     let xs = [0, 1, 2, 4, 5];
 369     let mut it = xs.iter();
 370     {
 371         let mut take = it.by_ref().take(3);
 372         let mut i = 0;
 373         while let Some(&x) = take.nth(0) {
 374             assert_eq!(x, i);
 375             i += 1;
 376         }
 377     }
 378     assert_eq!(it.nth(1), Some(&5));
 379     assert_eq!(it.nth(0), None);
 380
 381     let xs = [0, 1, 2, 3, 4];
 382     let mut it = xs.iter().take(7);
 383     let mut i = 1;
 384     while let Some(&x) = it.nth(1) {
 385         assert_eq!(x, i);
 386         i += 2;
 387     }
 388 }
 389
 390 #[test]
 391 fn test_iterator_take_short() {
 392     let xs = [0, 1, 2, 3];
 393     let ys = [0, 1, 2, 3];
 394     let mut it = xs.iter().take(5);
 395     let mut i = 0;
 396     assert_eq!(it.len(), 4);
 397     while let Some(&x) = it.next() {
 398         assert_eq!(x, ys[i]);
 399         i += 1;
 400         assert_eq!(it.len(), 4-i);
 401     }
 402     assert_eq!(i, ys.len());
 403     assert_eq!(it.len(), 0);
 404 }
 405
 406 #[test]
 407 fn test_iterator_scan() {
 408     // test the type inference
 409     fn add(old: &mut isize, new: &usize) -> Option<f64> {
 410         *old += *new as isize;
 411         Some(*old as f64)
 412     }
 413     let xs = [0, 1, 2, 3, 4];
 414     let ys = [0f64, 1.0, 3.0, 6.0, 10.0];
 415
 416     let it = xs.iter().scan(0, add);
 417     let mut i = 0;
 418     for x in it {
 419         assert_eq!(x, ys[i]);
 420         i += 1;
 421     }
 422     assert_eq!(i, ys.len());
 423 }
 424
 425 #[test]
 426 fn test_iterator_flat_map() {
 427     let xs = [0, 3, 6];
 428     let ys = [0, 1, 2, 3, 4, 5, 6, 7, 8];
 429     let it = xs.iter().flat_map(|&x| (x..).step_by(1).take(3));
 430     let mut i = 0;
 431     for x in it {
 432         assert_eq!(x, ys[i]);
 433         i += 1;
 434     }
 435     assert_eq!(i, ys.len());
 436 }
 437
 438 #[test]
 439 fn test_inspect() {
 440     let xs = [1, 2, 3, 4];
 441     let mut n = 0;
 442
 443     let ys = xs.iter()
 444                .cloned()
 445                .inspect(|_| n += 1)
 446                .collect::<Vec<usize>>();
 447
 448     assert_eq!(n, xs.len());
 449     assert_eq!(&xs[..], &ys[..]);
 450 }
 451
 452 #[test]
 453 fn test_cycle() {
 454     let cycle_len = 3;
 455     let it = (0..).step_by(1).take(cycle_len).cycle();
 456     assert_eq!(it.size_hint(), (usize::MAX, None));
 457     for (i, x) in it.take(100).enumerate() {
 458         assert_eq!(i % cycle_len, x);
 459     }
 460
 461     let mut it = (0..).step_by(1).take(0).cycle();
 462     assert_eq!(it.size_hint(), (0, Some(0)));
 463     assert_eq!(it.next(), None);
 464 }
 465
 466 #[test]
 467 fn test_iterator_nth() {
 468     let v: &[_] = &[0, 1, 2, 3, 4];
 469     for i in 0..v.len() {
 470         assert_eq!(v.iter().nth(i).unwrap(), &v[i]);
 471     }
 472     assert_eq!(v.iter().nth(v.len()), None);
 473 }
 474
 475 #[test]
 476 fn test_iterator_last() {
 477     let v: &[_] = &[0, 1, 2, 3, 4];
 478     assert_eq!(v.iter().last().unwrap(), &4);
 479     assert_eq!(v[..1].iter().last().unwrap(), &0);
 480 }
 481
 482 #[test]
 483 fn test_iterator_len() {
 484     let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 485     assert_eq!(v[..4].iter().count(), 4);
 486     assert_eq!(v[..10].iter().count(), 10);
 487     assert_eq!(v[..0].iter().count(), 0);
 488 }
 489
 490 #[test]
 491 fn test_iterator_sum() {
 492     let v: &[i32] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 493     assert_eq!(v[..4].iter().cloned().sum::<i32>(), 6);
 494     assert_eq!(v.iter().cloned().sum::<i32>(), 55);
 495     assert_eq!(v[..0].iter().cloned().sum::<i32>(), 0);
 496 }
 497
 498 #[test]
 499 fn test_iterator_product() {
 500     let v: &[i32] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 501     assert_eq!(v[..4].iter().cloned().product::<i32>(), 0);
 502     assert_eq!(v[1..5].iter().cloned().product::<i32>(), 24);
 503     assert_eq!(v[..0].iter().cloned().product::<i32>(), 1);
 504 }
 505
 506 #[test]
 507 fn test_iterator_max() {
 508     let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 509     assert_eq!(v[..4].iter().cloned().max(), Some(3));
 510     assert_eq!(v.iter().cloned().max(), Some(10));
 511     assert_eq!(v[..0].iter().cloned().max(), None);
 512 }
 513
 514 #[test]
 515 fn test_iterator_min() {
 516     let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 517     assert_eq!(v[..4].iter().cloned().min(), Some(0));
 518     assert_eq!(v.iter().cloned().min(), Some(0));
 519     assert_eq!(v[..0].iter().cloned().min(), None);
 520 }
 521
 522 #[test]
 523 fn test_iterator_size_hint() {
 524     let c = (0..).step_by(1);
 525     let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
 526     let v2 = &[10, 11, 12];
 527     let vi = v.iter();
 528
 529     assert_eq!(c.size_hint(), (usize::MAX, None));
 530     assert_eq!(vi.clone().size_hint(), (10, Some(10)));
 531
 532     assert_eq!(c.clone().take(5).size_hint(), (5, Some(5)));
 533     assert_eq!(c.clone().skip(5).size_hint().1, None);
 534     assert_eq!(c.clone().take_while(|_| false).size_hint(), (0, None));
 535     assert_eq!(c.clone().skip_while(|_| false).size_hint(), (0, None));
 536     assert_eq!(c.clone().enumerate().size_hint(), (usize::MAX, None));
 537     assert_eq!(c.clone().chain(vi.clone().cloned()).size_hint(), (usize::MAX, None));
 538     assert_eq!(c.clone().zip(vi.clone()).size_hint(), (10, Some(10)));
 539     assert_eq!(c.clone().scan(0, |_,_| Some(0)).size_hint(), (0, None));
 540     assert_eq!(c.clone().filter(|_| false).size_hint(), (0, None));
 541     assert_eq!(c.clone().map(|_| 0).size_hint(), (usize::MAX, None));
 542     assert_eq!(c.filter_map(|_| Some(0)).size_hint(), (0, None));
 543
 544     assert_eq!(vi.clone().take(5).size_hint(), (5, Some(5)));
 545     assert_eq!(vi.clone().take(12).size_hint(), (10, Some(10)));
 546     assert_eq!(vi.clone().skip(3).size_hint(), (7, Some(7)));
 547     assert_eq!(vi.clone().skip(12).size_hint(), (0, Some(0)));
 548     assert_eq!(vi.clone().take_while(|_| false).size_hint(), (0, Some(10)));
 549     assert_eq!(vi.clone().skip_while(|_| false).size_hint(), (0, Some(10)));
 550     assert_eq!(vi.clone().enumerate().size_hint(), (10, Some(10)));
 551     assert_eq!(vi.clone().chain(v2).size_hint(), (13, Some(13)));
 552     assert_eq!(vi.clone().zip(v2).size_hint(), (3, Some(3)));
 553     assert_eq!(vi.clone().scan(0, |_,_| Some(0)).size_hint(), (0, Some(10)));
 554     assert_eq!(vi.clone().filter(|_| false).size_hint(), (0, Some(10)));
 555     assert_eq!(vi.clone().map(|&i| i+1).size_hint(), (10, Some(10)));
 556     assert_eq!(vi.filter_map(|_| Some(0)).size_hint(), (0, Some(10)));
 557 }
 558
 559 #[test]
 560 fn test_collect() {
 561     let a = vec![1, 2, 3, 4, 5];
 562     let b: Vec<isize> = a.iter().cloned().collect();
 563     assert!(a == b);
 564 }
 565
 566 #[test]
 567 fn test_all() {
 568     // FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
 569     let v: Box<[isize]> = Box::new([1, 2, 3, 4, 5]);
 570     assert!(v.iter().all(|&x| x < 10));
 571     assert!(!v.iter().all(|&x| x % 2 == 0));
 572     assert!(!v.iter().all(|&x| x > 100));
 573     assert!(v[..0].iter().all(|_| panic!()));
 574 }
 575
 576 #[test]
 577 fn test_any() {
 578     // FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
 579     let v: Box<[isize]> = Box::new([1, 2, 3, 4, 5]);
 580     assert!(v.iter().any(|&x| x < 10));
 581     assert!(v.iter().any(|&x| x % 2 == 0));
 582     assert!(!v.iter().any(|&x| x > 100));
 583     assert!(!v[..0].iter().any(|_| panic!()));
 584 }
 585
 586 #[test]
 587 fn test_find() {
 588     let v: &[isize] = &[1, 3, 9, 27, 103, 14, 11];
 589     assert_eq!(*v.iter().find(|&&x| x & 1 == 0).unwrap(), 14);
 590     assert_eq!(*v.iter().find(|&&x| x % 3 == 0).unwrap(), 3);
 591     assert!(v.iter().find(|&&x| x % 12 == 0).is_none());
 592 }
 593
 594 #[test]
 595 fn test_position() {
 596     let v = &[1, 3, 9, 27, 103, 14, 11];
 597     assert_eq!(v.iter().position(|x| *x & 1 == 0).unwrap(), 5);
 598     assert_eq!(v.iter().position(|x| *x % 3 == 0).unwrap(), 1);
 599     assert!(v.iter().position(|x| *x % 12 == 0).is_none());
 600 }
 601
 602 #[test]
 603 fn test_count() {
 604     let xs = &[1, 2, 2, 1, 5, 9, 0, 2];
 605     assert_eq!(xs.iter().filter(|x| **x == 2).count(), 3);
 606     assert_eq!(xs.iter().filter(|x| **x == 5).count(), 1);
 607     assert_eq!(xs.iter().filter(|x| **x == 95).count(), 0);
 608 }
 609
 610 #[test]
 611 fn test_max_by() {
 612     let xs: &[isize] = &[-3, 0, 1, 5, -10];
 613     assert_eq!(*xs.iter().max_by(|x| x.abs()).unwrap(), -10);
 614 }
 615
 616 #[test]
 617 fn test_min_by() {
 618     let xs: &[isize] = &[-3, 0, 1, 5, -10];
 619     assert_eq!(*xs.iter().min_by(|x| x.abs()).unwrap(), 0);
 620 }
 621
 622 #[test]
 623 fn test_by_ref() {
 624     let mut xs = 0..10;
 625     // sum the first five values
 626     let partial_sum = xs.by_ref().take(5).fold(0, |a, b| a + b);
 627     assert_eq!(partial_sum, 10);
 628     assert_eq!(xs.next(), Some(5));
 629 }
 630
 631 #[test]
 632 fn test_rev() {
 633     let xs = [2, 4, 6, 8, 10, 12, 14, 16];
 634     let mut it = xs.iter();
 635     it.next();
 636     it.next();
 637     assert!(it.rev().cloned().collect::<Vec<isize>>() ==
 638             vec![16, 14, 12, 10, 8, 6]);
 639 }
 640
 641 #[test]
 642 fn test_cloned() {
 643     let xs = [2u8, 4, 6, 8];
 644
 645     let mut it = xs.iter().cloned();
 646     assert_eq!(it.len(), 4);
 647     assert_eq!(it.next(), Some(2));
 648     assert_eq!(it.len(), 3);
 649     assert_eq!(it.next(), Some(4));
 650     assert_eq!(it.len(), 2);
 651     assert_eq!(it.next_back(), Some(8));
 652     assert_eq!(it.len(), 1);
 653     assert_eq!(it.next_back(), Some(6));
 654     assert_eq!(it.len(), 0);
 655     assert_eq!(it.next_back(), None);
 656 }
 657
 658 #[test]
 659 fn test_double_ended_map() {
 660     let xs = [1, 2, 3, 4, 5, 6];
 661     let mut it = xs.iter().map(|&x| x * -1);
 662     assert_eq!(it.next(), Some(-1));
 663     assert_eq!(it.next(), Some(-2));
 664     assert_eq!(it.next_back(), Some(-6));
 665     assert_eq!(it.next_back(), Some(-5));
 666     assert_eq!(it.next(), Some(-3));
 667     assert_eq!(it.next_back(), Some(-4));
 668     assert_eq!(it.next(), None);
 669 }
 670
 671 #[test]
 672 fn test_double_ended_enumerate() {
 673     let xs = [1, 2, 3, 4, 5, 6];
 674     let mut it = xs.iter().cloned().enumerate();
 675     assert_eq!(it.next(), Some((0, 1)));
 676     assert_eq!(it.next(), Some((1, 2)));
 677     assert_eq!(it.next_back(), Some((5, 6)));
 678     assert_eq!(it.next_back(), Some((4, 5)));
 679     assert_eq!(it.next_back(), Some((3, 4)));
 680     assert_eq!(it.next_back(), Some((2, 3)));
 681     assert_eq!(it.next(), None);
 682 }
 683
 684 #[test]
 685 fn test_double_ended_zip() {
 686     let xs = [1, 2, 3, 4, 5, 6];
 687     let ys = [1, 2, 3, 7];
 688     let a = xs.iter().cloned();
 689     let b = ys.iter().cloned();
 690     let mut it = a.zip(b);
 691     assert_eq!(it.next(), Some((1, 1)));
 692     assert_eq!(it.next(), Some((2, 2)));
 693     assert_eq!(it.next_back(), Some((4, 7)));
 694     assert_eq!(it.next_back(), Some((3, 3)));
 695     assert_eq!(it.next(), None);
 696 }
 697
 698 #[test]
 699 fn test_double_ended_filter() {
 700     let xs = [1, 2, 3, 4, 5, 6];
 701     let mut it = xs.iter().filter(|&x| *x & 1 == 0);
 702     assert_eq!(it.next_back().unwrap(), &6);
 703     assert_eq!(it.next_back().unwrap(), &4);
 704     assert_eq!(it.next().unwrap(), &2);
 705     assert_eq!(it.next_back(), None);
 706 }
 707
 708 #[test]
 709 fn test_double_ended_filter_map() {
 710     let xs = [1, 2, 3, 4, 5, 6];
 711     let mut it = xs.iter().filter_map(|&x| if x & 1 == 0 { Some(x * 2) } else { None });
 712     assert_eq!(it.next_back().unwrap(), 12);
 713     assert_eq!(it.next_back().unwrap(), 8);
 714     assert_eq!(it.next().unwrap(), 4);
 715     assert_eq!(it.next_back(), None);
 716 }
 717
 718 #[test]
 719 fn test_double_ended_chain() {
 720     let xs = [1, 2, 3, 4, 5];
 721     let ys = [7, 9, 11];
 722     let mut it = xs.iter().chain(&ys).rev();
 723     assert_eq!(it.next().unwrap(), &11);
 724     assert_eq!(it.next().unwrap(), &9);
 725     assert_eq!(it.next_back().unwrap(), &1);
 726     assert_eq!(it.next_back().unwrap(), &2);
 727     assert_eq!(it.next_back().unwrap(), &3);
 728     assert_eq!(it.next_back().unwrap(), &4);
 729     assert_eq!(it.next_back().unwrap(), &5);
 730     assert_eq!(it.next_back().unwrap(), &7);
 731     assert_eq!(it.next_back(), None);
 732 }
 733
 734 #[test]
 735 fn test_rposition() {
 736     fn f(xy: &(isize, char)) -> bool { let (_x, y) = *xy; y == 'b' }
 737     fn g(xy: &(isize, char)) -> bool { let (_x, y) = *xy; y == 'd' }
 738     let v = [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
 739
 740     assert_eq!(v.iter().rposition(f), Some(3));
 741     assert!(v.iter().rposition(g).is_none());
 742 }
 743
 744 #[test]
 745 #[should_panic]
 746 fn test_rposition_panic() {
 747     let v: [(Box<_>, Box<_>); 4] =
 748         [(box 0, box 0), (box 0, box 0),
 749          (box 0, box 0), (box 0, box 0)];
 750     let mut i = 0;
 751     v.iter().rposition(|_elt| {
 752         if i == 2 {
 753             panic!()
 754         }
 755         i += 1;
 756         false
 757     });
 758 }
 759
 760
 761 #[test]
 762 fn test_double_ended_flat_map() {
 763     let u = [0,1];
 764     let v = [5,6,7,8];
 765     let mut it = u.iter().flat_map(|x| &v[*x..v.len()]);
 766     assert_eq!(it.next_back().unwrap(), &8);
 767     assert_eq!(it.next().unwrap(),      &5);
 768     assert_eq!(it.next_back().unwrap(), &7);
 769     assert_eq!(it.next_back().unwrap(), &6);
 770     assert_eq!(it.next_back().unwrap(), &8);
 771     assert_eq!(it.next().unwrap(),      &6);
 772     assert_eq!(it.next_back().unwrap(), &7);
 773     assert_eq!(it.next_back(), None);
 774     assert_eq!(it.next(),      None);
 775     assert_eq!(it.next_back(), None);
 776 }
 777
 778 #[test]
 779 fn test_double_ended_range() {
 780     assert_eq!((11..14).rev().collect::<Vec<_>>(), [13, 12, 11]);
 781     for _ in (10..0).rev() {
 782         panic!("unreachable");
 783     }
 784
 785     assert_eq!((11..14).rev().collect::<Vec<_>>(), [13, 12, 11]);
 786     for _ in (10..0).rev() {
 787         panic!("unreachable");
 788     }
 789 }
 790
 791 #[test]
 792 fn test_range() {
 793     assert_eq!((0..5).collect::<Vec<_>>(), [0, 1, 2, 3, 4]);
 794     assert_eq!((-10..-1).collect::<Vec<_>>(), [-10, -9, -8, -7, -6, -5, -4, -3, -2]);
 795     assert_eq!((0..5).rev().collect::<Vec<_>>(), [4, 3, 2, 1, 0]);
 796     assert_eq!((200..-5).count(), 0);
 797     assert_eq!((200..-5).rev().count(), 0);
 798     assert_eq!((200..200).count(), 0);
 799     assert_eq!((200..200).rev().count(), 0);
 800
 801     assert_eq!((0..100).size_hint(), (100, Some(100)));
 802     // this test is only meaningful when sizeof usize < sizeof u64
 803     assert_eq!((usize::MAX - 1..usize::MAX).size_hint(), (1, Some(1)));
 804     assert_eq!((-10..-1).size_hint(), (9, Some(9)));
 805     assert_eq!((-1..-10).size_hint(), (0, Some(0)));
 806
 807     assert_eq!((-70..58i8).size_hint(), (128, Some(128)));
 808     assert_eq!((-128..127i8).size_hint(), (255, Some(255)));
 809     assert_eq!((-2..isize::MAX).size_hint(),
 810                (isize::MAX as usize + 2, Some(isize::MAX as usize + 2)));
 811 }
 812
 813 #[test]
 814 fn test_range_inclusive() {
 815     assert!(range_inclusive(0, 5).collect::<Vec<isize>>() ==
 816             vec![0, 1, 2, 3, 4, 5]);
 817     assert!(range_inclusive(0, 5).rev().collect::<Vec<isize>>() ==
 818             vec![5, 4, 3, 2, 1, 0]);
 819     assert_eq!(range_inclusive(200, -5).count(), 0);
 820     assert_eq!(range_inclusive(200, -5).rev().count(), 0);
 821     assert_eq!(range_inclusive(200, 200).collect::<Vec<isize>>(), [200]);
 822     assert_eq!(range_inclusive(200, 200).rev().collect::<Vec<isize>>(), [200]);
 823 }
 824
 825 #[test]
 826 fn test_range_step() {
 827     assert_eq!((0..20).step_by(5).collect::<Vec<isize>>(), [0, 5, 10, 15]);
 828     assert_eq!((20..0).step_by(-5).collect::<Vec<isize>>(), [20, 15, 10, 5]);
 829     assert_eq!((20..0).step_by(-6).collect::<Vec<isize>>(), [20, 14, 8, 2]);
 830     assert_eq!((200..255).step_by(50).collect::<Vec<u8>>(), [200, 250]);
 831     assert_eq!((200..-5).step_by(1).collect::<Vec<isize>>(), []);
 832     assert_eq!((200..200).step_by(1).collect::<Vec<isize>>(), []);
 833
 834     assert_eq!((0..20).step_by(1).size_hint(), (20, Some(20)));
 835     assert_eq!((0..20).step_by(21).size_hint(), (1, Some(1)));
 836     assert_eq!((0..20).step_by(5).size_hint(), (4, Some(4)));
 837     assert_eq!((20..0).step_by(-5).size_hint(), (4, Some(4)));
 838     assert_eq!((20..0).step_by(-6).size_hint(), (4, Some(4)));
 839     assert_eq!((20..-5).step_by(1).size_hint(), (0, Some(0)));
 840     assert_eq!((20..20).step_by(1).size_hint(), (0, Some(0)));
 841     assert_eq!((0..1).step_by(0).size_hint(), (0, None));
 842     assert_eq!((i8::MAX..i8::MIN).step_by(i8::MIN).size_hint(), (2, Some(2)));
 843     assert_eq!((i16::MIN..i16::MAX).step_by(i16::MAX).size_hint(), (3, Some(3)));
 844     assert_eq!((isize::MIN..isize::MAX).step_by(1).size_hint(), (usize::MAX, Some(usize::MAX)));
 845 }
 846
 847 #[test]
 848 fn test_peekable_is_empty() {
 849     let a = [1];
 850     let mut it = a.iter().peekable();
 851     assert!( !it.is_empty() );
 852     it.next();
 853     assert!( it.is_empty() );
 854 }
 855
 856 #[test]
 857 fn test_repeat() {
 858     let mut it = repeat(42);
 859     assert_eq!(it.next(), Some(42));
 860     assert_eq!(it.next(), Some(42));
 861     assert_eq!(it.next(), Some(42));
 862 }
 863
 864 #[test]
 865 fn test_fuse() {
 866     let mut it = 0..3;
 867     assert_eq!(it.len(), 3);
 868     assert_eq!(it.next(), Some(0));
 869     assert_eq!(it.len(), 2);
 870     assert_eq!(it.next(), Some(1));
 871     assert_eq!(it.len(), 1);
 872     assert_eq!(it.next(), Some(2));
 873     assert_eq!(it.len(), 0);
 874     assert_eq!(it.next(), None);
 875     assert_eq!(it.len(), 0);
 876     assert_eq!(it.next(), None);
 877     assert_eq!(it.len(), 0);
 878     assert_eq!(it.next(), None);
 879     assert_eq!(it.len(), 0);
 880 }
 881
 882 #[test]
 883 fn test_fuse_nth() {
 884     let xs = [0, 1, 2];
 885     let mut it = xs.iter();
 886
 887     assert_eq!(it.len(), 3);
 888     assert_eq!(it.nth(2), Some(&2));
 889     assert_eq!(it.len(), 0);
 890     assert_eq!(it.nth(2), None);
 891     assert_eq!(it.len(), 0);
 892 }
 893
 894 #[test]
 895 fn test_fuse_last() {
 896     let xs = [0, 1, 2];
 897     let it = xs.iter();
 898
 899     assert_eq!(it.len(), 3);
 900     assert_eq!(it.last(), Some(&2));
 901 }
 902
 903 #[test]
 904 fn test_fuse_count() {
 905     let xs = [0, 1, 2];
 906     let it = xs.iter();
 907
 908     assert_eq!(it.len(), 3);
 909     assert_eq!(it.count(), 3);
 910     // Can't check len now because count consumes.
 911 }
 912
 913 #[test]
 914 fn test_once() {
 915     let mut it = once(42);
 916     assert_eq!(it.next(), Some(42));
 917     assert_eq!(it.next(), None);
 918 }
 919
 920 #[test]
 921 fn test_empty() {
 922     let mut it = empty::<i32>();
 923     assert_eq!(it.next(), None);
 924 }
 925
 926 #[bench]
 927 fn bench_rposition(b: &mut Bencher) {
 928     let it: Vec<usize> = (0..300).collect();
 929     b.iter(|| {
 930         it.iter().rposition(|&x| x <= 150);
 931     });
 932 }
 933
 934 #[bench]
 935 fn bench_skip_while(b: &mut Bencher) {
 936     b.iter(|| {
 937         let it = 0..100;
 938         let mut sum = 0;
 939         it.skip_while(|&x| { sum += x; sum < 4000 }).all(|_| true);
 940     });
 941 }
 942
 943 #[bench]
 944 fn bench_multiple_take(b: &mut Bencher) {
 945     let mut it = (0..42).cycle();
 946     b.iter(|| {
 947         let n = it.next().unwrap();
 948         for _ in 0..n {
 949             it.clone().take(it.next().unwrap()).all(|_| true);
 950         }
 951     });
 952 }
 953
 954 fn scatter(x: i32) -> i32 { (x * 31) % 127 }
 955
 956 #[bench]
 957 fn bench_max_by(b: &mut Bencher) {
 958     b.iter(|| {
 959         let it = 0..100;
 960         it.max_by(|&x| scatter(x))
 961     })
 962 }
 963
 964 // http://www.reddit.com/r/rust/comments/31syce/using_iterators_to_find_the_index_of_the_min_or/
 965 #[bench]
 966 fn bench_max_by2(b: &mut Bencher) {
 967     fn max_index_iter(array: &[i32]) -> usize {
 968         array.iter().enumerate().max_by(|&(_, item)| item).unwrap().0
 969     }
 970
 971     let mut data = vec![0i32; 1638];
 972     data[514] = 9999;
 973
 974     b.iter(|| max_index_iter(&data));
 975 }
 976
 977 #[bench]
 978 fn bench_max(b: &mut Bencher) {
 979     b.iter(|| {
 980         let it = 0..100;
 981         it.map(scatter).max()
 982     })
 983 }