library/core/tests/iter/adapters/enumerate.rs

   1 use core::iter::*;
   2
   3 #[test]
   4 fn test_iterator_enumerate() {
   5     let xs = [0, 1, 2, 3, 4, 5];
   6     let it = xs.iter().enumerate();
   7     for (i, &x) in it {
   8         assert_eq!(i, x);
   9     }
  10 }
  11
  12 #[test]
  13 fn test_iterator_enumerate_nth() {
  14     let xs = [0, 1, 2, 3, 4, 5];
  15     for (i, &x) in xs.iter().enumerate() {
  16         assert_eq!(i, x);
  17     }
  18
  19     let mut it = xs.iter().enumerate();
  20     while let Some((i, &x)) = it.nth(0) {
  21         assert_eq!(i, x);
  22     }
  23
  24     let mut it = xs.iter().enumerate();
  25     while let Some((i, &x)) = it.nth(1) {
  26         assert_eq!(i, x);
  27     }
  28
  29     let (i, &x) = xs.iter().enumerate().nth(3).unwrap();
  30     assert_eq!(i, x);
  31     assert_eq!(i, 3);
  32 }
  33
  34 #[test]
  35 fn test_iterator_enumerate_nth_back() {
  36     let xs = [0, 1, 2, 3, 4, 5];
  37     let mut it = xs.iter().enumerate();
  38     while let Some((i, &x)) = it.nth_back(0) {
  39         assert_eq!(i, x);
  40     }
  41
  42     let mut it = xs.iter().enumerate();
  43     while let Some((i, &x)) = it.nth_back(1) {
  44         assert_eq!(i, x);
  45     }
  46
  47     let (i, &x) = xs.iter().enumerate().nth_back(3).unwrap();
  48     assert_eq!(i, x);
  49     assert_eq!(i, 2);
  50 }
  51
  52 #[test]
  53 fn test_iterator_enumerate_count() {
  54     let xs = [0, 1, 2, 3, 4, 5];
  55     assert_eq!(xs.iter().enumerate().count(), 6);
  56 }
  57
  58 #[test]
  59 fn test_iterator_enumerate_fold() {
  60     let xs = [0, 1, 2, 3, 4, 5];
  61     let mut it = xs.iter().enumerate();
  62     // steal a couple to get an interesting offset
  63     assert_eq!(it.next(), Some((0, &0)));
  64     assert_eq!(it.next(), Some((1, &1)));
  65     let i = it.fold(2, |i, (j, &x)| {
  66         assert_eq!(i, j);
  67         assert_eq!(x, xs[j]);
  68         i + 1
  69     });
  70     assert_eq!(i, xs.len());
  71
  72     let mut it = xs.iter().enumerate();
  73     assert_eq!(it.next(), Some((0, &0)));
  74     let i = it.rfold(xs.len() - 1, |i, (j, &x)| {
  75         assert_eq!(i, j);
  76         assert_eq!(x, xs[j]);
  77         i - 1
  78     });
  79     assert_eq!(i, 0);
  80 }
  81
  82 #[test]
  83 fn test_enumerate_try_folds() {
  84     let f = &|acc, (i, x)| usize::checked_add(2 * acc, x / (i + 1) + i);
  85     assert_eq!((9..18).enumerate().try_fold(7, f), (0..9).map(|i| (i, i + 9)).try_fold(7, f));
  86     assert_eq!((9..18).enumerate().try_rfold(7, f), (0..9).map(|i| (i, i + 9)).try_rfold(7, f));
  87
  88     let mut iter = (100..200).enumerate();
  89     let f = &|acc, (i, x)| u8::checked_add(acc, u8::checked_div(x, i as u8 + 1)?);
  90     assert_eq!(iter.try_fold(0, f), None);
  91     assert_eq!(iter.next(), Some((7, 107)));
  92     assert_eq!(iter.try_rfold(0, f), None);
  93     assert_eq!(iter.next_back(), Some((11, 111)));
  94 }
  95
  96 #[test]
  97 fn test_double_ended_enumerate() {
  98     let xs = [1, 2, 3, 4, 5, 6];
  99     let mut it = xs.iter().cloned().enumerate();
 100     assert_eq!(it.next(), Some((0, 1)));
 101     assert_eq!(it.next(), Some((1, 2)));
 102     assert_eq!(it.next_back(), Some((5, 6)));
 103     assert_eq!(it.next_back(), Some((4, 5)));
 104     assert_eq!(it.next_back(), Some((3, 4)));
 105     assert_eq!(it.next_back(), Some((2, 3)));
 106     assert_eq!(it.next(), None);
 107 }