library/core/tests/iter/traits/iterator.rs

   1 /// A wrapper struct that implements `Eq` and `Ord` based on the wrapped
   2 /// integer modulo 3. Used to test that `Iterator::max` and `Iterator::min`
   3 /// return the correct element if some of them are equal.
   4 #[derive(Debug)]
   5 struct Mod3(i32);
   6
   7 impl PartialEq for Mod3 {
   8     fn eq(&self, other: &Self) -> bool {
   9         self.0 % 3 == other.0 % 3
  10     }
  11 }
  12
  13 impl Eq for Mod3 {}
  14
  15 impl PartialOrd for Mod3 {
  16     fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
  17         Some(self.cmp(other))
  18     }
  19 }
  20
  21 impl Ord for Mod3 {
  22     fn cmp(&self, other: &Self) -> core::cmp::Ordering {
  23         (self.0 % 3).cmp(&(other.0 % 3))
  24     }
  25 }
  26
  27 #[test]
  28 fn test_lt() {
  29     let empty: [isize; 0] = [];
  30     let xs = [1, 2, 3];
  31     let ys = [1, 2, 0];
  32
  33     assert!(!xs.iter().lt(ys.iter()));
  34     assert!(!xs.iter().le(ys.iter()));
  35     assert!(xs.iter().gt(ys.iter()));
  36     assert!(xs.iter().ge(ys.iter()));
  37
  38     assert!(ys.iter().lt(xs.iter()));
  39     assert!(ys.iter().le(xs.iter()));
  40     assert!(!ys.iter().gt(xs.iter()));
  41     assert!(!ys.iter().ge(xs.iter()));
  42
  43     assert!(empty.iter().lt(xs.iter()));
  44     assert!(empty.iter().le(xs.iter()));
  45     assert!(!empty.iter().gt(xs.iter()));
  46     assert!(!empty.iter().ge(xs.iter()));
  47
  48     // Sequence with NaN
  49     let u = [1.0f64, 2.0];
  50     let v = [0.0f64 / 0.0, 3.0];
  51
  52     assert!(!u.iter().lt(v.iter()));
  53     assert!(!u.iter().le(v.iter()));
  54     assert!(!u.iter().gt(v.iter()));
  55     assert!(!u.iter().ge(v.iter()));
  56
  57     let a = [0.0f64 / 0.0];
  58     let b = [1.0f64];
  59     let c = [2.0f64];
  60
  61     assert!(a.iter().lt(b.iter()) == (a[0] < b[0]));
  62     assert!(a.iter().le(b.iter()) == (a[0] <= b[0]));
  63     assert!(a.iter().gt(b.iter()) == (a[0] > b[0]));
  64     assert!(a.iter().ge(b.iter()) == (a[0] >= b[0]));
  65
  66     assert!(c.iter().lt(b.iter()) == (c[0] < b[0]));
  67     assert!(c.iter().le(b.iter()) == (c[0] <= b[0]));
  68     assert!(c.iter().gt(b.iter()) == (c[0] > b[0]));
  69     assert!(c.iter().ge(b.iter()) == (c[0] >= b[0]));
  70 }
  71
  72 #[test]
  73 fn test_cmp_by() {
  74     use core::cmp::Ordering;
  75
  76     let f = |x: i32, y: i32| (x * x).cmp(&y);
  77     let xs = || [1, 2, 3, 4].iter().copied();
  78     let ys = || [1, 4, 16].iter().copied();
  79
  80     assert_eq!(xs().cmp_by(ys(), f), Ordering::Less);
  81     assert_eq!(ys().cmp_by(xs(), f), Ordering::Greater);
  82     assert_eq!(xs().cmp_by(xs().map(|x| x * x), f), Ordering::Equal);
  83     assert_eq!(xs().rev().cmp_by(ys().rev(), f), Ordering::Greater);
  84     assert_eq!(xs().cmp_by(ys().rev(), f), Ordering::Less);
  85     assert_eq!(xs().cmp_by(ys().take(2), f), Ordering::Greater);
  86 }
  87
  88 #[test]
  89 fn test_partial_cmp_by() {
  90     use core::cmp::Ordering;
  91
  92     let f = |x: i32, y: i32| (x * x).partial_cmp(&y);
  93     let xs = || [1, 2, 3, 4].iter().copied();
  94     let ys = || [1, 4, 16].iter().copied();
  95
  96     assert_eq!(xs().partial_cmp_by(ys(), f), Some(Ordering::Less));
  97     assert_eq!(ys().partial_cmp_by(xs(), f), Some(Ordering::Greater));
  98     assert_eq!(xs().partial_cmp_by(xs().map(|x| x * x), f), Some(Ordering::Equal));
  99     assert_eq!(xs().rev().partial_cmp_by(ys().rev(), f), Some(Ordering::Greater));
 100     assert_eq!(xs().partial_cmp_by(xs().rev(), f), Some(Ordering::Less));
 101     assert_eq!(xs().partial_cmp_by(ys().take(2), f), Some(Ordering::Greater));
 102
 103     let f = |x: f64, y: f64| (x * x).partial_cmp(&y);
 104     let xs = || [1.0, 2.0, 3.0, 4.0].iter().copied();
 105     let ys = || [1.0, 4.0, f64::NAN, 16.0].iter().copied();
 106
 107     assert_eq!(xs().partial_cmp_by(ys(), f), None);
 108     assert_eq!(ys().partial_cmp_by(xs(), f), Some(Ordering::Greater));
 109 }
 110
 111 #[test]
 112 fn test_eq_by() {
 113     let f = |x: i32, y: i32| x * x == y;
 114     let xs = || [1, 2, 3, 4].iter().copied();
 115     let ys = || [1, 4, 9, 16].iter().copied();
 116
 117     assert!(xs().eq_by(ys(), f));
 118     assert!(!ys().eq_by(xs(), f));
 119     assert!(!xs().eq_by(xs(), f));
 120     assert!(!ys().eq_by(ys(), f));
 121
 122     assert!(!xs().take(3).eq_by(ys(), f));
 123     assert!(!xs().eq_by(ys().take(3), f));
 124     assert!(xs().take(3).eq_by(ys().take(3), f));
 125 }
 126
 127 #[test]
 128 fn test_iterator_nth() {
 129     let v: &[_] = &[0, 1, 2, 3, 4];
 130     for i in 0..v.len() {
 131         assert_eq!(v.iter().nth(i).unwrap(), &v[i]);
 132     }
 133     assert_eq!(v.iter().nth(v.len()), None);
 134 }
 135
 136 #[test]
 137 fn test_iterator_nth_back() {
 138     let v: &[_] = &[0, 1, 2, 3, 4];
 139     for i in 0..v.len() {
 140         assert_eq!(v.iter().nth_back(i).unwrap(), &v[v.len() - 1 - i]);
 141     }
 142     assert_eq!(v.iter().nth_back(v.len()), None);
 143 }
 144
 145 #[test]
 146 fn test_iterator_advance_by() {
 147     let v: &[_] = &[0, 1, 2, 3, 4];
 148
 149     for i in 0..v.len() {
 150         let mut iter = v.iter();
 151         assert_eq!(iter.advance_by(i), Ok(()));
 152         assert_eq!(iter.next().unwrap(), &v[i]);
 153         assert_eq!(iter.advance_by(100), Err(v.len() - 1 - i));
 154     }
 155
 156     assert_eq!(v.iter().advance_by(v.len()), Ok(()));
 157     assert_eq!(v.iter().advance_by(100), Err(v.len()));
 158 }
 159
 160 #[test]
 161 fn test_iterator_advance_back_by() {
 162     let v: &[_] = &[0, 1, 2, 3, 4];
 163
 164     for i in 0..v.len() {
 165         let mut iter = v.iter();
 166         assert_eq!(iter.advance_back_by(i), Ok(()));
 167         assert_eq!(iter.next_back().unwrap(), &v[v.len() - 1 - i]);
 168         assert_eq!(iter.advance_back_by(100), Err(v.len() - 1 - i));
 169     }
 170
 171     assert_eq!(v.iter().advance_back_by(v.len()), Ok(()));
 172     assert_eq!(v.iter().advance_back_by(100), Err(v.len()));
 173 }
 174
 175 #[test]
 176 fn test_iterator_rev_advance_back_by() {
 177     let v: &[_] = &[0, 1, 2, 3, 4];
 178
 179     for i in 0..v.len() {
 180         let mut iter = v.iter().rev();
 181         assert_eq!(iter.advance_back_by(i), Ok(()));
 182         assert_eq!(iter.next_back().unwrap(), &v[i]);
 183         assert_eq!(iter.advance_back_by(100), Err(v.len() - 1 - i));
 184     }
 185
 186     assert_eq!(v.iter().rev().advance_back_by(v.len()), Ok(()));
 187     assert_eq!(v.iter().rev().advance_back_by(100), Err(v.len()));
 188 }
 189
 190 #[test]
 191 fn test_iterator_last() {
 192     let v: &[_] = &[0, 1, 2, 3, 4];
 193     assert_eq!(v.iter().last().unwrap(), &4);
 194     assert_eq!(v[..1].iter().last().unwrap(), &0);
 195 }
 196
 197 #[test]
 198 fn test_iterator_max() {
 199     let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 200     assert_eq!(v[..4].iter().cloned().max(), Some(3));
 201     assert_eq!(v.iter().cloned().max(), Some(10));
 202     assert_eq!(v[..0].iter().cloned().max(), None);
 203     assert_eq!(v.iter().cloned().map(Mod3).max().map(|x| x.0), Some(8));
 204 }
 205
 206 #[test]
 207 fn test_iterator_min() {
 208     let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 209     assert_eq!(v[..4].iter().cloned().min(), Some(0));
 210     assert_eq!(v.iter().cloned().min(), Some(0));
 211     assert_eq!(v[..0].iter().cloned().min(), None);
 212     assert_eq!(v.iter().cloned().map(Mod3).min().map(|x| x.0), Some(0));
 213 }
 214
 215 #[test]
 216 fn test_iterator_size_hint() {
 217     let c = (0..).step_by(1);
 218     let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
 219     let v2 = &[10, 11, 12];
 220     let vi = v.iter();
 221
 222     assert_eq!((0..).size_hint(), (usize::MAX, None));
 223     assert_eq!(c.size_hint(), (usize::MAX, None));
 224     assert_eq!(vi.clone().size_hint(), (10, Some(10)));
 225
 226     assert_eq!(c.clone().take(5).size_hint(), (5, Some(5)));
 227     assert_eq!(c.clone().skip(5).size_hint().1, None);
 228     assert_eq!(c.clone().take_while(|_| false).size_hint(), (0, None));
 229     assert_eq!(c.clone().map_while(|_| None::<()>).size_hint(), (0, None));
 230     assert_eq!(c.clone().skip_while(|_| false).size_hint(), (0, None));
 231     assert_eq!(c.clone().enumerate().size_hint(), (usize::MAX, None));
 232     assert_eq!(c.clone().chain(vi.clone().cloned()).size_hint(), (usize::MAX, None));
 233     assert_eq!(c.clone().zip(vi.clone()).size_hint(), (10, Some(10)));
 234     assert_eq!(c.clone().scan(0, |_, _| Some(0)).size_hint(), (0, None));
 235     assert_eq!(c.clone().filter(|_| false).size_hint(), (0, None));
 236     assert_eq!(c.clone().map(|_| 0).size_hint(), (usize::MAX, None));
 237     assert_eq!(c.filter_map(|_| Some(0)).size_hint(), (0, None));
 238
 239     assert_eq!(vi.clone().take(5).size_hint(), (5, Some(5)));
 240     assert_eq!(vi.clone().take(12).size_hint(), (10, Some(10)));
 241     assert_eq!(vi.clone().skip(3).size_hint(), (7, Some(7)));
 242     assert_eq!(vi.clone().skip(12).size_hint(), (0, Some(0)));
 243     assert_eq!(vi.clone().take_while(|_| false).size_hint(), (0, Some(10)));
 244     assert_eq!(vi.clone().map_while(|_| None::<()>).size_hint(), (0, Some(10)));
 245     assert_eq!(vi.clone().skip_while(|_| false).size_hint(), (0, Some(10)));
 246     assert_eq!(vi.clone().enumerate().size_hint(), (10, Some(10)));
 247     assert_eq!(vi.clone().chain(v2).size_hint(), (13, Some(13)));
 248     assert_eq!(vi.clone().zip(v2).size_hint(), (3, Some(3)));
 249     assert_eq!(vi.clone().scan(0, |_, _| Some(0)).size_hint(), (0, Some(10)));
 250     assert_eq!(vi.clone().filter(|_| false).size_hint(), (0, Some(10)));
 251     assert_eq!(vi.clone().map(|&i| i + 1).size_hint(), (10, Some(10)));
 252     assert_eq!(vi.filter_map(|_| Some(0)).size_hint(), (0, Some(10)));
 253 }
 254
 255 #[test]
 256 fn test_all() {
 257     let v: Box<[isize]> = Box::new([1, 2, 3, 4, 5]);
 258     assert!(v.iter().all(|&x| x < 10));
 259     assert!(!v.iter().all(|&x| x % 2 == 0));
 260     assert!(!v.iter().all(|&x| x > 100));
 261     assert!(v[..0].iter().all(|_| panic!()));
 262 }
 263
 264 #[test]
 265 fn test_any() {
 266     let v: Box<[isize]> = Box::new([1, 2, 3, 4, 5]);
 267     assert!(v.iter().any(|&x| x < 10));
 268     assert!(v.iter().any(|&x| x % 2 == 0));
 269     assert!(!v.iter().any(|&x| x > 100));
 270     assert!(!v[..0].iter().any(|_| panic!()));
 271 }
 272
 273 #[test]
 274 fn test_find() {
 275     let v: &[isize] = &[1, 3, 9, 27, 103, 14, 11];
 276     assert_eq!(*v.iter().find(|&&x| x & 1 == 0).unwrap(), 14);
 277     assert_eq!(*v.iter().find(|&&x| x % 3 == 0).unwrap(), 3);
 278     assert!(v.iter().find(|&&x| x % 12 == 0).is_none());
 279 }
 280
 281 #[test]
 282 fn test_try_find() {
 283     let xs: &[isize] = &[];
 284     assert_eq!(xs.iter().try_find(testfn), Ok(None));
 285     let xs: &[isize] = &[1, 2, 3, 4];
 286     assert_eq!(xs.iter().try_find(testfn), Ok(Some(&2)));
 287     let xs: &[isize] = &[1, 3, 4];
 288     assert_eq!(xs.iter().try_find(testfn), Err(()));
 289
 290     let xs: &[isize] = &[1, 2, 3, 4, 5, 6, 7];
 291     let mut iter = xs.iter();
 292     assert_eq!(iter.try_find(testfn), Ok(Some(&2)));
 293     assert_eq!(iter.try_find(testfn), Err(()));
 294     assert_eq!(iter.next(), Some(&5));
 295
 296     fn testfn(x: &&isize) -> Result<bool, ()> {
 297         if **x == 2 {
 298             return Ok(true);
 299         }
 300         if **x == 4 {
 301             return Err(());
 302         }
 303         Ok(false)
 304     }
 305 }
 306
 307 #[test]
 308 fn test_try_find_api_usability() -> Result<(), Box<dyn std::error::Error>> {
 309     let a = ["1", "2"];
 310
 311     let is_my_num = |s: &str, search: i32| -> Result<bool, std::num::ParseIntError> {
 312         Ok(s.parse::<i32>()? == search)
 313     };
 314
 315     let val = a.iter().try_find(|&&s| is_my_num(s, 2))?;
 316     assert_eq!(val, Some(&"2"));
 317
 318     Ok(())
 319 }
 320
 321 #[test]
 322 fn test_position() {
 323     let v = &[1, 3, 9, 27, 103, 14, 11];
 324     assert_eq!(v.iter().position(|x| *x & 1 == 0).unwrap(), 5);
 325     assert_eq!(v.iter().position(|x| *x % 3 == 0).unwrap(), 1);
 326     assert!(v.iter().position(|x| *x % 12 == 0).is_none());
 327 }
 328
 329 #[test]
 330 fn test_count() {
 331     let xs = &[1, 2, 2, 1, 5, 9, 0, 2];
 332     assert_eq!(xs.iter().filter(|x| **x == 2).count(), 3);
 333     assert_eq!(xs.iter().filter(|x| **x == 5).count(), 1);
 334     assert_eq!(xs.iter().filter(|x| **x == 95).count(), 0);
 335 }
 336
 337 #[test]
 338 fn test_max_by_key() {
 339     let xs: &[isize] = &[-3, 0, 1, 5, -10];
 340     assert_eq!(*xs.iter().max_by_key(|x| x.abs()).unwrap(), -10);
 341 }
 342
 343 #[test]
 344 fn test_max_by() {
 345     let xs: &[isize] = &[-3, 0, 1, 5, -10];
 346     assert_eq!(*xs.iter().max_by(|x, y| x.abs().cmp(&y.abs())).unwrap(), -10);
 347 }
 348
 349 #[test]
 350 fn test_min_by_key() {
 351     let xs: &[isize] = &[-3, 0, 1, 5, -10];
 352     assert_eq!(*xs.iter().min_by_key(|x| x.abs()).unwrap(), 0);
 353 }
 354
 355 #[test]
 356 fn test_min_by() {
 357     let xs: &[isize] = &[-3, 0, 1, 5, -10];
 358     assert_eq!(*xs.iter().min_by(|x, y| x.abs().cmp(&y.abs())).unwrap(), 0);
 359 }
 360
 361 #[test]
 362 fn test_by_ref() {
 363     let mut xs = 0..10;
 364     // sum the first five values
 365     let partial_sum = xs.by_ref().take(5).fold(0, |a, b| a + b);
 366     assert_eq!(partial_sum, 10);
 367     assert_eq!(xs.next(), Some(5));
 368 }
 369
 370 #[test]
 371 fn test_is_sorted() {
 372     assert!([1, 2, 2, 9].iter().is_sorted());
 373     assert!(![1, 3, 2].iter().is_sorted());
 374     assert!([0].iter().is_sorted());
 375     assert!(std::iter::empty::<i32>().is_sorted());
 376     assert!(![0.0, 1.0, f32::NAN].iter().is_sorted());
 377     assert!([-2, -1, 0, 3].iter().is_sorted());
 378     assert!(![-2i32, -1, 0, 3].iter().is_sorted_by_key(|n| n.abs()));
 379     assert!(!["c", "bb", "aaa"].iter().is_sorted());
 380     assert!(["c", "bb", "aaa"].iter().is_sorted_by_key(|s| s.len()));
 381 }
 382
 383 #[test]
 384 fn test_partition() {
 385     fn check(xs: &mut [i32], ref p: impl Fn(&i32) -> bool, expected: usize) {
 386         let i = xs.iter_mut().partition_in_place(p);
 387         assert_eq!(expected, i);
 388         assert!(xs[..i].iter().all(p));
 389         assert!(!xs[i..].iter().any(p));
 390         assert!(xs.iter().is_partitioned(p));
 391         if i == 0 || i == xs.len() {
 392             assert!(xs.iter().rev().is_partitioned(p));
 393         } else {
 394             assert!(!xs.iter().rev().is_partitioned(p));
 395         }
 396     }
 397
 398     check(&mut [], |_| true, 0);
 399     check(&mut [], |_| false, 0);
 400
 401     check(&mut [0], |_| true, 1);
 402     check(&mut [0], |_| false, 0);
 403
 404     check(&mut [-1, 1], |&x| x > 0, 1);
 405     check(&mut [-1, 1], |&x| x < 0, 1);
 406
 407     let ref mut xs = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
 408     check(xs, |_| true, 10);
 409     check(xs, |_| false, 0);
 410     check(xs, |&x| x % 2 == 0, 5); // evens
 411     check(xs, |&x| x % 2 == 1, 5); // odds
 412     check(xs, |&x| x % 3 == 0, 4); // multiple of 3
 413     check(xs, |&x| x % 4 == 0, 3); // multiple of 4
 414     check(xs, |&x| x % 5 == 0, 2); // multiple of 5
 415     check(xs, |&x| x < 3, 3); // small
 416     check(xs, |&x| x > 6, 3); // large
 417 }
 418
 419 #[test]
 420 fn test_iterator_rev_advance_by() {
 421     let v: &[_] = &[0, 1, 2, 3, 4];
 422
 423     for i in 0..v.len() {
 424         let mut iter = v.iter().rev();
 425         assert_eq!(iter.advance_by(i), Ok(()));
 426         assert_eq!(iter.next().unwrap(), &v[v.len() - 1 - i]);
 427         assert_eq!(iter.advance_by(100), Err(v.len() - 1 - i));
 428     }
 429
 430     assert_eq!(v.iter().rev().advance_by(v.len()), Ok(()));
 431     assert_eq!(v.iter().rev().advance_by(100), Err(v.len()));
 432 }
 433
 434 #[test]
 435 fn test_find_map() {
 436     let xs: &[isize] = &[];
 437     assert_eq!(xs.iter().find_map(half_if_even), None);
 438     let xs: &[isize] = &[3, 5];
 439     assert_eq!(xs.iter().find_map(half_if_even), None);
 440     let xs: &[isize] = &[4, 5];
 441     assert_eq!(xs.iter().find_map(half_if_even), Some(2));
 442     let xs: &[isize] = &[3, 6];
 443     assert_eq!(xs.iter().find_map(half_if_even), Some(3));
 444
 445     let xs: &[isize] = &[1, 2, 3, 4, 5, 6, 7];
 446     let mut iter = xs.iter();
 447     assert_eq!(iter.find_map(half_if_even), Some(1));
 448     assert_eq!(iter.find_map(half_if_even), Some(2));
 449     assert_eq!(iter.find_map(half_if_even), Some(3));
 450     assert_eq!(iter.next(), Some(&7));
 451
 452     fn half_if_even(x: &isize) -> Option<isize> {
 453         if x % 2 == 0 { Some(x / 2) } else { None }
 454     }
 455 }
 456
 457 #[test]
 458 fn test_try_reduce() {
 459     let v = [1usize, 2, 3, 4, 5];
 460     let sum = v.into_iter().try_reduce(|x, y| x.checked_add(y));
 461     assert_eq!(sum, Some(Some(15)));
 462
 463     let v = [1, 2, 3, 4, 5, usize::MAX];
 464     let sum = v.into_iter().try_reduce(|x, y| x.checked_add(y));
 465     assert_eq!(sum, None);
 466
 467     let v: [usize; 0] = [];
 468     let sum = v.into_iter().try_reduce(|x, y| x.checked_add(y));
 469     assert_eq!(sum, Some(None));
 470
 471     let v = ["1", "2", "3", "4", "5"];
 472     let max = v.into_iter().try_reduce(|x, y| {
 473         if x.parse::<usize>().ok()? > y.parse::<usize>().ok()? { Some(x) } else { Some(y) }
 474     });
 475     assert_eq!(max, Some(Some("5")));
 476
 477     let v = ["1", "2", "3", "4", "5"];
 478     let max: Result<Option<_>, <usize as std::str::FromStr>::Err> =
 479         v.into_iter().try_reduce(|x, y| {
 480             if x.parse::<usize>()? > y.parse::<usize>()? { Ok(x) } else { Ok(y) }
 481         });
 482     assert_eq!(max, Ok(Some("5")));
 483 }
 484
 485 #[test]
 486 fn test_iterator_len() {
 487     let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 488     assert_eq!(v[..4].iter().count(), 4);
 489     assert_eq!(v[..10].iter().count(), 10);
 490     assert_eq!(v[..0].iter().count(), 0);
 491 }
 492
 493 #[test]
 494 fn test_collect() {
 495     let a = vec![1, 2, 3, 4, 5];
 496     let b: Vec<isize> = a.iter().cloned().collect();
 497     assert!(a == b);
 498 }
 499
 500 #[test]
 501 fn test_try_collect() {
 502     use core::ops::ControlFlow::{Break, Continue};
 503
 504     let u = vec![Some(1), Some(2), Some(3)];
 505     let v = u.into_iter().try_collect::<Vec<i32>>();
 506     assert_eq!(v, Some(vec![1, 2, 3]));
 507
 508     let u = vec![Some(1), Some(2), None, Some(3)];
 509     let mut it = u.into_iter();
 510     let v = it.try_collect::<Vec<i32>>();
 511     assert_eq!(v, None);
 512     let v = it.try_collect::<Vec<i32>>();
 513     assert_eq!(v, Some(vec![3]));
 514
 515     let u: Vec<Result<i32, ()>> = vec![Ok(1), Ok(2), Ok(3)];
 516     let v = u.into_iter().try_collect::<Vec<i32>>();
 517     assert_eq!(v, Ok(vec![1, 2, 3]));
 518
 519     let u = vec![Ok(1), Ok(2), Err(()), Ok(3)];
 520     let v = u.into_iter().try_collect::<Vec<i32>>();
 521     assert_eq!(v, Err(()));
 522
 523     let numbers = vec![1, 2, 3, 4, 5];
 524     let all_positive = numbers
 525         .iter()
 526         .cloned()
 527         .map(|n| if n > 0 { Some(n) } else { None })
 528         .try_collect::<Vec<i32>>();
 529     assert_eq!(all_positive, Some(numbers));
 530
 531     let numbers = vec![-2, -1, 0, 1, 2];
 532     let all_positive =
 533         numbers.into_iter().map(|n| if n > 0 { Some(n) } else { None }).try_collect::<Vec<i32>>();
 534     assert_eq!(all_positive, None);
 535
 536     let u = [Continue(1), Continue(2), Break(3), Continue(4), Continue(5)];
 537     let mut it = u.into_iter();
 538
 539     let v = it.try_collect::<Vec<_>>();
 540     assert_eq!(v, Break(3));
 541
 542     let v = it.try_collect::<Vec<_>>();
 543     assert_eq!(v, Continue(vec![4, 5]));
 544 }
 545
 546 #[test]
 547 fn test_collect_into() {
 548     let a = vec![1, 2, 3, 4, 5];
 549     let mut b = Vec::new();
 550     a.iter().cloned().collect_into(&mut b);
 551     assert!(a == b);
 552 }
 553
 554 #[test]
 555 fn iter_try_collect_uses_try_fold_not_next() {
 556     // This makes sure it picks up optimizations, and doesn't use the `&mut I` impl.
 557     struct PanicOnNext<I>(I);
 558     impl<I: Iterator> Iterator for PanicOnNext<I> {
 559         type Item = I::Item;
 560         fn next(&mut self) -> Option<Self::Item> {
 561             panic!("Iterator::next should not be called!")
 562         }
 563         fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
 564         where
 565             Self: Sized,
 566             F: FnMut(B, Self::Item) -> R,
 567             R: std::ops::Try<Output = B>,
 568         {
 569             self.0.try_fold(init, f)
 570         }
 571     }
 572
 573     let it = (0..10).map(Some);
 574     let _ = PanicOnNext(it).try_collect::<Vec<_>>();
 575     // validation is just that it didn't panic.
 576 }
 577
 578 #[test]
 579 fn test_next_chunk() {
 580     let mut it = 0..12;
 581     assert_eq!(it.next_chunk().unwrap(), [0, 1, 2, 3]);
 582     assert_eq!(it.next_chunk().unwrap(), []);
 583     assert_eq!(it.next_chunk().unwrap(), [4, 5, 6, 7, 8, 9]);
 584     assert_eq!(it.next_chunk::<4>().unwrap_err().as_slice(), &[10, 11]);
 585 }
 586
 587 // just tests by whether or not this compiles
 588 fn _empty_impl_all_auto_traits<T>() {
 589     use std::panic::{RefUnwindSafe, UnwindSafe};
 590     fn all_auto_traits<T: Send + Sync + Unpin + UnwindSafe + RefUnwindSafe>() {}
 591
 592     all_auto_traits::<std::iter::Empty<T>>();
 593 }