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
  21 #[test]
  22 fn test_zip_nth_side_effects() {
  23     let mut a = Vec::new();
  24     let mut b = Vec::new();
  25     let value = [1, 2, 3, 4, 5, 6]
  26         .iter()
  27         .cloned()
  28         .map(|n| {
  29             a.push(n);
  30             n * 10
  31         })
  32         .zip([2, 3, 4, 5, 6, 7, 8].iter().cloned().map(|n| {
  33             b.push(n * 100);
  34             n * 1000
  35         }))
  36         .skip(1)
  37         .nth(3);
  38     assert_eq!(value, Some((50, 6000)));
  39     assert_eq!(a, vec![1, 2, 3, 4, 5]);
  40     assert_eq!(b, vec![200, 300, 400, 500, 600]);
  41 }
  42
  43 #[test]
  44 fn test_zip_next_back_side_effects() {
  45     let mut a = Vec::new();
  46     let mut b = Vec::new();
  47     let mut iter = [1, 2, 3, 4, 5, 6]
  48         .iter()
  49         .cloned()
  50         .map(|n| {
  51             a.push(n);
  52             n * 10
  53         })
  54         .zip([2, 3, 4, 5, 6, 7, 8].iter().cloned().map(|n| {
  55             b.push(n * 100);
  56             n * 1000
  57         }));
  58
  59     // The second iterator is one item longer, so `next_back` is called on it
  60     // one more time.
  61     assert_eq!(iter.next_back(), Some((60, 7000)));
  62     assert_eq!(iter.next_back(), Some((50, 6000)));
  63     assert_eq!(iter.next_back(), Some((40, 5000)));
  64     assert_eq!(iter.next_back(), Some((30, 4000)));
  65     assert_eq!(a, vec![6, 5, 4, 3]);
  66     assert_eq!(b, vec![800, 700, 600, 500, 400]);
  67 }
  68
  69 #[test]
  70 fn test_zip_nth_back_side_effects() {
  71     let mut a = Vec::new();
  72     let mut b = Vec::new();
  73     let value = [1, 2, 3, 4, 5, 6]
  74         .iter()
  75         .cloned()
  76         .map(|n| {
  77             a.push(n);
  78             n * 10
  79         })
  80         .zip([2, 3, 4, 5, 6, 7, 8].iter().cloned().map(|n| {
  81             b.push(n * 100);
  82             n * 1000
  83         }))
  84         .nth_back(3);
  85     assert_eq!(value, Some((30, 4000)));
  86     assert_eq!(a, vec![6, 5, 4, 3]);
  87     assert_eq!(b, vec![800, 700, 600, 500, 400]);
  88 }
  89
  90 #[test]
  91 fn test_zip_next_back_side_effects_exhausted() {
  92     let mut a = Vec::new();
  93     let mut b = Vec::new();
  94     let mut iter = [1, 2, 3, 4, 5, 6]
  95         .iter()
  96         .cloned()
  97         .map(|n| {
  98             a.push(n);
  99             n * 10
 100         })
 101         .zip([2, 3, 4].iter().cloned().map(|n| {
 102             b.push(n * 100);
 103             n * 1000
 104         }));
 105
 106     iter.next();
 107     iter.next();
 108     iter.next();
 109     iter.next();
 110     assert_eq!(iter.next_back(), None);
 111     assert_eq!(a, vec![1, 2, 3, 4, 6, 5]);
 112     assert_eq!(b, vec![200, 300, 400]);
 113 }
 114
 115 #[test]
 116 fn test_zip_cloned_sideffectful() {
 117     let xs = [CountClone::new(), CountClone::new(), CountClone::new(), CountClone::new()];
 118     let ys = [CountClone::new(), CountClone::new()];
 119
 120     for _ in xs.iter().cloned().zip(ys.iter().cloned()) {}
 121
 122     assert_eq!(&xs, &[1, 1, 1, 0][..]);
 123     assert_eq!(&ys, &[1, 1][..]);
 124
 125     let xs = [CountClone::new(), CountClone::new()];
 126     let ys = [CountClone::new(), CountClone::new(), CountClone::new(), CountClone::new()];
 127
 128     for _ in xs.iter().cloned().zip(ys.iter().cloned()) {}
 129
 130     assert_eq!(&xs, &[1, 1][..]);
 131     assert_eq!(&ys, &[1, 1, 0, 0][..]);
 132 }
 133
 134 #[test]
 135 fn test_zip_map_sideffectful() {
 136     let mut xs = [0; 6];
 137     let mut ys = [0; 4];
 138
 139     for _ in xs.iter_mut().map(|x| *x += 1).zip(ys.iter_mut().map(|y| *y += 1)) {}
 140
 141     assert_eq!(&xs, &[1, 1, 1, 1, 1, 0]);
 142     assert_eq!(&ys, &[1, 1, 1, 1]);
 143
 144     let mut xs = [0; 4];
 145     let mut ys = [0; 6];
 146
 147     for _ in xs.iter_mut().map(|x| *x += 1).zip(ys.iter_mut().map(|y| *y += 1)) {}
 148
 149     assert_eq!(&xs, &[1, 1, 1, 1]);
 150     assert_eq!(&ys, &[1, 1, 1, 1, 0, 0]);
 151 }
 152
 153 #[test]
 154 fn test_zip_map_rev_sideffectful() {
 155     let mut xs = [0; 6];
 156     let mut ys = [0; 4];
 157
 158     {
 159         let mut it = xs.iter_mut().map(|x| *x += 1).zip(ys.iter_mut().map(|y| *y += 1));
 160         it.next_back();
 161     }
 162     assert_eq!(&xs, &[0, 0, 0, 1, 1, 1]);
 163     assert_eq!(&ys, &[0, 0, 0, 1]);
 164
 165     let mut xs = [0; 6];
 166     let mut ys = [0; 4];
 167
 168     {
 169         let mut it = xs.iter_mut().map(|x| *x += 1).zip(ys.iter_mut().map(|y| *y += 1));
 170         (&mut it).take(5).count();
 171         it.next_back();
 172     }
 173     assert_eq!(&xs, &[1, 1, 1, 1, 1, 1]);
 174     assert_eq!(&ys, &[1, 1, 1, 1]);
 175 }
 176
 177 #[test]
 178 fn test_zip_nested_sideffectful() {
 179     let mut xs = [0; 6];
 180     let ys = [0; 4];
 181
 182     {
 183         // test that it has the side effect nested inside enumerate
 184         let it = xs.iter_mut().map(|x| *x = 1).enumerate().zip(&ys);
 185         it.count();
 186     }
 187     assert_eq!(&xs, &[1, 1, 1, 1, 1, 0]);
 188 }
 189
 190 #[test]
 191 fn test_zip_nth_back_side_effects_exhausted() {
 192     let mut a = Vec::new();
 193     let mut b = Vec::new();
 194     let mut iter = [1, 2, 3, 4, 5, 6]
 195         .iter()
 196         .cloned()
 197         .map(|n| {
 198             a.push(n);
 199             n * 10
 200         })
 201         .zip([2, 3, 4].iter().cloned().map(|n| {
 202             b.push(n * 100);
 203             n * 1000
 204         }));
 205
 206     iter.next();
 207     iter.next();
 208     iter.next();
 209     iter.next();
 210     assert_eq!(iter.nth_back(0), None);
 211     assert_eq!(a, vec![1, 2, 3, 4, 6, 5]);
 212     assert_eq!(b, vec![200, 300, 400]);
 213 }
 214
 215 #[test]
 216 fn test_zip_trusted_random_access_composition() {
 217     let a = [0, 1, 2, 3, 4];
 218     let b = a;
 219     let c = a;
 220
 221     let a = a.iter().copied();
 222     let b = b.iter().copied();
 223     let mut c = c.iter().copied();
 224     c.next();
 225
 226     let mut z1 = a.zip(b);
 227     assert_eq!(z1.next().unwrap(), (0, 0));
 228
 229     let mut z2 = z1.zip(c);
 230     fn assert_trusted_random_access<T: TrustedRandomAccess>(_a: &T) {}
 231     assert_trusted_random_access(&z2);
 232     assert_eq!(z2.next().unwrap(), ((1, 1), 1));
 233 }
 234
 235 #[test]
 236 #[cfg(panic = "unwind")]
 237 fn test_zip_trusted_random_access_next_back_drop() {
 238     use std::panic::catch_unwind;
 239     use std::panic::AssertUnwindSafe;
 240
 241     let mut counter = 0;
 242
 243     let it = [42].iter().map(|e| {
 244         let c = counter;
 245         counter += 1;
 246         if c == 0 {
 247             panic!("bomb");
 248         }
 249
 250         e
 251     });
 252     let it2 = [(); 0].iter();
 253     let mut zip = it.zip(it2);
 254     catch_unwind(AssertUnwindSafe(|| {
 255         zip.next_back();
 256     }))
 257     .unwrap_err();
 258     assert!(zip.next().is_none());
 259     assert_eq!(counter, 1);
 260 }
 261
 262 #[test]
 263 fn test_double_ended_zip() {
 264     let xs = [1, 2, 3, 4, 5, 6];
 265     let ys = [1, 2, 3, 7];
 266     let mut it = xs.iter().cloned().zip(ys);
 267     assert_eq!(it.next(), Some((1, 1)));
 268     assert_eq!(it.next(), Some((2, 2)));
 269     assert_eq!(it.next_back(), Some((4, 7)));
 270     assert_eq!(it.next_back(), Some((3, 3)));
 271     assert_eq!(it.next(), None);
 272 }
 273
 274 #[test]
 275 fn test_issue_82282() {
 276     fn overflowed_zip(arr: &[i32]) -> impl Iterator<Item = (i32, &())> {
 277         static UNIT_EMPTY_ARR: [(); 0] = [];
 278
 279         let mapped = arr.into_iter().map(|i| *i);
 280         let mut zipped = mapped.zip(UNIT_EMPTY_ARR.iter());
 281         zipped.next();
 282         zipped
 283     }
 284
 285     let arr = [1, 2, 3];
 286     let zip = overflowed_zip(&arr).zip(overflowed_zip(&arr));
 287
 288     assert_eq!(zip.size_hint(), (0, Some(0)));
 289     for _ in zip {
 290         panic!();
 291     }
 292 }
 293
 294 #[test]
 295 fn test_issue_82291() {
 296     use std::cell::Cell;
 297
 298     let mut v1 = [()];
 299     let v2 = [()];
 300
 301     let called = Cell::new(0);
 302
 303     let mut zip = v1
 304         .iter_mut()
 305         .map(|r| {
 306             called.set(called.get() + 1);
 307             r
 308         })
 309         .zip(&v2);
 310
 311     zip.next_back();
 312     assert_eq!(called.get(), 1);
 313     zip.next();
 314     assert_eq!(called.get(), 1);
 315 }