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_iterator_take_short() {
  78     let xs = [0, 1, 2, 3];
  79
  80     let mut it = xs.iter().take(5);
  81     let mut i = 0;
  82     assert_eq!(it.len(), xs.len());
  83     while let Some(&x) = it.next() {
  84         assert_eq!(x, xs[i]);
  85         i += 1;
  86         assert_eq!(it.len(), xs.len() - i);
  87     }
  88     assert_eq!(i, xs.len());
  89     assert_eq!(it.len(), 0);
  90
  91     let mut it = xs.iter().take(5);
  92     let mut i = 0;
  93     assert_eq!(it.len(), xs.len());
  94     while let Some(&x) = it.next_back() {
  95         i += 1;
  96         assert_eq!(x, xs[xs.len() - i]);
  97         assert_eq!(it.len(), xs.len() - i);
  98     }
  99     assert_eq!(i, xs.len());
 100     assert_eq!(it.len(), 0);
 101 }
 102
 103 #[test]
 104 fn test_take_try_folds() {
 105     let f = &|acc, x| i32::checked_add(2 * acc, x);
 106     assert_eq!((10..30).take(10).try_fold(7, f), (10..20).try_fold(7, f));
 107     assert_eq!((10..30).take(10).try_rfold(7, f), (10..20).try_rfold(7, f));
 108
 109     let mut iter = (10..30).take(20);
 110     assert_eq!(iter.try_fold(0, i8::checked_add), None);
 111     assert_eq!(iter.next(), Some(20));
 112     assert_eq!(iter.try_rfold(0, i8::checked_add), None);
 113     assert_eq!(iter.next_back(), Some(24));
 114
 115     let mut iter = (2..20).take(3);
 116     assert_eq!(iter.try_for_each(Err), Err(2));
 117     assert_eq!(iter.try_for_each(Err), Err(3));
 118     assert_eq!(iter.try_for_each(Err), Err(4));
 119     assert_eq!(iter.try_for_each(Err), Ok(()));
 120
 121     let mut iter = (2..20).take(3).rev();
 122     assert_eq!(iter.try_for_each(Err), Err(4));
 123     assert_eq!(iter.try_for_each(Err), Err(3));
 124     assert_eq!(iter.try_for_each(Err), Err(2));
 125     assert_eq!(iter.try_for_each(Err), Ok(()));
 126 }