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

   1 use super::*;
   2 use core::iter::*;
   3
   4 #[test]
   5 fn test_zip_nth() {
   6     let xs = [0, 1, 2, 4, 5];
   7     let ys = [10, 11, 12];
   8
   9     let mut it = xs.iter().zip(&ys);
  10     assert_eq!(it.nth(0), Some((&0, &10)));
  11     assert_eq!(it.nth(1), Some((&2, &12)));
  12     assert_eq!(it.nth(0), None);
  13
  14     let mut it = xs.iter().zip(&ys);
  15     assert_eq!(it.nth(3), None);
  16
  17     let mut it = ys.iter().zip(&xs);
  18     assert_eq!(it.nth(3), None);
  19 }
  20 #[test]
  21 fn test_zip_nth_side_effects() {
  22     let mut a = Vec::new();
  23     let mut b = Vec::new();
  24     let value = [1, 2, 3, 4, 5, 6]
  25         .iter()
  26         .cloned()
  27         .map(|n| {
  28             a.push(n);
  29             n * 10
  30         })
  31         .zip([2, 3, 4, 5, 6, 7, 8].iter().cloned().map(|n| {
  32             b.push(n * 100);
  33             n * 1000
  34         }))
  35         .skip(1)
  36         .nth(3);
  37     assert_eq!(value, Some((50, 6000)));
  38     assert_eq!(a, vec![1, 2, 3, 4, 5]);
  39     assert_eq!(b, vec![200, 300, 400, 500, 600]);
  40 }
  41 #[test]
  42 fn test_zip_next_back_side_effects() {
  43     let mut a = Vec::new();
  44     let mut b = Vec::new();
  45     let mut iter = [1, 2, 3, 4, 5, 6]
  46         .iter()
  47         .cloned()
  48         .map(|n| {
  49             a.push(n);
  50             n * 10
  51         })
  52         .zip([2, 3, 4, 5, 6, 7, 8].iter().cloned().map(|n| {
  53             b.push(n * 100);
  54             n * 1000
  55         }));
  56
  57     // The second iterator is one item longer, so `next_back` is called on it
  58     // one more time.
  59     assert_eq!(iter.next_back(), Some((60, 7000)));
  60     assert_eq!(iter.next_back(), Some((50, 6000)));
  61     assert_eq!(iter.next_back(), Some((40, 5000)));
  62     assert_eq!(iter.next_back(), Some((30, 4000)));
  63     assert_eq!(a, vec![6, 5, 4, 3]);
  64     assert_eq!(b, vec![800, 700, 600, 500, 400]);
  65 }
  66 #[test]
  67 fn test_zip_nth_back_side_effects() {
  68     let mut a = Vec::new();
  69     let mut b = Vec::new();
  70     let value = [1, 2, 3, 4, 5, 6]
  71         .iter()
  72         .cloned()
  73         .map(|n| {
  74             a.push(n);
  75             n * 10
  76         })
  77         .zip([2, 3, 4, 5, 6, 7, 8].iter().cloned().map(|n| {
  78             b.push(n * 100);
  79             n * 1000
  80         }))
  81         .nth_back(3);
  82     assert_eq!(value, Some((30, 4000)));
  83     assert_eq!(a, vec![6, 5, 4, 3]);
  84     assert_eq!(b, vec![800, 700, 600, 500, 400]);
  85 }
  86 #[test]
  87 fn test_zip_next_back_side_effects_exhausted() {
  88     let mut a = Vec::new();
  89     let mut b = Vec::new();
  90     let mut iter = [1, 2, 3, 4, 5, 6]
  91         .iter()
  92         .cloned()
  93         .map(|n| {
  94             a.push(n);
  95             n * 10
  96         })
  97         .zip([2, 3, 4].iter().cloned().map(|n| {
  98             b.push(n * 100);
  99             n * 1000
 100         }));
 101
 102     iter.next();
 103     iter.next();
 104     iter.next();
 105     iter.next();
 106     assert_eq!(iter.next_back(), None);
 107     assert_eq!(a, vec![1, 2, 3, 4, 6, 5]);
 108     assert_eq!(b, vec![200, 300, 400]);
 109 }
 110 #[test]
 111 fn test_zip_cloned_sideffectful() {
 112     let xs = [CountClone::new(), CountClone::new(), CountClone::new(), CountClone::new()];
 113     let ys = [CountClone::new(), CountClone::new()];
 114
 115     for _ in xs.iter().cloned().zip(ys.iter().cloned()) {}
 116
 117     assert_eq!(&xs, &[1, 1, 1, 0][..]);
 118     assert_eq!(&ys, &[1, 1][..]);
 119
 120     let xs = [CountClone::new(), CountClone::new()];
 121     let ys = [CountClone::new(), CountClone::new(), CountClone::new(), CountClone::new()];
 122
 123     for _ in xs.iter().cloned().zip(ys.iter().cloned()) {}
 124
 125     assert_eq!(&xs, &[1, 1][..]);
 126     assert_eq!(&ys, &[1, 1, 0, 0][..]);
 127 }
 128 #[test]
 129 fn test_zip_map_sideffectful() {
 130     let mut xs = [0; 6];
 131     let mut ys = [0; 4];
 132
 133     for _ in xs.iter_mut().map(|x| *x += 1).zip(ys.iter_mut().map(|y| *y += 1)) {}
 134
 135     assert_eq!(&xs, &[1, 1, 1, 1, 1, 0]);
 136     assert_eq!(&ys, &[1, 1, 1, 1]);
 137
 138     let mut xs = [0; 4];
 139     let mut ys = [0; 6];
 140
 141     for _ in xs.iter_mut().map(|x| *x += 1).zip(ys.iter_mut().map(|y| *y += 1)) {}
 142
 143     assert_eq!(&xs, &[1, 1, 1, 1]);
 144     assert_eq!(&ys, &[1, 1, 1, 1, 0, 0]);
 145 }
 146 #[test]
 147 fn test_zip_map_rev_sideffectful() {
 148     let mut xs = [0; 6];
 149     let mut ys = [0; 4];
 150
 151     {
 152         let mut it = xs.iter_mut().map(|x| *x += 1).zip(ys.iter_mut().map(|y| *y += 1));
 153         it.next_back();
 154     }
 155     assert_eq!(&xs, &[0, 0, 0, 1, 1, 1]);
 156     assert_eq!(&ys, &[0, 0, 0, 1]);
 157
 158     let mut xs = [0; 6];
 159     let mut ys = [0; 4];
 160
 161     {
 162         let mut it = xs.iter_mut().map(|x| *x += 1).zip(ys.iter_mut().map(|y| *y += 1));
 163         (&mut it).take(5).count();
 164         it.next_back();
 165     }
 166     assert_eq!(&xs, &[1, 1, 1, 1, 1, 1]);
 167     assert_eq!(&ys, &[1, 1, 1, 1]);
 168 }
 169 #[test]
 170 fn test_zip_nested_sideffectful() {
 171     let mut xs = [0; 6];
 172     let ys = [0; 4];
 173
 174     {
 175         // test that it has the side effect nested inside enumerate
 176         let it = xs.iter_mut().map(|x| *x = 1).enumerate().zip(&ys);
 177         it.count();
 178     }
 179     assert_eq!(&xs, &[1, 1, 1, 1, 1, 0]);
 180 }
 181 #[test]
 182 fn test_zip_nth_back_side_effects_exhausted() {
 183     let mut a = Vec::new();
 184     let mut b = Vec::new();
 185     let mut iter = [1, 2, 3, 4, 5, 6]
 186         .iter()
 187         .cloned()
 188         .map(|n| {
 189             a.push(n);
 190             n * 10
 191         })
 192         .zip([2, 3, 4].iter().cloned().map(|n| {
 193             b.push(n * 100);
 194             n * 1000
 195         }));
 196
 197     iter.next();
 198     iter.next();
 199     iter.next();
 200     iter.next();
 201     assert_eq!(iter.nth_back(0), None);
 202     assert_eq!(a, vec![1, 2, 3, 4, 6, 5]);
 203     assert_eq!(b, vec![200, 300, 400]);
 204 }
 205 #[test]
 206 fn test_zip_trusted_random_access_composition() {
 207     let a = [0, 1, 2, 3, 4];
 208     let b = a;
 209     let c = a;
 210
 211     let a = a.iter().copied();
 212     let b = b.iter().copied();
 213     let mut c = c.iter().copied();
 214     c.next();
 215
 216     let mut z1 = a.zip(b);
 217     assert_eq!(z1.next().unwrap(), (0, 0));
 218
 219     let mut z2 = z1.zip(c);
 220     fn assert_trusted_random_access<T: TrustedRandomAccess>(_a: &T) {}
 221     assert_trusted_random_access(&z2);
 222     assert_eq!(z2.next().unwrap(), ((1, 1), 1));
 223 }