library/alloc/tests/slice.rs

   1 use std::cmp::Ordering::{Equal, Greater, Less};
   2 use std::convert::identity;
   3 use std::fmt;
   4 use std::mem;
   5 use std::panic;
   6 use std::rc::Rc;
   7
   8 fn square(n: usize) -> usize {
   9     n * n
  10 }
  11
  12 fn is_odd(n: &usize) -> bool {
  13     *n % 2 == 1
  14 }
  15
  16 #[test]
  17 fn test_from_fn() {
  18     // Test on-stack from_fn.
  19     let mut v: Vec<_> = (0..3).map(square).collect();
  20     {
  21         let v = v;
  22         assert_eq!(v.len(), 3);
  23         assert_eq!(v[0], 0);
  24         assert_eq!(v[1], 1);
  25         assert_eq!(v[2], 4);
  26     }
  27
  28     // Test on-heap from_fn.
  29     v = (0..5).map(square).collect();
  30     {
  31         let v = v;
  32         assert_eq!(v.len(), 5);
  33         assert_eq!(v[0], 0);
  34         assert_eq!(v[1], 1);
  35         assert_eq!(v[2], 4);
  36         assert_eq!(v[3], 9);
  37         assert_eq!(v[4], 16);
  38     }
  39 }
  40
  41 #[test]
  42 fn test_from_elem() {
  43     // Test on-stack from_elem.
  44     let mut v = vec![10, 10];
  45     {
  46         let v = v;
  47         assert_eq!(v.len(), 2);
  48         assert_eq!(v[0], 10);
  49         assert_eq!(v[1], 10);
  50     }
  51
  52     // Test on-heap from_elem.
  53     v = vec![20; 6];
  54     {
  55         let v = &v[..];
  56         assert_eq!(v[0], 20);
  57         assert_eq!(v[1], 20);
  58         assert_eq!(v[2], 20);
  59         assert_eq!(v[3], 20);
  60         assert_eq!(v[4], 20);
  61         assert_eq!(v[5], 20);
  62     }
  63 }
  64
  65 #[test]
  66 fn test_is_empty() {
  67     let xs: [i32; 0] = [];
  68     assert!(xs.is_empty());
  69     assert!(![0].is_empty());
  70 }
  71
  72 #[test]
  73 fn test_len_divzero() {
  74     type Z = [i8; 0];
  75     let v0: &[Z] = &[];
  76     let v1: &[Z] = &[[]];
  77     let v2: &[Z] = &[[], []];
  78     assert_eq!(mem::size_of::<Z>(), 0);
  79     assert_eq!(v0.len(), 0);
  80     assert_eq!(v1.len(), 1);
  81     assert_eq!(v2.len(), 2);
  82 }
  83
  84 #[test]
  85 fn test_get() {
  86     let mut a = vec![11];
  87     assert_eq!(a.get(1), None);
  88     a = vec![11, 12];
  89     assert_eq!(a.get(1).unwrap(), &12);
  90     a = vec![11, 12, 13];
  91     assert_eq!(a.get(1).unwrap(), &12);
  92 }
  93
  94 #[test]
  95 fn test_first() {
  96     let mut a = vec![];
  97     assert_eq!(a.first(), None);
  98     a = vec![11];
  99     assert_eq!(a.first().unwrap(), &11);
 100     a = vec![11, 12];
 101     assert_eq!(a.first().unwrap(), &11);
 102 }
 103
 104 #[test]
 105 fn test_first_mut() {
 106     let mut a = vec![];
 107     assert_eq!(a.first_mut(), None);
 108     a = vec![11];
 109     assert_eq!(*a.first_mut().unwrap(), 11);
 110     a = vec![11, 12];
 111     assert_eq!(*a.first_mut().unwrap(), 11);
 112 }
 113
 114 #[test]
 115 fn test_split_first() {
 116     let mut a = vec![11];
 117     let b: &[i32] = &[];
 118     assert!(b.split_first().is_none());
 119     assert_eq!(a.split_first(), Some((&11, b)));
 120     a = vec![11, 12];
 121     let b: &[i32] = &[12];
 122     assert_eq!(a.split_first(), Some((&11, b)));
 123 }
 124
 125 #[test]
 126 fn test_split_first_mut() {
 127     let mut a = vec![11];
 128     let b: &mut [i32] = &mut [];
 129     assert!(b.split_first_mut().is_none());
 130     assert!(a.split_first_mut() == Some((&mut 11, b)));
 131     a = vec![11, 12];
 132     let b: &mut [_] = &mut [12];
 133     assert!(a.split_first_mut() == Some((&mut 11, b)));
 134 }
 135
 136 #[test]
 137 fn test_split_last() {
 138     let mut a = vec![11];
 139     let b: &[i32] = &[];
 140     assert!(b.split_last().is_none());
 141     assert_eq!(a.split_last(), Some((&11, b)));
 142     a = vec![11, 12];
 143     let b: &[_] = &[11];
 144     assert_eq!(a.split_last(), Some((&12, b)));
 145 }
 146
 147 #[test]
 148 fn test_split_last_mut() {
 149     let mut a = vec![11];
 150     let b: &mut [i32] = &mut [];
 151     assert!(b.split_last_mut().is_none());
 152     assert!(a.split_last_mut() == Some((&mut 11, b)));
 153
 154     a = vec![11, 12];
 155     let b: &mut [_] = &mut [11];
 156     assert!(a.split_last_mut() == Some((&mut 12, b)));
 157 }
 158
 159 #[test]
 160 fn test_last() {
 161     let mut a = vec![];
 162     assert_eq!(a.last(), None);
 163     a = vec![11];
 164     assert_eq!(a.last().unwrap(), &11);
 165     a = vec![11, 12];
 166     assert_eq!(a.last().unwrap(), &12);
 167 }
 168
 169 #[test]
 170 fn test_last_mut() {
 171     let mut a = vec![];
 172     assert_eq!(a.last_mut(), None);
 173     a = vec![11];
 174     assert_eq!(*a.last_mut().unwrap(), 11);
 175     a = vec![11, 12];
 176     assert_eq!(*a.last_mut().unwrap(), 12);
 177 }
 178
 179 #[test]
 180 fn test_slice() {
 181     // Test fixed length vector.
 182     let vec_fixed = [1, 2, 3, 4];
 183     let v_a = vec_fixed[1..vec_fixed.len()].to_vec();
 184     assert_eq!(v_a.len(), 3);
 185
 186     assert_eq!(v_a[0], 2);
 187     assert_eq!(v_a[1], 3);
 188     assert_eq!(v_a[2], 4);
 189
 190     // Test on stack.
 191     let vec_stack: &[_] = &[1, 2, 3];
 192     let v_b = vec_stack[1..3].to_vec();
 193     assert_eq!(v_b.len(), 2);
 194
 195     assert_eq!(v_b[0], 2);
 196     assert_eq!(v_b[1], 3);
 197
 198     // Test `Box<[T]>`
 199     let vec_unique = vec![1, 2, 3, 4, 5, 6];
 200     let v_d = vec_unique[1..6].to_vec();
 201     assert_eq!(v_d.len(), 5);
 202
 203     assert_eq!(v_d[0], 2);
 204     assert_eq!(v_d[1], 3);
 205     assert_eq!(v_d[2], 4);
 206     assert_eq!(v_d[3], 5);
 207     assert_eq!(v_d[4], 6);
 208 }
 209
 210 #[test]
 211 fn test_slice_from() {
 212     let vec: &[_] = &[1, 2, 3, 4];
 213     assert_eq!(&vec[..], vec);
 214     let b: &[_] = &[3, 4];
 215     assert_eq!(&vec[2..], b);
 216     let b: &[_] = &[];
 217     assert_eq!(&vec[4..], b);
 218 }
 219
 220 #[test]
 221 fn test_slice_to() {
 222     let vec: &[_] = &[1, 2, 3, 4];
 223     assert_eq!(&vec[..4], vec);
 224     let b: &[_] = &[1, 2];
 225     assert_eq!(&vec[..2], b);
 226     let b: &[_] = &[];
 227     assert_eq!(&vec[..0], b);
 228 }
 229
 230 #[test]
 231 fn test_pop() {
 232     let mut v = vec![5];
 233     let e = v.pop();
 234     assert_eq!(v.len(), 0);
 235     assert_eq!(e, Some(5));
 236     let f = v.pop();
 237     assert_eq!(f, None);
 238     let g = v.pop();
 239     assert_eq!(g, None);
 240 }
 241
 242 #[test]
 243 fn test_swap_remove() {
 244     let mut v = vec![1, 2, 3, 4, 5];
 245     let mut e = v.swap_remove(0);
 246     assert_eq!(e, 1);
 247     assert_eq!(v, [5, 2, 3, 4]);
 248     e = v.swap_remove(3);
 249     assert_eq!(e, 4);
 250     assert_eq!(v, [5, 2, 3]);
 251 }
 252
 253 #[test]
 254 #[should_panic]
 255 fn test_swap_remove_fail() {
 256     let mut v = vec![1];
 257     let _ = v.swap_remove(0);
 258     let _ = v.swap_remove(0);
 259 }
 260
 261 #[test]
 262 fn test_swap_remove_noncopyable() {
 263     // Tests that we don't accidentally run destructors twice.
 264     let mut v: Vec<Box<_>> = Vec::new();
 265     v.push(Box::new(0));
 266     v.push(Box::new(0));
 267     v.push(Box::new(0));
 268     let mut _e = v.swap_remove(0);
 269     assert_eq!(v.len(), 2);
 270     _e = v.swap_remove(1);
 271     assert_eq!(v.len(), 1);
 272     _e = v.swap_remove(0);
 273     assert_eq!(v.len(), 0);
 274 }
 275
 276 #[test]
 277 fn test_push() {
 278     // Test on-stack push().
 279     let mut v = vec![];
 280     v.push(1);
 281     assert_eq!(v.len(), 1);
 282     assert_eq!(v[0], 1);
 283
 284     // Test on-heap push().
 285     v.push(2);
 286     assert_eq!(v.len(), 2);
 287     assert_eq!(v[0], 1);
 288     assert_eq!(v[1], 2);
 289 }
 290
 291 #[test]
 292 fn test_truncate() {
 293     let mut v: Vec<Box<_>> = vec![Box::new(6), Box::new(5), Box::new(4)];
 294     v.truncate(1);
 295     let v = v;
 296     assert_eq!(v.len(), 1);
 297     assert_eq!(*(v[0]), 6);
 298     // If the unsafe block didn't drop things properly, we blow up here.
 299 }
 300
 301 #[test]
 302 fn test_clear() {
 303     let mut v: Vec<Box<_>> = vec![Box::new(6), Box::new(5), Box::new(4)];
 304     v.clear();
 305     assert_eq!(v.len(), 0);
 306     // If the unsafe block didn't drop things properly, we blow up here.
 307 }
 308
 309 #[test]
 310 fn test_retain() {
 311     let mut v = vec![1, 2, 3, 4, 5];
 312     v.retain(is_odd);
 313     assert_eq!(v, [1, 3, 5]);
 314 }
 315
 316 #[test]
 317 fn test_binary_search() {
 318     assert_eq!([1, 2, 3, 4, 5].binary_search(&5).ok(), Some(4));
 319     assert_eq!([1, 2, 3, 4, 5].binary_search(&4).ok(), Some(3));
 320     assert_eq!([1, 2, 3, 4, 5].binary_search(&3).ok(), Some(2));
 321     assert_eq!([1, 2, 3, 4, 5].binary_search(&2).ok(), Some(1));
 322     assert_eq!([1, 2, 3, 4, 5].binary_search(&1).ok(), Some(0));
 323
 324     assert_eq!([2, 4, 6, 8, 10].binary_search(&1).ok(), None);
 325     assert_eq!([2, 4, 6, 8, 10].binary_search(&5).ok(), None);
 326     assert_eq!([2, 4, 6, 8, 10].binary_search(&4).ok(), Some(1));
 327     assert_eq!([2, 4, 6, 8, 10].binary_search(&10).ok(), Some(4));
 328
 329     assert_eq!([2, 4, 6, 8].binary_search(&1).ok(), None);
 330     assert_eq!([2, 4, 6, 8].binary_search(&5).ok(), None);
 331     assert_eq!([2, 4, 6, 8].binary_search(&4).ok(), Some(1));
 332     assert_eq!([2, 4, 6, 8].binary_search(&8).ok(), Some(3));
 333
 334     assert_eq!([2, 4, 6].binary_search(&1).ok(), None);
 335     assert_eq!([2, 4, 6].binary_search(&5).ok(), None);
 336     assert_eq!([2, 4, 6].binary_search(&4).ok(), Some(1));
 337     assert_eq!([2, 4, 6].binary_search(&6).ok(), Some(2));
 338
 339     assert_eq!([2, 4].binary_search(&1).ok(), None);
 340     assert_eq!([2, 4].binary_search(&5).ok(), None);
 341     assert_eq!([2, 4].binary_search(&2).ok(), Some(0));
 342     assert_eq!([2, 4].binary_search(&4).ok(), Some(1));
 343
 344     assert_eq!([2].binary_search(&1).ok(), None);
 345     assert_eq!([2].binary_search(&5).ok(), None);
 346     assert_eq!([2].binary_search(&2).ok(), Some(0));
 347
 348     assert_eq!([].binary_search(&1).ok(), None);
 349     assert_eq!([].binary_search(&5).ok(), None);
 350
 351     assert!([1, 1, 1, 1, 1].binary_search(&1).ok() != None);
 352     assert!([1, 1, 1, 1, 2].binary_search(&1).ok() != None);
 353     assert!([1, 1, 1, 2, 2].binary_search(&1).ok() != None);
 354     assert!([1, 1, 2, 2, 2].binary_search(&1).ok() != None);
 355     assert_eq!([1, 2, 2, 2, 2].binary_search(&1).ok(), Some(0));
 356
 357     assert_eq!([1, 2, 3, 4, 5].binary_search(&6).ok(), None);
 358     assert_eq!([1, 2, 3, 4, 5].binary_search(&0).ok(), None);
 359 }
 360
 361 #[test]
 362 fn test_reverse() {
 363     let mut v = vec![10, 20];
 364     assert_eq!(v[0], 10);
 365     assert_eq!(v[1], 20);
 366     v.reverse();
 367     assert_eq!(v[0], 20);
 368     assert_eq!(v[1], 10);
 369
 370     let mut v3 = Vec::<i32>::new();
 371     v3.reverse();
 372     assert!(v3.is_empty());
 373
 374     // check the 1-byte-types path
 375     let mut v = (-50..51i8).collect::<Vec<_>>();
 376     v.reverse();
 377     assert_eq!(v, (-50..51i8).rev().collect::<Vec<_>>());
 378
 379     // check the 2-byte-types path
 380     let mut v = (-50..51i16).collect::<Vec<_>>();
 381     v.reverse();
 382     assert_eq!(v, (-50..51i16).rev().collect::<Vec<_>>());
 383 }
 384
 385 #[test]
 386 fn test_rotate_left() {
 387     let expected: Vec<_> = (0..13).collect();
 388     let mut v = Vec::new();
 389
 390     // no-ops
 391     v.clone_from(&expected);
 392     v.rotate_left(0);
 393     assert_eq!(v, expected);
 394     v.rotate_left(expected.len());
 395     assert_eq!(v, expected);
 396     let mut zst_array = [(), (), ()];
 397     zst_array.rotate_left(2);
 398
 399     // happy path
 400     v = (5..13).chain(0..5).collect();
 401     v.rotate_left(8);
 402     assert_eq!(v, expected);
 403
 404     let expected: Vec<_> = (0..1000).collect();
 405
 406     // small rotations in large slice, uses ptr::copy
 407     v = (2..1000).chain(0..2).collect();
 408     v.rotate_left(998);
 409     assert_eq!(v, expected);
 410     v = (998..1000).chain(0..998).collect();
 411     v.rotate_left(2);
 412     assert_eq!(v, expected);
 413
 414     // non-small prime rotation, has a few rounds of swapping
 415     v = (389..1000).chain(0..389).collect();
 416     v.rotate_left(1000 - 389);
 417     assert_eq!(v, expected);
 418 }
 419
 420 #[test]
 421 fn test_rotate_right() {
 422     let expected: Vec<_> = (0..13).collect();
 423     let mut v = Vec::new();
 424
 425     // no-ops
 426     v.clone_from(&expected);
 427     v.rotate_right(0);
 428     assert_eq!(v, expected);
 429     v.rotate_right(expected.len());
 430     assert_eq!(v, expected);
 431     let mut zst_array = [(), (), ()];
 432     zst_array.rotate_right(2);
 433
 434     // happy path
 435     v = (5..13).chain(0..5).collect();
 436     v.rotate_right(5);
 437     assert_eq!(v, expected);
 438
 439     let expected: Vec<_> = (0..1000).collect();
 440
 441     // small rotations in large slice, uses ptr::copy
 442     v = (2..1000).chain(0..2).collect();
 443     v.rotate_right(2);
 444     assert_eq!(v, expected);
 445     v = (998..1000).chain(0..998).collect();
 446     v.rotate_right(998);
 447     assert_eq!(v, expected);
 448
 449     // non-small prime rotation, has a few rounds of swapping
 450     v = (389..1000).chain(0..389).collect();
 451     v.rotate_right(389);
 452     assert_eq!(v, expected);
 453 }
 454
 455 #[test]
 456 fn test_concat() {
 457     let v: [Vec<i32>; 0] = [];
 458     let c = v.concat();
 459     assert_eq!(c, []);
 460     let d = [vec![1], vec![2, 3]].concat();
 461     assert_eq!(d, [1, 2, 3]);
 462
 463     let v: &[&[_]] = &[&[1], &[2, 3]];
 464     assert_eq!(v.join(&0), [1, 0, 2, 3]);
 465     let v: &[&[_]] = &[&[1], &[2], &[3]];
 466     assert_eq!(v.join(&0), [1, 0, 2, 0, 3]);
 467 }
 468
 469 #[test]
 470 fn test_join() {
 471     let v: [Vec<i32>; 0] = [];
 472     assert_eq!(v.join(&0), []);
 473     assert_eq!([vec![1], vec![2, 3]].join(&0), [1, 0, 2, 3]);
 474     assert_eq!([vec![1], vec![2], vec![3]].join(&0), [1, 0, 2, 0, 3]);
 475
 476     let v: [&[_]; 2] = [&[1], &[2, 3]];
 477     assert_eq!(v.join(&0), [1, 0, 2, 3]);
 478     let v: [&[_]; 3] = [&[1], &[2], &[3]];
 479     assert_eq!(v.join(&0), [1, 0, 2, 0, 3]);
 480 }
 481
 482 #[test]
 483 fn test_join_nocopy() {
 484     let v: [String; 0] = [];
 485     assert_eq!(v.join(","), "");
 486     assert_eq!(["a".to_string(), "ab".into()].join(","), "a,ab");
 487     assert_eq!(["a".to_string(), "ab".into(), "abc".into()].join(","), "a,ab,abc");
 488     assert_eq!(["a".to_string(), "ab".into(), "".into()].join(","), "a,ab,");
 489 }
 490
 491 #[test]
 492 fn test_insert() {
 493     let mut a = vec![1, 2, 4];
 494     a.insert(2, 3);
 495     assert_eq!(a, [1, 2, 3, 4]);
 496
 497     let mut a = vec![1, 2, 3];
 498     a.insert(0, 0);
 499     assert_eq!(a, [0, 1, 2, 3]);
 500
 501     let mut a = vec![1, 2, 3];
 502     a.insert(3, 4);
 503     assert_eq!(a, [1, 2, 3, 4]);
 504
 505     let mut a = vec![];
 506     a.insert(0, 1);
 507     assert_eq!(a, [1]);
 508 }
 509
 510 #[test]
 511 #[should_panic]
 512 fn test_insert_oob() {
 513     let mut a = vec![1, 2, 3];
 514     a.insert(4, 5);
 515 }
 516
 517 #[test]
 518 fn test_remove() {
 519     let mut a = vec![1, 2, 3, 4];
 520
 521     assert_eq!(a.remove(2), 3);
 522     assert_eq!(a, [1, 2, 4]);
 523
 524     assert_eq!(a.remove(2), 4);
 525     assert_eq!(a, [1, 2]);
 526
 527     assert_eq!(a.remove(0), 1);
 528     assert_eq!(a, [2]);
 529
 530     assert_eq!(a.remove(0), 2);
 531     assert_eq!(a, []);
 532 }
 533
 534 #[test]
 535 #[should_panic]
 536 fn test_remove_fail() {
 537     let mut a = vec![1];
 538     let _ = a.remove(0);
 539     let _ = a.remove(0);
 540 }
 541
 542 #[test]
 543 fn test_capacity() {
 544     let mut v = vec![0];
 545     v.reserve_exact(10);
 546     assert!(v.capacity() >= 11);
 547 }
 548
 549 #[test]
 550 fn test_slice_2() {
 551     let v = vec![1, 2, 3, 4, 5];
 552     let v = &v[1..3];
 553     assert_eq!(v.len(), 2);
 554     assert_eq!(v[0], 2);
 555     assert_eq!(v[1], 3);
 556 }
 557
 558 macro_rules! assert_order {
 559     (Greater, $a:expr, $b:expr) => {
 560         assert_eq!($a.cmp($b), Greater);
 561         assert!($a > $b);
 562     };
 563     (Less, $a:expr, $b:expr) => {
 564         assert_eq!($a.cmp($b), Less);
 565         assert!($a < $b);
 566     };
 567     (Equal, $a:expr, $b:expr) => {
 568         assert_eq!($a.cmp($b), Equal);
 569         assert_eq!($a, $b);
 570     };
 571 }
 572
 573 #[test]
 574 fn test_total_ord_u8() {
 575     let c = &[1u8, 2, 3];
 576     assert_order!(Greater, &[1u8, 2, 3, 4][..], &c[..]);
 577     let c = &[1u8, 2, 3, 4];
 578     assert_order!(Less, &[1u8, 2, 3][..], &c[..]);
 579     let c = &[1u8, 2, 3, 6];
 580     assert_order!(Equal, &[1u8, 2, 3, 6][..], &c[..]);
 581     let c = &[1u8, 2, 3, 4, 5, 6];
 582     assert_order!(Less, &[1u8, 2, 3, 4, 5, 5, 5, 5][..], &c[..]);
 583     let c = &[1u8, 2, 3, 4];
 584     assert_order!(Greater, &[2u8, 2][..], &c[..]);
 585 }
 586
 587 #[test]
 588 fn test_total_ord_i32() {
 589     let c = &[1, 2, 3];
 590     assert_order!(Greater, &[1, 2, 3, 4][..], &c[..]);
 591     let c = &[1, 2, 3, 4];
 592     assert_order!(Less, &[1, 2, 3][..], &c[..]);
 593     let c = &[1, 2, 3, 6];
 594     assert_order!(Equal, &[1, 2, 3, 6][..], &c[..]);
 595     let c = &[1, 2, 3, 4, 5, 6];
 596     assert_order!(Less, &[1, 2, 3, 4, 5, 5, 5, 5][..], &c[..]);
 597     let c = &[1, 2, 3, 4];
 598     assert_order!(Greater, &[2, 2][..], &c[..]);
 599 }
 600
 601 #[test]
 602 fn test_iterator() {
 603     let xs = [1, 2, 5, 10, 11];
 604     let mut it = xs.iter();
 605     assert_eq!(it.size_hint(), (5, Some(5)));
 606     assert_eq!(it.next().unwrap(), &1);
 607     assert_eq!(it.size_hint(), (4, Some(4)));
 608     assert_eq!(it.next().unwrap(), &2);
 609     assert_eq!(it.size_hint(), (3, Some(3)));
 610     assert_eq!(it.next().unwrap(), &5);
 611     assert_eq!(it.size_hint(), (2, Some(2)));
 612     assert_eq!(it.next().unwrap(), &10);
 613     assert_eq!(it.size_hint(), (1, Some(1)));
 614     assert_eq!(it.next().unwrap(), &11);
 615     assert_eq!(it.size_hint(), (0, Some(0)));
 616     assert!(it.next().is_none());
 617 }
 618
 619 #[test]
 620 fn test_iter_size_hints() {
 621     let mut xs = [1, 2, 5, 10, 11];
 622     assert_eq!(xs.iter().size_hint(), (5, Some(5)));
 623     assert_eq!(xs.iter_mut().size_hint(), (5, Some(5)));
 624 }
 625
 626 #[test]
 627 fn test_iter_as_slice() {
 628     let xs = [1, 2, 5, 10, 11];
 629     let mut iter = xs.iter();
 630     assert_eq!(iter.as_slice(), &[1, 2, 5, 10, 11]);
 631     iter.next();
 632     assert_eq!(iter.as_slice(), &[2, 5, 10, 11]);
 633 }
 634
 635 #[test]
 636 fn test_iter_as_ref() {
 637     let xs = [1, 2, 5, 10, 11];
 638     let mut iter = xs.iter();
 639     assert_eq!(iter.as_ref(), &[1, 2, 5, 10, 11]);
 640     iter.next();
 641     assert_eq!(iter.as_ref(), &[2, 5, 10, 11]);
 642 }
 643
 644 #[test]
 645 fn test_iter_clone() {
 646     let xs = [1, 2, 5];
 647     let mut it = xs.iter();
 648     it.next();
 649     let mut jt = it.clone();
 650     assert_eq!(it.next(), jt.next());
 651     assert_eq!(it.next(), jt.next());
 652     assert_eq!(it.next(), jt.next());
 653 }
 654
 655 #[test]
 656 fn test_iter_is_empty() {
 657     let xs = [1, 2, 5, 10, 11];
 658     for i in 0..xs.len() {
 659         for j in i..xs.len() {
 660             assert_eq!(xs[i..j].iter().is_empty(), xs[i..j].is_empty());
 661         }
 662     }
 663 }
 664
 665 #[test]
 666 fn test_mut_iterator() {
 667     let mut xs = [1, 2, 3, 4, 5];
 668     for x in &mut xs {
 669         *x += 1;
 670     }
 671     assert!(xs == [2, 3, 4, 5, 6])
 672 }
 673
 674 #[test]
 675 fn test_rev_iterator() {
 676     let xs = [1, 2, 5, 10, 11];
 677     let ys = [11, 10, 5, 2, 1];
 678     let mut i = 0;
 679     for &x in xs.iter().rev() {
 680         assert_eq!(x, ys[i]);
 681         i += 1;
 682     }
 683     assert_eq!(i, 5);
 684 }
 685
 686 #[test]
 687 fn test_mut_rev_iterator() {
 688     let mut xs = [1, 2, 3, 4, 5];
 689     for (i, x) in xs.iter_mut().rev().enumerate() {
 690         *x += i;
 691     }
 692     assert!(xs == [5, 5, 5, 5, 5])
 693 }
 694
 695 #[test]
 696 fn test_move_iterator() {
 697     let xs = vec![1, 2, 3, 4, 5];
 698     assert_eq!(xs.into_iter().fold(0, |a: usize, b: usize| 10 * a + b), 12345);
 699 }
 700
 701 #[test]
 702 fn test_move_rev_iterator() {
 703     let xs = vec![1, 2, 3, 4, 5];
 704     assert_eq!(xs.into_iter().rev().fold(0, |a: usize, b: usize| 10 * a + b), 54321);
 705 }
 706
 707 #[test]
 708 fn test_splitator() {
 709     let xs = &[1, 2, 3, 4, 5];
 710
 711     let splits: &[&[_]] = &[&[1], &[3], &[5]];
 712     assert_eq!(xs.split(|x| *x % 2 == 0).collect::<Vec<_>>(), splits);
 713     let splits: &[&[_]] = &[&[], &[2, 3, 4, 5]];
 714     assert_eq!(xs.split(|x| *x == 1).collect::<Vec<_>>(), splits);
 715     let splits: &[&[_]] = &[&[1, 2, 3, 4], &[]];
 716     assert_eq!(xs.split(|x| *x == 5).collect::<Vec<_>>(), splits);
 717     let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
 718     assert_eq!(xs.split(|x| *x == 10).collect::<Vec<_>>(), splits);
 719     let splits: &[&[_]] = &[&[], &[], &[], &[], &[], &[]];
 720     assert_eq!(xs.split(|_| true).collect::<Vec<&[i32]>>(), splits);
 721
 722     let xs: &[i32] = &[];
 723     let splits: &[&[i32]] = &[&[]];
 724     assert_eq!(xs.split(|x| *x == 5).collect::<Vec<&[i32]>>(), splits);
 725 }
 726
 727 #[test]
 728 fn test_splitator_inclusive() {
 729     let xs = &[1, 2, 3, 4, 5];
 730
 731     let splits: &[&[_]] = &[&[1, 2], &[3, 4], &[5]];
 732     assert_eq!(xs.split_inclusive(|x| *x % 2 == 0).collect::<Vec<_>>(), splits);
 733     let splits: &[&[_]] = &[&[1], &[2, 3, 4, 5]];
 734     assert_eq!(xs.split_inclusive(|x| *x == 1).collect::<Vec<_>>(), splits);
 735     let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
 736     assert_eq!(xs.split_inclusive(|x| *x == 5).collect::<Vec<_>>(), splits);
 737     let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
 738     assert_eq!(xs.split_inclusive(|x| *x == 10).collect::<Vec<_>>(), splits);
 739     let splits: &[&[_]] = &[&[1], &[2], &[3], &[4], &[5]];
 740     assert_eq!(xs.split_inclusive(|_| true).collect::<Vec<&[i32]>>(), splits);
 741
 742     let xs: &[i32] = &[];
 743     let splits: &[&[i32]] = &[];
 744     assert_eq!(xs.split_inclusive(|x| *x == 5).collect::<Vec<&[i32]>>(), splits);
 745 }
 746
 747 #[test]
 748 fn test_splitator_inclusive_reverse() {
 749     let xs = &[1, 2, 3, 4, 5];
 750
 751     let splits: &[&[_]] = &[&[5], &[3, 4], &[1, 2]];
 752     assert_eq!(xs.split_inclusive(|x| *x % 2 == 0).rev().collect::<Vec<_>>(), splits);
 753     let splits: &[&[_]] = &[&[2, 3, 4, 5], &[1]];
 754     assert_eq!(xs.split_inclusive(|x| *x == 1).rev().collect::<Vec<_>>(), splits);
 755     let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
 756     assert_eq!(xs.split_inclusive(|x| *x == 5).rev().collect::<Vec<_>>(), splits);
 757     let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
 758     assert_eq!(xs.split_inclusive(|x| *x == 10).rev().collect::<Vec<_>>(), splits);
 759     let splits: &[&[_]] = &[&[5], &[4], &[3], &[2], &[1]];
 760     assert_eq!(xs.split_inclusive(|_| true).rev().collect::<Vec<_>>(), splits);
 761
 762     let xs: &[i32] = &[];
 763     let splits: &[&[i32]] = &[];
 764     assert_eq!(xs.split_inclusive(|x| *x == 5).rev().collect::<Vec<_>>(), splits);
 765 }
 766
 767 #[test]
 768 fn test_splitator_mut_inclusive() {
 769     let xs = &mut [1, 2, 3, 4, 5];
 770
 771     let splits: &[&[_]] = &[&[1, 2], &[3, 4], &[5]];
 772     assert_eq!(xs.split_inclusive_mut(|x| *x % 2 == 0).collect::<Vec<_>>(), splits);
 773     let splits: &[&[_]] = &[&[1], &[2, 3, 4, 5]];
 774     assert_eq!(xs.split_inclusive_mut(|x| *x == 1).collect::<Vec<_>>(), splits);
 775     let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
 776     assert_eq!(xs.split_inclusive_mut(|x| *x == 5).collect::<Vec<_>>(), splits);
 777     let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
 778     assert_eq!(xs.split_inclusive_mut(|x| *x == 10).collect::<Vec<_>>(), splits);
 779     let splits: &[&[_]] = &[&[1], &[2], &[3], &[4], &[5]];
 780     assert_eq!(xs.split_inclusive_mut(|_| true).collect::<Vec<_>>(), splits);
 781
 782     let xs: &mut [i32] = &mut [];
 783     let splits: &[&[i32]] = &[];
 784     assert_eq!(xs.split_inclusive_mut(|x| *x == 5).collect::<Vec<_>>(), splits);
 785 }
 786
 787 #[test]
 788 fn test_splitator_mut_inclusive_reverse() {
 789     let xs = &mut [1, 2, 3, 4, 5];
 790
 791     let splits: &[&[_]] = &[&[5], &[3, 4], &[1, 2]];
 792     assert_eq!(xs.split_inclusive_mut(|x| *x % 2 == 0).rev().collect::<Vec<_>>(), splits);
 793     let splits: &[&[_]] = &[&[2, 3, 4, 5], &[1]];
 794     assert_eq!(xs.split_inclusive_mut(|x| *x == 1).rev().collect::<Vec<_>>(), splits);
 795     let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
 796     assert_eq!(xs.split_inclusive_mut(|x| *x == 5).rev().collect::<Vec<_>>(), splits);
 797     let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
 798     assert_eq!(xs.split_inclusive_mut(|x| *x == 10).rev().collect::<Vec<_>>(), splits);
 799     let splits: &[&[_]] = &[&[5], &[4], &[3], &[2], &[1]];
 800     assert_eq!(xs.split_inclusive_mut(|_| true).rev().collect::<Vec<_>>(), splits);
 801
 802     let xs: &mut [i32] = &mut [];
 803     let splits: &[&[i32]] = &[];
 804     assert_eq!(xs.split_inclusive_mut(|x| *x == 5).rev().collect::<Vec<_>>(), splits);
 805 }
 806
 807 #[test]
 808 fn test_splitnator() {
 809     let xs = &[1, 2, 3, 4, 5];
 810
 811     let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
 812     assert_eq!(xs.splitn(1, |x| *x % 2 == 0).collect::<Vec<_>>(), splits);
 813     let splits: &[&[_]] = &[&[1], &[3, 4, 5]];
 814     assert_eq!(xs.splitn(2, |x| *x % 2 == 0).collect::<Vec<_>>(), splits);
 815     let splits: &[&[_]] = &[&[], &[], &[], &[4, 5]];
 816     assert_eq!(xs.splitn(4, |_| true).collect::<Vec<_>>(), splits);
 817
 818     let xs: &[i32] = &[];
 819     let splits: &[&[i32]] = &[&[]];
 820     assert_eq!(xs.splitn(2, |x| *x == 5).collect::<Vec<_>>(), splits);
 821 }
 822
 823 #[test]
 824 fn test_splitnator_mut() {
 825     let xs = &mut [1, 2, 3, 4, 5];
 826
 827     let splits: &[&mut [_]] = &[&mut [1, 2, 3, 4, 5]];
 828     assert_eq!(xs.splitn_mut(1, |x| *x % 2 == 0).collect::<Vec<_>>(), splits);
 829     let splits: &[&mut [_]] = &[&mut [1], &mut [3, 4, 5]];
 830     assert_eq!(xs.splitn_mut(2, |x| *x % 2 == 0).collect::<Vec<_>>(), splits);
 831     let splits: &[&mut [_]] = &[&mut [], &mut [], &mut [], &mut [4, 5]];
 832     assert_eq!(xs.splitn_mut(4, |_| true).collect::<Vec<_>>(), splits);
 833
 834     let xs: &mut [i32] = &mut [];
 835     let splits: &[&mut [i32]] = &[&mut []];
 836     assert_eq!(xs.splitn_mut(2, |x| *x == 5).collect::<Vec<_>>(), splits);
 837 }
 838
 839 #[test]
 840 fn test_rsplitator() {
 841     let xs = &[1, 2, 3, 4, 5];
 842
 843     let splits: &[&[_]] = &[&[5], &[3], &[1]];
 844     assert_eq!(xs.split(|x| *x % 2 == 0).rev().collect::<Vec<_>>(), splits);
 845     let splits: &[&[_]] = &[&[2, 3, 4, 5], &[]];
 846     assert_eq!(xs.split(|x| *x == 1).rev().collect::<Vec<_>>(), splits);
 847     let splits: &[&[_]] = &[&[], &[1, 2, 3, 4]];
 848     assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<_>>(), splits);
 849     let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
 850     assert_eq!(xs.split(|x| *x == 10).rev().collect::<Vec<_>>(), splits);
 851
 852     let xs: &[i32] = &[];
 853     let splits: &[&[i32]] = &[&[]];
 854     assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<&[i32]>>(), splits);
 855 }
 856
 857 #[test]
 858 fn test_rsplitnator() {
 859     let xs = &[1, 2, 3, 4, 5];
 860
 861     let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
 862     assert_eq!(xs.rsplitn(1, |x| *x % 2 == 0).collect::<Vec<_>>(), splits);
 863     let splits: &[&[_]] = &[&[5], &[1, 2, 3]];
 864     assert_eq!(xs.rsplitn(2, |x| *x % 2 == 0).collect::<Vec<_>>(), splits);
 865     let splits: &[&[_]] = &[&[], &[], &[], &[1, 2]];
 866     assert_eq!(xs.rsplitn(4, |_| true).collect::<Vec<_>>(), splits);
 867
 868     let xs: &[i32] = &[];
 869     let splits: &[&[i32]] = &[&[]];
 870     assert_eq!(xs.rsplitn(2, |x| *x == 5).collect::<Vec<&[i32]>>(), splits);
 871     assert!(xs.rsplitn(0, |x| *x % 2 == 0).next().is_none());
 872 }
 873
 874 #[test]
 875 fn test_split_iterators_size_hint() {
 876     #[derive(Copy, Clone)]
 877     enum Bounds {
 878         Lower,
 879         Upper,
 880     }
 881     fn assert_tight_size_hints(mut it: impl Iterator, which: Bounds, ctx: impl fmt::Display) {
 882         match which {
 883             Bounds::Lower => {
 884                 let mut lower_bounds = vec![it.size_hint().0];
 885                 while let Some(_) = it.next() {
 886                     lower_bounds.push(it.size_hint().0);
 887                 }
 888                 let target: Vec<_> = (0..lower_bounds.len()).rev().collect();
 889                 assert_eq!(lower_bounds, target, "lower bounds incorrect or not tight: {}", ctx);
 890             }
 891             Bounds::Upper => {
 892                 let mut upper_bounds = vec![it.size_hint().1];
 893                 while let Some(_) = it.next() {
 894                     upper_bounds.push(it.size_hint().1);
 895                 }
 896                 let target: Vec<_> = (0..upper_bounds.len()).map(Some).rev().collect();
 897                 assert_eq!(upper_bounds, target, "upper bounds incorrect or not tight: {}", ctx);
 898             }
 899         }
 900     }
 901
 902     for len in 0..=2 {
 903         let mut v: Vec<u8> = (0..len).collect();
 904
 905         // p: predicate, b: bound selection
 906         for (p, b) in [
 907             // with a predicate always returning false, the split*-iterators
 908             // become maximally short, so the size_hint lower bounds are tight
 909             ((|_| false) as fn(&_) -> _, Bounds::Lower),
 910             // with a predicate always returning true, the split*-iterators
 911             // become maximally long, so the size_hint upper bounds are tight
 912             ((|_| true) as fn(&_) -> _, Bounds::Upper),
 913         ] {
 914             use assert_tight_size_hints as a;
 915             use format_args as f;
 916
 917             a(v.split(p), b, "split");
 918             a(v.split_mut(p), b, "split_mut");
 919             a(v.split_inclusive(p), b, "split_inclusive");
 920             a(v.split_inclusive_mut(p), b, "split_inclusive_mut");
 921             a(v.rsplit(p), b, "rsplit");
 922             a(v.rsplit_mut(p), b, "rsplit_mut");
 923
 924             for n in 0..=3 {
 925                 a(v.splitn(n, p), b, f!("splitn, n = {n}"));
 926                 a(v.splitn_mut(n, p), b, f!("splitn_mut, n = {n}"));
 927                 a(v.rsplitn(n, p), b, f!("rsplitn, n = {n}"));
 928                 a(v.rsplitn_mut(n, p), b, f!("rsplitn_mut, n = {n}"));
 929             }
 930         }
 931     }
 932 }
 933
 934 #[test]
 935 fn test_windowsator() {
 936     let v = &[1, 2, 3, 4];
 937
 938     let wins: &[&[_]] = &[&[1, 2], &[2, 3], &[3, 4]];
 939     assert_eq!(v.windows(2).collect::<Vec<_>>(), wins);
 940
 941     let wins: &[&[_]] = &[&[1, 2, 3], &[2, 3, 4]];
 942     assert_eq!(v.windows(3).collect::<Vec<_>>(), wins);
 943     assert!(v.windows(6).next().is_none());
 944
 945     let wins: &[&[_]] = &[&[3, 4], &[2, 3], &[1, 2]];
 946     assert_eq!(v.windows(2).rev().collect::<Vec<&[_]>>(), wins);
 947 }
 948
 949 #[test]
 950 #[should_panic]
 951 fn test_windowsator_0() {
 952     let v = &[1, 2, 3, 4];
 953     let _it = v.windows(0);
 954 }
 955
 956 #[test]
 957 fn test_chunksator() {
 958     let v = &[1, 2, 3, 4, 5];
 959
 960     assert_eq!(v.chunks(2).len(), 3);
 961
 962     let chunks: &[&[_]] = &[&[1, 2], &[3, 4], &[5]];
 963     assert_eq!(v.chunks(2).collect::<Vec<_>>(), chunks);
 964     let chunks: &[&[_]] = &[&[1, 2, 3], &[4, 5]];
 965     assert_eq!(v.chunks(3).collect::<Vec<_>>(), chunks);
 966     let chunks: &[&[_]] = &[&[1, 2, 3, 4, 5]];
 967     assert_eq!(v.chunks(6).collect::<Vec<_>>(), chunks);
 968
 969     let chunks: &[&[_]] = &[&[5], &[3, 4], &[1, 2]];
 970     assert_eq!(v.chunks(2).rev().collect::<Vec<_>>(), chunks);
 971 }
 972
 973 #[test]
 974 #[should_panic]
 975 fn test_chunksator_0() {
 976     let v = &[1, 2, 3, 4];
 977     let _it = v.chunks(0);
 978 }
 979
 980 #[test]
 981 fn test_chunks_exactator() {
 982     let v = &[1, 2, 3, 4, 5];
 983
 984     assert_eq!(v.chunks_exact(2).len(), 2);
 985
 986     let chunks: &[&[_]] = &[&[1, 2], &[3, 4]];
 987     assert_eq!(v.chunks_exact(2).collect::<Vec<_>>(), chunks);
 988     let chunks: &[&[_]] = &[&[1, 2, 3]];
 989     assert_eq!(v.chunks_exact(3).collect::<Vec<_>>(), chunks);
 990     let chunks: &[&[_]] = &[];
 991     assert_eq!(v.chunks_exact(6).collect::<Vec<_>>(), chunks);
 992
 993     let chunks: &[&[_]] = &[&[3, 4], &[1, 2]];
 994     assert_eq!(v.chunks_exact(2).rev().collect::<Vec<_>>(), chunks);
 995 }
 996
 997 #[test]
 998 #[should_panic]
 999 fn test_chunks_exactator_0() {
1000     let v = &[1, 2, 3, 4];
1001     let _it = v.chunks_exact(0);
1002 }
1003
1004 #[test]
1005 fn test_rchunksator() {
1006     let v = &[1, 2, 3, 4, 5];
1007
1008     assert_eq!(v.rchunks(2).len(), 3);
1009
1010     let chunks: &[&[_]] = &[&[4, 5], &[2, 3], &[1]];
1011     assert_eq!(v.rchunks(2).collect::<Vec<_>>(), chunks);
1012     let chunks: &[&[_]] = &[&[3, 4, 5], &[1, 2]];
1013     assert_eq!(v.rchunks(3).collect::<Vec<_>>(), chunks);
1014     let chunks: &[&[_]] = &[&[1, 2, 3, 4, 5]];
1015     assert_eq!(v.rchunks(6).collect::<Vec<_>>(), chunks);
1016
1017     let chunks: &[&[_]] = &[&[1], &[2, 3], &[4, 5]];
1018     assert_eq!(v.rchunks(2).rev().collect::<Vec<_>>(), chunks);
1019 }
1020
1021 #[test]
1022 #[should_panic]
1023 fn test_rchunksator_0() {
1024     let v = &[1, 2, 3, 4];
1025     let _it = v.rchunks(0);
1026 }
1027
1028 #[test]
1029 fn test_rchunks_exactator() {
1030     let v = &[1, 2, 3, 4, 5];
1031
1032     assert_eq!(v.rchunks_exact(2).len(), 2);
1033
1034     let chunks: &[&[_]] = &[&[4, 5], &[2, 3]];
1035     assert_eq!(v.rchunks_exact(2).collect::<Vec<_>>(), chunks);
1036     let chunks: &[&[_]] = &[&[3, 4, 5]];
1037     assert_eq!(v.rchunks_exact(3).collect::<Vec<_>>(), chunks);
1038     let chunks: &[&[_]] = &[];
1039     assert_eq!(v.rchunks_exact(6).collect::<Vec<_>>(), chunks);
1040
1041     let chunks: &[&[_]] = &[&[2, 3], &[4, 5]];
1042     assert_eq!(v.rchunks_exact(2).rev().collect::<Vec<_>>(), chunks);
1043 }
1044
1045 #[test]
1046 #[should_panic]
1047 fn test_rchunks_exactator_0() {
1048     let v = &[1, 2, 3, 4];
1049     let _it = v.rchunks_exact(0);
1050 }
1051
1052 #[test]
1053 fn test_reverse_part() {
1054     let mut values = [1, 2, 3, 4, 5];
1055     values[1..4].reverse();
1056     assert!(values == [1, 4, 3, 2, 5]);
1057 }
1058
1059 #[test]
1060 fn test_show() {
1061     macro_rules! test_show_vec {
1062         ($x:expr, $x_str:expr) => {{
1063             let (x, x_str) = ($x, $x_str);
1064             assert_eq!(format!("{x:?}"), x_str);
1065             assert_eq!(format!("{x:?}"), x_str);
1066         }};
1067     }
1068     let empty = Vec::<i32>::new();
1069     test_show_vec!(empty, "[]");
1070     test_show_vec!(vec![1], "[1]");
1071     test_show_vec!(vec![1, 2, 3], "[1, 2, 3]");
1072     test_show_vec!(vec![vec![], vec![1], vec![1, 1]], "[[], [1], [1, 1]]");
1073
1074     let empty_mut: &mut [i32] = &mut [];
1075     test_show_vec!(empty_mut, "[]");
1076     let v = &mut [1];
1077     test_show_vec!(v, "[1]");
1078     let v = &mut [1, 2, 3];
1079     test_show_vec!(v, "[1, 2, 3]");
1080     let v: &mut [&mut [_]] = &mut [&mut [], &mut [1], &mut [1, 1]];
1081     test_show_vec!(v, "[[], [1], [1, 1]]");
1082 }
1083
1084 #[test]
1085 fn test_vec_default() {
1086     macro_rules! t {
1087         ($ty:ty) => {{
1088             let v: $ty = Default::default();
1089             assert!(v.is_empty());
1090         }};
1091     }
1092
1093     t!(&[i32]);
1094     t!(Vec<i32>);
1095 }
1096
1097 #[test]
1098 #[should_panic]
1099 fn test_overflow_does_not_cause_segfault() {
1100     let mut v = vec![];
1101     v.reserve_exact(!0);
1102     v.push(1);
1103     v.push(2);
1104 }
1105
1106 #[test]
1107 #[should_panic]
1108 fn test_overflow_does_not_cause_segfault_managed() {
1109     let mut v = vec![Rc::new(1)];
1110     v.reserve_exact(!0);
1111     v.push(Rc::new(2));
1112 }
1113
1114 #[test]
1115 fn test_mut_split_at() {
1116     let mut values = [1, 2, 3, 4, 5];
1117     {
1118         let (left, right) = values.split_at_mut(2);
1119         {
1120             let left: &[_] = left;
1121             assert!(left[..left.len()] == [1, 2]);
1122         }
1123         for p in left {
1124             *p += 1;
1125         }
1126
1127         {
1128             let right: &[_] = right;
1129             assert!(right[..right.len()] == [3, 4, 5]);
1130         }
1131         for p in right {
1132             *p += 2;
1133         }
1134     }
1135
1136     assert!(values == [2, 3, 5, 6, 7]);
1137 }
1138
1139 #[derive(Clone, PartialEq)]
1140 struct Foo;
1141
1142 #[test]
1143 fn test_iter_zero_sized() {
1144     let mut v = vec![Foo, Foo, Foo];
1145     assert_eq!(v.len(), 3);
1146     let mut cnt = 0;
1147
1148     for f in &v {
1149         assert!(*f == Foo);
1150         cnt += 1;
1151     }
1152     assert_eq!(cnt, 3);
1153
1154     for f in &v[1..3] {
1155         assert!(*f == Foo);
1156         cnt += 1;
1157     }
1158     assert_eq!(cnt, 5);
1159
1160     for f in &mut v {
1161         assert!(*f == Foo);
1162         cnt += 1;
1163     }
1164     assert_eq!(cnt, 8);
1165
1166     for f in v {
1167         assert!(f == Foo);
1168         cnt += 1;
1169     }
1170     assert_eq!(cnt, 11);
1171
1172     let xs: [Foo; 3] = [Foo, Foo, Foo];
1173     cnt = 0;
1174     for f in &xs {
1175         assert!(*f == Foo);
1176         cnt += 1;
1177     }
1178     assert!(cnt == 3);
1179 }
1180
1181 #[test]
1182 fn test_shrink_to_fit() {
1183     let mut xs = vec![0, 1, 2, 3];
1184     for i in 4..100 {
1185         xs.push(i)
1186     }
1187     assert_eq!(xs.capacity(), 128);
1188     xs.shrink_to_fit();
1189     assert_eq!(xs.capacity(), 100);
1190     assert_eq!(xs, (0..100).collect::<Vec<_>>());
1191 }
1192
1193 #[test]
1194 fn test_starts_with() {
1195     assert!(b"foobar".starts_with(b"foo"));
1196     assert!(!b"foobar".starts_with(b"oob"));
1197     assert!(!b"foobar".starts_with(b"bar"));
1198     assert!(!b"foo".starts_with(b"foobar"));
1199     assert!(!b"bar".starts_with(b"foobar"));
1200     assert!(b"foobar".starts_with(b"foobar"));
1201     let empty: &[u8] = &[];
1202     assert!(empty.starts_with(empty));
1203     assert!(!empty.starts_with(b"foo"));
1204     assert!(b"foobar".starts_with(empty));
1205 }
1206
1207 #[test]
1208 fn test_ends_with() {
1209     assert!(b"foobar".ends_with(b"bar"));
1210     assert!(!b"foobar".ends_with(b"oba"));
1211     assert!(!b"foobar".ends_with(b"foo"));
1212     assert!(!b"foo".ends_with(b"foobar"));
1213     assert!(!b"bar".ends_with(b"foobar"));
1214     assert!(b"foobar".ends_with(b"foobar"));
1215     let empty: &[u8] = &[];
1216     assert!(empty.ends_with(empty));
1217     assert!(!empty.ends_with(b"foo"));
1218     assert!(b"foobar".ends_with(empty));
1219 }
1220
1221 #[test]
1222 fn test_mut_splitator() {
1223     let mut xs = [0, 1, 0, 2, 3, 0, 0, 4, 5, 0];
1224     assert_eq!(xs.split_mut(|x| *x == 0).count(), 6);
1225     for slice in xs.split_mut(|x| *x == 0) {
1226         slice.reverse();
1227     }
1228     assert!(xs == [0, 1, 0, 3, 2, 0, 0, 5, 4, 0]);
1229
1230     let mut xs = [0, 1, 0, 2, 3, 0, 0, 4, 5, 0, 6, 7];
1231     for slice in xs.split_mut(|x| *x == 0).take(5) {
1232         slice.reverse();
1233     }
1234     assert!(xs == [0, 1, 0, 3, 2, 0, 0, 5, 4, 0, 6, 7]);
1235 }
1236
1237 #[test]
1238 fn test_mut_splitator_rev() {
1239     let mut xs = [1, 2, 0, 3, 4, 0, 0, 5, 6, 0];
1240     for slice in xs.split_mut(|x| *x == 0).rev().take(4) {
1241         slice.reverse();
1242     }
1243     assert!(xs == [1, 2, 0, 4, 3, 0, 0, 6, 5, 0]);
1244 }
1245
1246 #[test]
1247 fn test_get_mut() {
1248     let mut v = [0, 1, 2];
1249     assert_eq!(v.get_mut(3), None);
1250     v.get_mut(1).map(|e| *e = 7);
1251     assert_eq!(v[1], 7);
1252     let mut x = 2;
1253     assert_eq!(v.get_mut(2), Some(&mut x));
1254 }
1255
1256 #[test]
1257 fn test_mut_chunks() {
1258     let mut v = [0, 1, 2, 3, 4, 5, 6];
1259     assert_eq!(v.chunks_mut(3).len(), 3);
1260     for (i, chunk) in v.chunks_mut(3).enumerate() {
1261         for x in chunk {
1262             *x = i as u8;
1263         }
1264     }
1265     let result = [0, 0, 0, 1, 1, 1, 2];
1266     assert_eq!(v, result);
1267 }
1268
1269 #[test]
1270 fn test_mut_chunks_rev() {
1271     let mut v = [0, 1, 2, 3, 4, 5, 6];
1272     for (i, chunk) in v.chunks_mut(3).rev().enumerate() {
1273         for x in chunk {
1274             *x = i as u8;
1275         }
1276     }
1277     let result = [2, 2, 2, 1, 1, 1, 0];
1278     assert_eq!(v, result);
1279 }
1280
1281 #[test]
1282 #[should_panic]
1283 fn test_mut_chunks_0() {
1284     let mut v = [1, 2, 3, 4];
1285     let _it = v.chunks_mut(0);
1286 }
1287
1288 #[test]
1289 fn test_mut_chunks_exact() {
1290     let mut v = [0, 1, 2, 3, 4, 5, 6];
1291     assert_eq!(v.chunks_exact_mut(3).len(), 2);
1292     for (i, chunk) in v.chunks_exact_mut(3).enumerate() {
1293         for x in chunk {
1294             *x = i as u8;
1295         }
1296     }
1297     let result = [0, 0, 0, 1, 1, 1, 6];
1298     assert_eq!(v, result);
1299 }
1300
1301 #[test]
1302 fn test_mut_chunks_exact_rev() {
1303     let mut v = [0, 1, 2, 3, 4, 5, 6];
1304     for (i, chunk) in v.chunks_exact_mut(3).rev().enumerate() {
1305         for x in chunk {
1306             *x = i as u8;
1307         }
1308     }
1309     let result = [1, 1, 1, 0, 0, 0, 6];
1310     assert_eq!(v, result);
1311 }
1312
1313 #[test]
1314 #[should_panic]
1315 fn test_mut_chunks_exact_0() {
1316     let mut v = [1, 2, 3, 4];
1317     let _it = v.chunks_exact_mut(0);
1318 }
1319
1320 #[test]
1321 fn test_mut_rchunks() {
1322     let mut v = [0, 1, 2, 3, 4, 5, 6];
1323     assert_eq!(v.rchunks_mut(3).len(), 3);
1324     for (i, chunk) in v.rchunks_mut(3).enumerate() {
1325         for x in chunk {
1326             *x = i as u8;
1327         }
1328     }
1329     let result = [2, 1, 1, 1, 0, 0, 0];
1330     assert_eq!(v, result);
1331 }
1332
1333 #[test]
1334 fn test_mut_rchunks_rev() {
1335     let mut v = [0, 1, 2, 3, 4, 5, 6];
1336     for (i, chunk) in v.rchunks_mut(3).rev().enumerate() {
1337         for x in chunk {
1338             *x = i as u8;
1339         }
1340     }
1341     let result = [0, 1, 1, 1, 2, 2, 2];
1342     assert_eq!(v, result);
1343 }
1344
1345 #[test]
1346 #[should_panic]
1347 fn test_mut_rchunks_0() {
1348     let mut v = [1, 2, 3, 4];
1349     let _it = v.rchunks_mut(0);
1350 }
1351
1352 #[test]
1353 fn test_mut_rchunks_exact() {
1354     let mut v = [0, 1, 2, 3, 4, 5, 6];
1355     assert_eq!(v.rchunks_exact_mut(3).len(), 2);
1356     for (i, chunk) in v.rchunks_exact_mut(3).enumerate() {
1357         for x in chunk {
1358             *x = i as u8;
1359         }
1360     }
1361     let result = [0, 1, 1, 1, 0, 0, 0];
1362     assert_eq!(v, result);
1363 }
1364
1365 #[test]
1366 fn test_mut_rchunks_exact_rev() {
1367     let mut v = [0, 1, 2, 3, 4, 5, 6];
1368     for (i, chunk) in v.rchunks_exact_mut(3).rev().enumerate() {
1369         for x in chunk {
1370             *x = i as u8;
1371         }
1372     }
1373     let result = [0, 0, 0, 0, 1, 1, 1];
1374     assert_eq!(v, result);
1375 }
1376
1377 #[test]
1378 #[should_panic]
1379 fn test_mut_rchunks_exact_0() {
1380     let mut v = [1, 2, 3, 4];
1381     let _it = v.rchunks_exact_mut(0);
1382 }
1383
1384 #[test]
1385 fn test_mut_last() {
1386     let mut x = [1, 2, 3, 4, 5];
1387     let h = x.last_mut();
1388     assert_eq!(*h.unwrap(), 5);
1389
1390     let y: &mut [i32] = &mut [];
1391     assert!(y.last_mut().is_none());
1392 }
1393
1394 #[test]
1395 fn test_to_vec() {
1396     let xs: Box<_> = Box::new([1, 2, 3]);
1397     let ys = xs.to_vec();
1398     assert_eq!(ys, [1, 2, 3]);
1399 }
1400
1401 #[test]
1402 fn test_in_place_iterator_specialization() {
1403     let src: Box<[usize]> = Box::new([1, 2, 3]);
1404     let src_ptr = src.as_ptr();
1405     let sink: Box<_> = src.into_vec().into_iter().map(std::convert::identity).collect();
1406     let sink_ptr = sink.as_ptr();
1407     assert_eq!(src_ptr, sink_ptr);
1408 }
1409
1410 #[test]
1411 fn test_box_slice_clone() {
1412     let data = vec![vec![0, 1], vec![0], vec![1]];
1413     let data2 = data.clone().into_boxed_slice().clone().to_vec();
1414
1415     assert_eq!(data, data2);
1416 }
1417
1418 #[test]
1419 #[allow(unused_must_use)] // here, we care about the side effects of `.clone()`
1420 #[cfg_attr(target_os = "emscripten", ignore)]
1421 fn test_box_slice_clone_panics() {
1422     use std::sync::atomic::{AtomicUsize, Ordering};
1423     use std::sync::Arc;
1424
1425     struct Canary {
1426         count: Arc<AtomicUsize>,
1427         panics: bool,
1428     }
1429
1430     impl Drop for Canary {
1431         fn drop(&mut self) {
1432             self.count.fetch_add(1, Ordering::SeqCst);
1433         }
1434     }
1435
1436     impl Clone for Canary {
1437         fn clone(&self) -> Self {
1438             if self.panics {
1439                 panic!()
1440             }
1441
1442             Canary { count: self.count.clone(), panics: self.panics }
1443         }
1444     }
1445
1446     let drop_count = Arc::new(AtomicUsize::new(0));
1447     let canary = Canary { count: drop_count.clone(), panics: false };
1448     let panic = Canary { count: drop_count.clone(), panics: true };
1449
1450     std::panic::catch_unwind(move || {
1451         // When xs is dropped, +5.
1452         let xs =
1453             vec![canary.clone(), canary.clone(), canary.clone(), panic, canary].into_boxed_slice();
1454
1455         // When panic is cloned, +3.
1456         xs.clone();
1457     })
1458     .unwrap_err();
1459
1460     // Total = 8
1461     assert_eq!(drop_count.load(Ordering::SeqCst), 8);
1462 }
1463
1464 #[test]
1465 fn test_copy_from_slice() {
1466     let src = [0, 1, 2, 3, 4, 5];
1467     let mut dst = [0; 6];
1468     dst.copy_from_slice(&src);
1469     assert_eq!(src, dst)
1470 }
1471
1472 #[test]
1473 #[should_panic(expected = "source slice length (4) does not match destination slice length (5)")]
1474 fn test_copy_from_slice_dst_longer() {
1475     let src = [0, 1, 2, 3];
1476     let mut dst = [0; 5];
1477     dst.copy_from_slice(&src);
1478 }
1479
1480 #[test]
1481 #[should_panic(expected = "source slice length (4) does not match destination slice length (3)")]
1482 fn test_copy_from_slice_dst_shorter() {
1483     let src = [0, 1, 2, 3];
1484     let mut dst = [0; 3];
1485     dst.copy_from_slice(&src);
1486 }
1487
1488 #[test]
1489 fn repeat_generic_slice() {
1490     assert_eq!([1, 2].repeat(2), vec![1, 2, 1, 2]);
1491     assert_eq!([1, 2, 3, 4].repeat(0), vec![]);
1492     assert_eq!([1, 2, 3, 4].repeat(1), vec![1, 2, 3, 4]);
1493     assert_eq!([1, 2, 3, 4].repeat(3), vec![1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]);
1494 }
1495
1496 #[test]
1497 #[allow(unreachable_patterns)]
1498 fn subslice_patterns() {
1499     // This test comprehensively checks the passing static and dynamic semantics
1500     // of subslice patterns `..`, `x @ ..`, `ref x @ ..`, and `ref mut @ ..`
1501     // in slice patterns `[$($pat), $(,)?]` .
1502
1503     #[derive(PartialEq, Debug, Clone)]
1504     struct N(u8);
1505
1506     macro_rules! n {
1507         ($($e:expr),* $(,)?) => {
1508             [$(N($e)),*]
1509         }
1510     }
1511
1512     macro_rules! c {
1513         ($inp:expr, $typ:ty, $out:expr $(,)?) => {
1514             assert_eq!($out, identity::<$typ>($inp))
1515         };
1516     }
1517
1518     macro_rules! m {
1519         ($e:expr, $p:pat => $b:expr) => {
1520             match $e {
1521                 $p => $b,
1522                 _ => panic!(),
1523             }
1524         };
1525     }
1526
1527     // == Slices ==
1528
1529     // Matching slices using `ref` patterns:
1530     let mut v = vec![N(0), N(1), N(2), N(3), N(4)];
1531     let mut vc = (0..=4).collect::<Vec<u8>>();
1532
1533     let [..] = v[..]; // Always matches.
1534     m!(v[..], [N(0), ref sub @ .., N(4)] => c!(sub, &[N], n![1, 2, 3]));
1535     m!(v[..], [N(0), ref sub @ ..] => c!(sub, &[N], n![1, 2, 3, 4]));
1536     m!(v[..], [ref sub @ .., N(4)] => c!(sub, &[N], n![0, 1, 2, 3]));
1537     m!(v[..], [ref sub @ .., _, _, _, _, _] => c!(sub, &[N], &n![] as &[N]));
1538     m!(v[..], [_, _, _, _, _, ref sub @ ..] => c!(sub, &[N], &n![] as &[N]));
1539     m!(vc[..], [x, .., y] => c!((x, y), (u8, u8), (0, 4)));
1540
1541     // Matching slices using `ref mut` patterns:
1542     let [..] = v[..]; // Always matches.
1543     m!(v[..], [N(0), ref mut sub @ .., N(4)] => c!(sub, &mut [N], n![1, 2, 3]));
1544     m!(v[..], [N(0), ref mut sub @ ..] => c!(sub, &mut [N], n![1, 2, 3, 4]));
1545     m!(v[..], [ref mut sub @ .., N(4)] => c!(sub, &mut [N], n![0, 1, 2, 3]));
1546     m!(v[..], [ref mut sub @ .., _, _, _, _, _] => c!(sub, &mut [N], &mut n![] as &mut [N]));
1547     m!(v[..], [_, _, _, _, _, ref mut sub @ ..] => c!(sub, &mut [N], &mut n![] as &mut [N]));
1548     m!(vc[..], [x, .., y] => c!((x, y), (u8, u8), (0, 4)));
1549
1550     // Matching slices using default binding modes (&):
1551     let [..] = &v[..]; // Always matches.
1552     m!(&v[..], [N(0), sub @ .., N(4)] => c!(sub, &[N], n![1, 2, 3]));
1553     m!(&v[..], [N(0), sub @ ..] => c!(sub, &[N], n![1, 2, 3, 4]));
1554     m!(&v[..], [sub @ .., N(4)] => c!(sub, &[N], n![0, 1, 2, 3]));
1555     m!(&v[..], [sub @ .., _, _, _, _, _] => c!(sub, &[N], &n![] as &[N]));
1556     m!(&v[..], [_, _, _, _, _, sub @ ..] => c!(sub, &[N], &n![] as &[N]));
1557     m!(&vc[..], [x, .., y] => c!((x, y), (&u8, &u8), (&0, &4)));
1558
1559     // Matching slices using default binding modes (&mut):
1560     let [..] = &mut v[..]; // Always matches.
1561     m!(&mut v[..], [N(0), sub @ .., N(4)] => c!(sub, &mut [N], n![1, 2, 3]));
1562     m!(&mut v[..], [N(0), sub @ ..] => c!(sub, &mut [N], n![1, 2, 3, 4]));
1563     m!(&mut v[..], [sub @ .., N(4)] => c!(sub, &mut [N], n![0, 1, 2, 3]));
1564     m!(&mut v[..], [sub @ .., _, _, _, _, _] => c!(sub, &mut [N], &mut n![] as &mut [N]));
1565     m!(&mut v[..], [_, _, _, _, _, sub @ ..] => c!(sub, &mut [N], &mut n![] as &mut [N]));
1566     m!(&mut vc[..], [x, .., y] => c!((x, y), (&mut u8, &mut u8), (&mut 0, &mut 4)));
1567
1568     // == Arrays ==
1569     let mut v = n![0, 1, 2, 3, 4];
1570     let vc = [0, 1, 2, 3, 4];
1571
1572     // Matching arrays by value:
1573     m!(v.clone(), [N(0), sub @ .., N(4)] => c!(sub, [N; 3], n![1, 2, 3]));
1574     m!(v.clone(), [N(0), sub @ ..] => c!(sub, [N; 4], n![1, 2, 3, 4]));
1575     m!(v.clone(), [sub @ .., N(4)] => c!(sub, [N; 4], n![0, 1, 2, 3]));
1576     m!(v.clone(), [sub @ .., _, _, _, _, _] => c!(sub, [N; 0], n![] as [N; 0]));
1577     m!(v.clone(), [_, _, _, _, _, sub @ ..] => c!(sub, [N; 0], n![] as [N; 0]));
1578     m!(v.clone(), [x, .., y] => c!((x, y), (N, N), (N(0), N(4))));
1579     m!(v.clone(), [..] => ());
1580
1581     // Matching arrays by ref patterns:
1582     m!(v, [N(0), ref sub @ .., N(4)] => c!(sub, &[N; 3], &n![1, 2, 3]));
1583     m!(v, [N(0), ref sub @ ..] => c!(sub, &[N; 4], &n![1, 2, 3, 4]));
1584     m!(v, [ref sub @ .., N(4)] => c!(sub, &[N; 4], &n![0, 1, 2, 3]));
1585     m!(v, [ref sub @ .., _, _, _, _, _] => c!(sub, &[N; 0], &n![] as &[N; 0]));
1586     m!(v, [_, _, _, _, _, ref sub @ ..] => c!(sub, &[N; 0], &n![] as &[N; 0]));
1587     m!(vc, [x, .., y] => c!((x, y), (u8, u8), (0, 4)));
1588
1589     // Matching arrays by ref mut patterns:
1590     m!(v, [N(0), ref mut sub @ .., N(4)] => c!(sub, &mut [N; 3], &mut n![1, 2, 3]));
1591     m!(v, [N(0), ref mut sub @ ..] => c!(sub, &mut [N; 4], &mut n![1, 2, 3, 4]));
1592     m!(v, [ref mut sub @ .., N(4)] => c!(sub, &mut [N; 4], &mut n![0, 1, 2, 3]));
1593     m!(v, [ref mut sub @ .., _, _, _, _, _] => c!(sub, &mut [N; 0], &mut n![] as &mut [N; 0]));
1594     m!(v, [_, _, _, _, _, ref mut sub @ ..] => c!(sub, &mut [N; 0], &mut n![] as &mut [N; 0]));
1595
1596     // Matching arrays by default binding modes (&):
1597     m!(&v, [N(0), sub @ .., N(4)] => c!(sub, &[N; 3], &n![1, 2, 3]));
1598     m!(&v, [N(0), sub @ ..] => c!(sub, &[N; 4], &n![1, 2, 3, 4]));
1599     m!(&v, [sub @ .., N(4)] => c!(sub, &[N; 4], &n![0, 1, 2, 3]));
1600     m!(&v, [sub @ .., _, _, _, _, _] => c!(sub, &[N; 0], &n![] as &[N; 0]));
1601     m!(&v, [_, _, _, _, _, sub @ ..] => c!(sub, &[N; 0], &n![] as &[N; 0]));
1602     m!(&v, [..] => ());
1603     m!(&v, [x, .., y] => c!((x, y), (&N, &N), (&N(0), &N(4))));
1604
1605     // Matching arrays by default binding modes (&mut):
1606     m!(&mut v, [N(0), sub @ .., N(4)] => c!(sub, &mut [N; 3], &mut n![1, 2, 3]));
1607     m!(&mut v, [N(0), sub @ ..] => c!(sub, &mut [N; 4], &mut n![1, 2, 3, 4]));
1608     m!(&mut v, [sub @ .., N(4)] => c!(sub, &mut [N; 4], &mut n![0, 1, 2, 3]));
1609     m!(&mut v, [sub @ .., _, _, _, _, _] => c!(sub, &mut [N; 0], &mut n![] as &[N; 0]));
1610     m!(&mut v, [_, _, _, _, _, sub @ ..] => c!(sub, &mut [N; 0], &mut n![] as &[N; 0]));
1611     m!(&mut v, [..] => ());
1612     m!(&mut v, [x, .., y] => c!((x, y), (&mut N, &mut N), (&mut N(0), &mut N(4))));
1613 }
1614
1615 #[test]
1616 fn test_group_by() {
1617     let slice = &[1, 1, 1, 3, 3, 2, 2, 2, 1, 0];
1618
1619     let mut iter = slice.group_by(|a, b| a == b);
1620     assert_eq!(iter.next(), Some(&[1, 1, 1][..]));
1621     assert_eq!(iter.next(), Some(&[3, 3][..]));
1622     assert_eq!(iter.next(), Some(&[2, 2, 2][..]));
1623     assert_eq!(iter.next(), Some(&[1][..]));
1624     assert_eq!(iter.next(), Some(&[0][..]));
1625     assert_eq!(iter.next(), None);
1626
1627     let mut iter = slice.group_by(|a, b| a == b);
1628     assert_eq!(iter.next_back(), Some(&[0][..]));
1629     assert_eq!(iter.next_back(), Some(&[1][..]));
1630     assert_eq!(iter.next_back(), Some(&[2, 2, 2][..]));
1631     assert_eq!(iter.next_back(), Some(&[3, 3][..]));
1632     assert_eq!(iter.next_back(), Some(&[1, 1, 1][..]));
1633     assert_eq!(iter.next_back(), None);
1634
1635     let mut iter = slice.group_by(|a, b| a == b);
1636     assert_eq!(iter.next(), Some(&[1, 1, 1][..]));
1637     assert_eq!(iter.next_back(), Some(&[0][..]));
1638     assert_eq!(iter.next(), Some(&[3, 3][..]));
1639     assert_eq!(iter.next_back(), Some(&[1][..]));
1640     assert_eq!(iter.next(), Some(&[2, 2, 2][..]));
1641     assert_eq!(iter.next_back(), None);
1642 }
1643
1644 #[test]
1645 fn test_group_by_mut() {
1646     let slice = &mut [1, 1, 1, 3, 3, 2, 2, 2, 1, 0];
1647
1648     let mut iter = slice.group_by_mut(|a, b| a == b);
1649     assert_eq!(iter.next(), Some(&mut [1, 1, 1][..]));
1650     assert_eq!(iter.next(), Some(&mut [3, 3][..]));
1651     assert_eq!(iter.next(), Some(&mut [2, 2, 2][..]));
1652     assert_eq!(iter.next(), Some(&mut [1][..]));
1653     assert_eq!(iter.next(), Some(&mut [0][..]));
1654     assert_eq!(iter.next(), None);
1655
1656     let mut iter = slice.group_by_mut(|a, b| a == b);
1657     assert_eq!(iter.next_back(), Some(&mut [0][..]));
1658     assert_eq!(iter.next_back(), Some(&mut [1][..]));
1659     assert_eq!(iter.next_back(), Some(&mut [2, 2, 2][..]));
1660     assert_eq!(iter.next_back(), Some(&mut [3, 3][..]));
1661     assert_eq!(iter.next_back(), Some(&mut [1, 1, 1][..]));
1662     assert_eq!(iter.next_back(), None);
1663
1664     let mut iter = slice.group_by_mut(|a, b| a == b);
1665     assert_eq!(iter.next(), Some(&mut [1, 1, 1][..]));
1666     assert_eq!(iter.next_back(), Some(&mut [0][..]));
1667     assert_eq!(iter.next(), Some(&mut [3, 3][..]));
1668     assert_eq!(iter.next_back(), Some(&mut [1][..]));
1669     assert_eq!(iter.next(), Some(&mut [2, 2, 2][..]));
1670     assert_eq!(iter.next_back(), None);
1671 }