library/core/tests/slice.rs

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