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 fn test_iter_ref_consistency() {
1288     use std::fmt::Debug;
1289
1290     fn test<T: Copy + Debug + PartialEq>(x: T) {
1291         let v: &[T] = &[x, x, x];
1292         let v_ptrs: [*const T; 3] = match v {
1293             [ref v1, ref v2, ref v3] => [v1 as *const _, v2 as *const _, v3 as *const _],
1294             _ => unreachable!(),
1295         };
1296         let len = v.len();
1297
1298         // nth(i)
1299         for i in 0..len {
1300             assert_eq!(&v[i] as *const _, v_ptrs[i]); // check the v_ptrs array, just to be sure
1301             let nth = v.iter().nth(i).unwrap();
1302             assert_eq!(nth as *const _, v_ptrs[i]);
1303         }
1304         assert_eq!(v.iter().nth(len), None, "nth(len) should return None");
1305
1306         // stepping through with nth(0)
1307         {
1308             let mut it = v.iter();
1309             for i in 0..len {
1310                 let next = it.nth(0).unwrap();
1311                 assert_eq!(next as *const _, v_ptrs[i]);
1312             }
1313             assert_eq!(it.nth(0), None);
1314         }
1315
1316         // next()
1317         {
1318             let mut it = v.iter();
1319             for i in 0..len {
1320                 let remaining = len - i;
1321                 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1322
1323                 let next = it.next().unwrap();
1324                 assert_eq!(next as *const _, v_ptrs[i]);
1325             }
1326             assert_eq!(it.size_hint(), (0, Some(0)));
1327             assert_eq!(it.next(), None, "The final call to next() should return None");
1328         }
1329
1330         // next_back()
1331         {
1332             let mut it = v.iter();
1333             for i in 0..len {
1334                 let remaining = len - i;
1335                 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1336
1337                 let prev = it.next_back().unwrap();
1338                 assert_eq!(prev as *const _, v_ptrs[remaining - 1]);
1339             }
1340             assert_eq!(it.size_hint(), (0, Some(0)));
1341             assert_eq!(it.next_back(), None, "The final call to next_back() should return None");
1342         }
1343     }
1344
1345     fn test_mut<T: Copy + Debug + PartialEq>(x: T) {
1346         let v: &mut [T] = &mut [x, x, x];
1347         let v_ptrs: [*mut T; 3] = match v {
1348             [ref v1, ref v2, ref v3] => {
1349                 [v1 as *const _ as *mut _, v2 as *const _ as *mut _, v3 as *const _ as *mut _]
1350             }
1351             _ => unreachable!(),
1352         };
1353         let len = v.len();
1354
1355         // nth(i)
1356         for i in 0..len {
1357             assert_eq!(&mut v[i] as *mut _, v_ptrs[i]); // check the v_ptrs array, just to be sure
1358             let nth = v.iter_mut().nth(i).unwrap();
1359             assert_eq!(nth as *mut _, v_ptrs[i]);
1360         }
1361         assert_eq!(v.iter().nth(len), None, "nth(len) should return None");
1362
1363         // stepping through with nth(0)
1364         {
1365             let mut it = v.iter();
1366             for i in 0..len {
1367                 let next = it.nth(0).unwrap();
1368                 assert_eq!(next as *const _, v_ptrs[i]);
1369             }
1370             assert_eq!(it.nth(0), None);
1371         }
1372
1373         // next()
1374         {
1375             let mut it = v.iter_mut();
1376             for i in 0..len {
1377                 let remaining = len - i;
1378                 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1379
1380                 let next = it.next().unwrap();
1381                 assert_eq!(next as *mut _, v_ptrs[i]);
1382             }
1383             assert_eq!(it.size_hint(), (0, Some(0)));
1384             assert_eq!(it.next(), None, "The final call to next() should return None");
1385         }
1386
1387         // next_back()
1388         {
1389             let mut it = v.iter_mut();
1390             for i in 0..len {
1391                 let remaining = len - i;
1392                 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1393
1394                 let prev = it.next_back().unwrap();
1395                 assert_eq!(prev as *mut _, v_ptrs[remaining - 1]);
1396             }
1397             assert_eq!(it.size_hint(), (0, Some(0)));
1398             assert_eq!(it.next_back(), None, "The final call to next_back() should return None");
1399         }
1400     }
1401
1402     // Make sure iterators and slice patterns yield consistent addresses for various types,
1403     // including ZSTs.
1404     test(0u32);
1405     test(());
1406     test([0u32; 0]); // ZST with alignment > 0
1407     test_mut(0u32);
1408     test_mut(());
1409     test_mut([0u32; 0]); // ZST with alignment > 0
1410 }
1411
1412 // The current implementation of SliceIndex fails to handle methods
1413 // orthogonally from range types; therefore, it is worth testing
1414 // all of the indexing operations on each input.
1415 mod slice_index {
1416     // This checks all six indexing methods, given an input range that
1417     // should succeed. (it is NOT suitable for testing invalid inputs)
1418     macro_rules! assert_range_eq {
1419         ($arr:expr, $range:expr, $expected:expr) => {
1420             let mut arr = $arr;
1421             let mut expected = $expected;
1422             {
1423                 let s: &[_] = &arr;
1424                 let expected: &[_] = &expected;
1425
1426                 assert_eq!(&s[$range], expected, "(in assertion for: index)");
1427                 assert_eq!(s.get($range), Some(expected), "(in assertion for: get)");
1428                 unsafe {
1429                     assert_eq!(
1430                         s.get_unchecked($range),
1431                         expected,
1432                         "(in assertion for: get_unchecked)",
1433                     );
1434                 }
1435             }
1436             {
1437                 let s: &mut [_] = &mut arr;
1438                 let expected: &mut [_] = &mut expected;
1439
1440                 assert_eq!(&mut s[$range], expected, "(in assertion for: index_mut)",);
1441                 assert_eq!(
1442                     s.get_mut($range),
1443                     Some(&mut expected[..]),
1444                     "(in assertion for: get_mut)",
1445                 );
1446                 unsafe {
1447                     assert_eq!(
1448                         s.get_unchecked_mut($range),
1449                         expected,
1450                         "(in assertion for: get_unchecked_mut)",
1451                     );
1452                 }
1453             }
1454         };
1455     }
1456
1457     // Make sure the macro can actually detect bugs,
1458     // because if it can't, then what are we even doing here?
1459     //
1460     // (Be aware this only demonstrates the ability to detect bugs
1461     //  in the FIRST method that panics, as the macro is not designed
1462     //  to be used in `should_panic`)
1463     #[test]
1464     #[should_panic(expected = "out of range")]
1465     fn assert_range_eq_can_fail_by_panic() {
1466         assert_range_eq!([0, 1, 2], 0..5, [0, 1, 2]);
1467     }
1468
1469     // (Be aware this only demonstrates the ability to detect bugs
1470     //  in the FIRST method it calls, as the macro is not designed
1471     //  to be used in `should_panic`)
1472     #[test]
1473     #[should_panic(expected = "==")]
1474     fn assert_range_eq_can_fail_by_inequality() {
1475         assert_range_eq!([0, 1, 2], 0..2, [0, 1, 2]);
1476     }
1477
1478     // Test cases for bad index operations.
1479     //
1480     // This generates `should_panic` test cases for Index/IndexMut
1481     // and `None` test cases for get/get_mut.
1482     macro_rules! panic_cases {
1483         ($(
1484             // each test case needs a unique name to namespace the tests
1485             in mod $case_name:ident {
1486                 data: $data:expr;
1487
1488                 // optional:
1489                 //
1490                 // one or more similar inputs for which data[input] succeeds,
1491                 // and the corresponding output as an array.  This helps validate
1492                 // "critical points" where an input range straddles the boundary
1493                 // between valid and invalid.
1494                 // (such as the input `len..len`, which is just barely valid)
1495                 $(
1496                     good: data[$good:expr] == $output:expr;
1497                 )*
1498
1499                 bad: data[$bad:expr];
1500                 message: $expect_msg:expr;
1501             }
1502         )*) => {$(
1503             mod $case_name {
1504                 #[allow(unused_imports)]
1505                 use core::ops::Bound;
1506
1507                 #[test]
1508                 fn pass() {
1509                     let mut v = $data;
1510
1511                     $( assert_range_eq!($data, $good, $output); )*
1512
1513                     {
1514                         let v: &[_] = &v;
1515                         assert_eq!(v.get($bad), None, "(in None assertion for get)");
1516                     }
1517
1518                     {
1519                         let v: &mut [_] = &mut v;
1520                         assert_eq!(v.get_mut($bad), None, "(in None assertion for get_mut)");
1521                     }
1522                 }
1523
1524                 #[test]
1525                 #[should_panic(expected = $expect_msg)]
1526                 fn index_fail() {
1527                     let v = $data;
1528                     let v: &[_] = &v;
1529                     let _v = &v[$bad];
1530                 }
1531
1532                 #[test]
1533                 #[should_panic(expected = $expect_msg)]
1534                 fn index_mut_fail() {
1535                     let mut v = $data;
1536                     let v: &mut [_] = &mut v;
1537                     let _v = &mut v[$bad];
1538                 }
1539             }
1540         )*};
1541     }
1542
1543     #[test]
1544     fn simple() {
1545         let v = [0, 1, 2, 3, 4, 5];
1546
1547         assert_range_eq!(v, .., [0, 1, 2, 3, 4, 5]);
1548         assert_range_eq!(v, ..2, [0, 1]);
1549         assert_range_eq!(v, ..=1, [0, 1]);
1550         assert_range_eq!(v, 2.., [2, 3, 4, 5]);
1551         assert_range_eq!(v, 1..4, [1, 2, 3]);
1552         assert_range_eq!(v, 1..=3, [1, 2, 3]);
1553     }
1554
1555     panic_cases! {
1556         in mod rangefrom_len {
1557             data: [0, 1, 2, 3, 4, 5];
1558
1559             good: data[6..] == [];
1560             bad: data[7..];
1561             message: "out of range";
1562         }
1563
1564         in mod rangeto_len {
1565             data: [0, 1, 2, 3, 4, 5];
1566
1567             good: data[..6] == [0, 1, 2, 3, 4, 5];
1568             bad: data[..7];
1569             message: "out of range";
1570         }
1571
1572         in mod rangetoinclusive_len {
1573             data: [0, 1, 2, 3, 4, 5];
1574
1575             good: data[..=5] == [0, 1, 2, 3, 4, 5];
1576             bad: data[..=6];
1577             message: "out of range";
1578         }
1579
1580         in mod rangeinclusive_len {
1581             data: [0, 1, 2, 3, 4, 5];
1582
1583             good: data[0..=5] == [0, 1, 2, 3, 4, 5];
1584             bad: data[0..=6];
1585             message: "out of range";
1586         }
1587
1588         in mod range_len_len {
1589             data: [0, 1, 2, 3, 4, 5];
1590
1591             good: data[6..6] == [];
1592             bad: data[7..7];
1593             message: "out of range";
1594         }
1595
1596         in mod rangeinclusive_len_len {
1597             data: [0, 1, 2, 3, 4, 5];
1598
1599             good: data[6..=5] == [];
1600             bad: data[7..=6];
1601             message: "out of range";
1602         }
1603
1604         in mod boundpair_len {
1605             data: [0, 1, 2, 3, 4, 5];
1606
1607             good: data[(Bound::Included(6), Bound::Unbounded)] == [];
1608             good: data[(Bound::Unbounded, Bound::Included(5))] == [0, 1, 2, 3, 4, 5];
1609             good: data[(Bound::Unbounded, Bound::Excluded(6))] == [0, 1, 2, 3, 4, 5];
1610             good: data[(Bound::Included(0), Bound::Included(5))] == [0, 1, 2, 3, 4, 5];
1611             good: data[(Bound::Included(0), Bound::Excluded(6))] == [0, 1, 2, 3, 4, 5];
1612             good: data[(Bound::Included(2), Bound::Excluded(4))] == [2, 3];
1613             good: data[(Bound::Excluded(1), Bound::Included(4))] == [2, 3, 4];
1614             good: data[(Bound::Excluded(5), Bound::Excluded(6))] == [];
1615             good: data[(Bound::Included(6), Bound::Excluded(6))] == [];
1616             good: data[(Bound::Excluded(5), Bound::Included(5))] == [];
1617             good: data[(Bound::Included(6), Bound::Included(5))] == [];
1618             bad: data[(Bound::Unbounded, Bound::Included(6))];
1619             message: "out of range";
1620         }
1621     }
1622
1623     panic_cases! {
1624         in mod rangeinclusive_exhausted {
1625             data: [0, 1, 2, 3, 4, 5];
1626
1627             good: data[0..=5] == [0, 1, 2, 3, 4, 5];
1628             good: data[{
1629                 let mut iter = 0..=5;
1630                 iter.by_ref().count(); // exhaust it
1631                 iter
1632             }] == [];
1633
1634             // 0..=6 is out of range before exhaustion, so it
1635             // stands to reason that it still would be after.
1636             bad: data[{
1637                 let mut iter = 0..=6;
1638                 iter.by_ref().count(); // exhaust it
1639                 iter
1640             }];
1641             message: "out of range";
1642         }
1643     }
1644
1645     panic_cases! {
1646         in mod range_neg_width {
1647             data: [0, 1, 2, 3, 4, 5];
1648
1649             good: data[4..4] == [];
1650             bad: data[4..3];
1651             message: "but ends at";
1652         }
1653
1654         in mod rangeinclusive_neg_width {
1655             data: [0, 1, 2, 3, 4, 5];
1656
1657             good: data[4..=3] == [];
1658             bad: data[4..=2];
1659             message: "but ends at";
1660         }
1661
1662         in mod boundpair_neg_width {
1663             data: [0, 1, 2, 3, 4, 5];
1664
1665             good: data[(Bound::Included(4), Bound::Excluded(4))] == [];
1666             bad: data[(Bound::Included(4), Bound::Excluded(3))];
1667             message: "but ends at";
1668         }
1669     }
1670
1671     panic_cases! {
1672         in mod rangeinclusive_overflow {
1673             data: [0, 1];
1674
1675             // note: using 0 specifically ensures that the result of overflowing is 0..0,
1676             //       so that `get` doesn't simply return None for the wrong reason.
1677             bad: data[0 ..= usize::MAX];
1678             message: "maximum usize";
1679         }
1680
1681         in mod rangetoinclusive_overflow {
1682             data: [0, 1];
1683
1684             bad: data[..= usize::MAX];
1685             message: "maximum usize";
1686         }
1687
1688         in mod boundpair_overflow_end {
1689             data: [0; 1];
1690
1691             bad: data[(Bound::Unbounded, Bound::Included(usize::MAX))];
1692             message: "maximum usize";
1693         }
1694
1695         in mod boundpair_overflow_start {
1696             data: [0; 1];
1697
1698             bad: data[(Bound::Excluded(usize::MAX), Bound::Unbounded)];
1699             message: "maximum usize";
1700         }
1701     } // panic_cases!
1702 }
1703
1704 #[test]
1705 fn test_find_rfind() {
1706     let v = [0, 1, 2, 3, 4, 5];
1707     let mut iter = v.iter();
1708     let mut i = v.len();
1709     while let Some(&elt) = iter.rfind(|_| true) {
1710         i -= 1;
1711         assert_eq!(elt, v[i]);
1712     }
1713     assert_eq!(i, 0);
1714     assert_eq!(v.iter().rfind(|&&x| x <= 3), Some(&3));
1715 }
1716
1717 #[test]
1718 fn test_iter_folds() {
1719     let a = [1, 2, 3, 4, 5]; // len>4 so the unroll is used
1720     assert_eq!(a.iter().fold(0, |acc, &x| 2 * acc + x), 57);
1721     assert_eq!(a.iter().rfold(0, |acc, &x| 2 * acc + x), 129);
1722     let fold = |acc: i32, &x| acc.checked_mul(2)?.checked_add(x);
1723     assert_eq!(a.iter().try_fold(0, &fold), Some(57));
1724     assert_eq!(a.iter().try_rfold(0, &fold), Some(129));
1725
1726     // short-circuiting try_fold, through other methods
1727     let a = [0, 1, 2, 3, 5, 5, 5, 7, 8, 9];
1728     let mut iter = a.iter();
1729     assert_eq!(iter.position(|&x| x == 3), Some(3));
1730     assert_eq!(iter.rfind(|&&x| x == 5), Some(&5));
1731     assert_eq!(iter.len(), 2);
1732 }
1733
1734 #[test]
1735 fn test_rotate_left() {
1736     const N: usize = 600;
1737     let a: &mut [_] = &mut [0; N];
1738     for i in 0..N {
1739         a[i] = i;
1740     }
1741
1742     a.rotate_left(42);
1743     let k = N - 42;
1744
1745     for i in 0..N {
1746         assert_eq!(a[(i + k) % N], i);
1747     }
1748 }
1749
1750 #[test]
1751 fn test_rotate_right() {
1752     const N: usize = 600;
1753     let a: &mut [_] = &mut [0; N];
1754     for i in 0..N {
1755         a[i] = i;
1756     }
1757
1758     a.rotate_right(42);
1759
1760     for i in 0..N {
1761         assert_eq!(a[(i + 42) % N], i);
1762     }
1763 }
1764
1765 #[test]
1766 #[cfg_attr(miri, ignore)] // Miri is too slow
1767 fn brute_force_rotate_test_0() {
1768     // In case of edge cases involving multiple algorithms
1769     let n = 300;
1770     for len in 0..n {
1771         for s in 0..len {
1772             let mut v = Vec::with_capacity(len);
1773             for i in 0..len {
1774                 v.push(i);
1775             }
1776             v[..].rotate_right(s);
1777             for i in 0..v.len() {
1778                 assert_eq!(v[i], v.len().wrapping_add(i.wrapping_sub(s)) % v.len());
1779             }
1780         }
1781     }
1782 }
1783
1784 #[test]
1785 fn brute_force_rotate_test_1() {
1786     // `ptr_rotate` covers so many kinds of pointer usage, that this is just a good test for
1787     // pointers in general. This uses a `[usize; 4]` to hit all algorithms without overwhelming miri
1788     let n = 30;
1789     for len in 0..n {
1790         for s in 0..len {
1791             let mut v: Vec<[usize; 4]> = Vec::with_capacity(len);
1792             for i in 0..len {
1793                 v.push([i, 0, 0, 0]);
1794             }
1795             v[..].rotate_right(s);
1796             for i in 0..v.len() {
1797                 assert_eq!(v[i][0], v.len().wrapping_add(i.wrapping_sub(s)) % v.len());
1798             }
1799         }
1800     }
1801 }
1802
1803 #[test]
1804 #[cfg(not(target_arch = "wasm32"))]
1805 fn sort_unstable() {
1806     use core::cmp::Ordering::{Equal, Greater, Less};
1807     use core::slice::heapsort;
1808     use rand::{seq::SliceRandom, Rng};
1809
1810     // Miri is too slow (but still need to `chain` to make the types match)
1811     let lens = if cfg!(miri) { (2..20).chain(0..0) } else { (2..25).chain(500..510) };
1812     let rounds = if cfg!(miri) { 1 } else { 100 };
1813
1814     let mut v = [0; 600];
1815     let mut tmp = [0; 600];
1816     let mut rng = crate::test_rng();
1817
1818     for len in lens {
1819         let v = &mut v[0..len];
1820         let tmp = &mut tmp[0..len];
1821
1822         for &modulus in &[5, 10, 100, 1000] {
1823             for _ in 0..rounds {
1824                 for i in 0..len {
1825                     v[i] = rng.gen::<i32>() % modulus;
1826                 }
1827
1828                 // Sort in default order.
1829                 tmp.copy_from_slice(v);
1830                 tmp.sort_unstable();
1831                 assert!(tmp.windows(2).all(|w| w[0] <= w[1]));
1832
1833                 // Sort in ascending order.
1834                 tmp.copy_from_slice(v);
1835                 tmp.sort_unstable_by(|a, b| a.cmp(b));
1836                 assert!(tmp.windows(2).all(|w| w[0] <= w[1]));
1837
1838                 // Sort in descending order.
1839                 tmp.copy_from_slice(v);
1840                 tmp.sort_unstable_by(|a, b| b.cmp(a));
1841                 assert!(tmp.windows(2).all(|w| w[0] >= w[1]));
1842
1843                 // Test heapsort using `<` operator.
1844                 tmp.copy_from_slice(v);
1845                 heapsort(tmp, |a, b| a < b);
1846                 assert!(tmp.windows(2).all(|w| w[0] <= w[1]));
1847
1848                 // Test heapsort using `>` operator.
1849                 tmp.copy_from_slice(v);
1850                 heapsort(tmp, |a, b| a > b);
1851                 assert!(tmp.windows(2).all(|w| w[0] >= w[1]));
1852             }
1853         }
1854     }
1855
1856     // Sort using a completely random comparison function.
1857     // This will reorder the elements *somehow*, but won't panic.
1858     for i in 0..v.len() {
1859         v[i] = i as i32;
1860     }
1861     v.sort_unstable_by(|_, _| *[Less, Equal, Greater].choose(&mut rng).unwrap());
1862     v.sort_unstable();
1863     for i in 0..v.len() {
1864         assert_eq!(v[i], i as i32);
1865     }
1866
1867     // Should not panic.
1868     [0i32; 0].sort_unstable();
1869     [(); 10].sort_unstable();
1870     [(); 100].sort_unstable();
1871
1872     let mut v = [0xDEADBEEFu64];
1873     v.sort_unstable();
1874     assert!(v == [0xDEADBEEF]);
1875 }
1876
1877 #[test]
1878 #[cfg(not(target_arch = "wasm32"))]
1879 #[cfg_attr(miri, ignore)] // Miri is too slow
1880 fn select_nth_unstable() {
1881     use core::cmp::Ordering::{Equal, Greater, Less};
1882     use rand::seq::SliceRandom;
1883     use rand::Rng;
1884
1885     let mut rng = crate::test_rng();
1886
1887     for len in (2..21).chain(500..501) {
1888         let mut orig = vec![0; len];
1889
1890         for &modulus in &[5, 10, 1000] {
1891             for _ in 0..10 {
1892                 for i in 0..len {
1893                     orig[i] = rng.gen::<i32>() % modulus;
1894                 }
1895
1896                 let v_sorted = {
1897                     let mut v = orig.clone();
1898                     v.sort();
1899                     v
1900                 };
1901
1902                 // Sort in default order.
1903                 for pivot in 0..len {
1904                     let mut v = orig.clone();
1905                     v.select_nth_unstable(pivot);
1906
1907                     assert_eq!(v_sorted[pivot], v[pivot]);
1908                     for i in 0..pivot {
1909                         for j in pivot..len {
1910                             assert!(v[i] <= v[j]);
1911                         }
1912                     }
1913                 }
1914
1915                 // Sort in ascending order.
1916                 for pivot in 0..len {
1917                     let mut v = orig.clone();
1918                     let (left, pivot, right) = v.select_nth_unstable_by(pivot, |a, b| a.cmp(b));
1919
1920                     assert_eq!(left.len() + right.len(), len - 1);
1921
1922                     for l in left {
1923                         assert!(l <= pivot);
1924                         for r in right.iter_mut() {
1925                             assert!(l <= r);
1926                             assert!(pivot <= r);
1927                         }
1928                     }
1929                 }
1930
1931                 // Sort in descending order.
1932                 let sort_descending_comparator = |a: &i32, b: &i32| b.cmp(a);
1933                 let v_sorted_descending = {
1934                     let mut v = orig.clone();
1935                     v.sort_by(sort_descending_comparator);
1936                     v
1937                 };
1938
1939                 for pivot in 0..len {
1940                     let mut v = orig.clone();
1941                     v.select_nth_unstable_by(pivot, sort_descending_comparator);
1942
1943                     assert_eq!(v_sorted_descending[pivot], v[pivot]);
1944                     for i in 0..pivot {
1945                         for j in pivot..len {
1946                             assert!(v[j] <= v[i]);
1947                         }
1948                     }
1949                 }
1950             }
1951         }
1952     }
1953
1954     // Sort at index using a completely random comparison function.
1955     // This will reorder the elements *somehow*, but won't panic.
1956     let mut v = [0; 500];
1957     for i in 0..v.len() {
1958         v[i] = i as i32;
1959     }
1960
1961     for pivot in 0..v.len() {
1962         v.select_nth_unstable_by(pivot, |_, _| *[Less, Equal, Greater].choose(&mut rng).unwrap());
1963         v.sort();
1964         for i in 0..v.len() {
1965             assert_eq!(v[i], i as i32);
1966         }
1967     }
1968
1969     // Should not panic.
1970     [(); 10].select_nth_unstable(0);
1971     [(); 10].select_nth_unstable(5);
1972     [(); 10].select_nth_unstable(9);
1973     [(); 100].select_nth_unstable(0);
1974     [(); 100].select_nth_unstable(50);
1975     [(); 100].select_nth_unstable(99);
1976
1977     let mut v = [0xDEADBEEFu64];
1978     v.select_nth_unstable(0);
1979     assert!(v == [0xDEADBEEF]);
1980 }
1981
1982 #[test]
1983 #[should_panic(expected = "index 0 greater than length of slice")]
1984 fn select_nth_unstable_zero_length() {
1985     [0i32; 0].select_nth_unstable(0);
1986 }
1987
1988 #[test]
1989 #[should_panic(expected = "index 20 greater than length of slice")]
1990 fn select_nth_unstable_past_length() {
1991     [0i32; 10].select_nth_unstable(20);
1992 }
1993
1994 pub mod memchr {
1995     use core::slice::memchr::{memchr, memrchr};
1996
1997     // test fallback implementations on all platforms
1998     #[test]
1999     fn matches_one() {
2000         assert_eq!(Some(0), memchr(b'a', b"a"));
2001     }
2002
2003     #[test]
2004     fn matches_begin() {
2005         assert_eq!(Some(0), memchr(b'a', b"aaaa"));
2006     }
2007
2008     #[test]
2009     fn matches_end() {
2010         assert_eq!(Some(4), memchr(b'z', b"aaaaz"));
2011     }
2012
2013     #[test]
2014     fn matches_nul() {
2015         assert_eq!(Some(4), memchr(b'\x00', b"aaaa\x00"));
2016     }
2017
2018     #[test]
2019     fn matches_past_nul() {
2020         assert_eq!(Some(5), memchr(b'z', b"aaaa\x00z"));
2021     }
2022
2023     #[test]
2024     fn no_match_empty() {
2025         assert_eq!(None, memchr(b'a', b""));
2026     }
2027
2028     #[test]
2029     fn no_match() {
2030         assert_eq!(None, memchr(b'a', b"xyz"));
2031     }
2032
2033     #[test]
2034     fn matches_one_reversed() {
2035         assert_eq!(Some(0), memrchr(b'a', b"a"));
2036     }
2037
2038     #[test]
2039     fn matches_begin_reversed() {
2040         assert_eq!(Some(3), memrchr(b'a', b"aaaa"));
2041     }
2042
2043     #[test]
2044     fn matches_end_reversed() {
2045         assert_eq!(Some(0), memrchr(b'z', b"zaaaa"));
2046     }
2047
2048     #[test]
2049     fn matches_nul_reversed() {
2050         assert_eq!(Some(4), memrchr(b'\x00', b"aaaa\x00"));
2051     }
2052
2053     #[test]
2054     fn matches_past_nul_reversed() {
2055         assert_eq!(Some(0), memrchr(b'z', b"z\x00aaaa"));
2056     }
2057
2058     #[test]
2059     fn no_match_empty_reversed() {
2060         assert_eq!(None, memrchr(b'a', b""));
2061     }
2062
2063     #[test]
2064     fn no_match_reversed() {
2065         assert_eq!(None, memrchr(b'a', b"xyz"));
2066     }
2067
2068     #[test]
2069     fn each_alignment_reversed() {
2070         let mut data = [1u8; 64];
2071         let needle = 2;
2072         let pos = 40;
2073         data[pos] = needle;
2074         for start in 0..16 {
2075             assert_eq!(Some(pos - start), memrchr(needle, &data[start..]));
2076         }
2077     }
2078 }
2079
2080 #[test]
2081 fn test_align_to_simple() {
2082     let bytes = [1u8, 2, 3, 4, 5, 6, 7];
2083     let (prefix, aligned, suffix) = unsafe { bytes.align_to::<u16>() };
2084     assert_eq!(aligned.len(), 3);
2085     assert!(prefix == [1] || suffix == [7]);
2086     let expect1 = [1 << 8 | 2, 3 << 8 | 4, 5 << 8 | 6];
2087     let expect2 = [1 | 2 << 8, 3 | 4 << 8, 5 | 6 << 8];
2088     let expect3 = [2 << 8 | 3, 4 << 8 | 5, 6 << 8 | 7];
2089     let expect4 = [2 | 3 << 8, 4 | 5 << 8, 6 | 7 << 8];
2090     assert!(
2091         aligned == expect1 || aligned == expect2 || aligned == expect3 || aligned == expect4,
2092         "aligned={:?} expected={:?} || {:?} || {:?} || {:?}",
2093         aligned,
2094         expect1,
2095         expect2,
2096         expect3,
2097         expect4
2098     );
2099 }
2100
2101 #[test]
2102 fn test_align_to_zst() {
2103     let bytes = [1, 2, 3, 4, 5, 6, 7];
2104     let (prefix, aligned, suffix) = unsafe { bytes.align_to::<()>() };
2105     assert_eq!(aligned.len(), 0);
2106     assert!(prefix == [1, 2, 3, 4, 5, 6, 7] || suffix == [1, 2, 3, 4, 5, 6, 7]);
2107 }
2108
2109 #[test]
2110 fn test_align_to_non_trivial() {
2111     #[repr(align(8))]
2112     struct U64(u64, u64);
2113     #[repr(align(8))]
2114     struct U64U64U32(u64, u64, u32);
2115     let data = [
2116         U64(1, 2),
2117         U64(3, 4),
2118         U64(5, 6),
2119         U64(7, 8),
2120         U64(9, 10),
2121         U64(11, 12),
2122         U64(13, 14),
2123         U64(15, 16),
2124     ];
2125     let (prefix, aligned, suffix) = unsafe { data.align_to::<U64U64U32>() };
2126     assert_eq!(aligned.len(), 4);
2127     assert_eq!(prefix.len() + suffix.len(), 2);
2128 }
2129
2130 #[test]
2131 fn test_align_to_empty_mid() {
2132     use core::mem;
2133
2134     // Make sure that we do not create empty unaligned slices for the mid part, even when the
2135     // overall slice is too short to contain an aligned address.
2136     let bytes = [1, 2, 3, 4, 5, 6, 7];
2137     type Chunk = u32;
2138     for offset in 0..4 {
2139         let (_, mid, _) = unsafe { bytes[offset..offset + 1].align_to::<Chunk>() };
2140         assert_eq!(mid.as_ptr() as usize % mem::align_of::<Chunk>(), 0);
2141     }
2142 }
2143
2144 #[test]
2145 fn test_align_to_mut_aliasing() {
2146     let mut val = [1u8, 2, 3, 4, 5];
2147     // `align_to_mut` used to create `mid` in a way that there was some intermediate
2148     // incorrect aliasing, invalidating the resulting `mid` slice.
2149     let (begin, mid, end) = unsafe { val.align_to_mut::<[u8; 2]>() };
2150     assert!(begin.len() == 0);
2151     assert!(end.len() == 1);
2152     mid[0] = mid[1];
2153     assert_eq!(val, [3, 4, 3, 4, 5])
2154 }
2155
2156 #[test]
2157 fn test_slice_partition_dedup_by() {
2158     let mut slice: [i32; 9] = [1, -1, 2, 3, 1, -5, 5, -2, 2];
2159
2160     let (dedup, duplicates) = slice.partition_dedup_by(|a, b| a.abs() == b.abs());
2161
2162     assert_eq!(dedup, [1, 2, 3, 1, -5, -2]);
2163     assert_eq!(duplicates, [5, -1, 2]);
2164 }
2165
2166 #[test]
2167 fn test_slice_partition_dedup_empty() {
2168     let mut slice: [i32; 0] = [];
2169
2170     let (dedup, duplicates) = slice.partition_dedup();
2171
2172     assert_eq!(dedup, []);
2173     assert_eq!(duplicates, []);
2174 }
2175
2176 #[test]
2177 fn test_slice_partition_dedup_one() {
2178     let mut slice = [12];
2179
2180     let (dedup, duplicates) = slice.partition_dedup();
2181
2182     assert_eq!(dedup, [12]);
2183     assert_eq!(duplicates, []);
2184 }
2185
2186 #[test]
2187 fn test_slice_partition_dedup_multiple_ident() {
2188     let mut slice = [12, 12, 12, 12, 12, 11, 11, 11, 11, 11, 11];
2189
2190     let (dedup, duplicates) = slice.partition_dedup();
2191
2192     assert_eq!(dedup, [12, 11]);
2193     assert_eq!(duplicates, [12, 12, 12, 12, 11, 11, 11, 11, 11]);
2194 }
2195
2196 #[test]
2197 fn test_slice_partition_dedup_partialeq() {
2198     #[derive(Debug)]
2199     struct Foo(i32, i32);
2200
2201     impl PartialEq for Foo {
2202         fn eq(&self, other: &Foo) -> bool {
2203             self.0 == other.0
2204         }
2205     }
2206
2207     let mut slice = [Foo(0, 1), Foo(0, 5), Foo(1, 7), Foo(1, 9)];
2208
2209     let (dedup, duplicates) = slice.partition_dedup();
2210
2211     assert_eq!(dedup, [Foo(0, 1), Foo(1, 7)]);
2212     assert_eq!(duplicates, [Foo(0, 5), Foo(1, 9)]);
2213 }
2214
2215 #[test]
2216 fn test_copy_within() {
2217     // Start to end, with a RangeTo.
2218     let mut bytes = *b"Hello, World!";
2219     bytes.copy_within(..3, 10);
2220     assert_eq!(&bytes, b"Hello, WorHel");
2221
2222     // End to start, with a RangeFrom.
2223     let mut bytes = *b"Hello, World!";
2224     bytes.copy_within(10.., 0);
2225     assert_eq!(&bytes, b"ld!lo, World!");
2226
2227     // Overlapping, with a RangeInclusive.
2228     let mut bytes = *b"Hello, World!";
2229     bytes.copy_within(0..=11, 1);
2230     assert_eq!(&bytes, b"HHello, World");
2231
2232     // Whole slice, with a RangeFull.
2233     let mut bytes = *b"Hello, World!";
2234     bytes.copy_within(.., 0);
2235     assert_eq!(&bytes, b"Hello, World!");
2236
2237     // Ensure that copying at the end of slice won't cause UB.
2238     let mut bytes = *b"Hello, World!";
2239     bytes.copy_within(13..13, 5);
2240     assert_eq!(&bytes, b"Hello, World!");
2241     bytes.copy_within(5..5, 13);
2242     assert_eq!(&bytes, b"Hello, World!");
2243 }
2244
2245 #[test]
2246 #[should_panic(expected = "range end index 14 out of range for slice of length 13")]
2247 fn test_copy_within_panics_src_too_long() {
2248     let mut bytes = *b"Hello, World!";
2249     // The length is only 13, so 14 is out of bounds.
2250     bytes.copy_within(10..14, 0);
2251 }
2252
2253 #[test]
2254 #[should_panic(expected = "dest is out of bounds")]
2255 fn test_copy_within_panics_dest_too_long() {
2256     let mut bytes = *b"Hello, World!";
2257     // The length is only 13, so a slice of length 4 starting at index 10 is out of bounds.
2258     bytes.copy_within(0..4, 10);
2259 }
2260
2261 #[test]
2262 #[should_panic(expected = "slice index starts at 2 but ends at 1")]
2263 fn test_copy_within_panics_src_inverted() {
2264     let mut bytes = *b"Hello, World!";
2265     // 2 is greater than 1, so this range is invalid.
2266     bytes.copy_within(2..1, 0);
2267 }
2268 #[test]
2269 #[should_panic(expected = "attempted to index slice up to maximum usize")]
2270 fn test_copy_within_panics_src_out_of_bounds() {
2271     let mut bytes = *b"Hello, World!";
2272     // an inclusive range ending at usize::MAX would make src_end overflow
2273     bytes.copy_within(usize::MAX..=usize::MAX, 0);
2274 }
2275
2276 #[test]
2277 fn test_is_sorted() {
2278     let empty: [i32; 0] = [];
2279
2280     assert!([1, 2, 2, 9].is_sorted());
2281     assert!(![1, 3, 2].is_sorted());
2282     assert!([0].is_sorted());
2283     assert!(empty.is_sorted());
2284     assert!(![0.0, 1.0, f32::NAN].is_sorted());
2285     assert!([-2, -1, 0, 3].is_sorted());
2286     assert!(![-2i32, -1, 0, 3].is_sorted_by_key(|n| n.abs()));
2287     assert!(!["c", "bb", "aaa"].is_sorted());
2288     assert!(["c", "bb", "aaa"].is_sorted_by_key(|s| s.len()));
2289 }
2290
2291 #[test]
2292 fn test_slice_run_destructors() {
2293     // Make sure that destructors get run on slice literals
2294     struct Foo<'a> {
2295         x: &'a Cell<isize>,
2296     }
2297
2298     impl<'a> Drop for Foo<'a> {
2299         fn drop(&mut self) {
2300             self.x.set(self.x.get() + 1);
2301         }
2302     }
2303
2304     fn foo(x: &Cell<isize>) -> Foo<'_> {
2305         Foo { x }
2306     }
2307
2308     let x = &Cell::new(0);
2309
2310     {
2311         let l = &[foo(x)];
2312         assert_eq!(l[0].x.get(), 0);
2313     }
2314
2315     assert_eq!(x.get(), 1);
2316 }
2317
2318 #[test]
2319 fn test_const_from_ref() {
2320     const VALUE: &i32 = &1;
2321     const SLICE: &[i32] = core::slice::from_ref(VALUE);
2322
2323     assert!(core::ptr::eq(VALUE, &SLICE[0]))
2324 }
2325
2326 #[test]
2327 fn test_slice_fill_with_uninit() {
2328     // This should not UB. See #87891
2329     let mut a = [MaybeUninit::<u8>::uninit(); 10];
2330     a.fill(MaybeUninit::uninit());
2331 }
2332
2333 #[test]
2334 fn test_swap() {
2335     let mut x = ["a", "b", "c", "d"];
2336     x.swap(1, 3);
2337     assert_eq!(x, ["a", "d", "c", "b"]);
2338     x.swap(0, 3);
2339     assert_eq!(x, ["b", "d", "c", "a"]);
2340 }
2341
2342 mod swap_panics {
2343     #[test]
2344     #[should_panic(expected = "index out of bounds: the len is 4 but the index is 4")]
2345     fn index_a_equals_len() {
2346         let mut x = ["a", "b", "c", "d"];
2347         x.swap(4, 2);
2348     }
2349
2350     #[test]
2351     #[should_panic(expected = "index out of bounds: the len is 4 but the index is 4")]
2352     fn index_b_equals_len() {
2353         let mut x = ["a", "b", "c", "d"];
2354         x.swap(2, 4);
2355     }
2356
2357     #[test]
2358     #[should_panic(expected = "index out of bounds: the len is 4 but the index is 5")]
2359     fn index_a_greater_than_len() {
2360         let mut x = ["a", "b", "c", "d"];
2361         x.swap(5, 2);
2362     }
2363
2364     #[test]
2365     #[should_panic(expected = "index out of bounds: the len is 4 but the index is 5")]
2366     fn index_b_greater_than_len() {
2367         let mut x = ["a", "b", "c", "d"];
2368         x.swap(2, 5);
2369     }
2370 }
2371
2372 #[test]
2373 fn slice_split_array_mut() {
2374     let v = &mut [1, 2, 3, 4, 5, 6][..];
2375
2376     {
2377         let (left, right) = v.split_array_mut::<0>();
2378         assert_eq!(left, &mut []);
2379         assert_eq!(right, [1, 2, 3, 4, 5, 6]);
2380     }
2381
2382     {
2383         let (left, right) = v.split_array_mut::<6>();
2384         assert_eq!(left, &mut [1, 2, 3, 4, 5, 6]);
2385         assert_eq!(right, []);
2386     }
2387 }
2388
2389 #[test]
2390 fn slice_rsplit_array_mut() {
2391     let v = &mut [1, 2, 3, 4, 5, 6][..];
2392
2393     {
2394         let (left, right) = v.rsplit_array_mut::<0>();
2395         assert_eq!(left, [1, 2, 3, 4, 5, 6]);
2396         assert_eq!(right, &mut []);
2397     }
2398
2399     {
2400         let (left, right) = v.rsplit_array_mut::<6>();
2401         assert_eq!(left, []);
2402         assert_eq!(right, &mut [1, 2, 3, 4, 5, 6]);
2403     }
2404 }
2405
2406 #[test]
2407 fn split_as_slice() {
2408     let arr = [1, 2, 3, 4, 5, 6];
2409     let mut split = arr.split(|v| v % 2 == 0);
2410     assert_eq!(split.as_slice(), &[1, 2, 3, 4, 5, 6]);
2411     assert!(split.next().is_some());
2412     assert_eq!(split.as_slice(), &[3, 4, 5, 6]);
2413     assert!(split.next().is_some());
2414     assert!(split.next().is_some());
2415     assert_eq!(split.as_slice(), &[]);
2416 }
2417
2418 #[should_panic]
2419 #[test]
2420 fn slice_split_array_ref_out_of_bounds() {
2421     let v = &[1, 2, 3, 4, 5, 6][..];
2422
2423     let _ = v.split_array_ref::<7>();
2424 }
2425
2426 #[should_panic]
2427 #[test]
2428 fn slice_split_array_mut_out_of_bounds() {
2429     let v = &mut [1, 2, 3, 4, 5, 6][..];
2430
2431     let _ = v.split_array_mut::<7>();
2432 }
2433
2434 #[should_panic]
2435 #[test]
2436 fn slice_rsplit_array_ref_out_of_bounds() {
2437     let v = &[1, 2, 3, 4, 5, 6][..];
2438
2439     let _ = v.rsplit_array_ref::<7>();
2440 }
2441
2442 #[should_panic]
2443 #[test]
2444 fn slice_rsplit_array_mut_out_of_bounds() {
2445     let v = &mut [1, 2, 3, 4, 5, 6][..];
2446
2447     let _ = v.rsplit_array_mut::<7>();
2448 }
2449
2450 macro_rules! take_tests {
2451     (slice: &[], $($tts:tt)*) => {
2452         take_tests!(ty: &[()], slice: &[], $($tts)*);
2453     };
2454     (slice: &mut [], $($tts:tt)*) => {
2455         take_tests!(ty: &mut [()], slice: &mut [], $($tts)*);
2456     };
2457     (slice: &$slice:expr, $($tts:tt)*) => {
2458         take_tests!(ty: &[_], slice: &$slice, $($tts)*);
2459     };
2460     (slice: &mut $slice:expr, $($tts:tt)*) => {
2461         take_tests!(ty: &mut [_], slice: &mut $slice, $($tts)*);
2462     };
2463     (ty: $ty:ty, slice: $slice:expr, method: $method:ident, $(($test_name:ident, ($($args:expr),*), $output:expr, $remaining:expr),)*) => {
2464         $(
2465             #[test]
2466             fn $test_name() {
2467                 let mut slice: $ty = $slice;
2468                 assert_eq!($output, slice.$method($($args)*));
2469                 let remaining: $ty = $remaining;
2470                 assert_eq!(remaining, slice);
2471             }
2472         )*
2473     };
2474 }
2475
2476 take_tests! {
2477     slice: &[0, 1, 2, 3], method: take,
2478     (take_in_bounds_range_to, (..1), Some(&[0] as _), &[1, 2, 3]),
2479     (take_in_bounds_range_to_inclusive, (..=0), Some(&[0] as _), &[1, 2, 3]),
2480     (take_in_bounds_range_from, (2..), Some(&[2, 3] as _), &[0, 1]),
2481     (take_oob_range_to, (..5), None, &[0, 1, 2, 3]),
2482     (take_oob_range_to_inclusive, (..=4), None, &[0, 1, 2, 3]),
2483     (take_oob_range_from, (5..), None, &[0, 1, 2, 3]),
2484 }
2485
2486 take_tests! {
2487     slice: &mut [0, 1, 2, 3], method: take_mut,
2488     (take_mut_in_bounds_range_to, (..1), Some(&mut [0] as _), &mut [1, 2, 3]),
2489     (take_mut_in_bounds_range_to_inclusive, (..=0), Some(&mut [0] as _), &mut [1, 2, 3]),
2490     (take_mut_in_bounds_range_from, (2..), Some(&mut [2, 3] as _), &mut [0, 1]),
2491     (take_mut_oob_range_to, (..5), None, &mut [0, 1, 2, 3]),
2492     (take_mut_oob_range_to_inclusive, (..=4), None, &mut [0, 1, 2, 3]),
2493     (take_mut_oob_range_from, (5..), None, &mut [0, 1, 2, 3]),
2494 }
2495
2496 take_tests! {
2497     slice: &[1, 2], method: take_first,
2498     (take_first_nonempty, (), Some(&1), &[2]),
2499 }
2500
2501 take_tests! {
2502     slice: &mut [1, 2], method: take_first_mut,
2503     (take_first_mut_nonempty, (), Some(&mut 1), &mut [2]),
2504 }
2505
2506 take_tests! {
2507     slice: &[1, 2], method: take_last,
2508     (take_last_nonempty, (), Some(&2), &[1]),
2509 }
2510
2511 take_tests! {
2512     slice: &mut [1, 2], method: take_last_mut,
2513     (take_last_mut_nonempty, (), Some(&mut 2), &mut [1]),
2514 }
2515
2516 take_tests! {
2517     slice: &[], method: take_first,
2518     (take_first_empty, (), None, &[]),
2519 }
2520
2521 take_tests! {
2522     slice: &mut [], method: take_first_mut,
2523     (take_first_mut_empty, (), None, &mut []),
2524 }
2525
2526 take_tests! {
2527     slice: &[], method: take_last,
2528     (take_last_empty, (), None, &[]),
2529 }
2530
2531 take_tests! {
2532     slice: &mut [], method: take_last_mut,
2533     (take_last_mut_empty, (), None, &mut []),
2534 }
2535
2536 #[cfg(not(miri))] // unused in Miri
2537 const EMPTY_MAX: &'static [()] = &[(); usize::MAX];
2538
2539 // can't be a constant due to const mutability rules
2540 #[cfg(not(miri))] // unused in Miri
2541 macro_rules! empty_max_mut {
2542     () => {
2543         &mut [(); usize::MAX] as _
2544     };
2545 }
2546
2547 #[cfg(not(miri))] // Comparing usize::MAX many elements takes forever in Miri (and in rustc without optimizations)
2548 take_tests! {
2549     slice: &[(); usize::MAX], method: take,
2550     (take_in_bounds_max_range_to, (..usize::MAX), Some(EMPTY_MAX), &[(); 0]),
2551     (take_oob_max_range_to_inclusive, (..=usize::MAX), None, EMPTY_MAX),
2552     (take_in_bounds_max_range_from, (usize::MAX..), Some(&[] as _), EMPTY_MAX),
2553 }
2554
2555 #[cfg(not(miri))] // Comparing usize::MAX many elements takes forever in Miri (and in rustc without optimizations)
2556 take_tests! {
2557     slice: &mut [(); usize::MAX], method: take_mut,
2558     (take_mut_in_bounds_max_range_to, (..usize::MAX), Some(empty_max_mut!()), &mut [(); 0]),
2559     (take_mut_oob_max_range_to_inclusive, (..=usize::MAX), None, empty_max_mut!()),
2560     (take_mut_in_bounds_max_range_from, (usize::MAX..), Some(&mut [] as _), empty_max_mut!()),
2561 }
2562
2563 #[test]
2564 fn test_slice_from_ptr_range() {
2565     let arr = ["foo".to_owned(), "bar".to_owned()];
2566     let range = arr.as_ptr_range();
2567     unsafe {
2568         assert_eq!(slice::from_ptr_range(range), &arr);
2569     }
2570
2571     let mut arr = [1, 2, 3];
2572     let range = arr.as_mut_ptr_range();
2573     unsafe {
2574         assert_eq!(slice::from_mut_ptr_range(range), &mut [1, 2, 3]);
2575     }
2576
2577     let arr: [Vec<String>; 0] = [];
2578     let range = arr.as_ptr_range();
2579     unsafe {
2580         assert_eq!(slice::from_ptr_range(range), &arr);
2581     }
2582 }
2583
2584 #[test]
2585 #[should_panic = "slice len overflow"]
2586 fn test_flatten_size_overflow() {
2587     let x = &[[(); usize::MAX]; 2][..];
2588     let _ = x.flatten();
2589 }
2590
2591 #[test]
2592 #[should_panic = "slice len overflow"]
2593 fn test_flatten_mut_size_overflow() {
2594     let x = &mut [[(); usize::MAX]; 2][..];
2595     let _ = x.flatten_mut();
2596 }
2597
2598 #[test]
2599 fn test_get_many_mut_normal_2() {
2600     let mut v = vec![1, 2, 3, 4, 5];
2601     let [a, b] = v.get_many_mut([3, 0]).unwrap();
2602     *a += 10;
2603     *b += 100;
2604     assert_eq!(v, vec![101, 2, 3, 14, 5]);
2605 }
2606
2607 #[test]
2608 fn test_get_many_mut_normal_3() {
2609     let mut v = vec![1, 2, 3, 4, 5];
2610     let [a, b, c] = v.get_many_mut([0, 4, 2]).unwrap();
2611     *a += 10;
2612     *b += 100;
2613     *c += 1000;
2614     assert_eq!(v, vec![11, 2, 1003, 4, 105]);
2615 }
2616
2617 #[test]
2618 fn test_get_many_mut_empty() {
2619     let mut v = vec![1, 2, 3, 4, 5];
2620     let [] = v.get_many_mut([]).unwrap();
2621     assert_eq!(v, vec![1, 2, 3, 4, 5]);
2622 }
2623
2624 #[test]
2625 fn test_get_many_mut_single_first() {
2626     let mut v = vec![1, 2, 3, 4, 5];
2627     let [a] = v.get_many_mut([0]).unwrap();
2628     *a += 10;
2629     assert_eq!(v, vec![11, 2, 3, 4, 5]);
2630 }
2631
2632 #[test]
2633 fn test_get_many_mut_single_last() {
2634     let mut v = vec![1, 2, 3, 4, 5];
2635     let [a] = v.get_many_mut([4]).unwrap();
2636     *a += 10;
2637     assert_eq!(v, vec![1, 2, 3, 4, 15]);
2638 }
2639
2640 #[test]
2641 fn test_get_many_mut_oob_nonempty() {
2642     let mut v = vec![1, 2, 3, 4, 5];
2643     assert!(v.get_many_mut([5]).is_err());
2644 }
2645
2646 #[test]
2647 fn test_get_many_mut_oob_empty() {
2648     let mut v: Vec<i32> = vec![];
2649     assert!(v.get_many_mut([0]).is_err());
2650 }
2651
2652 #[test]
2653 fn test_get_many_mut_duplicate() {
2654     let mut v = vec![1, 2, 3, 4, 5];
2655     assert!(v.get_many_mut([1, 3, 3, 4]).is_err());
2656 }