vendor/generic-array-0.12.3/tests/iter.rs

   1 #[macro_use]
   2 extern crate generic_array;
   3
   4 use std::cell::Cell;
   5 use std::ops::Drop;
   6
   7 use generic_array::GenericArray;
   8 use generic_array::typenum::consts::U5;
   9
  10 #[test]
  11 fn test_into_iter_as_slice() {
  12     let array = arr![char; 'a', 'b', 'c'];
  13     let mut into_iter = array.into_iter();
  14     assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']);
  15     let _ = into_iter.next().unwrap();
  16     assert_eq!(into_iter.as_slice(), &['b', 'c']);
  17     let _ = into_iter.next().unwrap();
  18     let _ = into_iter.next().unwrap();
  19     assert_eq!(into_iter.as_slice(), &[]);
  20 }
  21
  22 #[test]
  23 fn test_into_iter_as_mut_slice() {
  24     let array = arr![char; 'a', 'b', 'c'];
  25     let mut into_iter = array.into_iter();
  26     assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']);
  27     into_iter.as_mut_slice()[0] = 'x';
  28     into_iter.as_mut_slice()[1] = 'y';
  29     assert_eq!(into_iter.next().unwrap(), 'x');
  30     assert_eq!(into_iter.as_slice(), &['y', 'c']);
  31 }
  32
  33 #[test]
  34 fn test_into_iter_debug() {
  35     let array = arr![char; 'a', 'b', 'c'];
  36     let into_iter = array.into_iter();
  37     let debug = format!("{:?}", into_iter);
  38     assert_eq!(debug, "GenericArrayIter(['a', 'b', 'c'])");
  39 }
  40
  41 #[test]
  42 fn test_into_iter_clone() {
  43     fn iter_equal<I: Iterator<Item = i32>>(it: I, slice: &[i32]) {
  44         let v: Vec<i32> = it.collect();
  45         assert_eq!(&v[..], slice);
  46     }
  47     let mut it = arr![i32; 1, 2, 3].into_iter();
  48     iter_equal(it.clone(), &[1, 2, 3]);
  49     assert_eq!(it.next(), Some(1));
  50     let mut it = it.rev();
  51     iter_equal(it.clone(), &[3, 2]);
  52     assert_eq!(it.next(), Some(3));
  53     iter_equal(it.clone(), &[2]);
  54     assert_eq!(it.next(), Some(2));
  55     iter_equal(it.clone(), &[]);
  56     assert_eq!(it.next(), None);
  57 }
  58
  59 #[test]
  60 fn test_into_iter_nth() {
  61     let v = arr![i32; 0, 1, 2, 3, 4];
  62     for i in 0..v.len() {
  63         assert_eq!(v.clone().into_iter().nth(i).unwrap(), v[i]);
  64     }
  65     assert_eq!(v.clone().into_iter().nth(v.len()), None);
  66
  67     let mut iter = v.into_iter();
  68     assert_eq!(iter.nth(2).unwrap(), v[2]);
  69     assert_eq!(iter.nth(1).unwrap(), v[4]);
  70 }
  71
  72 #[test]
  73 fn test_into_iter_last() {
  74     let v = arr![i32; 0, 1, 2, 3, 4];
  75     assert_eq!(v.into_iter().last().unwrap(), 4);
  76     assert_eq!(arr![i32; 0].into_iter().last().unwrap(), 0);
  77 }
  78
  79 #[test]
  80 fn test_into_iter_count() {
  81     let v = arr![i32; 0, 1, 2, 3, 4];
  82     assert_eq!(v.clone().into_iter().count(), 5);
  83
  84     let mut iter2 = v.into_iter();
  85     iter2.next();
  86     iter2.next();
  87     assert_eq!(iter2.count(), 3);
  88 }
  89
  90 #[test]
  91 fn test_into_iter_flat_map() {
  92     assert!((0..5).flat_map(|i| arr![i32; 2 * i, 2 * i + 1]).eq(0..10));
  93 }
  94
  95 #[test]
  96 fn test_into_iter_drops() {
  97     struct R<'a> {
  98        i: &'a Cell<usize>,
  99     }
 100
 101     impl<'a> Drop for R<'a> {
 102        fn drop(&mut self) {
 103             self.i.set(self.i.get() + 1);
 104         }
 105     }
 106
 107     fn r(i: &Cell<usize>) -> R {
 108         R {
 109             i: i
 110         }
 111     }
 112
 113     fn v(i: &Cell<usize>) -> GenericArray<R, U5> {
 114         arr![R; r(i), r(i), r(i), r(i), r(i)]
 115     }
 116
 117     let i = Cell::new(0);
 118     {
 119         v(&i).into_iter();
 120     }
 121     assert_eq!(i.get(), 5);
 122
 123     let i = Cell::new(0);
 124     {
 125         let mut iter = v(&i).into_iter();
 126         let _x = iter.next();
 127         assert_eq!(i.get(), 0);
 128         assert_eq!(iter.count(), 4);
 129         assert_eq!(i.get(), 4);
 130     }
 131     assert_eq!(i.get(), 5);
 132
 133     let i = Cell::new(0);
 134     {
 135         let mut iter = v(&i).into_iter();
 136         let _x = iter.nth(2);
 137         assert_eq!(i.get(), 2);
 138         let _y = iter.last();
 139         assert_eq!(i.get(), 3);
 140     }
 141     assert_eq!(i.get(), 5);
 142
 143     let i = Cell::new(0);
 144     for (index, _x) in v(&i).into_iter().enumerate() {
 145         assert_eq!(i.get(), index);
 146     }
 147     assert_eq!(i.get(), 5);
 148
 149     let i = Cell::new(0);
 150     for (index, _x) in v(&i).into_iter().rev().enumerate() {
 151         assert_eq!(i.get(), index);
 152     }
 153     assert_eq!(i.get(), 5);
 154 }
 155
 156 /*
 157 //TODO: Cover this
 158 #[allow(dead_code)]
 159 fn assert_covariance() {
 160     fn into_iter<'new>(i: GenericArrayIter<&'static str, U10>) -> GenericArrayIter<&'new str, U10> {
 161         i
 162     }
 163 }
 164 */