library/core/tests/slice.rs

   1 use core::cell::Cell;
   2 use core::result::Result::{Err, Ok};
   3
   4 #[test]
   5 fn test_position() {
   6     let b = [1, 2, 3, 5, 5];
   7     assert_eq!(b.iter().position(|&v| v == 9), None);
   8     assert_eq!(b.iter().position(|&v| v == 5), Some(3));
   9     assert_eq!(b.iter().position(|&v| v == 3), Some(2));
  10     assert_eq!(b.iter().position(|&v| v == 0), None);
  11 }
  12
  13 #[test]
  14 fn test_rposition() {
  15     let b = [1, 2, 3, 5, 5];
  16     assert_eq!(b.iter().rposition(|&v| v == 9), None);
  17     assert_eq!(b.iter().rposition(|&v| v == 5), Some(4));
  18     assert_eq!(b.iter().rposition(|&v| v == 3), Some(2));
  19     assert_eq!(b.iter().rposition(|&v| v == 0), None);
  20 }
  21
  22 #[test]
  23 fn test_binary_search() {
  24     let b: [i32; 0] = [];
  25     assert_eq!(b.binary_search(&5), Err(0));
  26
  27     let b = [4];
  28     assert_eq!(b.binary_search(&3), Err(0));
  29     assert_eq!(b.binary_search(&4), Ok(0));
  30     assert_eq!(b.binary_search(&5), Err(1));
  31
  32     let b = [1, 2, 4, 6, 8, 9];
  33     assert_eq!(b.binary_search(&5), Err(3));
  34     assert_eq!(b.binary_search(&6), Ok(3));
  35     assert_eq!(b.binary_search(&7), Err(4));
  36     assert_eq!(b.binary_search(&8), Ok(4));
  37
  38     let b = [1, 2, 4, 5, 6, 8];
  39     assert_eq!(b.binary_search(&9), Err(6));
  40
  41     let b = [1, 2, 4, 6, 7, 8, 9];
  42     assert_eq!(b.binary_search(&6), Ok(3));
  43     assert_eq!(b.binary_search(&5), Err(3));
  44     assert_eq!(b.binary_search(&8), Ok(5));
  45
  46     let b = [1, 2, 4, 5, 6, 8, 9];
  47     assert_eq!(b.binary_search(&7), Err(5));
  48     assert_eq!(b.binary_search(&0), Err(0));
  49
  50     let b = [1, 3, 3, 3, 7];
  51     assert_eq!(b.binary_search(&0), Err(0));
  52     assert_eq!(b.binary_search(&1), Ok(0));
  53     assert_eq!(b.binary_search(&2), Err(1));
  54     assert!(match b.binary_search(&3) {
  55         Ok(1..=3) => true,
  56         _ => false,
  57     });
  58     assert!(match b.binary_search(&3) {
  59         Ok(1..=3) => true,
  60         _ => false,
  61     });
  62     assert_eq!(b.binary_search(&4), Err(4));
  63     assert_eq!(b.binary_search(&5), Err(4));
  64     assert_eq!(b.binary_search(&6), Err(4));
  65     assert_eq!(b.binary_search(&7), Ok(4));
  66     assert_eq!(b.binary_search(&8), Err(5));
  67 }
  68
  69 #[test]
  70 // Test implementation specific behavior when finding equivalent elements.
  71 // It is ok to break this test but when you do a crater run is highly advisable.
  72 fn test_binary_search_implementation_details() {
  73     let b = [1, 1, 2, 2, 3, 3, 3];
  74     assert_eq!(b.binary_search(&1), Ok(1));
  75     assert_eq!(b.binary_search(&2), Ok(3));
  76     assert_eq!(b.binary_search(&3), Ok(6));
  77     let b = [1, 1, 1, 1, 1, 3, 3, 3, 3];
  78     assert_eq!(b.binary_search(&1), Ok(4));
  79     assert_eq!(b.binary_search(&3), Ok(8));
  80     let b = [1, 1, 1, 1, 3, 3, 3, 3, 3];
  81     assert_eq!(b.binary_search(&1), Ok(3));
  82     assert_eq!(b.binary_search(&3), Ok(8));
  83 }
  84
  85 #[test]
  86 fn test_partition_point() {
  87     let b: [i32; 0] = [];
  88     assert_eq!(b.partition_point(|&x| x < 5), 0);
  89
  90     let b = [4];
  91     assert_eq!(b.partition_point(|&x| x < 3), 0);
  92     assert_eq!(b.partition_point(|&x| x < 4), 0);
  93     assert_eq!(b.partition_point(|&x| x < 5), 1);
  94
  95     let b = [1, 2, 4, 6, 8, 9];
  96     assert_eq!(b.partition_point(|&x| x < 5), 3);
  97     assert_eq!(b.partition_point(|&x| x < 6), 3);
  98     assert_eq!(b.partition_point(|&x| x < 7), 4);
  99     assert_eq!(b.partition_point(|&x| x < 8), 4);
 100
 101     let b = [1, 2, 4, 5, 6, 8];
 102     assert_eq!(b.partition_point(|&x| x < 9), 6);
 103
 104     let b = [1, 2, 4, 6, 7, 8, 9];
 105     assert_eq!(b.partition_point(|&x| x < 6), 3);
 106     assert_eq!(b.partition_point(|&x| x < 5), 3);
 107     assert_eq!(b.partition_point(|&x| x < 8), 5);
 108
 109     let b = [1, 2, 4, 5, 6, 8, 9];
 110     assert_eq!(b.partition_point(|&x| x < 7), 5);
 111     assert_eq!(b.partition_point(|&x| x < 0), 0);
 112
 113     let b = [1, 3, 3, 3, 7];
 114     assert_eq!(b.partition_point(|&x| x < 0), 0);
 115     assert_eq!(b.partition_point(|&x| x < 1), 0);
 116     assert_eq!(b.partition_point(|&x| x < 2), 1);
 117     assert_eq!(b.partition_point(|&x| x < 3), 1);
 118     assert_eq!(b.partition_point(|&x| x < 4), 4);
 119     assert_eq!(b.partition_point(|&x| x < 5), 4);
 120     assert_eq!(b.partition_point(|&x| x < 6), 4);
 121     assert_eq!(b.partition_point(|&x| x < 7), 4);
 122     assert_eq!(b.partition_point(|&x| x < 8), 5);
 123 }
 124
 125 #[test]
 126 fn test_iterator_nth() {
 127     let v: &[_] = &[0, 1, 2, 3, 4];
 128     for i in 0..v.len() {
 129         assert_eq!(v.iter().nth(i).unwrap(), &v[i]);
 130     }
 131     assert_eq!(v.iter().nth(v.len()), None);
 132
 133     let mut iter = v.iter();
 134     assert_eq!(iter.nth(2).unwrap(), &v[2]);
 135     assert_eq!(iter.nth(1).unwrap(), &v[4]);
 136 }
 137
 138 #[test]
 139 fn test_iterator_nth_back() {
 140     let v: &[_] = &[0, 1, 2, 3, 4];
 141     for i in 0..v.len() {
 142         assert_eq!(v.iter().nth_back(i).unwrap(), &v[v.len() - i - 1]);
 143     }
 144     assert_eq!(v.iter().nth_back(v.len()), None);
 145
 146     let mut iter = v.iter();
 147     assert_eq!(iter.nth_back(2).unwrap(), &v[2]);
 148     assert_eq!(iter.nth_back(1).unwrap(), &v[0]);
 149 }
 150
 151 #[test]
 152 fn test_iterator_last() {
 153     let v: &[_] = &[0, 1, 2, 3, 4];
 154     assert_eq!(v.iter().last().unwrap(), &4);
 155     assert_eq!(v[..1].iter().last().unwrap(), &0);
 156 }
 157
 158 #[test]
 159 fn test_iterator_count() {
 160     let v: &[_] = &[0, 1, 2, 3, 4];
 161     assert_eq!(v.iter().count(), 5);
 162
 163     let mut iter2 = v.iter();
 164     iter2.next();
 165     iter2.next();
 166     assert_eq!(iter2.count(), 3);
 167 }
 168
 169 #[test]
 170 fn test_chunks_count() {
 171     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 172     let c = v.chunks(3);
 173     assert_eq!(c.count(), 2);
 174
 175     let v2: &[i32] = &[0, 1, 2, 3, 4];
 176     let c2 = v2.chunks(2);
 177     assert_eq!(c2.count(), 3);
 178
 179     let v3: &[i32] = &[];
 180     let c3 = v3.chunks(2);
 181     assert_eq!(c3.count(), 0);
 182 }
 183
 184 #[test]
 185 fn test_chunks_nth() {
 186     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 187     let mut c = v.chunks(2);
 188     assert_eq!(c.nth(1).unwrap(), &[2, 3]);
 189     assert_eq!(c.next().unwrap(), &[4, 5]);
 190
 191     let v2: &[i32] = &[0, 1, 2, 3, 4];
 192     let mut c2 = v2.chunks(3);
 193     assert_eq!(c2.nth(1).unwrap(), &[3, 4]);
 194     assert_eq!(c2.next(), None);
 195 }
 196
 197 #[test]
 198 fn test_chunks_nth_back() {
 199     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 200     let mut c = v.chunks(2);
 201     assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
 202     assert_eq!(c.next().unwrap(), &[0, 1]);
 203     assert_eq!(c.next(), None);
 204
 205     let v2: &[i32] = &[0, 1, 2, 3, 4];
 206     let mut c2 = v2.chunks(3);
 207     assert_eq!(c2.nth_back(1).unwrap(), &[0, 1, 2]);
 208     assert_eq!(c2.next(), None);
 209     assert_eq!(c2.next_back(), None);
 210
 211     let v3: &[i32] = &[0, 1, 2, 3, 4];
 212     let mut c3 = v3.chunks(10);
 213     assert_eq!(c3.nth_back(0).unwrap(), &[0, 1, 2, 3, 4]);
 214     assert_eq!(c3.next(), None);
 215
 216     let v4: &[i32] = &[0, 1, 2];
 217     let mut c4 = v4.chunks(10);
 218     assert_eq!(c4.nth_back(1_000_000_000usize), None);
 219 }
 220
 221 #[test]
 222 fn test_chunks_last() {
 223     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 224     let c = v.chunks(2);
 225     assert_eq!(c.last().unwrap()[1], 5);
 226
 227     let v2: &[i32] = &[0, 1, 2, 3, 4];
 228     let c2 = v2.chunks(2);
 229     assert_eq!(c2.last().unwrap()[0], 4);
 230 }
 231
 232 #[test]
 233 fn test_chunks_zip() {
 234     let v1: &[i32] = &[0, 1, 2, 3, 4];
 235     let v2: &[i32] = &[6, 7, 8, 9, 10];
 236
 237     let res = v1
 238         .chunks(2)
 239         .zip(v2.chunks(2))
 240         .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
 241         .collect::<Vec<_>>();
 242     assert_eq!(res, vec![14, 22, 14]);
 243 }
 244
 245 #[test]
 246 fn test_chunks_mut_count() {
 247     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 248     let c = v.chunks_mut(3);
 249     assert_eq!(c.count(), 2);
 250
 251     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
 252     let c2 = v2.chunks_mut(2);
 253     assert_eq!(c2.count(), 3);
 254
 255     let v3: &mut [i32] = &mut [];
 256     let c3 = v3.chunks_mut(2);
 257     assert_eq!(c3.count(), 0);
 258 }
 259
 260 #[test]
 261 fn test_chunks_mut_nth() {
 262     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 263     let mut c = v.chunks_mut(2);
 264     assert_eq!(c.nth(1).unwrap(), &[2, 3]);
 265     assert_eq!(c.next().unwrap(), &[4, 5]);
 266
 267     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
 268     let mut c2 = v2.chunks_mut(3);
 269     assert_eq!(c2.nth(1).unwrap(), &[3, 4]);
 270     assert_eq!(c2.next(), None);
 271 }
 272
 273 #[test]
 274 fn test_chunks_mut_nth_back() {
 275     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 276     let mut c = v.chunks_mut(2);
 277     assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
 278     assert_eq!(c.next().unwrap(), &[0, 1]);
 279
 280     let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
 281     let mut c1 = v1.chunks_mut(3);
 282     assert_eq!(c1.nth_back(1).unwrap(), &[0, 1, 2]);
 283     assert_eq!(c1.next(), None);
 284
 285     let v3: &mut [i32] = &mut [0, 1, 2, 3, 4];
 286     let mut c3 = v3.chunks_mut(10);
 287     assert_eq!(c3.nth_back(0).unwrap(), &[0, 1, 2, 3, 4]);
 288     assert_eq!(c3.next(), None);
 289
 290     let v4: &mut [i32] = &mut [0, 1, 2];
 291     let mut c4 = v4.chunks_mut(10);
 292     assert_eq!(c4.nth_back(1_000_000_000usize), None);
 293 }
 294
 295 #[test]
 296 fn test_chunks_mut_last() {
 297     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 298     let c = v.chunks_mut(2);
 299     assert_eq!(c.last().unwrap(), &[4, 5]);
 300
 301     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
 302     let c2 = v2.chunks_mut(2);
 303     assert_eq!(c2.last().unwrap(), &[4]);
 304 }
 305
 306 #[test]
 307 fn test_chunks_mut_zip() {
 308     let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
 309     let v2: &[i32] = &[6, 7, 8, 9, 10];
 310
 311     for (a, b) in v1.chunks_mut(2).zip(v2.chunks(2)) {
 312         let sum = b.iter().sum::<i32>();
 313         for v in a {
 314             *v += sum;
 315         }
 316     }
 317     assert_eq!(v1, [13, 14, 19, 20, 14]);
 318 }
 319
 320 #[test]
 321 fn test_chunks_exact_count() {
 322     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 323     let c = v.chunks_exact(3);
 324     assert_eq!(c.count(), 2);
 325
 326     let v2: &[i32] = &[0, 1, 2, 3, 4];
 327     let c2 = v2.chunks_exact(2);
 328     assert_eq!(c2.count(), 2);
 329
 330     let v3: &[i32] = &[];
 331     let c3 = v3.chunks_exact(2);
 332     assert_eq!(c3.count(), 0);
 333 }
 334
 335 #[test]
 336 fn test_chunks_exact_nth() {
 337     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 338     let mut c = v.chunks_exact(2);
 339     assert_eq!(c.nth(1).unwrap(), &[2, 3]);
 340     assert_eq!(c.next().unwrap(), &[4, 5]);
 341
 342     let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
 343     let mut c2 = v2.chunks_exact(3);
 344     assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
 345     assert_eq!(c2.next(), None);
 346 }
 347
 348 #[test]
 349 fn test_chunks_exact_nth_back() {
 350     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 351     let mut c = v.chunks_exact(2);
 352     assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
 353     assert_eq!(c.next().unwrap(), &[0, 1]);
 354     assert_eq!(c.next(), None);
 355
 356     let v2: &[i32] = &[0, 1, 2, 3, 4];
 357     let mut c2 = v2.chunks_exact(3);
 358     assert_eq!(c2.nth_back(0).unwrap(), &[0, 1, 2]);
 359     assert_eq!(c2.next(), None);
 360     assert_eq!(c2.next_back(), None);
 361
 362     let v3: &[i32] = &[0, 1, 2, 3, 4];
 363     let mut c3 = v3.chunks_exact(10);
 364     assert_eq!(c3.nth_back(0), None);
 365 }
 366
 367 #[test]
 368 fn test_chunks_exact_last() {
 369     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 370     let c = v.chunks_exact(2);
 371     assert_eq!(c.last().unwrap(), &[4, 5]);
 372
 373     let v2: &[i32] = &[0, 1, 2, 3, 4];
 374     let c2 = v2.chunks_exact(2);
 375     assert_eq!(c2.last().unwrap(), &[2, 3]);
 376 }
 377
 378 #[test]
 379 fn test_chunks_exact_remainder() {
 380     let v: &[i32] = &[0, 1, 2, 3, 4];
 381     let c = v.chunks_exact(2);
 382     assert_eq!(c.remainder(), &[4]);
 383 }
 384
 385 #[test]
 386 fn test_chunks_exact_zip() {
 387     let v1: &[i32] = &[0, 1, 2, 3, 4];
 388     let v2: &[i32] = &[6, 7, 8, 9, 10];
 389
 390     let res = v1
 391         .chunks_exact(2)
 392         .zip(v2.chunks_exact(2))
 393         .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
 394         .collect::<Vec<_>>();
 395     assert_eq!(res, vec![14, 22]);
 396 }
 397
 398 #[test]
 399 fn test_chunks_exact_mut_count() {
 400     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 401     let c = v.chunks_exact_mut(3);
 402     assert_eq!(c.count(), 2);
 403
 404     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
 405     let c2 = v2.chunks_exact_mut(2);
 406     assert_eq!(c2.count(), 2);
 407
 408     let v3: &mut [i32] = &mut [];
 409     let c3 = v3.chunks_exact_mut(2);
 410     assert_eq!(c3.count(), 0);
 411 }
 412
 413 #[test]
 414 fn test_chunks_exact_mut_nth() {
 415     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 416     let mut c = v.chunks_exact_mut(2);
 417     assert_eq!(c.nth(1).unwrap(), &[2, 3]);
 418     assert_eq!(c.next().unwrap(), &[4, 5]);
 419
 420     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
 421     let mut c2 = v2.chunks_exact_mut(3);
 422     assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
 423     assert_eq!(c2.next(), None);
 424 }
 425
 426 #[test]
 427 fn test_chunks_exact_mut_nth_back() {
 428     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 429     let mut c = v.chunks_exact_mut(2);
 430     assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
 431     assert_eq!(c.next().unwrap(), &[0, 1]);
 432     assert_eq!(c.next(), None);
 433
 434     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
 435     let mut c2 = v2.chunks_exact_mut(3);
 436     assert_eq!(c2.nth_back(0).unwrap(), &[0, 1, 2]);
 437     assert_eq!(c2.next(), None);
 438     assert_eq!(c2.next_back(), None);
 439
 440     let v3: &mut [i32] = &mut [0, 1, 2, 3, 4];
 441     let mut c3 = v3.chunks_exact_mut(10);
 442     assert_eq!(c3.nth_back(0), None);
 443 }
 444
 445 #[test]
 446 fn test_chunks_exact_mut_last() {
 447     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 448     let c = v.chunks_exact_mut(2);
 449     assert_eq!(c.last().unwrap(), &[4, 5]);
 450
 451     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
 452     let c2 = v2.chunks_exact_mut(2);
 453     assert_eq!(c2.last().unwrap(), &[2, 3]);
 454 }
 455
 456 #[test]
 457 fn test_chunks_exact_mut_remainder() {
 458     let v: &mut [i32] = &mut [0, 1, 2, 3, 4];
 459     let c = v.chunks_exact_mut(2);
 460     assert_eq!(c.into_remainder(), &[4]);
 461 }
 462
 463 #[test]
 464 fn test_chunks_exact_mut_zip() {
 465     let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
 466     let v2: &[i32] = &[6, 7, 8, 9, 10];
 467
 468     for (a, b) in v1.chunks_exact_mut(2).zip(v2.chunks_exact(2)) {
 469         let sum = b.iter().sum::<i32>();
 470         for v in a {
 471             *v += sum;
 472         }
 473     }
 474     assert_eq!(v1, [13, 14, 19, 20, 4]);
 475 }
 476
 477 #[test]
 478 fn test_array_chunks_infer() {
 479     let v: &[i32] = &[0, 1, 2, 3, 4, -4];
 480     let c = v.array_chunks();
 481     for &[a, b, c] in c {
 482         assert_eq!(a + b + c, 3);
 483     }
 484
 485     let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
 486     let total = v2.array_chunks().map(|&[a, b]| a * b).sum::<i32>();
 487     assert_eq!(total, 2 * 3 + 4 * 5);
 488 }
 489
 490 #[test]
 491 fn test_array_chunks_count() {
 492     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 493     let c = v.array_chunks::<3>();
 494     assert_eq!(c.count(), 2);
 495
 496     let v2: &[i32] = &[0, 1, 2, 3, 4];
 497     let c2 = v2.array_chunks::<2>();
 498     assert_eq!(c2.count(), 2);
 499
 500     let v3: &[i32] = &[];
 501     let c3 = v3.array_chunks::<2>();
 502     assert_eq!(c3.count(), 0);
 503 }
 504
 505 #[test]
 506 fn test_array_chunks_nth() {
 507     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 508     let mut c = v.array_chunks::<2>();
 509     assert_eq!(c.nth(1).unwrap(), &[2, 3]);
 510     assert_eq!(c.next().unwrap(), &[4, 5]);
 511
 512     let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
 513     let mut c2 = v2.array_chunks::<3>();
 514     assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
 515     assert_eq!(c2.next(), None);
 516 }
 517
 518 #[test]
 519 fn test_array_chunks_nth_back() {
 520     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 521     let mut c = v.array_chunks::<2>();
 522     assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
 523     assert_eq!(c.next().unwrap(), &[0, 1]);
 524     assert_eq!(c.next(), None);
 525
 526     let v2: &[i32] = &[0, 1, 2, 3, 4];
 527     let mut c2 = v2.array_chunks::<3>();
 528     assert_eq!(c2.nth_back(0).unwrap(), &[0, 1, 2]);
 529     assert_eq!(c2.next(), None);
 530     assert_eq!(c2.next_back(), None);
 531
 532     let v3: &[i32] = &[0, 1, 2, 3, 4];
 533     let mut c3 = v3.array_chunks::<10>();
 534     assert_eq!(c3.nth_back(0), None);
 535 }
 536
 537 #[test]
 538 fn test_array_chunks_last() {
 539     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 540     let c = v.array_chunks::<2>();
 541     assert_eq!(c.last().unwrap(), &[4, 5]);
 542
 543     let v2: &[i32] = &[0, 1, 2, 3, 4];
 544     let c2 = v2.array_chunks::<2>();
 545     assert_eq!(c2.last().unwrap(), &[2, 3]);
 546 }
 547
 548 #[test]
 549 fn test_array_chunks_remainder() {
 550     let v: &[i32] = &[0, 1, 2, 3, 4];
 551     let c = v.array_chunks::<2>();
 552     assert_eq!(c.remainder(), &[4]);
 553 }
 554
 555 #[test]
 556 fn test_array_chunks_zip() {
 557     let v1: &[i32] = &[0, 1, 2, 3, 4];
 558     let v2: &[i32] = &[6, 7, 8, 9, 10];
 559
 560     let res = v1
 561         .array_chunks::<2>()
 562         .zip(v2.array_chunks::<2>())
 563         .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
 564         .collect::<Vec<_>>();
 565     assert_eq!(res, vec![14, 22]);
 566 }
 567
 568 #[test]
 569 fn test_array_chunks_mut_infer() {
 570     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
 571     for a in v.array_chunks_mut() {
 572         let sum = a.iter().sum::<i32>();
 573         *a = [sum; 3];
 574     }
 575     assert_eq!(v, &[3, 3, 3, 12, 12, 12, 6]);
 576
 577     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
 578     v2.array_chunks_mut().for_each(|[a, b]| core::mem::swap(a, b));
 579     assert_eq!(v2, &[1, 0, 3, 2, 5, 4, 6]);
 580 }
 581
 582 #[test]
 583 fn test_array_chunks_mut_count() {
 584     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 585     let c = v.array_chunks_mut::<3>();
 586     assert_eq!(c.count(), 2);
 587
 588     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
 589     let c2 = v2.array_chunks_mut::<2>();
 590     assert_eq!(c2.count(), 2);
 591
 592     let v3: &mut [i32] = &mut [];
 593     let c3 = v3.array_chunks_mut::<2>();
 594     assert_eq!(c3.count(), 0);
 595 }
 596
 597 #[test]
 598 fn test_array_chunks_mut_nth() {
 599     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 600     let mut c = v.array_chunks_mut::<2>();
 601     assert_eq!(c.nth(1).unwrap(), &[2, 3]);
 602     assert_eq!(c.next().unwrap(), &[4, 5]);
 603
 604     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
 605     let mut c2 = v2.array_chunks_mut::<3>();
 606     assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
 607     assert_eq!(c2.next(), None);
 608 }
 609
 610 #[test]
 611 fn test_array_chunks_mut_nth_back() {
 612     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 613     let mut c = v.array_chunks_mut::<2>();
 614     assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
 615     assert_eq!(c.next().unwrap(), &[0, 1]);
 616     assert_eq!(c.next(), None);
 617
 618     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
 619     let mut c2 = v2.array_chunks_mut::<3>();
 620     assert_eq!(c2.nth_back(0).unwrap(), &[0, 1, 2]);
 621     assert_eq!(c2.next(), None);
 622     assert_eq!(c2.next_back(), None);
 623
 624     let v3: &mut [i32] = &mut [0, 1, 2, 3, 4];
 625     let mut c3 = v3.array_chunks_mut::<10>();
 626     assert_eq!(c3.nth_back(0), None);
 627 }
 628
 629 #[test]
 630 fn test_array_chunks_mut_last() {
 631     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 632     let c = v.array_chunks_mut::<2>();
 633     assert_eq!(c.last().unwrap(), &[4, 5]);
 634
 635     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
 636     let c2 = v2.array_chunks_mut::<2>();
 637     assert_eq!(c2.last().unwrap(), &[2, 3]);
 638 }
 639
 640 #[test]
 641 fn test_array_chunks_mut_remainder() {
 642     let v: &mut [i32] = &mut [0, 1, 2, 3, 4];
 643     let c = v.array_chunks_mut::<2>();
 644     assert_eq!(c.into_remainder(), &[4]);
 645 }
 646
 647 #[test]
 648 fn test_array_chunks_mut_zip() {
 649     let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
 650     let v2: &[i32] = &[6, 7, 8, 9, 10];
 651
 652     for (a, b) in v1.array_chunks_mut::<2>().zip(v2.array_chunks::<2>()) {
 653         let sum = b.iter().sum::<i32>();
 654         for v in a {
 655             *v += sum;
 656         }
 657     }
 658     assert_eq!(v1, [13, 14, 19, 20, 4]);
 659 }
 660
 661 #[test]
 662 fn test_array_windows_infer() {
 663     let v: &[i32] = &[0, 1, 0, 1];
 664     assert_eq!(v.array_windows::<2>().count(), 3);
 665     let c = v.array_windows();
 666     for &[a, b] in c {
 667         assert_eq!(a + b, 1);
 668     }
 669
 670     let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
 671     let total = v2.array_windows().map(|&[a, b, c]| a + b + c).sum::<i32>();
 672     assert_eq!(total, 3 + 6 + 9 + 12 + 15);
 673 }
 674
 675 #[test]
 676 fn test_array_windows_count() {
 677     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 678     let c = v.array_windows::<3>();
 679     assert_eq!(c.count(), 4);
 680
 681     let v2: &[i32] = &[0, 1, 2, 3, 4];
 682     let c2 = v2.array_windows::<6>();
 683     assert_eq!(c2.count(), 0);
 684
 685     let v3: &[i32] = &[];
 686     let c3 = v3.array_windows::<2>();
 687     assert_eq!(c3.count(), 0);
 688 }
 689
 690 #[test]
 691 fn test_array_windows_nth() {
 692     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 693     let snd = v.array_windows::<4>().nth(1);
 694     assert_eq!(snd, Some(&[1, 2, 3, 4]));
 695     let mut arr_windows = v.array_windows::<2>();
 696     assert_ne!(arr_windows.nth(0), arr_windows.nth(0));
 697     let last = v.array_windows::<3>().last();
 698     assert_eq!(last, Some(&[3, 4, 5]));
 699 }
 700
 701 #[test]
 702 fn test_array_windows_nth_back() {
 703     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 704     let snd = v.array_windows::<4>().nth_back(1);
 705     assert_eq!(snd, Some(&[1, 2, 3, 4]));
 706     let mut arr_windows = v.array_windows::<2>();
 707     assert_ne!(arr_windows.nth_back(0), arr_windows.nth_back(0));
 708 }
 709
 710 #[test]
 711 fn test_rchunks_count() {
 712     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 713     let c = v.rchunks(3);
 714     assert_eq!(c.count(), 2);
 715
 716     let v2: &[i32] = &[0, 1, 2, 3, 4];
 717     let c2 = v2.rchunks(2);
 718     assert_eq!(c2.count(), 3);
 719
 720     let v3: &[i32] = &[];
 721     let c3 = v3.rchunks(2);
 722     assert_eq!(c3.count(), 0);
 723 }
 724
 725 #[test]
 726 fn test_rchunks_nth() {
 727     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 728     let mut c = v.rchunks(2);
 729     assert_eq!(c.nth(1).unwrap(), &[2, 3]);
 730     assert_eq!(c.next().unwrap(), &[0, 1]);
 731
 732     let v2: &[i32] = &[0, 1, 2, 3, 4];
 733     let mut c2 = v2.rchunks(3);
 734     assert_eq!(c2.nth(1).unwrap(), &[0, 1]);
 735     assert_eq!(c2.next(), None);
 736 }
 737
 738 #[test]
 739 fn test_rchunks_nth_back() {
 740     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 741     let mut c = v.rchunks(2);
 742     assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
 743     assert_eq!(c.next_back().unwrap(), &[4, 5]);
 744
 745     let v2: &[i32] = &[0, 1, 2, 3, 4];
 746     let mut c2 = v2.rchunks(3);
 747     assert_eq!(c2.nth_back(1).unwrap(), &[2, 3, 4]);
 748     assert_eq!(c2.next_back(), None);
 749 }
 750
 751 #[test]
 752 fn test_rchunks_last() {
 753     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 754     let c = v.rchunks(2);
 755     assert_eq!(c.last().unwrap()[1], 1);
 756
 757     let v2: &[i32] = &[0, 1, 2, 3, 4];
 758     let c2 = v2.rchunks(2);
 759     assert_eq!(c2.last().unwrap()[0], 0);
 760 }
 761
 762 #[test]
 763 fn test_rchunks_zip() {
 764     let v1: &[i32] = &[0, 1, 2, 3, 4];
 765     let v2: &[i32] = &[6, 7, 8, 9, 10];
 766
 767     let res = v1
 768         .rchunks(2)
 769         .zip(v2.rchunks(2))
 770         .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
 771         .collect::<Vec<_>>();
 772     assert_eq!(res, vec![26, 18, 6]);
 773 }
 774
 775 #[test]
 776 fn test_rchunks_mut_count() {
 777     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 778     let c = v.rchunks_mut(3);
 779     assert_eq!(c.count(), 2);
 780
 781     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
 782     let c2 = v2.rchunks_mut(2);
 783     assert_eq!(c2.count(), 3);
 784
 785     let v3: &mut [i32] = &mut [];
 786     let c3 = v3.rchunks_mut(2);
 787     assert_eq!(c3.count(), 0);
 788 }
 789
 790 #[test]
 791 fn test_rchunks_mut_nth() {
 792     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 793     let mut c = v.rchunks_mut(2);
 794     assert_eq!(c.nth(1).unwrap(), &[2, 3]);
 795     assert_eq!(c.next().unwrap(), &[0, 1]);
 796
 797     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
 798     let mut c2 = v2.rchunks_mut(3);
 799     assert_eq!(c2.nth(1).unwrap(), &[0, 1]);
 800     assert_eq!(c2.next(), None);
 801 }
 802
 803 #[test]
 804 fn test_rchunks_mut_nth_back() {
 805     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 806     let mut c = v.rchunks_mut(2);
 807     assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
 808     assert_eq!(c.next_back().unwrap(), &[4, 5]);
 809
 810     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
 811     let mut c2 = v2.rchunks_mut(3);
 812     assert_eq!(c2.nth_back(1).unwrap(), &[2, 3, 4]);
 813     assert_eq!(c2.next_back(), None);
 814 }
 815
 816 #[test]
 817 fn test_rchunks_mut_last() {
 818     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 819     let c = v.rchunks_mut(2);
 820     assert_eq!(c.last().unwrap(), &[0, 1]);
 821
 822     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
 823     let c2 = v2.rchunks_mut(2);
 824     assert_eq!(c2.last().unwrap(), &[0]);
 825 }
 826
 827 #[test]
 828 fn test_rchunks_mut_zip() {
 829     let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
 830     let v2: &[i32] = &[6, 7, 8, 9, 10];
 831
 832     for (a, b) in v1.rchunks_mut(2).zip(v2.rchunks(2)) {
 833         let sum = b.iter().sum::<i32>();
 834         for v in a {
 835             *v += sum;
 836         }
 837     }
 838     assert_eq!(v1, [6, 16, 17, 22, 23]);
 839 }
 840
 841 #[test]
 842 fn test_rchunks_exact_count() {
 843     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 844     let c = v.rchunks_exact(3);
 845     assert_eq!(c.count(), 2);
 846
 847     let v2: &[i32] = &[0, 1, 2, 3, 4];
 848     let c2 = v2.rchunks_exact(2);
 849     assert_eq!(c2.count(), 2);
 850
 851     let v3: &[i32] = &[];
 852     let c3 = v3.rchunks_exact(2);
 853     assert_eq!(c3.count(), 0);
 854 }
 855
 856 #[test]
 857 fn test_rchunks_exact_nth() {
 858     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 859     let mut c = v.rchunks_exact(2);
 860     assert_eq!(c.nth(1).unwrap(), &[2, 3]);
 861     assert_eq!(c.next().unwrap(), &[0, 1]);
 862
 863     let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
 864     let mut c2 = v2.rchunks_exact(3);
 865     assert_eq!(c2.nth(1).unwrap(), &[1, 2, 3]);
 866     assert_eq!(c2.next(), None);
 867 }
 868
 869 #[test]
 870 fn test_rchunks_exact_nth_back() {
 871     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 872     let mut c = v.rchunks_exact(2);
 873     assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
 874     assert_eq!(c.next_back().unwrap(), &[4, 5]);
 875
 876     let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
 877     let mut c2 = v2.rchunks_exact(3);
 878     assert_eq!(c2.nth_back(1).unwrap(), &[4, 5, 6]);
 879     assert_eq!(c2.next(), None);
 880 }
 881
 882 #[test]
 883 fn test_rchunks_exact_last() {
 884     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 885     let c = v.rchunks_exact(2);
 886     assert_eq!(c.last().unwrap(), &[0, 1]);
 887
 888     let v2: &[i32] = &[0, 1, 2, 3, 4];
 889     let c2 = v2.rchunks_exact(2);
 890     assert_eq!(c2.last().unwrap(), &[1, 2]);
 891 }
 892
 893 #[test]
 894 fn test_rchunks_exact_remainder() {
 895     let v: &[i32] = &[0, 1, 2, 3, 4];
 896     let c = v.rchunks_exact(2);
 897     assert_eq!(c.remainder(), &[0]);
 898 }
 899
 900 #[test]
 901 fn test_rchunks_exact_zip() {
 902     let v1: &[i32] = &[0, 1, 2, 3, 4];
 903     let v2: &[i32] = &[6, 7, 8, 9, 10];
 904
 905     let res = v1
 906         .rchunks_exact(2)
 907         .zip(v2.rchunks_exact(2))
 908         .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
 909         .collect::<Vec<_>>();
 910     assert_eq!(res, vec![26, 18]);
 911 }
 912
 913 #[test]
 914 fn test_rchunks_exact_mut_count() {
 915     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 916     let c = v.rchunks_exact_mut(3);
 917     assert_eq!(c.count(), 2);
 918
 919     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
 920     let c2 = v2.rchunks_exact_mut(2);
 921     assert_eq!(c2.count(), 2);
 922
 923     let v3: &mut [i32] = &mut [];
 924     let c3 = v3.rchunks_exact_mut(2);
 925     assert_eq!(c3.count(), 0);
 926 }
 927
 928 #[test]
 929 fn test_rchunks_exact_mut_nth() {
 930     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 931     let mut c = v.rchunks_exact_mut(2);
 932     assert_eq!(c.nth(1).unwrap(), &[2, 3]);
 933     assert_eq!(c.next().unwrap(), &[0, 1]);
 934
 935     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
 936     let mut c2 = v2.rchunks_exact_mut(3);
 937     assert_eq!(c2.nth(1).unwrap(), &[1, 2, 3]);
 938     assert_eq!(c2.next(), None);
 939 }
 940
 941 #[test]
 942 fn test_rchunks_exact_mut_nth_back() {
 943     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 944     let mut c = v.rchunks_exact_mut(2);
 945     assert_eq!(c.nth_back(1).unwrap(), &[2, 3]);
 946     assert_eq!(c.next_back().unwrap(), &[4, 5]);
 947
 948     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
 949     let mut c2 = v2.rchunks_exact_mut(3);
 950     assert_eq!(c2.nth_back(1).unwrap(), &[4, 5, 6]);
 951     assert_eq!(c2.next(), None);
 952 }
 953
 954 #[test]
 955 fn test_rchunks_exact_mut_last() {
 956     let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
 957     let c = v.rchunks_exact_mut(2);
 958     assert_eq!(c.last().unwrap(), &[0, 1]);
 959
 960     let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
 961     let c2 = v2.rchunks_exact_mut(2);
 962     assert_eq!(c2.last().unwrap(), &[1, 2]);
 963 }
 964
 965 #[test]
 966 fn test_rchunks_exact_mut_remainder() {
 967     let v: &mut [i32] = &mut [0, 1, 2, 3, 4];
 968     let c = v.rchunks_exact_mut(2);
 969     assert_eq!(c.into_remainder(), &[0]);
 970 }
 971
 972 #[test]
 973 fn test_rchunks_exact_mut_zip() {
 974     let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
 975     let v2: &[i32] = &[6, 7, 8, 9, 10];
 976
 977     for (a, b) in v1.rchunks_exact_mut(2).zip(v2.rchunks_exact(2)) {
 978         let sum = b.iter().sum::<i32>();
 979         for v in a {
 980             *v += sum;
 981         }
 982     }
 983     assert_eq!(v1, [0, 16, 17, 22, 23]);
 984 }
 985
 986 #[test]
 987 fn test_windows_count() {
 988     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
 989     let c = v.windows(3);
 990     assert_eq!(c.count(), 4);
 991
 992     let v2: &[i32] = &[0, 1, 2, 3, 4];
 993     let c2 = v2.windows(6);
 994     assert_eq!(c2.count(), 0);
 995
 996     let v3: &[i32] = &[];
 997     let c3 = v3.windows(2);
 998     assert_eq!(c3.count(), 0);
 999 }
