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

   1 use super::*;
   2 use core::iter::*;
   3
   4 #[test]
   5 fn test_iterator_peekable() {
   6     let xs = vec![0, 1, 2, 3, 4, 5];
   7
   8     let mut it = xs.iter().cloned().peekable();
   9     assert_eq!(it.len(), 6);
  10     assert_eq!(it.peek().unwrap(), &0);
  11     assert_eq!(it.len(), 6);
  12     assert_eq!(it.next().unwrap(), 0);
  13     assert_eq!(it.len(), 5);
  14     assert_eq!(it.next().unwrap(), 1);
  15     assert_eq!(it.len(), 4);
  16     assert_eq!(it.next().unwrap(), 2);
  17     assert_eq!(it.len(), 3);
  18     assert_eq!(it.peek().unwrap(), &3);
  19     assert_eq!(it.len(), 3);
  20     assert_eq!(it.peek().unwrap(), &3);
  21     assert_eq!(it.len(), 3);
  22     assert_eq!(it.next().unwrap(), 3);
  23     assert_eq!(it.len(), 2);
  24     assert_eq!(it.next().unwrap(), 4);
  25     assert_eq!(it.len(), 1);
  26     assert_eq!(it.peek().unwrap(), &5);
  27     assert_eq!(it.len(), 1);
  28     assert_eq!(it.next().unwrap(), 5);
  29     assert_eq!(it.len(), 0);
  30     assert!(it.peek().is_none());
  31     assert_eq!(it.len(), 0);
  32     assert!(it.next().is_none());
  33     assert_eq!(it.len(), 0);
  34
  35     let mut it = xs.iter().cloned().peekable();
  36     assert_eq!(it.len(), 6);
  37     assert_eq!(it.peek().unwrap(), &0);
  38     assert_eq!(it.len(), 6);
  39     assert_eq!(it.next_back().unwrap(), 5);
  40     assert_eq!(it.len(), 5);
  41     assert_eq!(it.next_back().unwrap(), 4);
  42     assert_eq!(it.len(), 4);
  43     assert_eq!(it.next_back().unwrap(), 3);
  44     assert_eq!(it.len(), 3);
  45     assert_eq!(it.peek().unwrap(), &0);
  46     assert_eq!(it.len(), 3);
  47     assert_eq!(it.peek().unwrap(), &0);
  48     assert_eq!(it.len(), 3);
  49     assert_eq!(it.next_back().unwrap(), 2);
  50     assert_eq!(it.len(), 2);
  51     assert_eq!(it.next_back().unwrap(), 1);
  52     assert_eq!(it.len(), 1);
  53     assert_eq!(it.peek().unwrap(), &0);
  54     assert_eq!(it.len(), 1);
  55     assert_eq!(it.next_back().unwrap(), 0);
  56     assert_eq!(it.len(), 0);
  57     assert!(it.peek().is_none());
  58     assert_eq!(it.len(), 0);
  59     assert!(it.next_back().is_none());
  60     assert_eq!(it.len(), 0);
  61 }
  62
  63 #[test]
  64 fn test_iterator_peekable_count() {
  65     let xs = [0, 1, 2, 3, 4, 5];
  66     let ys = [10];
  67     let zs: [i32; 0] = [];
  68
  69     assert_eq!(xs.iter().peekable().count(), 6);
  70
  71     let mut it = xs.iter().peekable();
  72     assert_eq!(it.peek(), Some(&&0));
  73     assert_eq!(it.count(), 6);
  74
  75     assert_eq!(ys.iter().peekable().count(), 1);
  76
  77     let mut it = ys.iter().peekable();
  78     assert_eq!(it.peek(), Some(&&10));
  79     assert_eq!(it.count(), 1);
  80
  81     assert_eq!(zs.iter().peekable().count(), 0);
  82
  83     let mut it = zs.iter().peekable();
  84     assert_eq!(it.peek(), None);
  85 }
  86
  87 #[test]
  88 fn test_iterator_peekable_nth() {
  89     let xs = [0, 1, 2, 3, 4, 5];
  90     let mut it = xs.iter().peekable();
  91
  92     assert_eq!(it.peek(), Some(&&0));
  93     assert_eq!(it.nth(0), Some(&0));
  94     assert_eq!(it.peek(), Some(&&1));
  95     assert_eq!(it.nth(1), Some(&2));
  96     assert_eq!(it.peek(), Some(&&3));
  97     assert_eq!(it.nth(2), Some(&5));
  98     assert_eq!(it.next(), None);
  99 }
 100
 101 #[test]
 102 fn test_iterator_peekable_last() {
 103     let xs = [0, 1, 2, 3, 4, 5];
 104     let ys = [0];
 105
 106     let mut it = xs.iter().peekable();
 107     assert_eq!(it.peek(), Some(&&0));
 108     assert_eq!(it.last(), Some(&5));
 109
 110     let mut it = ys.iter().peekable();
 111     assert_eq!(it.peek(), Some(&&0));
 112     assert_eq!(it.last(), Some(&0));
 113
 114     let mut it = ys.iter().peekable();
 115     assert_eq!(it.next(), Some(&0));
 116     assert_eq!(it.peek(), None);
 117     assert_eq!(it.last(), None);
 118 }
 119
 120 #[test]
 121 fn test_iterator_peekable_fold() {
 122     let xs = [0, 1, 2, 3, 4, 5];
 123     let mut it = xs.iter().peekable();
 124     assert_eq!(it.peek(), Some(&&0));
 125     let i = it.fold(0, |i, &x| {
 126         assert_eq!(x, xs[i]);
 127         i + 1
 128     });
 129     assert_eq!(i, xs.len());
 130 }
 131
 132 #[test]
 133 fn test_iterator_peekable_rfold() {
 134     let xs = [0, 1, 2, 3, 4, 5];
 135     let mut it = xs.iter().peekable();
 136     assert_eq!(it.peek(), Some(&&0));
 137     let i = it.rfold(0, |i, &x| {
 138         assert_eq!(x, xs[xs.len() - 1 - i]);
 139         i + 1
 140     });
 141     assert_eq!(i, xs.len());
 142 }
 143
 144 #[test]
 145 fn test_iterator_peekable_next_if_eq() {
 146     // first, try on references
 147     let xs = ["Heart", "of", "Gold"];
 148     let mut it = xs.into_iter().peekable();
 149     // try before `peek()`
 150     assert_eq!(it.next_if_eq(&"trillian"), None);
 151     assert_eq!(it.next_if_eq(&"Heart"), Some("Heart"));
 152     // try after peek()
 153     assert_eq!(it.peek(), Some(&"of"));
 154     assert_eq!(it.next_if_eq(&"of"), Some("of"));
 155     assert_eq!(it.next_if_eq(&"zaphod"), None);
 156     // make sure `next()` still behaves
 157     assert_eq!(it.next(), Some("Gold"));
 158
 159     // make sure comparison works for owned values
 160     let xs = [String::from("Ludicrous"), "speed".into()];
 161     let mut it = xs.into_iter().peekable();
 162     // make sure basic functionality works
 163     assert_eq!(it.next_if_eq("Ludicrous"), Some("Ludicrous".into()));
 164     assert_eq!(it.next_if_eq("speed"), Some("speed".into()));
 165     assert_eq!(it.next_if_eq(""), None);
 166 }
 167
 168 #[test]
 169 fn test_iterator_peekable_mut() {
 170     let mut it = [1, 2, 3].into_iter().peekable();
 171     if let Some(p) = it.peek_mut() {
 172         if *p == 1 {
 173             *p = 5;
 174         }
 175     }
 176     assert_eq!(it.collect::<Vec<_>>(), vec![5, 2, 3]);
 177 }
 178
 179 #[test]
 180 fn test_iterator_peekable_remember_peek_none_1() {
 181     // Check that the loop using .peek() terminates
 182     let data = [1, 2, 3];
 183     let mut iter = CycleIter::new(&data).peekable();
 184
 185     let mut n = 0;
 186     while let Some(_) = iter.next() {
 187         let is_the_last = iter.peek().is_none();
 188         assert_eq!(is_the_last, n == data.len() - 1);
 189         n += 1;
 190         if n > data.len() {
 191             break;
 192         }
 193     }
 194     assert_eq!(n, data.len());
 195 }
 196
 197 #[test]
 198 fn test_iterator_peekable_remember_peek_none_2() {
 199     let data = [0];
 200     let mut iter = CycleIter::new(&data).peekable();
 201     iter.next();
 202     assert_eq!(iter.peek(), None);
 203     assert_eq!(iter.last(), None);
 204 }
 205
 206 #[test]
 207 fn test_iterator_peekable_remember_peek_none_3() {
 208     let data = [0];
 209     let mut iter = CycleIter::new(&data).peekable();
 210     iter.peek();
 211     assert_eq!(iter.nth(0), Some(&0));
 212
 213     let mut iter = CycleIter::new(&data).peekable();
 214     iter.next();
 215     assert_eq!(iter.peek(), None);
 216     assert_eq!(iter.nth(0), None);
 217 }
 218
 219 #[test]
 220 fn test_peek_try_folds() {
 221     let f = &|acc, x| i32::checked_add(2 * acc, x);
 222
 223     assert_eq!((1..20).peekable().try_fold(7, f), (1..20).try_fold(7, f));
 224     assert_eq!((1..20).peekable().try_rfold(7, f), (1..20).try_rfold(7, f));
 225
 226     let mut iter = (1..20).peekable();
 227     assert_eq!(iter.peek(), Some(&1));
 228     assert_eq!(iter.try_fold(7, f), (1..20).try_fold(7, f));
 229
 230     let mut iter = (1..20).peekable();
 231     assert_eq!(iter.peek(), Some(&1));
 232     assert_eq!(iter.try_rfold(7, f), (1..20).try_rfold(7, f));
 233
 234     let mut iter = [100, 20, 30, 40, 50, 60, 70].iter().cloned().peekable();
 235     assert_eq!(iter.peek(), Some(&100));
 236     assert_eq!(iter.try_fold(0, i8::checked_add), None);
 237     assert_eq!(iter.peek(), Some(&40));
 238
 239     let mut iter = [100, 20, 30, 40, 50, 60, 70].iter().cloned().peekable();
 240     assert_eq!(iter.peek(), Some(&100));
 241     assert_eq!(iter.try_rfold(0, i8::checked_add), None);
 242     assert_eq!(iter.peek(), Some(&100));
 243     assert_eq!(iter.next_back(), Some(50));
 244
 245     let mut iter = (2..5).peekable();
 246     assert_eq!(iter.peek(), Some(&2));
 247     assert_eq!(iter.try_for_each(Err), Err(2));
 248     assert_eq!(iter.peek(), Some(&3));
 249     assert_eq!(iter.try_for_each(Err), Err(3));
 250     assert_eq!(iter.peek(), Some(&4));
 251     assert_eq!(iter.try_for_each(Err), Err(4));
 252     assert_eq!(iter.peek(), None);
 253     assert_eq!(iter.try_for_each(Err), Ok(()));
 254
 255     let mut iter = (2..5).peekable();
 256     assert_eq!(iter.peek(), Some(&2));
 257     assert_eq!(iter.try_rfold((), |(), x| Err(x)), Err(4));
 258     assert_eq!(iter.peek(), Some(&2));
 259     assert_eq!(iter.try_rfold((), |(), x| Err(x)), Err(3));
 260     assert_eq!(iter.peek(), Some(&2));
 261     assert_eq!(iter.try_rfold((), |(), x| Err(x)), Err(2));
 262     assert_eq!(iter.peek(), None);
 263     assert_eq!(iter.try_rfold((), |(), x| Err(x)), Ok(()));
 264 }
 265
 266 #[test]
 267 fn test_peekable_non_fused() {
 268     let mut iter = NonFused::new(empty::<i32>()).peekable();
 269
 270     assert_eq!(iter.peek(), None);
 271     assert_eq!(iter.next_back(), None);
 272 }