vendor/itertools-0.7.8/tests/test_core.rs

   1 //! Licensed under the Apache License, Version 2.0
   2 //! http://www.apache.org/licenses/LICENSE-2.0 or the MIT license
   3 //! http://opensource.org/licenses/MIT, at your
   4 //! option. This file may not be copied, modified, or distributed
   5 //! except according to those terms.
   6 #![no_std]
   7
   8 #[macro_use] extern crate itertools as it;
   9
  10 use it::flatten;
  11 use it::Itertools;
  12 use it::interleave;
  13 use it::multizip;
  14 use it::free::put_back;
  15
  16 #[test]
  17 fn product2() {
  18     let s = "αβ";
  19
  20     let mut prod = iproduct!(s.chars(), 0..2);
  21     assert!(prod.next() == Some(('α', 0)));
  22     assert!(prod.next() == Some(('α', 1)));
  23     assert!(prod.next() == Some(('β', 0)));
  24     assert!(prod.next() == Some(('β', 1)));
  25     assert!(prod.next() == None);
  26 }
  27
  28 #[test]
  29 fn product_temporary() {
  30     for (_x, _y, _z) in iproduct!(
  31         [0, 1, 2].iter().cloned(),
  32         [0, 1, 2].iter().cloned(),
  33         [0, 1, 2].iter().cloned())
  34     {
  35         // ok
  36     }
  37 }
  38
  39
  40 #[test]
  41 fn izip_macro() {
  42     let mut zip = izip!(2..3);
  43     assert!(zip.next() == Some(2));
  44     assert!(zip.next().is_none());
  45
  46     let mut zip = izip!(0..3, 0..2, 0..2i8);
  47     for i in 0..2 {
  48         assert!((i as usize, i, i as i8) == zip.next().unwrap());
  49     }
  50     assert!(zip.next().is_none());
  51
  52     let xs: [isize; 0] = [];
  53     let mut zip = izip!(0..3, 0..2, 0..2i8, &xs);
  54     assert!(zip.next().is_none());
  55 }
  56
  57 #[test]
  58 fn izip3() {
  59     let mut zip = multizip((0..3, 0..2, 0..2i8));
  60     for i in 0..2 {
  61         assert!((i as usize, i, i as i8) == zip.next().unwrap());
  62     }
  63     assert!(zip.next().is_none());
  64
  65     let xs: [isize; 0] = [];
  66     let mut zip = multizip((0..3, 0..2, 0..2i8, xs.iter()));
  67     assert!(zip.next().is_none());
  68
  69     for (_, _, _, _, _) in multizip((0..3, 0..2, xs.iter(), &xs, xs.to_vec())) {
  70         /* test compiles */
  71     }
  72 }
  73
  74 #[test]
  75 fn write_to() {
  76     let xs = [7, 9, 8];
  77     let mut ys = [0; 5];
  78     let cnt = ys.iter_mut().set_from(xs.iter().map(|x| *x));
  79     assert!(cnt == xs.len());
  80     assert!(ys == [7, 9, 8, 0, 0]);
  81
  82     let cnt = ys.iter_mut().set_from(0..10);
  83     assert!(cnt == ys.len());
  84     assert!(ys == [0, 1, 2, 3, 4]);
  85 }
  86
  87 #[test]
  88 fn test_interleave() {
  89     let xs: [u8; 0]  = [];
  90     let ys = [7u8, 9, 8, 10];
  91     let zs = [2u8, 77];
  92     let it = interleave(xs.iter(), ys.iter());
  93     it::assert_equal(it, ys.iter());
  94
  95     let rs = [7u8, 2, 9, 77, 8, 10];
  96     let it = interleave(ys.iter(), zs.iter());
  97     it::assert_equal(it, rs.iter());
  98 }
  99
 100 #[test]
 101 fn foreach() {
 102     let xs = [1i32, 2, 3];
 103     let mut sum = 0;
 104     xs.iter().foreach(|elt| sum += *elt);
 105     assert!(sum == 6);
 106 }
 107
 108 #[test]
 109 fn dropping() {
 110     let xs = [1, 2, 3];
 111     let mut it = xs.iter().dropping(2);
 112     assert_eq!(it.next(), Some(&3));
 113     assert!(it.next().is_none());
 114     let mut it = xs.iter().dropping(5);
 115     assert!(it.next().is_none());
 116 }
 117
 118 #[test]
 119 fn batching() {
 120     let xs = [0, 1, 2, 1, 3];
 121     let ys = [(0, 1), (2, 1)];
 122
 123     // An iterator that gathers elements up in pairs
 124     let pit = xs.iter().cloned().batching(|it| {
 125                match it.next() {
 126                    None => None,
 127                    Some(x) => match it.next() {
 128                        None => None,
 129                        Some(y) => Some((x, y)),
 130                    }
 131                }
 132            });
 133     it::assert_equal(pit, ys.iter().cloned());
 134 }
 135
 136 #[test]
 137 fn test_put_back() {
 138     let xs = [0, 1, 1, 1, 2, 1, 3, 3];
 139     let mut pb = put_back(xs.iter().cloned());
 140     pb.next();
 141     pb.put_back(1);
 142     pb.put_back(0);
 143     it::assert_equal(pb, xs.iter().cloned());
 144 }
 145
 146 #[test]
 147 fn step() {
 148     it::assert_equal((0..10).step(1), 0..10);
 149     it::assert_equal((0..10).step(2), (0..10).filter(|x: &i32| *x % 2 == 0));
 150     it::assert_equal((0..10).step(10), 0..1);
 151 }
 152
 153 #[test]
 154 fn merge() {
 155     it::assert_equal((0..10).step(2).merge((1..10).step(2)), 0..10);
 156 }
 157
 158
 159 #[test]
 160 fn repeatn() {
 161     let s = "α";
 162     let mut it = it::repeat_n(s, 3);
 163     assert_eq!(it.len(), 3);
 164     assert_eq!(it.next(), Some(s));
 165     assert_eq!(it.next(), Some(s));
 166     assert_eq!(it.next(), Some(s));
 167     assert_eq!(it.next(), None);
 168     assert_eq!(it.next(), None);
 169 }
 170
 171 #[test]
 172 fn count_clones() {
 173     // Check that RepeatN only clones N - 1 times.
 174
 175     use core::cell::Cell;
 176     #[derive(PartialEq, Debug)]
 177     struct Foo {
 178         n: Cell<usize>
 179     }
 180
 181     impl Clone for Foo
 182     {
 183         fn clone(&self) -> Self
 184         {
 185             let n = self.n.get();
 186             self.n.set(n + 1);
 187             Foo { n: Cell::new(n + 1) }
 188         }
 189     }
 190
 191
 192     for n in 0..10 {
 193         let f = Foo{n: Cell::new(0)};
 194         let it = it::repeat_n(f, n);
 195         // drain it
 196         let last = it.last();
 197         if n == 0 {
 198             assert_eq!(last, None);
 199         } else {
 200             assert_eq!(last, Some(Foo{n: Cell::new(n - 1)}));
 201         }
 202     }
 203 }
 204
 205 #[test]
 206 fn part() {
 207     let mut data = [7, 1, 1, 9, 1, 1, 3];
 208     let i = it::partition(&mut data, |elt| *elt >= 3);
 209     assert_eq!(i, 3);
 210     assert_eq!(data, [7, 3, 9, 1, 1, 1, 1]);
 211
 212     let i = it::partition(&mut data, |elt| *elt == 1);
 213     assert_eq!(i, 4);
 214     assert_eq!(data, [1, 1, 1, 1, 9, 3, 7]);
 215
 216     let mut data = [1, 2, 3, 4, 5, 6, 7, 8, 9];
 217     let i = it::partition(&mut data, |elt| *elt % 3 == 0);
 218     assert_eq!(i, 3);
 219     assert_eq!(data, [9, 6, 3, 4, 5, 2, 7, 8, 1]);
 220 }
 221
 222 #[test]
 223 fn flatten_clone() {
 224     let data = &[
 225         &[1,2,3],
 226         &[4,5,6]
 227     ];
 228     let flattened1 = flatten(data.into_iter().cloned());
 229     let flattened2 = flattened1.clone();
 230
 231     it::assert_equal(flattened1, &[1,2,3,4,5,6]);
 232     it::assert_equal(flattened2, &[1,2,3,4,5,6]);
 233 }
 234
 235 #[test]
 236 fn tree_fold1() {
 237     for i in 0..100 {
 238         assert_eq!((0..i).tree_fold1(|x, y| x + y), (0..i).fold1(|x, y| x + y));
 239     }
 240 }