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

   1 use core::iter::*;
   2
   3 #[test]
   4 fn test_iterator_skip() {
   5     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
   6     let ys = [13, 15, 16, 17, 19, 20, 30];
   7     let mut it = xs.iter().skip(5);
   8     let mut i = 0;
   9     while let Some(&x) = it.next() {
  10         assert_eq!(x, ys[i]);
  11         i += 1;
  12         assert_eq!(it.len(), xs.len() - 5 - i);
  13     }
  14     assert_eq!(i, ys.len());
  15     assert_eq!(it.len(), 0);
  16 }
  17 #[test]
  18 fn test_iterator_skip_doubleended() {
  19     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
  20     let mut it = xs.iter().rev().skip(5);
  21     assert_eq!(it.next(), Some(&15));
  22     assert_eq!(it.by_ref().rev().next(), Some(&0));
  23     assert_eq!(it.next(), Some(&13));
  24     assert_eq!(it.by_ref().rev().next(), Some(&1));
  25     assert_eq!(it.next(), Some(&5));
  26     assert_eq!(it.by_ref().rev().next(), Some(&2));
  27     assert_eq!(it.next(), Some(&3));
  28     assert_eq!(it.next(), None);
  29     let mut it = xs.iter().rev().skip(5).rev();
  30     assert_eq!(it.next(), Some(&0));
  31     assert_eq!(it.rev().next(), Some(&15));
  32     let mut it_base = xs.iter();
  33     {
  34         let mut it = it_base.by_ref().skip(5).rev();
  35         assert_eq!(it.next(), Some(&30));
  36         assert_eq!(it.next(), Some(&20));
  37         assert_eq!(it.next(), Some(&19));
  38         assert_eq!(it.next(), Some(&17));
  39         assert_eq!(it.next(), Some(&16));
  40         assert_eq!(it.next(), Some(&15));
  41         assert_eq!(it.next(), Some(&13));
  42         assert_eq!(it.next(), None);
  43     }
  44     // make sure the skipped parts have not been consumed
  45     assert_eq!(it_base.next(), Some(&0));
  46     assert_eq!(it_base.next(), Some(&1));
  47     assert_eq!(it_base.next(), Some(&2));
  48     assert_eq!(it_base.next(), Some(&3));
  49     assert_eq!(it_base.next(), Some(&5));
  50     assert_eq!(it_base.next(), None);
  51     let it = xs.iter().skip(5).rev();
  52     assert_eq!(it.last(), Some(&13));
  53 }
  54 #[test]
  55 fn test_iterator_skip_nth() {
  56     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
  57
  58     let mut it = xs.iter().skip(0);
  59     assert_eq!(it.nth(0), Some(&0));
  60     assert_eq!(it.nth(1), Some(&2));
  61
  62     let mut it = xs.iter().skip(5);
  63     assert_eq!(it.nth(0), Some(&13));
  64     assert_eq!(it.nth(1), Some(&16));
  65
  66     let mut it = xs.iter().skip(12);
  67     assert_eq!(it.nth(0), None);
  68 }
  69 #[test]
  70 fn test_iterator_skip_count() {
  71     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
  72
  73     assert_eq!(xs.iter().skip(0).count(), 12);
  74     assert_eq!(xs.iter().skip(1).count(), 11);
  75     assert_eq!(xs.iter().skip(11).count(), 1);
  76     assert_eq!(xs.iter().skip(12).count(), 0);
  77     assert_eq!(xs.iter().skip(13).count(), 0);
  78 }
  79 #[test]
  80 fn test_iterator_skip_last() {
  81     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
  82
  83     assert_eq!(xs.iter().skip(0).last(), Some(&30));
  84     assert_eq!(xs.iter().skip(1).last(), Some(&30));
  85     assert_eq!(xs.iter().skip(11).last(), Some(&30));
  86     assert_eq!(xs.iter().skip(12).last(), None);
  87     assert_eq!(xs.iter().skip(13).last(), None);
  88
  89     let mut it = xs.iter().skip(5);
  90     assert_eq!(it.next(), Some(&13));
  91     assert_eq!(it.last(), Some(&30));
  92 }
  93 #[test]
  94 fn test_iterator_skip_fold() {
  95     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
  96     let ys = [13, 15, 16, 17, 19, 20, 30];
  97
  98     let it = xs.iter().skip(5);
  99     let i = it.fold(0, |i, &x| {
 100         assert_eq!(x, ys[i]);
 101         i + 1
 102     });
 103     assert_eq!(i, ys.len());
 104
 105     let mut it = xs.iter().skip(5);
 106     assert_eq!(it.next(), Some(&ys[0])); // process skips before folding
 107     let i = it.fold(1, |i, &x| {
 108         assert_eq!(x, ys[i]);
 109         i + 1
 110     });
 111     assert_eq!(i, ys.len());
 112
 113     let it = xs.iter().skip(5);
 114     let i = it.rfold(ys.len(), |i, &x| {
 115         let i = i - 1;
 116         assert_eq!(x, ys[i]);
 117         i
 118     });
 119     assert_eq!(i, 0);
 120
 121     let mut it = xs.iter().skip(5);
 122     assert_eq!(it.next(), Some(&ys[0])); // process skips before folding
 123     let i = it.rfold(ys.len(), |i, &x| {
 124         let i = i - 1;
 125         assert_eq!(x, ys[i]);
 126         i
 127     });
 128     assert_eq!(i, 1);
 129 }
 130 #[test]
 131 fn test_skip_try_folds() {
 132     let f = &|acc, x| i32::checked_add(2 * acc, x);
 133     assert_eq!((1..20).skip(9).try_fold(7, f), (10..20).try_fold(7, f));
 134     assert_eq!((1..20).skip(9).try_rfold(7, f), (10..20).try_rfold(7, f));
 135
 136     let mut iter = (0..30).skip(10);
 137     assert_eq!(iter.try_fold(0, i8::checked_add), None);
 138     assert_eq!(iter.next(), Some(20));
 139     assert_eq!(iter.try_rfold(0, i8::checked_add), None);
 140     assert_eq!(iter.next_back(), Some(24));
 141 }
 142 #[test]
 143 fn test_skip_nth_back() {
 144     let xs = [0, 1, 2, 3, 4, 5];
 145     let mut it = xs.iter().skip(2);
 146     assert_eq!(it.nth_back(0), Some(&5));
 147     assert_eq!(it.nth_back(1), Some(&3));
 148     assert_eq!(it.nth_back(0), Some(&2));
 149     assert_eq!(it.nth_back(0), None);
 150
 151     let ys = [2, 3, 4, 5];
 152     let mut ity = ys.iter();
 153     let mut it = xs.iter().skip(2);
 154     assert_eq!(it.nth_back(1), ity.nth_back(1));
 155     assert_eq!(it.clone().nth(0), ity.clone().nth(0));
 156     assert_eq!(it.nth_back(0), ity.nth_back(0));
 157     assert_eq!(it.clone().nth(0), ity.clone().nth(0));
 158     assert_eq!(it.nth_back(0), ity.nth_back(0));
 159     assert_eq!(it.clone().nth(0), ity.clone().nth(0));
 160     assert_eq!(it.nth_back(0), ity.nth_back(0));
 161     assert_eq!(it.clone().nth(0), ity.clone().nth(0));
 162
 163     let mut it = xs.iter().skip(2);
 164     assert_eq!(it.nth_back(4), None);
 165     assert_eq!(it.nth_back(0), None);
 166
 167     let mut it = xs.iter();
 168     it.by_ref().skip(2).nth_back(3);
 169     assert_eq!(it.next_back(), Some(&1));
 170
 171     let mut it = xs.iter();
 172     it.by_ref().skip(2).nth_back(10);
 173     assert_eq!(it.next_back(), Some(&1));
 174 }