library/core/tests/slice.rs

   1 use core::cell::Cell;
   2 use core::cmp::Ordering;
   3 use core::mem::MaybeUninit;
   4 use core::result::Result::{Err, Ok};
   5 use core::slice;
   6
   7 #[test]
   8 fn test_position() {
   9     let b = [1, 2, 3, 5, 5];
  10     assert_eq!(b.iter().position(|&v| v == 9), None);
  11     assert_eq!(b.iter().position(|&v| v == 5), Some(3));
  12     assert_eq!(b.iter().position(|&v| v == 3), Some(2));
  13     assert_eq!(b.iter().position(|&v| v == 0), None);
  14 }
  15
  16 #[test]
  17 fn test_rposition() {
  18     let b = [1, 2, 3, 5, 5];
  19     assert_eq!(b.iter().rposition(|&v| v == 9), None);
  20     assert_eq!(b.iter().rposition(|&v| v == 5), Some(4));
  21     assert_eq!(b.iter().rposition(|&v| v == 3), Some(2));
  22     assert_eq!(b.iter().rposition(|&v| v == 0), None);
  23 }
  24
  25 #[test]
  26 fn test_binary_search() {
  27     let b: [i32; 0] = [];
  28     assert_eq!(b.binary_search(&5), Err(0));
  29
  30     let b = [4];
  31     assert_eq!(b.binary_search(&3), Err(0));
  32     assert_eq!(b.binary_search(&4), Ok(0));
  33     assert_eq!(b.binary_search(&5), Err(1));
  34
  35     let b = [1, 2, 4, 6, 8, 9];
  36     assert_eq!(b.binary_search(&5), Err(3));
  37     assert_eq!(b.binary_search(&6), Ok(3));
  38     assert_eq!(b.binary_search(&7), Err(4));
  39     assert_eq!(b.binary_search(&8), Ok(4));
  40
  41     let b = [1, 2, 4, 5, 6, 8];
  42     assert_eq!(b.binary_search(&9), Err(6));
  43
  44     let b = [1, 2, 4, 6, 7, 8, 9];
  45     assert_eq!(b.binary_search(&6), Ok(3));
  46     assert_eq!(b.binary_search(&5), Err(3));
  47     assert_eq!(b.binary_search(&8), Ok(5));
  48
  49     let b = [1, 2, 4, 5, 6, 8, 9];
  50     assert_eq!(b.binary_search(&7), Err(5));
  51     assert_eq!(b.binary_search(&0), Err(0));
  52
  53     let b = [1, 3, 3, 3, 7];
  54     assert_eq!(b.binary_search(&0), Err(0));
  55     assert_eq!(b.binary_search(&1), Ok(0));
  56     assert_eq!(b.binary_search(&2), Err(1));
  57     assert!(match b.binary_search(&3) {
  58         Ok(1..=3) => true,
  59         _ => false,
  60     });
  61     assert!(match b.binary_search(&3) {
  62         Ok(1..=3) => true,
  63         _ => false,
  64     });
  65     assert_eq!(b.binary_search(&4), Err(4));
  66     assert_eq!(b.binary_search(&5), Err(4));
  67     assert_eq!(b.binary_search(&6), Err(4));
  68     assert_eq!(b.binary_search(&7), Ok(4));
  69     assert_eq!(b.binary_search(&8), Err(5));
  70
  71     let b = [(); usize::MAX];
  72     assert_eq!(b.binary_search(&()), Ok(usize::MAX / 2));
  73 }
  74
  75 #[test]
  76 fn test_binary_search_by_overflow() {
  77     let b = [(); usize::MAX];
  78     assert_eq!(b.binary_search_by(|_| Ordering::Equal), Ok(usize::MAX / 2));
  79     assert_eq!(b.binary_search_by(|_| Ordering::Greater), Err(0));
  80     assert_eq!(b.binary_search_by(|_| Ordering::Less), Err(usize::MAX));
  81 }
  82
  83 #[test]
  84 // Test implementation specific behavior when finding equivalent elements.
  85 // It is ok to break this test but when you do a crater run is highly advisable.
  86 fn test_binary_search_implementation_details() {
  87     let b = [1, 1, 2, 2, 3, 3, 3];
  88     assert_eq!(b.binary_search(&1), Ok(1));
  89     assert_eq!(b.binary_search(&2), Ok(3));
  90     assert_eq!(b.binary_search(&3), Ok(5));
  91     let b = [1, 1, 1, 1, 1, 3, 3, 3, 3];
  92     assert_eq!(b.binary_search(&1), Ok(4));
  93     assert_eq!(b.binary_search(&3), Ok(7));
  94     let b = [1, 1, 1, 1, 3, 3, 3, 3, 3];
  95     assert_eq!(b.binary_search(&1), Ok(2));
  96     assert_eq!(b.binary_search(&3), Ok(4));
  97 }
  98
  99 #[test]
 100 fn test_partition_point() {
 101     let b: [i32; 0] = [];
 102     assert_eq!(b.partition_point(|&x| x < 5), 0);
 103
 104     let b = [4];
 105     assert_eq!(b.partition_point(|&x| x < 3), 0);
 106     assert_eq!(b.partition_point(|&x| x < 4), 0);
 107     assert_eq!(b.partition_point(|&x| x < 5), 1);
 108
 109     let b = [1, 2, 4, 6, 8, 9];
 110     assert_eq!(b.partition_point(|&x| x < 5), 3);
 111     assert_eq!(b.partition_point(|&x| x < 6), 3);
 112     assert_eq!(b.partition_point(|&x| x < 7), 4);
 113     assert_eq!(b.partition_point(|&x| x < 8), 4);
 114
 115     let b = [1, 2, 4, 5, 6, 8];
 116     assert_eq!(b.partition_point(|&x| x < 9), 6);
 117
 118     let b = [1, 2, 4, 6, 7, 8, 9];
 119     assert_eq!(b.partition_point(|&x| x < 6), 3);
 120     assert_eq!(b.partition_point(|&x| x < 5), 3);
 121     assert_eq!(b.partition_point(|&x| x < 8), 5);
 122
 123     let b = [1, 2, 4, 5, 6, 8, 9];
 124     assert_eq!(b.partition_point(|&x| x < 7), 5);
 125     assert_eq!(b.partition_point(|&x| x < 0), 0);
 126
 127     let b = [1, 3, 3, 3, 7];
 128     assert_eq!(b.partition_point(|&x| x < 0), 0);
 129     assert_eq!(b.partition_point(|&x| x < 1), 0);
 130     assert_eq!(b.partition_point(|&x| x < 2), 1);
 131     assert_eq!(b.partition_point(|&x| x < 3), 1);
 132     assert_eq!(b.partition_point(|&x| x < 4), 4);
 133     assert_eq!(b.partition_point(|&x| x < 5), 4);
 134     assert_eq!(b.partition_point(|&x| x < 6), 4);
 135     assert_eq!(b.partition_point(|&x| x < 7), 4);
 136     assert_eq!(b.partition_point(|&x| x < 8), 5);
 137 }
 138
 139 #[test]
 140 fn test_iterator_advance_by() {
 141     let v = &[0, 1, 2, 3, 4];
 142
 143     for i in 0..=v.len() {
 144         let mut iter = v.iter();
 145         iter.advance_by(i).unwrap();
 146         assert_eq!(iter.as_slice(), &v[i..]);
 147     }
 148
 149     let mut iter = v.iter();
 150     assert_eq!(iter.advance_by(v.len() + 1), Err(v.len()));
 151     assert_eq!(iter.as_slice(), &[]);
 152
 153     let mut iter = v.iter();
 154     iter.advance_by(3).unwrap();
 155     assert_eq!(iter.as_slice(), &v[3..]);
 156     iter.advance_by(2).unwrap();
 157     assert_eq!(iter.as_slice(), &[]);
 158     iter.advance_by(0).unwrap();
 159 }
 160
 161 #[test]
 162 fn test_iterator_advance_back_by() {
 163     let v = &[0, 1, 2, 3, 4];
 164
 165     for i in 0..=v.len() {
 166         let mut iter = v.iter();
 167         iter.advance_back_by(i).unwrap();
 168         assert_eq!(iter.as_slice(), &v[..v.len() - i]);
 169     }
 170
 171     let mut iter = v.iter();
 172     assert_eq!(iter.advance_back_by(v.len() + 1), Err(v.len()));
 173     assert_eq!(iter.as_slice(), &[]);
 174
 175     let mut iter = v.iter();
 176     iter.advance_back_by(3).unwrap();
 177     assert_eq!(iter.as_slice(), &v[..v.len() - 3]);
 178     iter.advance_back_by(2).unwrap();
 179     assert_eq!(iter.as_slice(), &[]);
 180     iter.advance_back_by(0).unwrap();
 181 }
 182
 183 #[test]
 184 fn test_iterator_nth() {
 185     let v: &[_] = &[0, 1, 2, 3, 4];
 186     for i in 0..v.len() {
 187         assert_eq!(v.iter().nth(i).unwrap(), &v[i]);
 188     }
 189     assert_eq!(v.iter().nth(v.len()), None);
 190
 191     let mut iter = v.iter();
 192     assert_eq!(iter.nth(2).unwrap(), &v[2]);
 193     assert_eq!(iter.nth(1).unwrap(), &v[4]);
 194 }
 195
 196 #[test]
 197 fn test_iterator_nth_back() {
 198     let v: &[_] = &[0, 1, 2, 3, 4];
 199     for i in 0..v.len() {
 200         assert_eq!(v.iter().nth_back(i).unwrap(), &v[v.len() - i - 1]);
 201     }
 202     assert_eq!(v.iter().nth_back(v.len()), None);
 203
 204     let mut iter = v.iter();
 205     assert_eq!(iter.nth_back(2).unwrap(), &v[2]);
 206     assert_eq!(iter.nth_back(1).unwrap(), &v[0]);
 207 }
 208
 209 #[test]
 210 fn test_iterator_last() {
 211     let v: &[_] = &[0, 1, 2, 3, 4];
 212     assert_eq!(v.iter().last().unwrap(), &4);
 213     assert_eq!(v[..1].iter().last().unwrap(), &0);
 214 }
 215
 216 #[test]
 217 fn test_iterator_count() {
 218     let v: &[_] = &[0, 1, 2, 3, 4];
 219     assert_eq!(v.iter().count(), 5);
 220
 221     let mut iter2 = v.iter();
 222     iter2.next();
 223     iter2.next();
 224     assert_eq!(iter2.count(), 3);
 225 }
 226
 227 #[test]
 228 fn test_chunks_count() {
 229     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 230     let c = v.chunks(3);
 231     assert_eq!(c.count(), 2);
 232
 233     let v2: &[i32] = &[0, 1, 2, 3, 4];
 234     let c2 = v2.chunks(2);
 235     assert_eq!(c2.count(), 3);
 236
 237     let v3: &[i32] = &[];
 238     let c3 = v3.chunks(2);
 239     assert_eq!(c3.count(), 0);
 240 }
 241
 242 #[test]
 243 fn test_chunks_nth() {
 244     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 245     let mut c = v.chunks(2);
 246     assert_eq!(c.nth(1).unwrap(), &[2, 3]);
 247     assert_eq!(c.next().unwrap(), &[4, 5]);
 248
 249     let v2: &[i32] = &[0, 1, 2, 3, 4];
 250     let mut c2 = v2.chunks(3);
 251     assert_eq!(c2.nth(1).unwrap(), &[3, 4]);
 252     assert_eq!(c2.next(), None);
 253 }
 254
 255 #[test]
 256 fn test_chunks_next() {
 257     let v = [0, 1, 2, 3, 4, 5];
 258     let mut c = v.chunks(2);
 259     assert_eq!(c.next().unwrap(), &[0, 1]);
 260     assert_eq!(c.next().unwrap(), &[2, 3]);
 261     assert_eq!(c.next().unwrap(), &[4, 5]);
 262     assert_eq!(c.next(), None);
 263
 264     let v = [0, 1, 2, 3, 4, 5, 6, 7];
 265     let mut c = v.chunks(3);
 266     assert_eq!(c.next().unwrap(), &[0, 1, 2]);
 267     assert_eq!(c.next().unwrap(), &[3, 4, 5]);
 268     assert_eq!(c.next().unwrap(), &[6, 7]);
 269     assert_eq!(c.next(), None);
 270 }
 271
 272 #[test]
 273 fn test_chunks_next_back() {
 274     let v = [0, 1, 2, 3, 4, 5];
 275     let mut c = v.chunks(2);
 276     assert_eq!(c.next_back().unwrap(), &[4, 5]);
 277     assert_eq!(c.next_back().unwrap(), &[2, 3]);
 278     assert_eq!(c.next_back().unwrap(), &[0, 1]);
 279     assert_eq!(c.next_back(), None);
 280
 281     let v = [0, 1, 2, 3, 4, 5, 6, 7];
 282     let mut c = v.chunks(3);
 283     assert_eq!(c.next_back().unwrap(), &[6, 7]);
 284     assert_eq!(c.next_back().unwrap(), &[3, 4, 5]);
 285     assert_eq!(c.next_back().unwrap(), &[0, 1, 2]);
 286     assert_eq!(c.next_back(), None);
 287 }
 288
 289 #[test]
 290 fn test_chunks_nth_back() {
 291     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 292     let mut c = v.chunks(2);
 293     assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
 294     assert_eq!(c.next().unwrap(), &[0, 1]);
 295     assert_eq!(c.next(), None);
 296
 297     let v2: &[i32] = &[0, 1, 2, 3, 4];
 298     let mut c2 = v2.chunks(3);
 299     assert_eq!(c2.nth_back(1).unwrap(), &[0, 1, 2]);
 300     assert_eq!(c2.next(), None);
 301     assert_eq!(c2.next_back(), None);
 302
 303     let v3: &[i32] = &[0, 1, 2, 3, 4];
 304     let mut c3 = v3.chunks(10);
 305     assert_eq!(c3.nth_back(0).unwrap(), &[0, 1, 2, 3, 4]);
 306     assert_eq!(c3.next(), None);
 307
 308     let v4: &[i32] = &[0, 1, 2];
 309     let mut c4 = v4.chunks(10);
 310     assert_eq!(c4.nth_back(1_000_000_000usize), None);
 311 }
 312
 313 #[test]
 314 fn test_chunks_last() {
 315     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 316     let c = v.chunks(2);
 317     assert_eq!(c.last().unwrap()[1], 5);
 318
 319     let v2: &[i32] = &[0, 1, 2, 3, 4];
 320     let c2 = v2.chunks(2);
 321     assert_eq!(c2.last().unwrap()[0], 4);
 322 }
 323
 324 #[test]
 325 fn test_chunks_zip() {
 326     let v1: &[i32] = &[0, 1, 2, 3, 4];
 327     let v2: &[i32] = &[6, 7, 8, 9, 10];
 328
 329     let res = v1
 330         .chunks(2)
 331         .zip(v2.chunks(2))
 332         .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
 333         .collect::<Vec<_>>();
 334     assert_eq!(res, vec![14, 22, 14]);
 335 }
 336
 337 #[test]
 338 fn test_chunks_mut_count() {
 339     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 340     let c = v.chunks_mut(3);
 341     assert_eq!(c.count(), 2);
 342
 343     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
 344     let c2 = v2.chunks_mut(2);
 345     assert_eq!(c2.count(), 3);
 346
 347     let v3: &mut [i32] = &mut [];
 348     let c3 = v3.chunks_mut(2);
 349     assert_eq!(c3.count(), 0);
 350 }
 351
 352 #[test]
 353 fn test_chunks_mut_nth() {
 354     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 355     let mut c = v.chunks_mut(2);
 356     assert_eq!(c.nth(1).unwrap(), &[2, 3]);
 357     assert_eq!(c.next().unwrap(), &[4, 5]);
 358
 359     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
 360     let mut c2 = v2.chunks_mut(3);
 361     assert_eq!(c2.nth(1).unwrap(), &[3, 4]);
 362     assert_eq!(c2.next(), None);
 363 }
 364
 365 #[test]
 366 fn test_chunks_mut_nth_back() {
 367     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 368     let mut c = v.chunks_mut(2);
 369     assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
 370     assert_eq!(c.next().unwrap(), &[0, 1]);
 371
 372     let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
 373     let mut c1 = v1.chunks_mut(3);
 374     assert_eq!(c1.nth_back(1).unwrap(), &[0, 1, 2]);
 375     assert_eq!(c1.next(), None);
 376
 377     let v3: &mut [i32] = &mut [0, 1, 2, 3, 4];
 378     let mut c3 = v3.chunks_mut(10);
 379     assert_eq!(c3.nth_back(0).unwrap(), &[0, 1, 2, 3, 4]);
 380     assert_eq!(c3.next(), None);
 381
 382     let v4: &mut [i32] = &mut [0, 1, 2];
 383     let mut c4 = v4.chunks_mut(10);
 384     assert_eq!(c4.nth_back(1_000_000_000usize), None);
 385 }
 386
 387 #[test]
 388 fn test_chunks_mut_last() {
 389     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 390     let c = v.chunks_mut(2);
 391     assert_eq!(c.last().unwrap(), &[4, 5]);
 392
 393     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
 394     let c2 = v2.chunks_mut(2);
 395     assert_eq!(c2.last().unwrap(), &[4]);
 396 }
 397
 398 #[test]
 399 fn test_chunks_mut_zip() {
 400     let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
 401     let v2: &[i32] = &[6, 7, 8, 9, 10];
 402
 403     for (a, b) in v1.chunks_mut(2).zip(v2.chunks(2)) {
 404         let sum = b.iter().sum::<i32>();
 405         for v in a {
 406             *v += sum;
 407         }
 408     }
 409     assert_eq!(v1, [13, 14, 19, 20, 14]);
 410 }
 411
 412 #[test]
 413 fn test_chunks_mut_zip_aliasing() {
 414     let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
 415     let v2: &[i32] = &[6, 7, 8, 9, 10];
 416
 417     let mut it = v1.chunks_mut(2).zip(v2.chunks(2));
 418     let first = it.next().unwrap();
 419     let _ = it.next().unwrap();
 420     assert_eq!(first, (&mut [0, 1][..], &[6, 7][..]));
 421 }
 422
 423 #[test]
 424 fn test_chunks_exact_mut_zip_aliasing() {
 425     let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
 426     let v2: &[i32] = &[6, 7, 8, 9, 10];
 427
 428     let mut it = v1.chunks_exact_mut(2).zip(v2.chunks(2));
 429     let first = it.next().unwrap();
 430     let _ = it.next().unwrap();
 431     assert_eq!(first, (&mut [0, 1][..], &[6, 7][..]));
 432 }
 433
 434 #[test]
 435 fn test_rchunks_mut_zip_aliasing() {
 436     let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
 437     let v2: &[i32] = &[6, 7, 8, 9, 10];
 438
 439     let mut it = v1.rchunks_mut(2).zip(v2.chunks(2));
 440     let first = it.next().unwrap();
 441     let _ = it.next().unwrap();
 442     assert_eq!(first, (&mut [3, 4][..], &[6, 7][..]));
 443 }
 444
 445 #[test]
 446 fn test_rchunks_exact_mut_zip_aliasing() {
 447     let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
 448     let v2: &[i32] = &[6, 7, 8, 9, 10];
 449
 450     let mut it = v1.rchunks_exact_mut(2).zip(v2.chunks(2));
 451     let first = it.next().unwrap();
 452     let _ = it.next().unwrap();
 453     assert_eq!(first, (&mut [3, 4][..], &[6, 7][..]));
 454 }
 455
 456 #[test]
 457 fn test_chunks_exact_count() {
 458     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 459     let c = v.chunks_exact(3);
 460     assert_eq!(c.count(), 2);
 461
 462     let v2: &[i32] = &[0, 1, 2, 3, 4];
 463     let c2 = v2.chunks_exact(2);
 464     assert_eq!(c2.count(), 2);
 465
 466     let v3: &[i32] = &[];
 467     let c3 = v3.chunks_exact(2);
 468     assert_eq!(c3.count(), 0);
 469 }
 470
 471 #[test]
 472 fn test_chunks_exact_nth() {
 473     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 474     let mut c = v.chunks_exact(2);
 475     assert_eq!(c.nth(1).unwrap(), &[2, 3]);
 476     assert_eq!(c.next().unwrap(), &[4, 5]);
 477
 478     let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
 479     let mut c2 = v2.chunks_exact(3);
 480     assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
 481     assert_eq!(c2.next(), None);
 482 }
 483
 484 #[test]
 485 fn test_chunks_exact_nth_back() {
 486     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 487     let mut c = v.chunks_exact(2);
 488     assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
 489     assert_eq!(c.next().unwrap(), &[0, 1]);
 490     assert_eq!(c.next(), None);
 491
 492     let v2: &[i32] = &[0, 1, 2, 3, 4];
 493     let mut c2 = v2.chunks_exact(3);
 494     assert_eq!(c2.nth_back(0).unwrap(), &[0, 1, 2]);
 495     assert_eq!(c2.next(), None);
 496     assert_eq!(c2.next_back(), None);
 497
 498     let v3: &[i32] = &[0, 1, 2, 3, 4];
 499     let mut c3 = v3.chunks_exact(10);
 500     assert_eq!(c3.nth_back(0), None);
 501 }
 502
 503 #[test]
 504 fn test_chunks_exact_last() {
 505     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 506     let c = v.chunks_exact(2);
 507     assert_eq!(c.last().unwrap(), &[4, 5]);
 508
 509     let v2: &[i32] = &[0, 1, 2, 3, 4];
 510     let c2 = v2.chunks_exact(2);
 511     assert_eq!(c2.last().unwrap(), &[2, 3]);
 512 }
 513
 514 #[test]
 515 fn test_chunks_exact_remainder() {
 516     let v: &[i32] = &[0, 1, 2, 3, 4];
 517     let c = v.chunks_exact(2);
 518     assert_eq!(c.remainder(), &[4]);
 519 }
 520
 521 #[test]
 522 fn test_chunks_exact_zip() {
 523     let v1: &[i32] = &[0, 1, 2, 3, 4];
 524     let v2: &[i32] = &[6, 7, 8, 9, 10];
 525
 526     let res = v1
 527         .chunks_exact(2)
 528         .zip(v2.chunks_exact(2))
 529         .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
 530         .collect::<Vec<_>>();
 531     assert_eq!(res, vec![14, 22]);
 532 }
 533
 534 #[test]
 535 fn test_chunks_exact_mut_count() {
 536     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 537     let c = v.chunks_exact_mut(3);
 538     assert_eq!(c.count(), 2);
 539
 540     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
 541     let c2 = v2.chunks_exact_mut(2);
 542     assert_eq!(c2.count(), 2);
 543
 544     let v3: &mut [i32] = &mut [];
 545     let c3 = v3.chunks_exact_mut(2);
 546     assert_eq!(c3.count(), 0);
 547 }
 548
 549 #[test]
 550 fn test_chunks_exact_mut_nth() {
 551     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 552     let mut c = v.chunks_exact_mut(2);
 553     assert_eq!(c.nth(1).unwrap(), &[2, 3]);
 554     assert_eq!(c.next().unwrap(), &[4, 5]);
 555
 556     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
 557     let mut c2 = v2.chunks_exact_mut(3);
 558     assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
 559     assert_eq!(c2.next(), None);
 560 }
 561
 562 #[test]
 563 fn test_chunks_exact_mut_nth_back() {
 564     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 565     let mut c = v.chunks_exact_mut(2);
 566     assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
 567     assert_eq!(c.next().unwrap(), &[0, 1]);
 568     assert_eq!(c.next(), None);
 569
 570     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
 571     let mut c2 = v2.chunks_exact_mut(3);
 572     assert_eq!(c2.nth_back(0).unwrap(), &[0, 1, 2]);
 573     assert_eq!(c2.next(), None);
 574     assert_eq!(c2.next_back(), None);
 575
 576     let v3: &mut [i32] = &mut [0, 1, 2, 3, 4];
 577     let mut c3 = v3.chunks_exact_mut(10);
 578     assert_eq!(c3.nth_back(0), None);
 579 }
 580
 581 #[test]
 582 fn test_chunks_exact_mut_last() {
 583     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 584     let c = v.chunks_exact_mut(2);
 585     assert_eq!(c.last().unwrap(), &[4, 5]);
 586
 587     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
 588     let c2 = v2.chunks_exact_mut(2);
 589     assert_eq!(c2.last().unwrap(), &[2, 3]);
 590 }
 591
 592 #[test]
 593 fn test_chunks_exact_mut_remainder() {
 594     let v: &mut [i32] = &mut [0, 1, 2, 3, 4];
 595     let c = v.chunks_exact_mut(2);
 596     assert_eq!(c.into_remainder(), &[4]);
 597 }
 598
 599 #[test]
 600 fn test_chunks_exact_mut_zip() {
 601     let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
 602     let v2: &[i32] = &[6, 7, 8, 9, 10];
 603
 604     for (a, b) in v1.chunks_exact_mut(2).zip(v2.chunks_exact(2)) {
 605         let sum = b.iter().sum::<i32>();
 606         for v in a {
 607             *v += sum;
 608         }
 609     }
 610     assert_eq!(v1, [13, 14, 19, 20, 4]);
 611 }
 612
 613 #[test]
 614 fn test_array_chunks_infer() {
 615     let v: &[i32] = &[0, 1, 2, 3, 4, -4];
 616     let c = v.array_chunks();
 617     for &[a, b, c] in c {
 618         assert_eq!(a + b + c, 3);
 619     }
 620
 621     let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
 622     let total = v2.array_chunks().map(|&[a, b]| a * b).sum::<i32>();
 623     assert_eq!(total, 2 * 3 + 4 * 5);
 624 }
 625
 626 #[test]
 627 fn test_array_chunks_count() {
 628     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 629     let c = v.array_chunks::<3>();
 630     assert_eq!(c.count(), 2);
 631
 632     let v2: &[i32] = &[0, 1, 2, 3, 4];
 633     let c2 = v2.array_chunks::<2>();
 634     assert_eq!(c2.count(), 2);
 635
 636     let v3: &[i32] = &[];
 637     let c3 = v3.array_chunks::<2>();
 638     assert_eq!(c3.count(), 0);
 639 }
 640
 641 #[test]
 642 fn test_array_chunks_nth() {
 643     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 644     let mut c = v.array_chunks::<2>();
 645     assert_eq!(c.nth(1).unwrap(), &[2, 3]);
 646     assert_eq!(c.next().unwrap(), &[4, 5]);
 647
 648     let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
 649     let mut c2 = v2.array_chunks::<3>();
 650     assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
 651     assert_eq!(c2.next(), None);
 652 }
 653
 654 #[test]
 655 fn test_array_chunks_nth_back() {
 656     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 657     let mut c = v.array_chunks::<2>();
 658     assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
 659     assert_eq!(c.next().unwrap(), &[0, 1]);
 660     assert_eq!(c.next(), None);
 661
 662     let v2: &[i32] = &[0, 1, 2, 3, 4];
 663     let mut c2 = v2.array_chunks::<3>();
 664     assert_eq!(c2.nth_back(0).unwrap(), &[0, 1, 2]);
 665     assert_eq!(c2.next(), None);
 666     assert_eq!(c2.next_back(), None);
 667
 668     let v3: &[i32] = &[0, 1, 2, 3, 4];
 669     let mut c3 = v3.array_chunks::<10>();
 670     assert_eq!(c3.nth_back(0), None);
 671 }
 672
 673 #[test]
 674 fn test_array_chunks_last() {
 675     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 676     let c = v.array_chunks::<2>();
 677     assert_eq!(c.last().unwrap(), &[4, 5]);
 678
 679     let v2: &[i32] = &[0, 1, 2, 3, 4];
 680     let c2 = v2.array_chunks::<2>();
 681     assert_eq!(c2.last().unwrap(), &[2, 3]);
 682 }
 683
 684 #[test]
 685 fn test_array_chunks_remainder() {
 686     let v: &[i32] = &[0, 1, 2, 3, 4];
 687     let c = v.array_chunks::<2>();
 688     assert_eq!(c.remainder(), &[4]);
 689 }
 690
 691 #[test]
 692 fn test_array_chunks_zip() {
 693     let v1: &[i32] = &[0, 1, 2, 3, 4];
 694     let v2: &[i32] = &[6, 7, 8, 9, 10];
 695
 696     let res = v1
 697         .array_chunks::<2>()
 698         .zip(v2.array_chunks::<2>())
 699         .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
 700         .collect::<Vec<_>>();
 701     assert_eq!(res, vec![14, 22]);
 702 }
 703
 704 #[test]
 705 fn test_array_chunks_mut_infer() {
 706     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
 707     for a in v.array_chunks_mut() {
 708         let sum = a.iter().sum::<i32>();
 709         *a = [sum; 3];
 710     }
 711     assert_eq!(v, &[3, 3, 3, 12, 12, 12, 6]);
 712
 713     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
 714     v2.array_chunks_mut().for_each(|[a, b]| core::mem::swap(a, b));
 715     assert_eq!(v2, &[1, 0, 3, 2, 5, 4, 6]);
 716 }
 717
 718 #[test]
 719 fn test_array_chunks_mut_count() {
 720     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 721     let c = v.array_chunks_mut::<3>();
 722     assert_eq!(c.count(), 2);
 723
 724     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
 725     let c2 = v2.array_chunks_mut::<2>();
 726     assert_eq!(c2.count(), 2);
 727
 728     let v3: &mut [i32] = &mut [];
 729     let c3 = v3.array_chunks_mut::<2>();
 730     assert_eq!(c3.count(), 0);
 731 }
 732
 733 #[test]
 734 fn test_array_chunks_mut_nth() {
 735     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 736     let mut c = v.array_chunks_mut::<2>();
 737     assert_eq!(c.nth(1).unwrap(), &[2, 3]);
 738     assert_eq!(c.next().unwrap(), &[4, 5]);
 739
 740     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
 741     let mut c2 = v2.array_chunks_mut::<3>();
 742     assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
 743     assert_eq!(c2.next(), None);
 744 }
 745
 746 #[test]
 747 fn test_array_chunks_mut_nth_back() {
 748     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 749     let mut c = v.array_chunks_mut::<2>();
 750     assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
 751     assert_eq!(c.next().unwrap(), &[0, 1]);
 752     assert_eq!(c.next(), None);
 753
 754     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
 755     let mut c2 = v2.array_chunks_mut::<3>();
 756     assert_eq!(c2.nth_back(0).unwrap(), &[0, 1, 2]);
 757     assert_eq!(c2.next(), None);
 758     assert_eq!(c2.next_back(), None);
 759
 760     let v3: &mut [i32] = &mut [0, 1, 2, 3, 4];
 761     let mut c3 = v3.array_chunks_mut::<10>();
 762     assert_eq!(c3.nth_back(0), None);
 763 }
 764
 765 #[test]
 766 fn test_array_chunks_mut_last() {
 767     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 768     let c = v.array_chunks_mut::<2>();
 769     assert_eq!(c.last().unwrap(), &[4, 5]);
 770
 771     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
 772     let c2 = v2.array_chunks_mut::<2>();
 773     assert_eq!(c2.last().unwrap(), &[2, 3]);
 774 }
 775
 776 #[test]
 777 fn test_array_chunks_mut_remainder() {
 778     let v: &mut [i32] = &mut [0, 1, 2, 3, 4];
 779     let c = v.array_chunks_mut::<2>();
 780     assert_eq!(c.into_remainder(), &[4]);
 781 }
 782
 783 #[test]
 784 fn test_array_chunks_mut_zip() {
 785     let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
 786     let v2: &[i32] = &[6, 7, 8, 9, 10];
 787
 788     for (a, b) in v1.array_chunks_mut::<2>().zip(v2.array_chunks::<2>()) {
 789         let sum = b.iter().sum::<i32>();
 790         for v in a {
 791             *v += sum;
 792         }
 793     }
 794     assert_eq!(v1, [13, 14, 19, 20, 4]);
 795 }
 796
 797 #[test]
 798 fn test_array_windows_infer() {
 799     let v: &[i32] = &[0, 1, 0, 1];
 800     assert_eq!(v.array_windows::<2>().count(), 3);
 801     let c = v.array_windows();
 802     for &[a, b] in c {
 803         assert_eq!(a + b, 1);
 804     }
 805
 806     let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
 807     let total = v2.array_windows().map(|&[a, b, c]| a + b + c).sum::<i32>();
 808     assert_eq!(total, 3 + 6 + 9 + 12 + 15);
 809 }
 810
 811 #[test]
 812 fn test_array_windows_count() {
 813     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 814     let c = v.array_windows::<3>();
 815     assert_eq!(c.count(), 4);
 816
 817     let v2: &[i32] = &[0, 1, 2, 3, 4];
 818     let c2 = v2.array_windows::<6>();
 819     assert_eq!(c2.count(), 0);
 820
 821     let v3: &[i32] = &[];
 822     let c3 = v3.array_windows::<2>();
 823     assert_eq!(c3.count(), 0);
 824
 825     let v4: &[()] = &[(); usize::MAX];
 826     let c4 = v4.array_windows::<1>();
 827     assert_eq!(c4.count(), usize::MAX);
 828 }
 829
 830 #[test]
 831 fn test_array_windows_nth() {
 832     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 833     let snd = v.array_windows::<4>().nth(1);
 834     assert_eq!(snd, Some(&[1, 2, 3, 4]));
 835     let mut arr_windows = v.array_windows::<2>();
 836     assert_ne!(arr_windows.nth(0), arr_windows.nth(0));
 837     let last = v.array_windows::<3>().last();
 838     assert_eq!(last, Some(&[3, 4, 5]));
 839 }
 840
 841 #[test]
 842 fn test_array_windows_nth_back() {
 843     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 844     let snd = v.array_windows::<4>().nth_back(1);
 845     assert_eq!(snd, Some(&[1, 2, 3, 4]));
 846     let mut arr_windows = v.array_windows::<2>();
 847     assert_ne!(arr_windows.nth_back(0), arr_windows.nth_back(0));
 848 }
 849
 850 #[test]
 851 fn test_rchunks_count() {
 852     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 853     let c = v.rchunks(3);
 854     assert_eq!(c.count(), 2);
 855
 856     let v2: &[i32] = &[0, 1, 2, 3, 4];
 857     let c2 = v2.rchunks(2);
 858     assert_eq!(c2.count(), 3);
 859
 860     let v3: &[i32] = &[];
 861     let c3 = v3.rchunks(2);
 862     assert_eq!(c3.count(), 0);
 863 }
 864
 865 #[test]
 866 fn test_rchunks_nth() {
 867     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 868     let mut c = v.rchunks(2);
 869     assert_eq!(c.nth(1).unwrap(), &[2, 3]);
 870     assert_eq!(c.next().unwrap(), &[0, 1]);
 871
 872     let v2: &[i32] = &[0, 1, 2, 3, 4];
 873     let mut c2 = v2.rchunks(3);
 874     assert_eq!(c2.nth(1).unwrap(), &[0, 1]);
 875     assert_eq!(c2.next(), None);
 876 }
 877
 878 #[test]
 879 fn test_rchunks_nth_back() {
 880     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 881     let mut c = v.rchunks(2);
 882     assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
 883     assert_eq!(c.next_back().unwrap(), &[4, 5]);
 884
 885     let v2: &[i32] = &[0, 1, 2, 3, 4];
 886     let mut c2 = v2.rchunks(3);
 887     assert_eq!(c2.nth_back(1).unwrap(), &[2, 3, 4]);
 888     assert_eq!(c2.next_back(), None);
 889 }
 890
 891 #[test]
 892 fn test_rchunks_next() {
 893     let v = [0, 1, 2, 3, 4, 5];
 894     let mut c = v.rchunks(2);
 895     assert_eq!(c.next().unwrap(), &[4, 5]);
 896     assert_eq!(c.next().unwrap(), &[2, 3]);
 897     assert_eq!(c.next().unwrap(), &[0, 1]);
 898     assert_eq!(c.next(), None);
 899
 900     let v = [0, 1, 2, 3, 4, 5, 6, 7];
 901     let mut c = v.rchunks(3);
 902     assert_eq!(c.next().unwrap(), &[5, 6, 7]);
 903     assert_eq!(c.next().unwrap(), &[2, 3, 4]);
 904     assert_eq!(c.next().unwrap(), &[0, 1]);
 905     assert_eq!(c.next(), None);
 906 }
 907
 908 #[test]
 909 fn test_rchunks_next_back() {
 910     let v = [0, 1, 2, 3, 4, 5];
 911     let mut c = v.rchunks(2);
 912     assert_eq!(c.next_back().unwrap(), &[0, 1]);
 913     assert_eq!(c.next_back().unwrap(), &[2, 3]);
 914     assert_eq!(c.next_back().unwrap(), &[4, 5]);
 915     assert_eq!(c.next_back(), None);
 916
 917     let v = [0, 1, 2, 3, 4, 5, 6, 7];
 918     let mut c = v.rchunks(3);
 919     assert_eq!(c.next_back().unwrap(), &[0, 1]);
 920     assert_eq!(c.next_back().unwrap(), &[2, 3, 4]);
 921     assert_eq!(c.next_back().unwrap(), &[5, 6, 7]);
 922     assert_eq!(c.next_back(), None);
 923 }
 924
 925 #[test]
 926 fn test_rchunks_last() {
 927     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 928     let c = v.rchunks(2);
 929     assert_eq!(c.last().unwrap()[1], 1);
 930
 931     let v2: &[i32] = &[0, 1, 2, 3, 4];
 932     let c2 = v2.rchunks(2);
 933     assert_eq!(c2.last().unwrap()[0], 0);
 934 }
 935
 936 #[test]
 937 fn test_rchunks_zip() {
 938     let v1: &[i32] = &[0, 1, 2, 3, 4];
 939     let v2: &[i32] = &[6, 7, 8, 9, 10];
 940
 941     let res = v1
 942         .rchunks(2)
 943         .zip(v2.rchunks(2))
 944         .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
 945         .collect::<Vec<_>>();
 946     assert_eq!(res, vec![26, 18, 6]);
 947 }
 948
 949 #[test]
 950 fn test_rchunks_mut_count() {
 951     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 952     let c = v.rchunks_mut(3);
 953     assert_eq!(c.count(), 2);
 954
 955     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
 956     let c2 = v2.rchunks_mut(2);
 957     assert_eq!(c2.count(), 3);
 958
 959     let v3: &mut [i32] = &mut [];
 960     let c3 = v3.rchunks_mut(2);
 961     assert_eq!(c3.count(), 0);
 962 }
 963
 964 #[test]
 965 fn test_rchunks_mut_nth() {
 966     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 967     let mut c = v.rchunks_mut(2);
 968     assert_eq!(c.nth(1).unwrap(), &[2, 3]);
 969     assert_eq!(c.next().unwrap(), &[0, 1]);
 970
 971     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
 972     let mut c2 = v2.rchunks_mut(3);
 973     assert_eq!(c2.nth(1).unwrap(), &[0, 1]);
 974     assert_eq!(c2.next(), None);
 975 }
 976
 977 #[test]
 978 fn test_rchunks_mut_nth_back() {
 979     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 980     let mut c = v.rchunks_mut(2);
 981     assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
 982     assert_eq!(c.next_back().unwrap(), &[4, 5]);
 983
 984     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
 985     let mut c2 = v2.rchunks_mut(3);
 986     assert_eq!(c2.nth_back(1).unwrap(), &[2, 3, 4]);
 987     assert_eq!(c2.next_back(), None);
 988 }
 989
 990 #[test]
 991 fn test_rchunks_mut_next() {
 992     let mut v = [0, 1, 2, 3, 4, 5];
 993     let mut c = v.rchunks_mut(2);
 994     assert_eq!(c.next().unwrap(), &mut [4, 5]);
 995     assert_eq!(c.next().unwrap(), &mut [2, 3]);
 996     assert_eq!(c.next().unwrap(), &mut [0, 1]);
 997     assert_eq!(c.next(), None);
 998
 999     let mut v = [0, 1, 2, 3, 4, 5, 6, 7];
1000     let mut c = v.rchunks_mut(3);
1001     assert_eq!(c.next().unwrap(), &mut [5, 6, 7]);
1002     assert_eq!(c.next().unwrap(), &mut [2, 3, 4]);
1003     assert_eq!(c.next().unwrap(), &mut [0, 1]);
1004     assert_eq!(c.next(), None);
1005 }
1006
1007 #[test]
1008 fn test_rchunks_mut_next_back() {
1009     let mut v = [0, 1, 2, 3, 4, 5];
1010     let mut c = v.rchunks_mut(2);
1011     assert_eq!(c.next_back().unwrap(), &mut [0, 1]);
1012     assert_eq!(c.next_back().unwrap(), &mut [2, 3]);
1013     assert_eq!(c.next_back().unwrap(), &mut [4, 5]);
1014     assert_eq!(c.next_back(), None);
1015
1016     let mut v = [0, 1, 2, 3, 4, 5, 6, 7];
1017     let mut c = v.rchunks_mut(3);
1018     assert_eq!(c.next_back().unwrap(), &mut [0, 1]);
1019     assert_eq!(c.next_back().unwrap(), &mut [2, 3, 4]);
1020     assert_eq!(c.next_back().unwrap(), &mut [5, 6, 7]);
1021     assert_eq!(c.next_back(), None);
1022 }
1023
1024 #[test]
1025 fn test_rchunks_mut_last() {
1026     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
1027     let c = v.rchunks_mut(2);
1028     assert_eq!(c.last().unwrap(), &[0, 1]);
1029
1030     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
1031     let c2 = v2.rchunks_mut(2);
1032     assert_eq!(c2.last().unwrap(), &[0]);
1033 }
1034
1035 #[test]
1036 fn test_rchunks_mut_zip() {
1037     let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
1038     let v2: &[i32] = &[6, 7, 8, 9, 10];
1039
1040     for (a, b) in v1.rchunks_mut(2).zip(v2.rchunks(2)) {
1041         let sum = b.iter().sum::<i32>();
1042         for v in a {
1043             *v += sum;
1044         }
1045     }
1046     assert_eq!(v1, [6, 16, 17, 22, 23]);
1047 }
1048
1049 #[test]
1050 fn test_rchunks_exact_count() {
1051     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1052     let c = v.rchunks_exact(3);
1053     assert_eq!(c.count(), 2);
1054
1055     let v2: &[i32] = &[0, 1, 2, 3, 4];
1056     let c2 = v2.rchunks_exact(2);
1057     assert_eq!(c2.count(), 2);
1058
1059     let v3: &[i32] = &[];
1060     let c3 = v3.rchunks_exact(2);
1061     assert_eq!(c3.count(), 0);
1062 }
1063
1064 #[test]
1065 fn test_rchunks_exact_nth() {
1066     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1067     let mut c = v.rchunks_exact(2);
1068     assert_eq!(c.nth(1).unwrap(), &[2, 3]);
1069     assert_eq!(c.next().unwrap(), &[0, 1]);
1070
1071     let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
1072     let mut c2 = v2.rchunks_exact(3);
1073     assert_eq!(c2.nth(1).unwrap(), &[1, 2, 3]);
1074     assert_eq!(c2.next(), None);
1075 }
1076
1077 #[test]
1078 fn test_rchunks_exact_nth_back() {
1079     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1080     let mut c = v.rchunks_exact(2);
1081     assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
1082     assert_eq!(c.next_back().unwrap(), &[4, 5]);
1083
1084     let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
1085     let mut c2 = v2.rchunks_exact(3);
1086     assert_eq!(c2.nth_back(1).unwrap(), &[4, 5, 6]);
1087     assert_eq!(c2.next(), None);
1088 }
1089
1090 #[test]
1091 fn test_rchunks_exact_last() {
1092     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1093     let c = v.rchunks_exact(2);
1094     assert_eq!(c.last().unwrap(), &[0, 1]);
1095
1096     let v2: &[i32] = &[0, 1, 2, 3, 4];
1097     let c2 = v2.rchunks_exact(2);
1098     assert_eq!(c2.last().unwrap(), &[1, 2]);
1099 }
1100
1101 #[test]
1102 fn test_rchunks_exact_remainder() {
1103     let v: &[i32] = &[0, 1, 2, 3, 4];
1104     let c = v.rchunks_exact(2);
1105     assert_eq!(c.remainder(), &[0]);
1106 }
1107
1108 #[test]
1109 fn test_rchunks_exact_zip() {
1110     let v1: &[i32] = &[0, 1, 2, 3, 4];
1111     let v2: &[i32] = &[6, 7, 8, 9, 10];
1112
1113     let res = v1
1114         .rchunks_exact(2)
1115         .zip(v2.rchunks_exact(2))
1116         .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
1117         .collect::<Vec<_>>();
1118     assert_eq!(res, vec![26, 18]);
1119 }
1120
1121 #[test]
1122 fn test_rchunks_exact_mut_count() {
1123     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
1124     let c = v.rchunks_exact_mut(3);
1125     assert_eq!(c.count(), 2);
1126
1127     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
1128     let c2 = v2.rchunks_exact_mut(2);
1129     assert_eq!(c2.count(), 2);
1130
1131     let v3: &mut [i32] = &mut [];
1132     let c3 = v3.rchunks_exact_mut(2);
1133     assert_eq!(c3.count(), 0);
1134 }
1135
1136 #[test]
1137 fn test_rchunks_exact_mut_nth() {
1138     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
1139     let mut c = v.rchunks_exact_mut(2);
1140     assert_eq!(c.nth(1).unwrap(), &[2, 3]);
1141     assert_eq!(c.next().unwrap(), &[0, 1]);
1142
1143     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
1144     let mut c2 = v2.rchunks_exact_mut(3);
1145     assert_eq!(c2.nth(1).unwrap(), &[1, 2, 3]);
1146     assert_eq!(c2.next(), None);
1147 }
1148
1149 #[test]
1150 fn test_rchunks_exact_mut_nth_back() {
1151     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
1152     let mut c = v.rchunks_exact_mut(2);
1153     assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
1154     assert_eq!(c.next_back().unwrap(), &[4, 5]);
1155
1156     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
1157     let mut c2 = v2.rchunks_exact_mut(3);
1158     assert_eq!(c2.nth_back(1).unwrap(), &[4, 5, 6]);
1159     assert_eq!(c2.next(), None);
1160 }
1161
1162 #[test]
1163 fn test_rchunks_exact_mut_last() {
1164     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
1165     let c = v.rchunks_exact_mut(2);
1166     assert_eq!(c.last().unwrap(), &[0, 1]);
1167
1168     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
1169     let c2 = v2.rchunks_exact_mut(2);
1170     assert_eq!(c2.last().unwrap(), &[1, 2]);
1171 }
1172
1173 #[test]
1174 fn test_rchunks_exact_mut_remainder() {
1175     let v: &mut [i32] = &mut [0, 1, 2, 3, 4];
1176     let c = v.rchunks_exact_mut(2);
1177     assert_eq!(c.into_remainder(), &[0]);
1178 }
1179
1180 #[test]
1181 fn test_rchunks_exact_mut_zip() {
1182     let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
1183     let v2: &[i32] = &[6, 7, 8, 9, 10];
1184
1185     for (a, b) in v1.rchunks_exact_mut(2).zip(v2.rchunks_exact(2)) {
1186         let sum = b.iter().sum::<i32>();
1187         for v in a {
1188             *v += sum;
1189         }
1190     }
1191     assert_eq!(v1, [0, 16, 17, 22, 23]);
1192 }
1193
1194 #[test]
1195 fn chunks_mut_are_send_and_sync() {
1196     use std::cell::Cell;
1197     use std::slice::{ChunksExactMut, ChunksMut, RChunksExactMut, RChunksMut};
1198     use std::sync::MutexGuard;
1199
1200     fn assert_send_and_sync()
1201     where
1202         ChunksMut<'static, Cell<i32>>: Send,
1203         ChunksMut<'static, MutexGuard<'static, u32>>: Sync,
1204         ChunksExactMut<'static, Cell<i32>>: Send,
1205         ChunksExactMut<'static, MutexGuard<'static, u32>>: Sync,
1206         RChunksMut<'static, Cell<i32>>: Send,
1207         RChunksMut<'static, MutexGuard<'static, u32>>: Sync,
1208         RChunksExactMut<'static, Cell<i32>>: Send,
1209         RChunksExactMut<'static, MutexGuard<'static, u32>>: Sync,
1210     {
1211     }
1212
1213     assert_send_and_sync();
1214 }
1215
1216 #[test]
1217 fn test_windows_count() {
1218     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1219     let c = v.windows(3);
1220     assert_eq!(c.count(), 4);
1221
1222     let v2: &[i32] = &[0, 1, 2, 3, 4];
1223     let c2 = v2.windows(6);
1224     assert_eq!(c2.count(), 0);
1225
1226     let v3: &[i32] = &[];
1227     let c3 = v3.windows(2);
1228     assert_eq!(c3.count(), 0);
1229
1230     let v4 = &[(); usize::MAX];
1231     let c4 = v4.windows(1);
1232     assert_eq!(c4.count(), usize::MAX);
1233 }
1234
1235 #[test]
1236 fn test_windows_nth() {
1237     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1238     let mut c = v.windows(2);
1239     assert_eq!(c.nth(2).unwrap()[1], 3);
1240     assert_eq!(c.next().unwrap()[0], 3);
1241
1242     let v2: &[i32] = &[0, 1, 2, 3, 4];
1243     let mut c2 = v2.windows(4);
1244     assert_eq!(c2.nth(1).unwrap()[1], 2);
1245     assert_eq!(c2.next(), None);
1246 }
1247
1248 #[test]
1249 fn test_windows_nth_back() {
1250     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1251     let mut c = v.windows(2);
1252     assert_eq!(c.nth_back(2).unwrap()[0], 2);
1253     assert_eq!(c.next_back().unwrap()[1], 2);
1254
1255     let v2: &[i32] = &[0, 1, 2, 3, 4];
1256     let mut c2 = v2.windows(4);
1257     assert_eq!(c2.nth_back(1).unwrap()[1], 1);
1258     assert_eq!(c2.next_back(), None);
1259 }
1260
1261 #[test]
1262 fn test_windows_last() {
1263     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1264     let c = v.windows(2);
1265     assert_eq!(c.last().unwrap()[1], 5);
1266
1267     let v2: &[i32] = &[0, 1, 2, 3, 4];
1268     let c2 = v2.windows(2);
1269     assert_eq!(c2.last().unwrap()[0], 3);
1270 }
1271
1272 #[test]
1273 fn test_windows_zip() {
1274     let v1: &[i32] = &[0, 1, 2, 3, 4];
1275     let v2: &[i32] = &[6, 7, 8, 9, 10];
1276
1277     let res = v1
1278         .windows(2)
1279         .zip(v2.windows(2))
1280         .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
1281         .collect::<Vec<_>>();
1282
1283     assert_eq!(res, [14, 18, 22, 26]);
1284 }
1285
1286 #[test]
1287 #[allow(const_err)]
1288 fn test_iter_ref_consistency() {
1289     use std::fmt::Debug;
1290
1291     fn test<T: Copy + Debug + PartialEq>(x: T) {
1292         let v: &[T] = &[x, x, x];
1293         let v_ptrs: [*const T; 3] = match v {
1294             [ref v1, ref v2, ref v3] => [v1 as *const _, v2 as *const _, v3 as *const _],
1295             _ => unreachable!(),
1296         };
1297         let len = v.len();
1298
1299         // nth(i)
1300         for i in 0..len {
1301             assert_eq!(&v[i] as *const _, v_ptrs[i]); // check the v_ptrs array, just to be sure
1302             let nth = v.iter().nth(i).unwrap();
1303             assert_eq!(nth as *const _, v_ptrs[i]);
1304         }
1305         assert_eq!(v.iter().nth(len), None, "nth(len) should return None");
1306
1307         // stepping through with nth(0)
1308         {
1309             let mut it = v.iter();
1310             for i in 0..len {
1311                 let next = it.nth(0).unwrap();
1312                 assert_eq!(next as *const _, v_ptrs[i]);
1313             }
1314             assert_eq!(it.nth(0), None);
1315         }
1316
1317         // next()
1318         {
1319             let mut it = v.iter();
1320             for i in 0..len {
1321                 let remaining = len - i;
1322                 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1323
1324                 let next = it.next().unwrap();
1325                 assert_eq!(next as *const _, v_ptrs[i]);
1326             }
1327             assert_eq!(it.size_hint(), (0, Some(0)));
1328             assert_eq!(it.next(), None, "The final call to next() should return None");
1329         }
1330
1331         // next_back()
1332         {
1333             let mut it = v.iter();
1334             for i in 0..len {
1335                 let remaining = len - i;
1336                 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1337
1338                 let prev = it.next_back().unwrap();
1339                 assert_eq!(prev as *const _, v_ptrs[remaining - 1]);
1340             }
1341             assert_eq!(it.size_hint(), (0, Some(0)));
1342             assert_eq!(it.next_back(), None, "The final call to next_back() should return None");
1343         }
1344     }
1345
1346     fn test_mut<T: Copy + Debug + PartialEq>(x: T) {
1347         let v: &mut [T] = &mut [x, x, x];
1348         let v_ptrs: [*mut T; 3] = match v {
1349             [ref v1, ref v2, ref v3] => {
1350                 [v1 as *const _ as *mut _, v2 as *const _ as *mut _, v3 as *const _ as *mut _]
1351             }
1352             _ => unreachable!(),
1353         };
1354         let len = v.len();
1355
1356         // nth(i)
1357         for i in 0..len {
1358             assert_eq!(&mut v[i] as *mut _, v_ptrs[i]); // check the v_ptrs array, just to be sure
1359             let nth = v.iter_mut().nth(i).unwrap();
1360             assert_eq!(nth as *mut _, v_ptrs[i]);
1361         }
1362         assert_eq!(v.iter().nth(len), None, "nth(len) should return None");
1363
1364         // stepping through with nth(0)
1365         {
1366             let mut it = v.iter();
1367             for i in 0..len {
1368                 let next = it.nth(0).unwrap();
1369                 assert_eq!(next as *const _, v_ptrs[i]);
1370             }
1371             assert_eq!(it.nth(0), None);
1372         }
1373
1374         // next()
1375         {
1376             let mut it = v.iter_mut();
1377             for i in 0..len {
1378                 let remaining = len - i;
1379                 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1380
1381                 let next = it.next().unwrap();
1382                 assert_eq!(next as *mut _, v_ptrs[i]);
1383             }
1384             assert_eq!(it.size_hint(), (0, Some(0)));
1385             assert_eq!(it.next(), None, "The final call to next() should return None");
1386         }
1387
1388         // next_back()
1389         {
1390             let mut it = v.iter_mut();
1391             for i in 0..len {
1392                 let remaining = len - i;
1393                 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1394
1395                 let prev = it.next_back().unwrap();
1396                 assert_eq!(prev as *mut _, v_ptrs[remaining - 1]);
1397             }
1398             assert_eq!(it.size_hint(), (0, Some(0)));
1399             assert_eq!(it.next_back(), None, "The final call to next_back() should return None");
1400         }
1401     }
1402
1403     // Make sure iterators and slice patterns yield consistent addresses for various types,
1404     // including ZSTs.
1405     test(0u32);
1406     test(());
1407     test([0u32; 0]); // ZST with alignment > 0
1408     test_mut(0u32);
1409     test_mut(());
1410     test_mut([0u32; 0]); // ZST with alignment > 0
1411 }
1412
1413 // The current implementation of SliceIndex fails to handle methods
1414 // orthogonally from range types; therefore, it is worth testing
1415 // all of the indexing operations on each input.
1416 mod slice_index {
1417     // This checks all six indexing methods, given an input range that
1418     // should succeed. (it is NOT suitable for testing invalid inputs)
1419     macro_rules! assert_range_eq {
1420         ($arr:expr, $range:expr, $expected:expr) => {
1421             let mut arr = $arr;
1422             let mut expected = $expected;
1423             {
1424                 let s: &[_] = &arr;
1425                 let expected: &[_] = &expected;
1426
1427                 assert_eq!(&s[$range], expected, "(in assertion for: index)");
1428                 assert_eq!(s.get($range), Some(expected), "(in assertion for: get)");
1429                 unsafe {
1430                     assert_eq!(
1431                         s.get_unchecked($range),
1432                         expected,
1433                         "(in assertion for: get_unchecked)",
1434                     );
1435                 }
1436             }
1437             {
1438                 let s: &mut [_] = &mut arr;
1439                 let expected: &mut [_] = &mut expected;
1440
1441                 assert_eq!(&mut s[$range], expected, "(in assertion for: index_mut)",);
1442                 assert_eq!(
1443                     s.get_mut($range),
1444                     Some(&mut expected[..]),
1445                     "(in assertion for: get_mut)",
1446                 );
1447                 unsafe {
1448                     assert_eq!(
1449                         s.get_unchecked_mut($range),
1450                         expected,
1451                         "(in assertion for: get_unchecked_mut)",
1452                     );
1453                 }
1454             }
1455         };
1456     }
1457
1458     // Make sure the macro can actually detect bugs,
1459     // because if it can't, then what are we even doing here?
1460     //
1461     // (Be aware this only demonstrates the ability to detect bugs
1462     //  in the FIRST method that panics, as the macro is not designed
1463     //  to be used in `should_panic`)
1464     #[test]
1465     #[should_panic(expected = "out of range")]
1466     fn assert_range_eq_can_fail_by_panic() {
1467         assert_range_eq!([0, 1, 2], 0..5, [0, 1, 2]);
1468     }
1469
1470     // (Be aware this only demonstrates the ability to detect bugs
1471     //  in the FIRST method it calls, as the macro is not designed
1472     //  to be used in `should_panic`)
1473     #[test]
1474     #[should_panic(expected = "==")]
1475     fn assert_range_eq_can_fail_by_inequality() {
1476         assert_range_eq!([0, 1, 2], 0..2, [0, 1, 2]);
1477     }
1478
1479     // Test cases for bad index operations.
1480     //
1481     // This generates `should_panic` test cases for Index/IndexMut
1482     // and `None` test cases for get/get_mut.
1483     macro_rules! panic_cases {
1484         ($(
1485             // each test case needs a unique name to namespace the tests
1486             in mod $case_name:ident {
1487                 data: $data:expr;
1488
1489                 // optional:
1490                 //
1491                 // one or more similar inputs for which data[input] succeeds,
1492                 // and the corresponding output as an array.  This helps validate
1493                 // "critical points" where an input range straddles the boundary
1494                 // between valid and invalid.
1495                 // (such as the input `len..len`, which is just barely valid)
1496                 $(
1497                     good: data[$good:expr] == $output:expr;
1498                 )*
1499
1500                 bad: data[$bad:expr];
1501                 message: $expect_msg:expr;
1502             }
1503         )*) => {$(
1504             mod $case_name {
1505                 #[allow(unused_imports)]
1506                 use core::ops::Bound;
1507
1508                 #[test]
1509                 fn pass() {
1510                     let mut v = $data;
1511
1512                     $( assert_range_eq!($data, $good, $output); )*
1513
1514                     {
1515                         let v: &[_] = &v;
1516                         assert_eq!(v.get($bad), None, "(in None assertion for get)");
1517                     }
1518
1519                     {
1520                         let v: &mut [_] = &mut v;
1521                         assert_eq!(v.get_mut($bad), None, "(in None assertion for get_mut)");
1522                     }
1523                 }
1524
1525                 #[test]
1526                 #[should_panic(expected = $expect_msg)]
1527                 fn index_fail() {
1528                     let v = $data;
1529                     let v: &[_] = &v;
1530                     let _v = &v[$bad];
1531                 }
1532
1533                 #[test]
1534                 #[should_panic(expected = $expect_msg)]
1535                 fn index_mut_fail() {
1536                     let mut v = $data;
1537                     let v: &mut [_] = &mut v;
1538                     let _v = &mut v[$bad];
1539                 }
1540             }
1541         )*};
1542     }
1543
1544     #[test]
1545     fn simple() {
1546         let v = [0, 1, 2, 3, 4, 5];
1547
1548         assert_range_eq!(v, .., [0, 1, 2, 3, 4, 5]);
1549         assert_range_eq!(v, ..2, [0, 1]);
1550         assert_range_eq!(v, ..=1, [0, 1]);
1551         assert_range_eq!(v, 2.., [2, 3, 4, 5]);
1552         assert_range_eq!(v, 1..4, [1, 2, 3]);
1553         assert_range_eq!(v, 1..=3, [1, 2, 3]);
1554     }
1555
1556     panic_cases! {
1557         in mod rangefrom_len {
1558             data: [0, 1, 2, 3, 4, 5];
1559
1560             good: data[6..] == [];
1561             bad: data[7..];
1562             message: "out of range";
1563         }
1564
1565         in mod rangeto_len {
1566             data: [0, 1, 2, 3, 4, 5];
1567
1568             good: data[..6] == [0, 1, 2, 3, 4, 5];
1569             bad: data[..7];
1570             message: "out of range";
1571         }
1572
1573         in mod rangetoinclusive_len {
1574             data: [0, 1, 2, 3, 4, 5];
1575
1576             good: data[..=5] == [0, 1, 2, 3, 4, 5];
1577             bad: data[..=6];
1578             message: "out of range";
1579         }
1580
1581         in mod rangeinclusive_len {
1582             data: [0, 1, 2, 3, 4, 5];
1583
1584             good: data[0..=5] == [0, 1, 2, 3, 4, 5];
1585             bad: data[0..=6];
1586             message: "out of range";
1587         }
1588
1589         in mod range_len_len {
1590             data: [0, 1, 2, 3, 4, 5];
1591
1592             good: data[6..6] == [];
1593             bad: data[7..7];
1594             message: "out of range";
1595         }
1596
1597         in mod rangeinclusive_len_len {
1598             data: [0, 1, 2, 3, 4, 5];
1599
1600             good: data[6..=5] == [];
1601             bad: data[7..=6];
1602             message: "out of range";
1603         }
1604
1605         in mod boundpair_len {
1606             data: [0, 1, 2, 3, 4, 5];
1607
1608             good: data[(Bound::Included(6), Bound::Unbounded)] == [];
1609             good: data[(Bound::Unbounded, Bound::Included(5))] == [0, 1, 2, 3, 4, 5];
1610             good: data[(Bound::Unbounded, Bound::Excluded(6))] == [0, 1, 2, 3, 4, 5];
1611             good: data[(Bound::Included(0), Bound::Included(5))] == [0, 1, 2, 3, 4, 5];
1612             good: data[(Bound::Included(0), Bound::Excluded(6))] == [0, 1, 2, 3, 4, 5];
1613             good: data[(Bound::Included(2), Bound::Excluded(4))] == [2, 3];
1614             good: data[(Bound::Excluded(1), Bound::Included(4))] == [2, 3, 4];
1615             good: data[(Bound::Excluded(5), Bound::Excluded(6))] == [];
1616             good: data[(Bound::Included(6), Bound::Excluded(6))] == [];
1617             good: data[(Bound::Excluded(5), Bound::Included(5))] == [];
1618             good: data[(Bound::Included(6), Bound::Included(5))] == [];
1619             bad: data[(Bound::Unbounded, Bound::Included(6))];
1620             message: "out of range";
1621         }
1622     }
1623
1624     panic_cases! {
1625         in mod rangeinclusive_exhausted {
1626             data: [0, 1, 2, 3, 4, 5];
1627
1628             good: data[0..=5] == [0, 1, 2, 3, 4, 5];
1629             good: data[{
1630                 let mut iter = 0..=5;
1631                 iter.by_ref().count(); // exhaust it
1632                 iter
1633             }] == [];
1634
1635             // 0..=6 is out of range before exhaustion, so it
1636             // stands to reason that it still would be after.
1637             bad: data[{
1638                 let mut iter = 0..=6;
1639                 iter.by_ref().count(); // exhaust it
1640                 iter
1641             }];
1642             message: "out of range";
1643         }
1644     }
1645
1646     panic_cases! {
1647         in mod range_neg_width {
1648             data: [0, 1, 2, 3, 4, 5];
1649
1650             good: data[4..4] == [];
1651             bad: data[4..3];
1652             message: "but ends at";
1653         }
1654
1655         in mod rangeinclusive_neg_width {
1656             data: [0, 1, 2, 3, 4, 5];
1657
1658             good: data[4..=3] == [];
1659             bad: data[4..=2];
1660             message: "but ends at";
1661         }
1662
1663         in mod boundpair_neg_width {
1664             data: [0, 1, 2, 3, 4, 5];
1665
1666             good: data[(Bound::Included(4), Bound::Excluded(4))] == [];
1667             bad: data[(Bound::Included(4), Bound::Excluded(3))];
1668             message: "but ends at";
1669         }
1670     }
1671
1672     panic_cases! {
1673         in mod rangeinclusive_overflow {
1674             data: [0, 1];
1675
1676             // note: using 0 specifically ensures that the result of overflowing is 0..0,
1677             //       so that `get` doesn't simply return None for the wrong reason.
1678             bad: data[0 ..= usize::MAX];
1679             message: "maximum usize";
1680         }
1681
1682         in mod rangetoinclusive_overflow {
1683             data: [0, 1];
1684
1685             bad: data[..= usize::MAX];
1686             message: "maximum usize";
1687         }
1688
1689         in mod boundpair_overflow_end {
1690             data: [0; 1];
1691
1692             bad: data[(Bound::Unbounded, Bound::Included(usize::MAX))];
1693             message: "maximum usize";
1694         }
1695
1696         in mod boundpair_overflow_start {
1697             data: [0; 1];
1698
1699             bad: data[(Bound::Excluded(usize::MAX), Bound::Unbounded)];
1700             message: "maximum usize";
1701         }
1702     } // panic_cases!
1703 }
1704
1705 #[test]
1706 fn test_find_rfind() {
1707     let v = [0, 1, 2, 3, 4, 5];
1708     let mut iter = v.iter();
1709     let mut i = v.len();
1710     while let Some(&elt) = iter.rfind(|_| true) {
1711         i -= 1;
1712         assert_eq!(elt, v[i]);
1713     }
1714     assert_eq!(i, 0);
1715     assert_eq!(v.iter().rfind(|&&x| x <= 3), Some(&3));
1716 }
1717
1718 #[test]
1719 fn test_iter_folds() {
1720     let a = [1, 2, 3, 4, 5]; // len>4 so the unroll is used
1721     assert_eq!(a.iter().fold(0, |acc, &x| 2 * acc + x), 57);
1722     assert_eq!(a.iter().rfold(0, |acc, &x| 2 * acc + x), 129);
1723     let fold = |acc: i32, &x| acc.checked_mul(2)?.checked_add(x);
1724     assert_eq!(a.iter().try_fold(0, &fold), Some(57));
1725     assert_eq!(a.iter().try_rfold(0, &fold), Some(129));
1726
1727     // short-circuiting try_fold, through other methods
1728     let a = [0, 1, 2, 3, 5, 5, 5, 7, 8, 9];
1729     let mut iter = a.iter();
1730     assert_eq!(iter.position(|&x| x == 3), Some(3));
1731     assert_eq!(iter.rfind(|&&x| x == 5), Some(&5));
1732     assert_eq!(iter.len(), 2);
1733 }
1734
1735 #[test]
1736 fn test_rotate_left() {
1737     const N: usize = 600;
1738     let a: &mut [_] = &mut [0; N];
1739     for i in 0..N {
1740         a[i] = i;
1741     }
1742
1743     a.rotate_left(42);
1744     let k = N - 42;
1745
1746     for i in 0..N {
1747         assert_eq!(a[(i + k) % N], i);
1748     }
1749 }
1750
1751 #[test]
1752 fn test_rotate_right() {
1753     const N: usize = 600;
1754     let a: &mut [_] = &mut [0; N];
1755     for i in 0..N {
1756         a[i] = i;
1757     }
1758
1759     a.rotate_right(42);
1760
1761     for i in 0..N {
1762         assert_eq!(a[(i + 42) % N], i);
1763     }
1764 }
1765
1766 #[test]
1767 #[cfg_attr(miri, ignore)] // Miri is too slow
1768 fn brute_force_rotate_test_0() {
1769     // In case of edge cases involving multiple algorithms
1770     let n = 300;
1771     for len in 0..n {
1772         for s in 0..len {
1773             let mut v = Vec::with_capacity(len);
1774             for i in 0..len {
1775                 v.push(i);
1776             }
1777             v[..].rotate_right(s);
1778             for i in 0..v.len() {
1779                 assert_eq!(v[i], v.len().wrapping_add(i.wrapping_sub(s)) % v.len());
1780             }
1781         }
1782     }
1783 }
1784
1785 #[test]
1786 fn brute_force_rotate_test_1() {
1787     // `ptr_rotate` covers so many kinds of pointer usage, that this is just a good test for
1788     // pointers in general. This uses a `[usize; 4]` to hit all algorithms without overwhelming miri
1789     let n = 30;
1790     for len in 0..n {
1791         for s in 0..len {
1792             let mut v: Vec<[usize; 4]> = Vec::with_capacity(len);
1793             for i in 0..len {
1794                 v.push([i, 0, 0, 0]);
1795             }
1796             v[..].rotate_right(s);
1797             for i in 0..v.len() {
1798                 assert_eq!(v[i][0], v.len().wrapping_add(i.wrapping_sub(s)) % v.len());
1799             }
1800         }
1801     }
1802 }
1803
1804 #[test]
1805 #[cfg(not(target_arch = "wasm32"))]
1806 fn sort_unstable() {
1807     use core::cmp::Ordering::{Equal, Greater, Less};
1808     use core::slice::heapsort;
1809     use rand::{rngs::StdRng, seq::SliceRandom, Rng, SeedableRng};
1810
1811     // Miri is too slow (but still need to `chain` to make the types match)
1812     let lens = if cfg!(miri) { (2..20).chain(0..0) } else { (2..25).chain(500..510) };
1813     let rounds = if cfg!(miri) { 1 } else { 100 };
1814
1815     let mut v = [0; 600];
1816     let mut tmp = [0; 600];
1817     let mut rng = StdRng::from_entropy();
1818
1819     for len in lens {
1820         let v = &mut v[0..len];
1821         let tmp = &mut tmp[0..len];
1822
1823         for &modulus in &[5, 10, 100, 1000] {
1824             for _ in 0..rounds {
1825                 for i in 0..len {
1826                     v[i] = rng.gen::<i32>() % modulus;
1827                 }
1828
1829                 // Sort in default order.
1830                 tmp.copy_from_slice(v);
1831                 tmp.sort_unstable();
1832                 assert!(tmp.windows(2).all(|w| w[0] <= w[1]));
1833
1834                 // Sort in ascending order.
1835                 tmp.copy_from_slice(v);
1836                 tmp.sort_unstable_by(|a, b| a.cmp(b));
1837                 assert!(tmp.windows(2).all(|w| w[0] <= w[1]));
1838
1839                 // Sort in descending order.
1840                 tmp.copy_from_slice(v);
1841                 tmp.sort_unstable_by(|a, b| b.cmp(a));
1842                 assert!(tmp.windows(2).all(|w| w[0] >= w[1]));
1843
1844                 // Test heapsort using `<` operator.
1845                 tmp.copy_from_slice(v);
1846                 heapsort(tmp, |a, b| a < b);
1847                 assert!(tmp.windows(2).all(|w| w[0] <= w[1]));
1848
1849                 // Test heapsort using `>` operator.
1850                 tmp.copy_from_slice(v);
1851                 heapsort(tmp, |a, b| a > b);
1852                 assert!(tmp.windows(2).all(|w| w[0] >= w[1]));
1853             }
1854         }
1855     }
1856
1857     // Sort using a completely random comparison function.
1858     // This will reorder the elements *somehow*, but won't panic.
1859     for i in 0..v.len() {
1860         v[i] = i as i32;
1861     }
1862     v.sort_unstable_by(|_, _| *[Less, Equal, Greater].choose(&mut rng).unwrap());
1863     v.sort_unstable();
1864     for i in 0..v.len() {
1865         assert_eq!(v[i], i as i32);
1866     }
1867
1868     // Should not panic.
1869     [0i32; 0].sort_unstable();
1870     [(); 10].sort_unstable();
1871     [(); 100].sort_unstable();
1872
1873     let mut v = [0xDEADBEEFu64];
1874     v.sort_unstable();
1875     assert!(v == [0xDEADBEEF]);
1876 }
1877
1878 #[test]
1879 #[cfg(not(target_arch = "wasm32"))]
1880 #[cfg_attr(miri, ignore)] // Miri is too slow
1881 fn select_nth_unstable() {
1882     use core::cmp::Ordering::{Equal, Greater, Less};
1883     use rand::rngs::StdRng;
1884     use rand::seq::SliceRandom;
1885     use rand::{Rng, SeedableRng};
1886
1887     let mut rng = StdRng::from_entropy();
1888
1889     for len in (2..21).chain(500..501) {
1890         let mut orig = vec![0; len];
1891
1892         for &modulus in &[5, 10, 1000] {
1893             for _ in 0..10 {
1894                 for i in 0..len {
1895                     orig[i] = rng.gen::<i32>() % modulus;
1896                 }
1897
1898                 let v_sorted = {
1899                     let mut v = orig.clone();
1900                     v.sort();
1901                     v
1902                 };
1903
1904                 // Sort in default order.
1905                 for pivot in 0..len {
1906                     let mut v = orig.clone();
1907                     v.select_nth_unstable(pivot);
1908
1909                     assert_eq!(v_sorted[pivot], v[pivot]);
1910                     for i in 0..pivot {
1911                         for j in pivot..len {
1912                             assert!(v[i] <= v[j]);
1913                         }
1914                     }
1915                 }
1916
1917                 // Sort in ascending order.
1918                 for pivot in 0..len {
1919                     let mut v = orig.clone();
1920                     let (left, pivot, right) = v.select_nth_unstable_by(pivot, |a, b| a.cmp(b));
1921
1922                     assert_eq!(left.len() + right.len(), len - 1);
1923
1924                     for l in left {
1925                         assert!(l <= pivot);
1926                         for r in right.iter_mut() {
1927                             assert!(l <= r);
1928                             assert!(pivot <= r);
1929                         }
1930                     }
1931                 }
1932
1933                 // Sort in descending order.
1934                 let sort_descending_comparator = |a: &i32, b: &i32| b.cmp(a);
1935                 let v_sorted_descending = {
1936                     let mut v = orig.clone();
1937                     v.sort_by(sort_descending_comparator);
1938                     v
1939                 };
1940
1941                 for pivot in 0..len {
1942                     let mut v = orig.clone();
1943                     v.select_nth_unstable_by(pivot, sort_descending_comparator);
1944
1945                     assert_eq!(v_sorted_descending[pivot], v[pivot]);
1946                     for i in 0..pivot {
1947                         for j in pivot..len {
1948                             assert!(v[j] <= v[i]);
1949                         }
1950                     }
1951                 }
1952             }
1953         }
1954     }
1955
1956     // Sort at index using a completely random comparison function.
1957     // This will reorder the elements *somehow*, but won't panic.
1958     let mut v = [0; 500];
1959     for i in 0..v.len() {
1960         v[i] = i as i32;
1961     }
1962
1963     for pivot in 0..v.len() {
1964         v.select_nth_unstable_by(pivot, |_, _| *[Less, Equal, Greater].choose(&mut rng).unwrap());
1965         v.sort();
1966         for i in 0..v.len() {
1967             assert_eq!(v[i], i as i32);
1968         }
1969     }
1970
1971     // Should not panic.
1972     [(); 10].select_nth_unstable(0);
1973     [(); 10].select_nth_unstable(5);
1974     [(); 10].select_nth_unstable(9);
1975     [(); 100].select_nth_unstable(0);
1976     [(); 100].select_nth_unstable(50);
1977     [(); 100].select_nth_unstable(99);
1978
1979     let mut v = [0xDEADBEEFu64];
1980     v.select_nth_unstable(0);
1981     assert!(v == [0xDEADBEEF]);
1982 }
1983
1984 #[test]
1985 #[should_panic(expected = "index 0 greater than length of slice")]
1986 fn select_nth_unstable_zero_length() {
1987     [0i32; 0].select_nth_unstable(0);
1988 }
1989
1990 #[test]
1991 #[should_panic(expected = "index 20 greater than length of slice")]
1992 fn select_nth_unstable_past_length() {
1993     [0i32; 10].select_nth_unstable(20);
1994 }
1995
1996 pub mod memchr {
1997     use core::slice::memchr::{memchr, memrchr};
1998
1999     // test fallback implementations on all platforms
2000     #[test]
2001     fn matches_one() {
2002         assert_eq!(Some(0), memchr(b'a', b"a"));
2003     }
2004
2005     #[test]
2006     fn matches_begin() {
2007         assert_eq!(Some(0), memchr(b'a', b"aaaa"));
2008     }
2009
2010     #[test]
2011     fn matches_end() {
2012         assert_eq!(Some(4), memchr(b'z', b"aaaaz"));
2013     }
2014
2015     #[test]
2016     fn matches_nul() {
2017         assert_eq!(Some(4), memchr(b'\x00', b"aaaa\x00"));
2018     }
2019
2020     #[test]
2021     fn matches_past_nul() {
2022         assert_eq!(Some(5), memchr(b'z', b"aaaa\x00z"));
2023     }
2024
2025     #[test]
2026     fn no_match_empty() {
2027         assert_eq!(None, memchr(b'a', b""));
2028     }
2029
2030     #[test]
2031     fn no_match() {
2032         assert_eq!(None, memchr(b'a', b"xyz"));
2033     }
2034
2035     #[test]
2036     fn matches_one_reversed() {
2037         assert_eq!(Some(0), memrchr(b'a', b"a"));
2038     }
2039
2040     #[test]
2041     fn matches_begin_reversed() {
2042         assert_eq!(Some(3), memrchr(b'a', b"aaaa"));
2043     }
2044
2045     #[test]
2046     fn matches_end_reversed() {
2047         assert_eq!(Some(0), memrchr(b'z', b"zaaaa"));
2048     }
2049
2050     #[test]
2051     fn matches_nul_reversed() {
2052         assert_eq!(Some(4), memrchr(b'\x00', b"aaaa\x00"));
2053     }
2054
2055     #[test]
2056     fn matches_past_nul_reversed() {
2057         assert_eq!(Some(0), memrchr(b'z', b"z\x00aaaa"));
2058     }
2059
2060     #[test]
2061     fn no_match_empty_reversed() {
2062         assert_eq!(None, memrchr(b'a', b""));
2063     }
2064
2065     #[test]
2066     fn no_match_reversed() {
2067         assert_eq!(None, memrchr(b'a', b"xyz"));
2068     }
2069
2070     #[test]
2071     fn each_alignment_reversed() {
2072         let mut data = [1u8; 64];
2073         let needle = 2;
2074         let pos = 40;
2075         data[pos] = needle;
2076         for start in 0..16 {
2077             assert_eq!(Some(pos - start), memrchr(needle, &data[start..]));
2078         }
2079     }
2080 }
2081
2082 #[test]
2083 fn test_align_to_simple() {
2084     let bytes = [1u8, 2, 3, 4, 5, 6, 7];
2085     let (prefix, aligned, suffix) = unsafe { bytes.align_to::<u16>() };
2086     assert_eq!(aligned.len(), 3);
2087     assert!(prefix == [1] || suffix == [7]);
2088     let expect1 = [1 << 8 | 2, 3 << 8 | 4, 5 << 8 | 6];
2089     let expect2 = [1 | 2 << 8, 3 | 4 << 8, 5 | 6 << 8];
2090     let expect3 = [2 << 8 | 3, 4 << 8 | 5, 6 << 8 | 7];
2091     let expect4 = [2 | 3 << 8, 4 | 5 << 8, 6 | 7 << 8];
2092     assert!(
2093         aligned == expect1 || aligned == expect2 || aligned == expect3 || aligned == expect4,
2094         "aligned={:?} expected={:?} || {:?} || {:?} || {:?}",
2095         aligned,
2096         expect1,
2097         expect2,
2098         expect3,
2099         expect4
2100     );
2101 }
2102
2103 #[test]
2104 fn test_align_to_zst() {
2105     let bytes = [1, 2, 3, 4, 5, 6, 7];
2106     let (prefix, aligned, suffix) = unsafe { bytes.align_to::<()>() };
2107     assert_eq!(aligned.len(), 0);
2108     assert!(prefix == [1, 2, 3, 4, 5, 6, 7] || suffix == [1, 2, 3, 4, 5, 6, 7]);
2109 }
2110
2111 #[test]
2112 fn test_align_to_non_trivial() {
2113     #[repr(align(8))]
2114     struct U64(u64, u64);
2115     #[repr(align(8))]
2116     struct U64U64U32(u64, u64, u32);
2117     let data = [
2118         U64(1, 2),
2119         U64(3, 4),
2120         U64(5, 6),
2121         U64(7, 8),
2122         U64(9, 10),
2123         U64(11, 12),
2124         U64(13, 14),
2125         U64(15, 16),
2126     ];
2127     let (prefix, aligned, suffix) = unsafe { data.align_to::<U64U64U32>() };
2128     assert_eq!(aligned.len(), 4);
2129     assert_eq!(prefix.len() + suffix.len(), 2);
2130 }
2131
2132 #[test]
2133 fn test_align_to_empty_mid() {
2134     use core::mem;
2135
2136     // Make sure that we do not create empty unaligned slices for the mid part, even when the
2137     // overall slice is too short to contain an aligned address.
2138     let bytes = [1, 2, 3, 4, 5, 6, 7];
2139     type Chunk = u32;
2140     for offset in 0..4 {
2141         let (_, mid, _) = unsafe { bytes[offset..offset + 1].align_to::<Chunk>() };
2142         assert_eq!(mid.as_ptr() as usize % mem::align_of::<Chunk>(), 0);
2143     }
2144 }
2145
2146 #[test]
2147 fn test_align_to_mut_aliasing() {
2148     let mut val = [1u8, 2, 3, 4, 5];
2149     // `align_to_mut` used to create `mid` in a way that there was some intermediate
2150     // incorrect aliasing, invalidating the resulting `mid` slice.
2151     let (begin, mid, end) = unsafe { val.align_to_mut::<[u8; 2]>() };
2152     assert!(begin.len() == 0);
2153     assert!(end.len() == 1);
2154     mid[0] = mid[1];
2155     assert_eq!(val, [3, 4, 3, 4, 5])
2156 }
2157
2158 #[test]
2159 fn test_slice_partition_dedup_by() {
2160     let mut slice: [i32; 9] = [1, -1, 2, 3, 1, -5, 5, -2, 2];
2161
2162     let (dedup, duplicates) = slice.partition_dedup_by(|a, b| a.abs() == b.abs());
2163
2164     assert_eq!(dedup, [1, 2, 3, 1, -5, -2]);
2165     assert_eq!(duplicates, [5, -1, 2]);
2166 }
2167
2168 #[test]
2169 fn test_slice_partition_dedup_empty() {
2170     let mut slice: [i32; 0] = [];
2171
2172     let (dedup, duplicates) = slice.partition_dedup();
2173
2174     assert_eq!(dedup, []);
2175     assert_eq!(duplicates, []);
2176 }
2177
2178 #[test]
2179 fn test_slice_partition_dedup_one() {
2180     let mut slice = [12];
2181
2182     let (dedup, duplicates) = slice.partition_dedup();
2183
2184     assert_eq!(dedup, [12]);
2185     assert_eq!(duplicates, []);
2186 }
2187
2188 #[test]
2189 fn test_slice_partition_dedup_multiple_ident() {
2190     let mut slice = [12, 12, 12, 12, 12, 11, 11, 11, 11, 11, 11];
2191
2192     let (dedup, duplicates) = slice.partition_dedup();
2193
2194     assert_eq!(dedup, [12, 11]);
2195     assert_eq!(duplicates, [12, 12, 12, 12, 11, 11, 11, 11, 11]);
2196 }
2197
2198 #[test]
2199 fn test_slice_partition_dedup_partialeq() {
2200     #[derive(Debug)]
2201     struct Foo(i32, i32);
2202
2203     impl PartialEq for Foo {
2204         fn eq(&self, other: &Foo) -> bool {
2205             self.0 == other.0
2206         }
2207     }
2208
2209     let mut slice = [Foo(0, 1), Foo(0, 5), Foo(1, 7), Foo(1, 9)];
2210
2211     let (dedup, duplicates) = slice.partition_dedup();
2212
2213     assert_eq!(dedup, [Foo(0, 1), Foo(1, 7)]);
2214     assert_eq!(duplicates, [Foo(0, 5), Foo(1, 9)]);
2215 }
2216
2217 #[test]
2218 fn test_copy_within() {
2219     // Start to end, with a RangeTo.
2220     let mut bytes = *b"Hello, World!";
2221     bytes.copy_within(..3, 10);
2222     assert_eq!(&bytes, b"Hello, WorHel");
2223
2224     // End to start, with a RangeFrom.
2225     let mut bytes = *b"Hello, World!";
2226     bytes.copy_within(10.., 0);
2227     assert_eq!(&bytes, b"ld!lo, World!");
2228
2229     // Overlapping, with a RangeInclusive.
2230     let mut bytes = *b"Hello, World!";
2231     bytes.copy_within(0..=11, 1);
2232     assert_eq!(&bytes, b"HHello, World");
2233
2234     // Whole slice, with a RangeFull.
2235     let mut bytes = *b"Hello, World!";
2236     bytes.copy_within(.., 0);
2237     assert_eq!(&bytes, b"Hello, World!");
2238
2239     // Ensure that copying at the end of slice won't cause UB.
2240     let mut bytes = *b"Hello, World!";
2241     bytes.copy_within(13..13, 5);
2242     assert_eq!(&bytes, b"Hello, World!");
2243     bytes.copy_within(5..5, 13);
2244     assert_eq!(&bytes, b"Hello, World!");
2245 }
2246
2247 #[test]
2248 #[should_panic(expected = "range end index 14 out of range for slice of length 13")]
2249 fn test_copy_within_panics_src_too_long() {
2250     let mut bytes = *b"Hello, World!";
2251     // The length is only 13, so 14 is out of bounds.
2252     bytes.copy_within(10..14, 0);
2253 }
2254
2255 #[test]
2256 #[should_panic(expected = "dest is out of bounds")]
2257 fn test_copy_within_panics_dest_too_long() {
2258     let mut bytes = *b"Hello, World!";
2259     // The length is only 13, so a slice of length 4 starting at index 10 is out of bounds.
2260     bytes.copy_within(0..4, 10);
2261 }
2262
2263 #[test]
2264 #[should_panic(expected = "slice index starts at 2 but ends at 1")]
2265 fn test_copy_within_panics_src_inverted() {
2266     let mut bytes = *b"Hello, World!";
2267     // 2 is greater than 1, so this range is invalid.
2268     bytes.copy_within(2..1, 0);
2269 }
2270 #[test]
2271 #[should_panic(expected = "attempted to index slice up to maximum usize")]
2272 fn test_copy_within_panics_src_out_of_bounds() {
2273     let mut bytes = *b"Hello, World!";
2274     // an inclusive range ending at usize::MAX would make src_end overflow
2275     bytes.copy_within(usize::MAX..=usize::MAX, 0);
2276 }
2277
2278 #[test]
2279 fn test_is_sorted() {
2280     let empty: [i32; 0] = [];
2281
2282     assert!([1, 2, 2, 9].is_sorted());
2283     assert!(![1, 3, 2].is_sorted());
2284     assert!([0].is_sorted());
2285     assert!(empty.is_sorted());
2286     assert!(![0.0, 1.0, f32::NAN].is_sorted());
2287     assert!([-2, -1, 0, 3].is_sorted());
2288     assert!(![-2i32, -1, 0, 3].is_sorted_by_key(|n| n.abs()));
2289     assert!(!["c", "bb", "aaa"].is_sorted());
2290     assert!(["c", "bb", "aaa"].is_sorted_by_key(|s| s.len()));
2291 }
2292
2293 #[test]
2294 fn test_slice_run_destructors() {
2295     // Make sure that destructors get run on slice literals
2296     struct Foo<'a> {
2297         x: &'a Cell<isize>,
2298     }
2299
2300     impl<'a> Drop for Foo<'a> {
2301         fn drop(&mut self) {
2302             self.x.set(self.x.get() + 1);
2303         }
2304     }
2305
2306     fn foo(x: &Cell<isize>) -> Foo<'_> {
2307         Foo { x }
2308     }
2309
2310     let x = &Cell::new(0);
2311
2312     {
2313         let l = &[foo(x)];
2314         assert_eq!(l[0].x.get(), 0);
2315     }
2316
2317     assert_eq!(x.get(), 1);
2318 }
2319
2320 #[test]
2321 fn test_const_from_ref() {
2322     const VALUE: &i32 = &1;
2323     const SLICE: &[i32] = core::slice::from_ref(VALUE);
2324
2325     assert!(core::ptr::eq(VALUE, &SLICE[0]))
2326 }
2327
2328 #[test]
2329 fn test_slice_fill_with_uninit() {
2330     // This should not UB. See #87891
2331     let mut a = [MaybeUninit::<u8>::uninit(); 10];
2332     a.fill(MaybeUninit::uninit());
2333 }
2334
2335 #[test]
2336 fn test_swap() {
2337     let mut x = ["a", "b", "c", "d"];
2338     x.swap(1, 3);
2339     assert_eq!(x, ["a", "d", "c", "b"]);
2340     x.swap(0, 3);
2341     assert_eq!(x, ["b", "d", "c", "a"]);
2342 }
2343
2344 mod swap_panics {
2345     #[test]
2346     #[should_panic(expected = "index out of bounds: the len is 4 but the index is 4")]
2347     fn index_a_equals_len() {
2348         let mut x = ["a", "b", "c", "d"];
2349         x.swap(4, 2);
2350     }
2351
2352     #[test]
2353     #[should_panic(expected = "index out of bounds: the len is 4 but the index is 4")]
2354     fn index_b_equals_len() {
2355         let mut x = ["a", "b", "c", "d"];
2356         x.swap(2, 4);
2357     }
2358
2359     #[test]
2360     #[should_panic(expected = "index out of bounds: the len is 4 but the index is 5")]
2361     fn index_a_greater_than_len() {
2362         let mut x = ["a", "b", "c", "d"];
2363         x.swap(5, 2);
2364     }
2365
2366     #[test]
2367     #[should_panic(expected = "index out of bounds: the len is 4 but the index is 5")]
2368     fn index_b_greater_than_len() {
2369         let mut x = ["a", "b", "c", "d"];
2370         x.swap(2, 5);
2371     }
2372 }
2373
2374 #[test]
2375 fn slice_split_array_mut() {
2376     let v = &mut [1, 2, 3, 4, 5, 6][..];
2377
2378     {
2379         let (left, right) = v.split_array_mut::<0>();
2380         assert_eq!(left, &mut []);
2381         assert_eq!(right, [1, 2, 3, 4, 5, 6]);
2382     }
2383
2384     {
2385         let (left, right) = v.split_array_mut::<6>();
2386         assert_eq!(left, &mut [1, 2, 3, 4, 5, 6]);
2387         assert_eq!(right, []);
2388     }
2389 }
2390
2391 #[test]
2392 fn slice_rsplit_array_mut() {
2393     let v = &mut [1, 2, 3, 4, 5, 6][..];
2394
2395     {
2396         let (left, right) = v.rsplit_array_mut::<0>();
2397         assert_eq!(left, [1, 2, 3, 4, 5, 6]);
2398         assert_eq!(right, &mut []);
2399     }
2400
2401     {
2402         let (left, right) = v.rsplit_array_mut::<6>();
2403         assert_eq!(left, []);
2404         assert_eq!(right, &mut [1, 2, 3, 4, 5, 6]);
2405     }
2406 }
2407
2408 #[test]
2409 fn split_as_slice() {
2410     let arr = [1, 2, 3, 4, 5, 6];
2411     let mut split = arr.split(|v| v % 2 == 0);
2412     assert_eq!(split.as_slice(), &[1, 2, 3, 4, 5, 6]);
2413     assert!(split.next().is_some());
2414     assert_eq!(split.as_slice(), &[3, 4, 5, 6]);
2415     assert!(split.next().is_some());
2416     assert!(split.next().is_some());
2417     assert_eq!(split.as_slice(), &[]);
2418 }
2419
2420 #[should_panic]
2421 #[test]
2422 fn slice_split_array_ref_out_of_bounds() {
2423     let v = &[1, 2, 3, 4, 5, 6][..];
2424
2425     let _ = v.split_array_ref::<7>();
2426 }
2427
2428 #[should_panic]
2429 #[test]
2430 fn slice_split_array_mut_out_of_bounds() {
2431     let v = &mut [1, 2, 3, 4, 5, 6][..];
2432
2433     let _ = v.split_array_mut::<7>();
2434 }
2435
2436 #[should_panic]
2437 #[test]
2438 fn slice_rsplit_array_ref_out_of_bounds() {
2439     let v = &[1, 2, 3, 4, 5, 6][..];
2440
2441     let _ = v.rsplit_array_ref::<7>();
2442 }
2443
2444 #[should_panic]
2445 #[test]
2446 fn slice_rsplit_array_mut_out_of_bounds() {
2447     let v = &mut [1, 2, 3, 4, 5, 6][..];
2448
2449     let _ = v.rsplit_array_mut::<7>();
2450 }
2451
2452 macro_rules! take_tests {
2453     (slice: &[], $($tts:tt)*) => {
2454         take_tests!(ty: &[()], slice: &[], $($tts)*);
2455     };
2456     (slice: &mut [], $($tts:tt)*) => {
2457         take_tests!(ty: &mut [()], slice: &mut [], $($tts)*);
2458     };
2459     (slice: &$slice:expr, $($tts:tt)*) => {
2460         take_tests!(ty: &[_], slice: &$slice, $($tts)*);
2461     };
2462     (slice: &mut $slice:expr, $($tts:tt)*) => {
2463         take_tests!(ty: &mut [_], slice: &mut $slice, $($tts)*);
2464     };
2465     (ty: $ty:ty, slice: $slice:expr, method: $method:ident, $(($test_name:ident, ($($args:expr),*), $output:expr, $remaining:expr),)*) => {
2466         $(
2467             #[test]
2468             fn $test_name() {
2469                 let mut slice: $ty = $slice;
2470                 assert_eq!($output, slice.$method($($args)*));
2471                 let remaining: $ty = $remaining;
2472                 assert_eq!(remaining, slice);
2473             }
2474         )*
2475     };
2476 }
2477
2478 take_tests! {
2479     slice: &[0, 1, 2, 3], method: take,
2480     (take_in_bounds_range_to, (..1), Some(&[0] as _), &[1, 2, 3]),
2481     (take_in_bounds_range_to_inclusive, (..=0), Some(&[0] as _), &[1, 2, 3]),
2482     (take_in_bounds_range_from, (2..), Some(&[2, 3] as _), &[0, 1]),
2483     (take_oob_range_to, (..5), None, &[0, 1, 2, 3]),
2484     (take_oob_range_to_inclusive, (..=4), None, &[0, 1, 2, 3]),
2485     (take_oob_range_from, (5..), None, &[0, 1, 2, 3]),
2486 }
2487
2488 take_tests! {
2489     slice: &mut [0, 1, 2, 3], method: take_mut,
2490     (take_mut_in_bounds_range_to, (..1), Some(&mut [0] as _), &mut [1, 2, 3]),
2491     (take_mut_in_bounds_range_to_inclusive, (..=0), Some(&mut [0] as _), &mut [1, 2, 3]),
2492     (take_mut_in_bounds_range_from, (2..), Some(&mut [2, 3] as _), &mut [0, 1]),
2493     (take_mut_oob_range_to, (..5), None, &mut [0, 1, 2, 3]),
2494     (take_mut_oob_range_to_inclusive, (..=4), None, &mut [0, 1, 2, 3]),
2495     (take_mut_oob_range_from, (5..), None, &mut [0, 1, 2, 3]),
2496 }
2497
2498 take_tests! {
2499     slice: &[1, 2], method: take_first,
2500     (take_first_nonempty, (), Some(&1), &[2]),
2501 }
2502
2503 take_tests! {
2504     slice: &mut [1, 2], method: take_first_mut,
2505     (take_first_mut_nonempty, (), Some(&mut 1), &mut [2]),
2506 }
2507
2508 take_tests! {
2509     slice: &[1, 2], method: take_last,
2510     (take_last_nonempty, (), Some(&2), &[1]),
2511 }
2512
2513 take_tests! {
2514     slice: &mut [1, 2], method: take_last_mut,
2515     (take_last_mut_nonempty, (), Some(&mut 2), &mut [1]),
2516 }
2517
2518 take_tests! {
2519     slice: &[], method: take_first,
2520     (take_first_empty, (), None, &[]),
2521 }
2522
2523 take_tests! {
2524     slice: &mut [], method: take_first_mut,
2525     (take_first_mut_empty, (), None, &mut []),
2526 }
2527
2528 take_tests! {
2529     slice: &[], method: take_last,
2530     (take_last_empty, (), None, &[]),
2531 }
2532
2533 take_tests! {
2534     slice: &mut [], method: take_last_mut,
2535     (take_last_mut_empty, (), None, &mut []),
2536 }
2537
2538 #[cfg(not(miri))] // unused in Miri
2539 const EMPTY_MAX: &'static [()] = &[(); usize::MAX];
2540
2541 // can't be a constant due to const mutability rules
2542 #[cfg(not(miri))] // unused in Miri
2543 macro_rules! empty_max_mut {
2544     () => {
2545         &mut [(); usize::MAX] as _
2546     };
2547 }
2548
2549 #[cfg(not(miri))] // Comparing usize::MAX many elements takes forever in Miri (and in rustc without optimizations)
2550 take_tests! {
2551     slice: &[(); usize::MAX], method: take,
2552     (take_in_bounds_max_range_to, (..usize::MAX), Some(EMPTY_MAX), &[(); 0]),
2553     (take_oob_max_range_to_inclusive, (..=usize::MAX), None, EMPTY_MAX),
2554     (take_in_bounds_max_range_from, (usize::MAX..), Some(&[] as _), EMPTY_MAX),
2555 }
2556
2557 #[cfg(not(miri))] // Comparing usize::MAX many elements takes forever in Miri (and in rustc without optimizations)
2558 take_tests! {
2559     slice: &mut [(); usize::MAX], method: take_mut,
2560     (take_mut_in_bounds_max_range_to, (..usize::MAX), Some(empty_max_mut!()), &mut [(); 0]),
2561     (take_mut_oob_max_range_to_inclusive, (..=usize::MAX), None, empty_max_mut!()),
2562     (take_mut_in_bounds_max_range_from, (usize::MAX..), Some(&mut [] as _), empty_max_mut!()),
2563 }
2564
2565 #[test]
2566 fn test_slice_from_ptr_range() {
2567     let arr = ["foo".to_owned(), "bar".to_owned()];
2568     let range = arr.as_ptr_range();
2569     unsafe {
2570         assert_eq!(slice::from_ptr_range(range), &arr);
2571     }
2572
2573     let mut arr = [1, 2, 3];
2574     let range = arr.as_mut_ptr_range();
2575     unsafe {
2576         assert_eq!(slice::from_mut_ptr_range(range), &mut [1, 2, 3]);
2577     }
2578
2579     let arr: [Vec<String>; 0] = [];
2580     let range = arr.as_ptr_range();
2581     unsafe {
2582         assert_eq!(slice::from_ptr_range(range), &arr);
2583     }
2584 }
2585
2586 #[test]
2587 #[should_panic = "slice len overflow"]
2588 fn test_flatten_size_overflow() {
2589     let x = &[[(); usize::MAX]; 2][..];
2590     let _ = x.flatten();
2591 }
2592
2593 #[test]
2594 #[should_panic = "slice len overflow"]
2595 fn test_flatten_mut_size_overflow() {
2596     let x = &mut [[(); usize::MAX]; 2][..];
2597     let _ = x.flatten_mut();
2598 }