1000
1001 #[test]
1002 fn test_windows_nth() {
1003     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1004     let mut c = v.windows(2);
1005     assert_eq!(c.nth(2).unwrap()[1], 3);
1006     assert_eq!(c.next().unwrap()[0], 3);
1007
1008     let v2: &[i32] = &[0, 1, 2, 3, 4];
1009     let mut c2 = v2.windows(4);
1010     assert_eq!(c2.nth(1).unwrap()[1], 2);
1011     assert_eq!(c2.next(), None);
1012 }
1013
1014 #[test]
1015 fn test_windows_nth_back() {
1016     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1017     let mut c = v.windows(2);
1018     assert_eq!(c.nth_back(2).unwrap()[0], 2);
1019     assert_eq!(c.next_back().unwrap()[1], 2);
1020
1021     let v2: &[i32] = &[0, 1, 2, 3, 4];
1022     let mut c2 = v2.windows(4);
1023     assert_eq!(c2.nth_back(1).unwrap()[1], 1);
1024     assert_eq!(c2.next_back(), None);
1025 }
1026
1027 #[test]
1028 fn test_windows_last() {
1029     let v: &[i32] = &[0, 1, 2, 3, 4, 5];
1030     let c = v.windows(2);
1031     assert_eq!(c.last().unwrap()[1], 5);
1032
1033     let v2: &[i32] = &[0, 1, 2, 3, 4];
1034     let c2 = v2.windows(2);
1035     assert_eq!(c2.last().unwrap()[0], 3);
1036 }
1037
1038 #[test]
1039 fn test_windows_zip() {
1040     let v1: &[i32] = &[0, 1, 2, 3, 4];
1041     let v2: &[i32] = &[6, 7, 8, 9, 10];
1042
1043     let res = v1
1044         .windows(2)
1045         .zip(v2.windows(2))
1046         .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
1047         .collect::<Vec<_>>();
1048
1049     assert_eq!(res, [14, 18, 22, 26]);
1050 }
1051
1052 #[test]
1053 #[allow(const_err)]
1054 fn test_iter_ref_consistency() {
1055     use std::fmt::Debug;
1056
1057     fn test<T: Copy + Debug + PartialEq>(x: T) {
1058         let v: &[T] = &[x, x, x];
1059         let v_ptrs: [*const T; 3] = match v {
1060             [ref v1, ref v2, ref v3] => [v1 as *const _, v2 as *const _, v3 as *const _],
1061             _ => unreachable!(),
1062         };
1063         let len = v.len();
1064
1065         // nth(i)
1066         for i in 0..len {
1067             assert_eq!(&v[i] as *const _, v_ptrs[i]); // check the v_ptrs array, just to be sure
1068             let nth = v.iter().nth(i).unwrap();
1069             assert_eq!(nth as *const _, v_ptrs[i]);
1070         }
1071         assert_eq!(v.iter().nth(len), None, "nth(len) should return None");
1072
1073         // stepping through with nth(0)
1074         {
1075             let mut it = v.iter();
1076             for i in 0..len {
1077                 let next = it.nth(0).unwrap();
1078                 assert_eq!(next as *const _, v_ptrs[i]);
1079             }
1080             assert_eq!(it.nth(0), None);
1081         }
1082
1083         // next()
1084         {
1085             let mut it = v.iter();
1086             for i in 0..len {
1087                 let remaining = len - i;
1088                 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1089
1090                 let next = it.next().unwrap();
1091                 assert_eq!(next as *const _, v_ptrs[i]);
1092             }
1093             assert_eq!(it.size_hint(), (0, Some(0)));
1094             assert_eq!(it.next(), None, "The final call to next() should return None");
1095         }
1096
1097         // next_back()
1098         {
1099             let mut it = v.iter();
1100             for i in 0..len {
1101                 let remaining = len - i;
1102                 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1103
1104                 let prev = it.next_back().unwrap();
1105                 assert_eq!(prev as *const _, v_ptrs[remaining - 1]);
1106             }
1107             assert_eq!(it.size_hint(), (0, Some(0)));
1108             assert_eq!(it.next_back(), None, "The final call to next_back() should return None");
1109         }
1110     }
1111
1112     fn test_mut<T: Copy + Debug + PartialEq>(x: T) {
1113         let v: &mut [T] = &mut [x, x, x];
1114         let v_ptrs: [*mut T; 3] = match v {
1115             [ref v1, ref v2, ref v3] => {
1116                 [v1 as *const _ as *mut _, v2 as *const _ as *mut _, v3 as *const _ as *mut _]
1117             }
1118             _ => unreachable!(),
1119         };
1120         let len = v.len();
1121
1122         // nth(i)
1123         for i in 0..len {
1124             assert_eq!(&mut v[i] as *mut _, v_ptrs[i]); // check the v_ptrs array, just to be sure
1125             let nth = v.iter_mut().nth(i).unwrap();
1126             assert_eq!(nth as *mut _, v_ptrs[i]);
1127         }
1128         assert_eq!(v.iter().nth(len), None, "nth(len) should return None");
1129
1130         // stepping through with nth(0)
1131         {
1132             let mut it = v.iter();
1133             for i in 0..len {
1134                 let next = it.nth(0).unwrap();
1135                 assert_eq!(next as *const _, v_ptrs[i]);
1136             }
1137             assert_eq!(it.nth(0), None);
1138         }
1139
1140         // next()
1141         {
1142             let mut it = v.iter_mut();
1143             for i in 0..len {
1144                 let remaining = len - i;
1145                 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1146
1147                 let next = it.next().unwrap();
1148                 assert_eq!(next as *mut _, v_ptrs[i]);
1149             }
1150             assert_eq!(it.size_hint(), (0, Some(0)));
1151             assert_eq!(it.next(), None, "The final call to next() should return None");
1152         }
1153
1154         // next_back()
1155         {
1156             let mut it = v.iter_mut();
1157             for i in 0..len {
1158                 let remaining = len - i;
1159                 assert_eq!(it.size_hint(), (remaining, Some(remaining)));
1160
1161                 let prev = it.next_back().unwrap();
1162                 assert_eq!(prev as *mut _, v_ptrs[remaining - 1]);
1163             }
1164             assert_eq!(it.size_hint(), (0, Some(0)));
1165             assert_eq!(it.next_back(), None, "The final call to next_back() should return None");
1166         }
1167     }
1168
1169     // Make sure iterators and slice patterns yield consistent addresses for various types,
1170     // including ZSTs.
1171     test(0u32);
1172     test(());
1173     test([0u32; 0]); // ZST with alignment > 0
1174     test_mut(0u32);
1175     test_mut(());
1176     test_mut([0u32; 0]); // ZST with alignment > 0
1177 }
1178
1179 // The current implementation of SliceIndex fails to handle methods
1180 // orthogonally from range types; therefore, it is worth testing
1181 // all of the indexing operations on each input.
1182 mod slice_index {
1183     // This checks all six indexing methods, given an input range that
1184     // should succeed. (it is NOT suitable for testing invalid inputs)
1185     macro_rules! assert_range_eq {
1186         ($arr:expr, $range:expr, $expected:expr) => {
1187             let mut arr = $arr;
1188             let mut expected = $expected;
1189             {
1190                 let s: &[_] = &arr;
1191                 let expected: &[_] = &expected;
1192
1193                 assert_eq!(&s[$range], expected, "(in assertion for: index)");
1194                 assert_eq!(s.get($range), Some(expected), "(in assertion for: get)");
1195                 unsafe {
1196                     assert_eq!(
1197                         s.get_unchecked($range),
1198                         expected,
1199                         "(in assertion for: get_unchecked)",
1200                     );
1201                 }
1202             }
1203             {
1204                 let s: &mut [_] = &mut arr;
1205                 let expected: &mut [_] = &mut expected;
1206
1207                 assert_eq!(&mut s[$range], expected, "(in assertion for: index_mut)",);
1208                 assert_eq!(
1209                     s.get_mut($range),
1210                     Some(&mut expected[..]),
1211                     "(in assertion for: get_mut)",
1212                 );
1213                 unsafe {
1214                     assert_eq!(
1215                         s.get_unchecked_mut($range),
1216                         expected,
1217                         "(in assertion for: get_unchecked_mut)",
1218                     );
1219                 }
1220             }
1221         };
1222     }
1223
1224     // Make sure the macro can actually detect bugs,
1225     // because if it can't, then what are we even doing here?
1226     //
1227     // (Be aware this only demonstrates the ability to detect bugs
1228     //  in the FIRST method that panics, as the macro is not designed
1229     //  to be used in `should_panic`)
1230     #[test]
1231     #[should_panic(expected = "out of range")]
1232     fn assert_range_eq_can_fail_by_panic() {
1233         assert_range_eq!([0, 1, 2], 0..5, [0, 1, 2]);
1234     }
1235
1236     // (Be aware this only demonstrates the ability to detect bugs
1237     //  in the FIRST method it calls, as the macro is not designed
1238     //  to be used in `should_panic`)
1239     #[test]
1240     #[should_panic(expected = "==")]
1241     fn assert_range_eq_can_fail_by_inequality() {
1242         assert_range_eq!([0, 1, 2], 0..2, [0, 1, 2]);
1243     }
1244
1245     // Test cases for bad index operations.
1246     //
1247     // This generates `should_panic` test cases for Index/IndexMut
1248     // and `None` test cases for get/get_mut.
1249     macro_rules! panic_cases {
1250         ($(
1251             // each test case needs a unique name to namespace the tests
1252             in mod $case_name:ident {
1253                 data: $data:expr;
1254
1255                 // optional:
1256                 //
1257                 // one or more similar inputs for which data[input] succeeds,
1258                 // and the corresponding output as an array.  This helps validate
1259                 // "critical points" where an input range straddles the boundary
1260                 // between valid and invalid.
1261                 // (such as the input `len..len`, which is just barely valid)
1262                 $(
1263                     good: data[$good:expr] == $output:expr;
1264                 )*
1265
1266                 bad: data[$bad:expr];
1267                 message: $expect_msg:expr;
1268             }
1269         )*) => {$(
1270             mod $case_name {
1271                 #[test]
1272                 fn pass() {
1273                     let mut v = $data;
1274
1275                     $( assert_range_eq!($data, $good, $output); )*
1276
1277                     {
1278                         let v: &[_] = &v;
1279                         assert_eq!(v.get($bad), None, "(in None assertion for get)");
1280                     }
1281
1282                     {
1283                         let v: &mut [_] = &mut v;
1284                         assert_eq!(v.get_mut($bad), None, "(in None assertion for get_mut)");
1285                     }
1286                 }
1287
1288                 #[test]
1289                 #[should_panic(expected = $expect_msg)]
1290                 fn index_fail() {
1291                     let v = $data;
1292                     let v: &[_] = &v;
1293                     let _v = &v[$bad];
1294                 }
1295
1296                 #[test]
1297                 #[should_panic(expected = $expect_msg)]
1298                 fn index_mut_fail() {
1299                     let mut v = $data;
1300                     let v: &mut [_] = &mut v;
1301                     let _v = &mut v[$bad];
1302                 }
1303             }
1304         )*};
1305     }
1306
1307     #[test]
1308     fn simple() {
1309         let v = [0, 1, 2, 3, 4, 5];
1310
1311         assert_range_eq!(v, .., [0, 1, 2, 3, 4, 5]);
1312         assert_range_eq!(v, ..2, [0, 1]);
1313         assert_range_eq!(v, ..=1, [0, 1]);
1314         assert_range_eq!(v, 2.., [2, 3, 4, 5]);
1315         assert_range_eq!(v, 1..4, [1, 2, 3]);
1316         assert_range_eq!(v, 1..=3, [1, 2, 3]);
1317     }
1318
1319     panic_cases! {
1320         in mod rangefrom_len {
1321             data: [0, 1, 2, 3, 4, 5];
1322
1323             good: data[6..] == [];
1324             bad: data[7..];
1325             message: "out of range";
1326         }
1327
1328         in mod rangeto_len {
1329             data: [0, 1, 2, 3, 4, 5];
1330
1331             good: data[..6] == [0, 1, 2, 3, 4, 5];
1332             bad: data[..7];
1333             message: "out of range";
1334         }
1335
1336         in mod rangetoinclusive_len {
1337             data: [0, 1, 2, 3, 4, 5];
1338
1339             good: data[..=5] == [0, 1, 2, 3, 4, 5];
1340             bad: data[..=6];
1341             message: "out of range";
1342         }
1343
1344         in mod rangeinclusive_len {
1345             data: [0, 1, 2, 3, 4, 5];
1346
1347             good: data[0..=5] == [0, 1, 2, 3, 4, 5];
1348             bad: data[0..=6];
1349             message: "out of range";
1350         }
1351
1352         in mod range_len_len {
1353             data: [0, 1, 2, 3, 4, 5];
1354
1355             good: data[6..6] == [];
1356             bad: data[7..7];
1357             message: "out of range";
1358         }
1359
1360         in mod rangeinclusive_len_len {
1361             data: [0, 1, 2, 3, 4, 5];
1362
1363             good: data[6..=5] == [];
1364             bad: data[7..=6];
1365             message: "out of range";
1366         }
1367     }
1368
1369     panic_cases! {
1370         in mod rangeinclusive_exhausted {
1371             data: [0, 1, 2, 3, 4, 5];
1372
1373             good: data[0..=5] == [0, 1, 2, 3, 4, 5];
1374             good: data[{
1375                 let mut iter = 0..=5;
1376                 iter.by_ref().count(); // exhaust it
1377                 iter
1378             }] == [];
1379
1380             // 0..=6 is out of range before exhaustion, so it
1381             // stands to reason that it still would be after.
1382             bad: data[{
1383                 let mut iter = 0..=6;
1384                 iter.by_ref().count(); // exhaust it
1385                 iter
1386             }];
1387             message: "out of range";
1388         }
1389     }
1390
1391     panic_cases! {
1392         in mod range_neg_width {
1393             data: [0, 1, 2, 3, 4, 5];
1394
1395             good: data[4..4] == [];
1396             bad: data[4..3];
1397             message: "but ends at";
1398         }
1399
1400         in mod rangeinclusive_neg_width {
1401             data: [0, 1, 2, 3, 4, 5];
1402
1403             good: data[4..=3] == [];
1404             bad: data[4..=2];
1405             message: "but ends at";
1406         }
1407     }
1408
1409     panic_cases! {
1410         in mod rangeinclusive_overflow {
1411             data: [0, 1];
1412
1413             // note: using 0 specifically ensures that the result of overflowing is 0..0,
1414             //       so that `get` doesn't simply return None for the wrong reason.
1415             bad: data[0 ..= usize::MAX];
1416             message: "maximum usize";
1417         }
1418
1419         in mod rangetoinclusive_overflow {
1420             data: [0, 1];
1421
1422             bad: data[..= usize::MAX];
1423             message: "maximum usize";
1424         }
1425     } // panic_cases!
1426 }
1427
1428 #[test]
1429 fn test_find_rfind() {
1430     let v = [0, 1, 2, 3, 4, 5];
1431     let mut iter = v.iter();
1432     let mut i = v.len();
1433     while let Some(&elt) = iter.rfind(|_| true) {
1434         i -= 1;
1435         assert_eq!(elt, v[i]);
1436     }
1437     assert_eq!(i, 0);
1438     assert_eq!(v.iter().rfind(|&&x| x <= 3), Some(&3));
1439 }
1440
1441 #[test]
1442 fn test_iter_folds() {
1443     let a = [1, 2, 3, 4, 5]; // len>4 so the unroll is used
1444     assert_eq!(a.iter().fold(0, |acc, &x| 2 * acc + x), 57);
1445     assert_eq!(a.iter().rfold(0, |acc, &x| 2 * acc + x), 129);
1446     let fold = |acc: i32, &x| acc.checked_mul(2)?.checked_add(x);
1447     assert_eq!(a.iter().try_fold(0, &fold), Some(57));
1448     assert_eq!(a.iter().try_rfold(0, &fold), Some(129));
1449
1450     // short-circuiting try_fold, through other methods
1451     let a = [0, 1, 2, 3, 5, 5, 5, 7, 8, 9];
1452     let mut iter = a.iter();
1453     assert_eq!(iter.position(|&x| x == 3), Some(3));
1454     assert_eq!(iter.rfind(|&&x| x == 5), Some(&5));
1455     assert_eq!(iter.len(), 2);
1456 }
1457
1458 #[test]
1459 fn test_rotate_left() {
1460     const N: usize = 600;
1461     let a: &mut [_] = &mut [0; N];
1462     for i in 0..N {
1463         a[i] = i;
1464     }
1465
1466     a.rotate_left(42);
1467     let k = N - 42;
1468
1469     for i in 0..N {
1470         assert_eq!(a[(i + k) % N], i);
1471     }
1472 }
1473
1474 #[test]
1475 fn test_rotate_right() {
1476     const N: usize = 600;
1477     let a: &mut [_] = &mut [0; N];
1478     for i in 0..N {
1479         a[i] = i;
1480     }
1481
1482     a.rotate_right(42);
1483
1484     for i in 0..N {
1485         assert_eq!(a[(i + 42) % N], i);
1486     }
1487 }
1488
1489 #[test]
1490 #[cfg_attr(miri, ignore)] // Miri is too slow
1491 fn brute_force_rotate_test_0() {
1492     // In case of edge cases involving multiple algorithms
1493     let n = 300;
1494     for len in 0..n {
1495         for s in 0..len {
1496             let mut v = Vec::with_capacity(len);
1497             for i in 0..len {
1498                 v.push(i);
1499             }
1500             v[..].rotate_right(s);
1501             for i in 0..v.len() {
1502                 assert_eq!(v[i], v.len().wrapping_add(i.wrapping_sub(s)) % v.len());
1503             }
1504         }
1505     }
1506 }
1507
1508 #[test]
1509 fn brute_force_rotate_test_1() {
1510     // `ptr_rotate` covers so many kinds of pointer usage, that this is just a good test for
1511     // pointers in general. This uses a `[usize; 4]` to hit all algorithms without overwhelming miri
1512     let n = 30;
1513     for len in 0..n {
1514         for s in 0..len {
1515             let mut v: Vec<[usize; 4]> = Vec::with_capacity(len);
1516             for i in 0..len {
1517                 v.push([i, 0, 0, 0]);
1518             }
1519             v[..].rotate_right(s);
1520             for i in 0..v.len() {
1521                 assert_eq!(v[i][0], v.len().wrapping_add(i.wrapping_sub(s)) % v.len());
1522             }
1523         }
1524     }
1525 }
1526
1527 #[test]
1528 #[cfg(not(target_arch = "wasm32"))]
1529 fn sort_unstable() {
1530     use core::cmp::Ordering::{Equal, Greater, Less};
1531     use core::slice::heapsort;
1532     use rand::{rngs::StdRng, seq::SliceRandom, Rng, SeedableRng};
1533
1534     // Miri is too slow (but still need to `chain` to make the types match)
1535     let lens = if cfg!(miri) { (2..20).chain(0..0) } else { (2..25).chain(500..510) };
1536     let rounds = if cfg!(miri) { 1 } else { 100 };
1537
1538     let mut v = [0; 600];
1539     let mut tmp = [0; 600];
1540     let mut rng = StdRng::from_entropy();
1541
1542     for len in lens {
1543         let v = &mut v[0..len];
1544         let tmp = &mut tmp[0..len];
1545
1546         for &modulus in &[5, 10, 100, 1000] {
1547             for _ in 0..rounds {
1548                 for i in 0..len {
1549                     v[i] = rng.gen::<i32>() % modulus;
1550                 }
1551
1552                 // Sort in default order.
1553                 tmp.copy_from_slice(v);
1554                 tmp.sort_unstable();
1555                 assert!(tmp.windows(2).all(|w| w[0] <= w[1]));
1556
1557                 // Sort in ascending order.
1558                 tmp.copy_from_slice(v);
1559                 tmp.sort_unstable_by(|a, b| a.cmp(b));
1560                 assert!(tmp.windows(2).all(|w| w[0] <= w[1]));
1561
1562                 // Sort in descending order.
1563                 tmp.copy_from_slice(v);
1564                 tmp.sort_unstable_by(|a, b| b.cmp(a));
1565                 assert!(tmp.windows(2).all(|w| w[0] >= w[1]));
1566
1567                 // Test heapsort using `<` operator.
1568                 tmp.copy_from_slice(v);
1569                 heapsort(tmp, |a, b| a < b);
1570                 assert!(tmp.windows(2).all(|w| w[0] <= w[1]));
1571
1572                 // Test heapsort using `>` operator.
1573                 tmp.copy_from_slice(v);
1574                 heapsort(tmp, |a, b| a > b);
1575                 assert!(tmp.windows(2).all(|w| w[0] >= w[1]));
1576             }
1577         }
1578     }
1579
1580     // Sort using a completely random comparison function.
1581     // This will reorder the elements *somehow*, but won't panic.
1582     for i in 0..v.len() {
1583         v[i] = i as i32;
1584     }
1585     v.sort_unstable_by(|_, _| *[Less, Equal, Greater].choose(&mut rng).unwrap());
1586     v.sort_unstable();
1587     for i in 0..v.len() {
1588         assert_eq!(v[i], i as i32);
1589     }
1590
1591     // Should not panic.
1592     [0i32; 0].sort_unstable();
1593     [(); 10].sort_unstable();
1594     [(); 100].sort_unstable();
1595
1596     let mut v = [0xDEADBEEFu64];
1597     v.sort_unstable();
1598     assert!(v == [0xDEADBEEF]);
1599 }
1600
1601 #[test]
1602 #[cfg(not(target_arch = "wasm32"))]
1603 #[cfg_attr(miri, ignore)] // Miri is too slow
1604 fn select_nth_unstable() {
1605     use core::cmp::Ordering::{Equal, Greater, Less};
1606     use rand::rngs::StdRng;
1607     use rand::seq::SliceRandom;
1608     use rand::{Rng, SeedableRng};
1609
1610     let mut rng = StdRng::from_entropy();
1611
1612     for len in (2..21).chain(500..501) {
1613         let mut orig = vec![0; len];
1614
1615         for &modulus in &[5, 10, 1000] {
1616             for _ in 0..10 {
1617                 for i in 0..len {
1618                     orig[i] = rng.gen::<i32>() % modulus;
1619                 }
1620
1621                 let v_sorted = {
1622                     let mut v = orig.clone();
1623                     v.sort();
1624                     v
1625                 };
1626
1627                 // Sort in default order.
1628                 for pivot in 0..len {
1629                     let mut v = orig.clone();
1630                     v.select_nth_unstable(pivot);
1631
1632                     assert_eq!(v_sorted[pivot], v[pivot]);
1633                     for i in 0..pivot {
1634                         for j in pivot..len {
1635                             assert!(v[i] <= v[j]);
1636                         }
1637                     }
1638                 }
1639
1640                 // Sort in ascending order.
1641                 for pivot in 0..len {
1642                     let mut v = orig.clone();
1643                     let (left, pivot, right) = v.select_nth_unstable_by(pivot, |a, b| a.cmp(b));
1644
1645                     assert_eq!(left.len() + right.len(), len - 1);
1646
1647                     for l in left {
1648                         assert!(l <= pivot);
1649                         for r in right.iter_mut() {
1650                             assert!(l <= r);
1651                             assert!(pivot <= r);
1652                         }
1653                     }
1654                 }
1655
1656                 // Sort in descending order.
1657                 let sort_descending_comparator = |a: &i32, b: &i32| b.cmp(a);
1658                 let v_sorted_descending = {
1659                     let mut v = orig.clone();
1660                     v.sort_by(sort_descending_comparator);
1661                     v
1662                 };
1663
1664                 for pivot in 0..len {
1665                     let mut v = orig.clone();
1666                     v.select_nth_unstable_by(pivot, sort_descending_comparator);
1667
1668                     assert_eq!(v_sorted_descending[pivot], v[pivot]);
1669                     for i in 0..pivot {
1670                         for j in pivot..len {
1671                             assert!(v[j] <= v[i]);
1672                         }
1673                     }
1674                 }
1675             }
1676         }
1677     }
1678
1679     // Sort at index using a completely random comparison function.
1680     // This will reorder the elements *somehow*, but won't panic.
1681     let mut v = [0; 500];
1682     for i in 0..v.len() {
1683         v[i] = i as i32;
1684     }
1685
1686     for pivot in 0..v.len() {
1687         v.select_nth_unstable_by(pivot, |_, _| *[Less, Equal, Greater].choose(&mut rng).unwrap());
1688         v.sort();
1689         for i in 0..v.len() {
1690             assert_eq!(v[i], i as i32);
1691         }
1692     }
1693
1694     // Should not panic.
1695     [(); 10].select_nth_unstable(0);
1696     [(); 10].select_nth_unstable(5);
1697     [(); 10].select_nth_unstable(9);
1698     [(); 100].select_nth_unstable(0);
1699     [(); 100].select_nth_unstable(50);
1700     [(); 100].select_nth_unstable(99);
1701
1702     let mut v = [0xDEADBEEFu64];
1703     v.select_nth_unstable(0);
1704     assert!(v == [0xDEADBEEF]);
1705 }
1706
1707 #[test]
1708 #[should_panic(expected = "index 0 greater than length of slice")]
1709 fn select_nth_unstable_zero_length() {
1710     [0i32; 0].select_nth_unstable(0);
1711 }
1712
1713 #[test]
1714 #[should_panic(expected = "index 20 greater than length of slice")]
1715 fn select_nth_unstable_past_length() {
1716     [0i32; 10].select_nth_unstable(20);
1717 }
1718
1719 pub mod memchr {
1720     use core::slice::memchr::{memchr, memrchr};
1721
1722     // test fallback implementations on all platforms
1723     #[test]
1724     fn matches_one() {
1725         assert_eq!(Some(0), memchr(b'a', b"a"));
1726     }
1727
1728     #[test]
1729     fn matches_begin() {
1730         assert_eq!(Some(0), memchr(b'a', b"aaaa"));
1731     }
1732
1733     #[test]
1734     fn matches_end() {
1735         assert_eq!(Some(4), memchr(b'z', b"aaaaz"));
1736     }
1737
1738     #[test]
1739     fn matches_nul() {
1740         assert_eq!(Some(4), memchr(b'\x00', b"aaaa\x00"));
1741     }
1742
1743     #[test]
1744     fn matches_past_nul() {
1745         assert_eq!(Some(5), memchr(b'z', b"aaaa\x00z"));
1746     }
1747
1748     #[test]
1749     fn no_match_empty() {
1750         assert_eq!(None, memchr(b'a', b""));
1751     }
1752
1753     #[test]
1754     fn no_match() {
1755         assert_eq!(None, memchr(b'a', b"xyz"));
1756     }
1757
1758     #[test]
1759     fn matches_one_reversed() {
1760         assert_eq!(Some(0), memrchr(b'a', b"a"));
1761     }
1762
1763     #[test]
1764     fn matches_begin_reversed() {
1765         assert_eq!(Some(3), memrchr(b'a', b"aaaa"));
1766     }
1767
1768     #[test]
1769     fn matches_end_reversed() {
1770         assert_eq!(Some(0), memrchr(b'z', b"zaaaa"));
1771     }
1772
1773     #[test]
1774     fn matches_nul_reversed() {
1775         assert_eq!(Some(4), memrchr(b'\x00', b"aaaa\x00"));
1776     }
1777
1778     #[test]
1779     fn matches_past_nul_reversed() {
1780         assert_eq!(Some(0), memrchr(b'z', b"z\x00aaaa"));
1781     }
1782
1783     #[test]
1784     fn no_match_empty_reversed() {
1785         assert_eq!(None, memrchr(b'a', b""));
1786     }
1787
1788     #[test]
1789     fn no_match_reversed() {
1790         assert_eq!(None, memrchr(b'a', b"xyz"));
1791     }
1792
1793     #[test]
1794     fn each_alignment_reversed() {
1795         let mut data = [1u8; 64];
1796         let needle = 2;
1797         let pos = 40;
1798         data[pos] = needle;
1799         for start in 0..16 {
1800             assert_eq!(Some(pos - start), memrchr(needle, &data[start..]));
1801         }
1802     }
1803 }
1804
1805 #[test]
1806 fn test_align_to_simple() {
1807     let bytes = [1u8, 2, 3, 4, 5, 6, 7];
1808     let (prefix, aligned, suffix) = unsafe { bytes.align_to::<u16>() };
1809     assert_eq!(aligned.len(), 3);
1810     assert!(prefix == [1] || suffix == [7]);
1811     let expect1 = [1 << 8 | 2, 3 << 8 | 4, 5 << 8 | 6];
1812     let expect2 = [1 | 2 << 8, 3 | 4 << 8, 5 | 6 << 8];
1813     let expect3 = [2 << 8 | 3, 4 << 8 | 5, 6 << 8 | 7];
1814     let expect4 = [2 | 3 << 8, 4 | 5 << 8, 6 | 7 << 8];
1815     assert!(
1816         aligned == expect1 || aligned == expect2 || aligned == expect3 || aligned == expect4,
1817         "aligned={:?} expected={:?} || {:?} || {:?} || {:?}",
1818         aligned,
1819         expect1,
1820         expect2,
1821         expect3,
1822         expect4
1823     );
1824 }
1825
1826 #[test]
1827 fn test_align_to_zst() {
1828     let bytes = [1, 2, 3, 4, 5, 6, 7];
1829     let (prefix, aligned, suffix) = unsafe { bytes.align_to::<()>() };
1830     assert_eq!(aligned.len(), 0);
1831     assert!(prefix == [1, 2, 3, 4, 5, 6, 7] || suffix == [1, 2, 3, 4, 5, 6, 7]);
1832 }
1833
1834 #[test]
1835 fn test_align_to_non_trivial() {
1836     #[repr(align(8))]
1837     struct U64(u64, u64);
1838     #[repr(align(8))]
1839     struct U64U64U32(u64, u64, u32);
1840     let data = [
1841         U64(1, 2),
1842         U64(3, 4),
1843         U64(5, 6),
1844         U64(7, 8),
1845         U64(9, 10),
1846         U64(11, 12),
1847         U64(13, 14),
1848         U64(15, 16),
1849     ];
1850     let (prefix, aligned, suffix) = unsafe { data.align_to::<U64U64U32>() };
1851     assert_eq!(aligned.len(), 4);
1852     assert_eq!(prefix.len() + suffix.len(), 2);
1853 }
1854
1855 #[test]
1856 fn test_align_to_empty_mid() {
1857     use core::mem;
1858
1859     // Make sure that we do not create empty unaligned slices for the mid part, even when the
1860     // overall slice is too short to contain an aligned address.
1861     let bytes = [1, 2, 3, 4, 5, 6, 7];
1862     type Chunk = u32;
1863     for offset in 0..4 {
1864         let (_, mid, _) = unsafe { bytes[offset..offset + 1].align_to::<Chunk>() };
1865         assert_eq!(mid.as_ptr() as usize % mem::align_of::<Chunk>(), 0);
1866     }
1867 }
1868
1869 #[test]
1870 fn test_align_to_mut_aliasing() {
1871     let mut val = [1u8, 2, 3, 4, 5];
1872     // `align_to_mut` used to create `mid` in a way that there was some intermediate
1873     // incorrect aliasing, invalidating the resulting `mid` slice.
1874     let (begin, mid, end) = unsafe { val.align_to_mut::<[u8; 2]>() };
1875     assert!(begin.len() == 0);
1876     assert!(end.len() == 1);
1877     mid[0] = mid[1];
1878     assert_eq!(val, [3, 4, 3, 4, 5])
1879 }
1880
1881 #[test]
1882 fn test_slice_partition_dedup_by() {
1883     let mut slice: [i32; 9] = [1, -1, 2, 3, 1, -5, 5, -2, 2];
1884
1885     let (dedup, duplicates) = slice.partition_dedup_by(|a, b| a.abs() == b.abs());
1886
1887     assert_eq!(dedup, [1, 2, 3, 1, -5, -2]);
1888     assert_eq!(duplicates, [5, -1, 2]);
1889 }
1890
1891 #[test]
1892 fn test_slice_partition_dedup_empty() {
1893     let mut slice: [i32; 0] = [];
1894
1895     let (dedup, duplicates) = slice.partition_dedup();
1896
1897     assert_eq!(dedup, []);
1898     assert_eq!(duplicates, []);
1899 }
1900
1901 #[test]
1902 fn test_slice_partition_dedup_one() {
1903     let mut slice = [12];
1904
1905     let (dedup, duplicates) = slice.partition_dedup();
1906
1907     assert_eq!(dedup, [12]);
1908     assert_eq!(duplicates, []);
1909 }
1910
1911 #[test]
1912 fn test_slice_partition_dedup_multiple_ident() {
1913     let mut slice = [12, 12, 12, 12, 12, 11, 11, 11, 11, 11, 11];
1914
1915     let (dedup, duplicates) = slice.partition_dedup();
1916
1917     assert_eq!(dedup, [12, 11]);
1918     assert_eq!(duplicates, [12, 12, 12, 12, 11, 11, 11, 11, 11]);
1919 }
1920
1921 #[test]
1922 fn test_slice_partition_dedup_partialeq() {
1923     #[derive(Debug)]
1924     struct Foo(i32, i32);
1925
1926     impl PartialEq for Foo {
1927         fn eq(&self, other: &Foo) -> bool {
1928             self.0 == other.0
1929         }
1930     }
1931
1932     let mut slice = [Foo(0, 1), Foo(0, 5), Foo(1, 7), Foo(1, 9)];
1933
1934     let (dedup, duplicates) = slice.partition_dedup();
1935
1936     assert_eq!(dedup, [Foo(0, 1), Foo(1, 7)]);
1937     assert_eq!(duplicates, [Foo(0, 5), Foo(1, 9)]);
1938 }
1939
1940 #[test]
1941 fn test_copy_within() {
1942     // Start to end, with a RangeTo.
1943     let mut bytes = *b"Hello, World!";
1944     bytes.copy_within(..3, 10);
1945     assert_eq!(&bytes, b"Hello, WorHel");
1946
1947     // End to start, with a RangeFrom.
1948     let mut bytes = *b"Hello, World!";
1949     bytes.copy_within(10.., 0);
1950     assert_eq!(&bytes, b"ld!lo, World!");
1951
1952     // Overlapping, with a RangeInclusive.
1953     let mut bytes = *b"Hello, World!";
1954     bytes.copy_within(0..=11, 1);
1955     assert_eq!(&bytes, b"HHello, World");
1956
1957     // Whole slice, with a RangeFull.
1958     let mut bytes = *b"Hello, World!";
1959     bytes.copy_within(.., 0);
1960     assert_eq!(&bytes, b"Hello, World!");
1961
1962     // Ensure that copying at the end of slice won't cause UB.
1963     let mut bytes = *b"Hello, World!";
1964     bytes.copy_within(13..13, 5);
1965     assert_eq!(&bytes, b"Hello, World!");
1966     bytes.copy_within(5..5, 13);
1967     assert_eq!(&bytes, b"Hello, World!");
1968 }
1969
1970 #[test]
1971 #[should_panic(expected = "range end index 14 out of range for slice of length 13")]
1972 fn test_copy_within_panics_src_too_long() {
1973     let mut bytes = *b"Hello, World!";
1974     // The length is only 13, so 14 is out of bounds.
1975     bytes.copy_within(10..14, 0);
1976 }
1977
1978 #[test]
1979 #[should_panic(expected = "dest is out of bounds")]
1980 fn test_copy_within_panics_dest_too_long() {
1981     let mut bytes = *b"Hello, World!";
1982     // The length is only 13, so a slice of length 4 starting at index 10 is out of bounds.
1983     bytes.copy_within(0..4, 10);
1984 }
1985 #[test]
1986 #[should_panic(expected = "slice index starts at 2 but ends at 1")]
1987 fn test_copy_within_panics_src_inverted() {
1988     let mut bytes = *b"Hello, World!";
1989     // 2 is greater than 1, so this range is invalid.
1990     bytes.copy_within(2..1, 0);
1991 }
1992 #[test]
1993 #[should_panic(expected = "attempted to index slice up to maximum usize")]
1994 fn test_copy_within_panics_src_out_of_bounds() {
1995     let mut bytes = *b"Hello, World!";
1996     // an inclusive range ending at usize::MAX would make src_end overflow
1997     bytes.copy_within(usize::MAX..=usize::MAX, 0);
1998 }
1999
2000 #[test]
2001 fn test_is_sorted() {
2002     let empty: [i32; 0] = [];
2003
2004     assert!([1, 2, 2, 9].is_sorted());
2005     assert!(![1, 3, 2].is_sorted());
2006     assert!([0].is_sorted());
2007     assert!(empty.is_sorted());
2008     assert!(![0.0, 1.0, f32::NAN].is_sorted());
2009     assert!([-2, -1, 0, 3].is_sorted());
2010     assert!(![-2i32, -1, 0, 3].is_sorted_by_key(|n| n.abs()));
2011     assert!(!["c", "bb", "aaa"].is_sorted());
2012     assert!(["c", "bb", "aaa"].is_sorted_by_key(|s| s.len()));
2013 }
2014
2015 #[test]
2016 fn test_slice_run_destructors() {
2017     // Make sure that destructors get run on slice literals
2018     struct Foo<'a> {
2019         x: &'a Cell<isize>,
2020     }
2021
2022     impl<'a> Drop for Foo<'a> {
2023         fn drop(&mut self) {
2024             self.x.set(self.x.get() + 1);
2025         }
2026     }
2027
2028     fn foo(x: &Cell<isize>) -> Foo<'_> {
2029         Foo { x }
2030     }
2031
2032     let x = &Cell::new(0);
2033
2034     {
2035         let l = &[foo(x)];
2036         assert_eq!(l[0].x.get(), 0);
2037     }
2038
2039     assert_eq!(x.get(), 1);
2040 }