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

   1 use core::iter::*;
   2
   3 use super::Unfuse;
   4
   5 #[test]
   6 fn test_iterator_skip() {
   7     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
   8     let ys = [13, 15, 16, 17, 19, 20, 30];
   9     let mut it = xs.iter().skip(5);
  10     let mut i = 0;
  11     while let Some(&x) = it.next() {
  12         assert_eq!(x, ys[i]);
  13         i += 1;
  14         assert_eq!(it.len(), xs.len() - 5 - i);
  15     }
  16     assert_eq!(i, ys.len());
  17     assert_eq!(it.len(), 0);
  18 }
  19
  20 #[test]
  21 fn test_iterator_skip_doubleended() {
  22     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
  23     let mut it = xs.iter().rev().skip(5);
  24     assert_eq!(it.next(), Some(&15));
  25     assert_eq!(it.by_ref().rev().next(), Some(&0));
  26     assert_eq!(it.next(), Some(&13));
  27     assert_eq!(it.by_ref().rev().next(), Some(&1));
  28     assert_eq!(it.next(), Some(&5));
  29     assert_eq!(it.by_ref().rev().next(), Some(&2));
  30     assert_eq!(it.next(), Some(&3));
  31     assert_eq!(it.next(), None);
  32     let mut it = xs.iter().rev().skip(5).rev();
  33     assert_eq!(it.next(), Some(&0));
  34     assert_eq!(it.rev().next(), Some(&15));
  35     let mut it_base = xs.iter();
  36     {
  37         let mut it = it_base.by_ref().skip(5).rev();
  38         assert_eq!(it.next(), Some(&30));
  39         assert_eq!(it.next(), Some(&20));
  40         assert_eq!(it.next(), Some(&19));
  41         assert_eq!(it.next(), Some(&17));
  42         assert_eq!(it.next(), Some(&16));
  43         assert_eq!(it.next(), Some(&15));
  44         assert_eq!(it.next(), Some(&13));
  45         assert_eq!(it.next(), None);
  46     }
  47     // make sure the skipped parts have not been consumed
  48     assert_eq!(it_base.next(), Some(&0));
  49     assert_eq!(it_base.next(), Some(&1));
  50     assert_eq!(it_base.next(), Some(&2));
  51     assert_eq!(it_base.next(), Some(&3));
  52     assert_eq!(it_base.next(), Some(&5));
  53     assert_eq!(it_base.next(), None);
  54     let it = xs.iter().skip(5).rev();
  55     assert_eq!(it.last(), Some(&13));
  56 }
  57
  58 #[test]
  59 fn test_iterator_skip_nth() {
  60     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
  61
  62     let mut it = xs.iter().skip(0);
  63     assert_eq!(it.nth(0), Some(&0));
  64     assert_eq!(it.nth(1), Some(&2));
  65
  66     let mut it = xs.iter().skip(5);
  67     assert_eq!(it.nth(0), Some(&13));
  68     assert_eq!(it.nth(1), Some(&16));
  69
  70     let mut it = xs.iter().skip(12);
  71     assert_eq!(it.nth(0), None);
  72 }
  73
  74 #[test]
  75 fn test_skip_advance_by() {
  76     assert_eq!((0..0).skip(10).advance_by(0), Ok(()));
  77     assert_eq!((0..0).skip(10).advance_by(1), Err(0));
  78     assert_eq!((0u128..(usize::MAX as u128) + 1).skip(usize::MAX).advance_by(usize::MAX), Err(1));
  79     assert_eq!((0u128..u128::MAX).skip(usize::MAX).advance_by(1), Ok(()));
  80
  81     assert_eq!((0..2).skip(1).advance_back_by(10), Err(1));
  82     assert_eq!((0..0).skip(1).advance_back_by(0), Ok(()));
  83 }
  84
  85 #[test]
  86 fn test_iterator_skip_count() {
  87     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
  88
  89     assert_eq!(xs.iter().skip(0).count(), 12);
  90     assert_eq!(xs.iter().skip(1).count(), 11);
  91     assert_eq!(xs.iter().skip(11).count(), 1);
  92     assert_eq!(xs.iter().skip(12).count(), 0);
  93     assert_eq!(xs.iter().skip(13).count(), 0);
  94 }
  95
  96 #[test]
  97 fn test_iterator_skip_last() {
  98     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
  99
 100     assert_eq!(xs.iter().skip(0).last(), Some(&30));
 101     assert_eq!(xs.iter().skip(1).last(), Some(&30));
 102     assert_eq!(xs.iter().skip(11).last(), Some(&30));
 103     assert_eq!(xs.iter().skip(12).last(), None);
 104     assert_eq!(xs.iter().skip(13).last(), None);
 105
 106     let mut it = xs.iter().skip(5);
 107     assert_eq!(it.next(), Some(&13));
 108     assert_eq!(it.last(), Some(&30));
 109 }
 110
 111 #[test]
 112 fn test_iterator_skip_fold() {
 113     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
 114     let ys = [13, 15, 16, 17, 19, 20, 30];
 115
 116     let it = xs.iter().skip(5);
 117     let i = it.fold(0, |i, &x| {
 118         assert_eq!(x, ys[i]);
 119         i + 1
 120     });
 121     assert_eq!(i, ys.len());
 122
 123     let mut it = xs.iter().skip(5);
 124     assert_eq!(it.next(), Some(&ys[0])); // process skips before folding
 125     let i = it.fold(1, |i, &x| {
 126         assert_eq!(x, ys[i]);
 127         i + 1
 128     });
 129     assert_eq!(i, ys.len());
 130
 131     let it = xs.iter().skip(5);
 132     let i = it.rfold(ys.len(), |i, &x| {
 133         let i = i - 1;
 134         assert_eq!(x, ys[i]);
 135         i
 136     });
 137     assert_eq!(i, 0);
 138
 139     let mut it = xs.iter().skip(5);
 140     assert_eq!(it.next(), Some(&ys[0])); // process skips before folding
 141     let i = it.rfold(ys.len(), |i, &x| {
 142         let i = i - 1;
 143         assert_eq!(x, ys[i]);
 144         i
 145     });
 146     assert_eq!(i, 1);
 147 }
 148
 149 #[test]
 150 fn test_skip_try_folds() {
 151     let f = &|acc, x| i32::checked_add(2 * acc, x);
 152     assert_eq!((1..20).skip(9).try_fold(7, f), (10..20).try_fold(7, f));
 153     assert_eq!((1..20).skip(9).try_rfold(7, f), (10..20).try_rfold(7, f));
 154
 155     let mut iter = (0..30).skip(10);
 156     assert_eq!(iter.try_fold(0, i8::checked_add), None);
 157     assert_eq!(iter.next(), Some(20));
 158     assert_eq!(iter.try_rfold(0, i8::checked_add), None);
 159     assert_eq!(iter.next_back(), Some(24));
 160 }
 161
 162 #[test]
 163 fn test_skip_nth_back() {
 164     let xs = [0, 1, 2, 3, 4, 5];
 165     let mut it = xs.iter().skip(2);
 166     assert_eq!(it.nth_back(0), Some(&5));
 167     assert_eq!(it.nth_back(1), Some(&3));
 168     assert_eq!(it.nth_back(0), Some(&2));
 169     assert_eq!(it.nth_back(0), None);
 170
 171     let ys = [2, 3, 4, 5];
 172     let mut ity = ys.iter();
 173     let mut it = xs.iter().skip(2);
 174     assert_eq!(it.nth_back(1), ity.nth_back(1));
 175     assert_eq!(it.clone().nth(0), ity.clone().nth(0));
 176     assert_eq!(it.nth_back(0), ity.nth_back(0));
 177     assert_eq!(it.clone().nth(0), ity.clone().nth(0));
 178     assert_eq!(it.nth_back(0), ity.nth_back(0));
 179     assert_eq!(it.clone().nth(0), ity.clone().nth(0));
 180     assert_eq!(it.nth_back(0), ity.nth_back(0));
 181     assert_eq!(it.clone().nth(0), ity.clone().nth(0));
 182
 183     let mut it = xs.iter().skip(2);
 184     assert_eq!(it.nth_back(4), None);
 185     assert_eq!(it.nth_back(0), None);
 186
 187     let mut it = xs.iter();
 188     it.by_ref().skip(2).nth_back(3);
 189     assert_eq!(it.next_back(), Some(&1));
 190
 191     let mut it = xs.iter();
 192     it.by_ref().skip(2).nth_back(10);
 193     assert_eq!(it.next_back(), Some(&1));
 194 }
 195
 196 #[test]
 197 fn test_skip_non_fused() {
 198     let non_fused = Unfuse::new(0..10);
 199
 200     // `Skip` would previously exhaust the iterator in this `next` call and then erroneously try to
 201     // advance it further. `Unfuse` tests that this doesn't happen by panicking in that scenario.
 202     let _ = non_fused.skip(20).next();
 203 }
 204
 205 #[test]
 206 fn test_skip_non_fused_nth_overflow() {
 207     let non_fused = Unfuse::new(0..10);
 208
 209     // Ensures that calling skip and `nth` where the sum would overflow does not fail for non-fused
 210     // iterators.
 211     let _ = non_fused.skip(20).nth(usize::MAX);
 212 }
 213
 214 #[test]
 215 fn test_skip_overflow_wrapping() {
 216     // Test to ensure even on overflowing on `skip+nth` the correct amount of elements are yielded.
 217     struct WrappingIterator(usize);
 218
 219     impl Iterator for WrappingIterator {
 220         type Item = usize;
 221
 222         fn next(&mut self) -> core::option::Option<Self::Item> {
 223             <Self as Iterator>::nth(self, 0)
 224         }
 225
 226         fn nth(&mut self, nth: usize) -> core::option::Option<Self::Item> {
 227             self.0 = self.0.wrapping_add(nth.wrapping_add(1));
 228             Some(self.0)
 229         }
 230     }
 231
 232     let wrap = WrappingIterator(0);
 233     assert_eq!(wrap.skip(20).nth(usize::MAX), Some(20));
 234 }