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

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