src/liballoc/tests/vec.rs

   1 use std::borrow::Cow;
   2 use std::collections::TryReserveError::*;
   3 use std::mem::size_of;
   4 use std::vec::{Drain, IntoIter};
   5 use std::{isize, usize};
   6
   7 struct DropCounter<'a> {
   8     count: &'a mut u32,
   9 }
  10
  11 impl Drop for DropCounter<'_> {
  12     fn drop(&mut self) {
  13         *self.count += 1;
  14     }
  15 }
  16
  17 #[test]
  18 fn test_small_vec_struct() {
  19     assert!(size_of::<Vec<u8>>() == size_of::<usize>() * 3);
  20 }
  21
  22 #[test]
  23 fn test_double_drop() {
  24     struct TwoVec<T> {
  25         x: Vec<T>,
  26         y: Vec<T>,
  27     }
  28
  29     let (mut count_x, mut count_y) = (0, 0);
  30     {
  31         let mut tv = TwoVec { x: Vec::new(), y: Vec::new() };
  32         tv.x.push(DropCounter { count: &mut count_x });
  33         tv.y.push(DropCounter { count: &mut count_y });
  34
  35         // If Vec had a drop flag, here is where it would be zeroed.
  36         // Instead, it should rely on its internal state to prevent
  37         // doing anything significant when dropped multiple times.
  38         drop(tv.x);
  39
  40         // Here tv goes out of scope, tv.y should be dropped, but not tv.x.
  41     }
  42
  43     assert_eq!(count_x, 1);
  44     assert_eq!(count_y, 1);
  45 }
  46
  47 #[test]
  48 fn test_reserve() {
  49     let mut v = Vec::new();
  50     assert_eq!(v.capacity(), 0);
  51
  52     v.reserve(2);
  53     assert!(v.capacity() >= 2);
  54
  55     for i in 0..16 {
  56         v.push(i);
  57     }
  58
  59     assert!(v.capacity() >= 16);
  60     v.reserve(16);
  61     assert!(v.capacity() >= 32);
  62
  63     v.push(16);
  64
  65     v.reserve(16);
  66     assert!(v.capacity() >= 33)
  67 }
  68
  69 #[test]
  70 fn test_zst_capacity() {
  71     assert_eq!(Vec::<()>::new().capacity(), usize::max_value());
  72 }
  73
  74 #[test]
  75 fn test_extend() {
  76     let mut v = Vec::new();
  77     let mut w = Vec::new();
  78
  79     v.extend(w.clone());
  80     assert_eq!(v, &[]);
  81
  82     v.extend(0..3);
  83     for i in 0..3 {
  84         w.push(i)
  85     }
  86
  87     assert_eq!(v, w);
  88
  89     v.extend(3..10);
  90     for i in 3..10 {
  91         w.push(i)
  92     }
  93
  94     assert_eq!(v, w);
  95
  96     v.extend(w.clone()); // specializes to `append`
  97     assert!(v.iter().eq(w.iter().chain(w.iter())));
  98
  99     // Zero sized types
 100     #[derive(PartialEq, Debug)]
 101     struct Foo;
 102
 103     let mut a = Vec::new();
 104     let b = vec![Foo, Foo];
 105
 106     a.extend(b);
 107     assert_eq!(a, &[Foo, Foo]);
 108
 109     // Double drop
 110     let mut count_x = 0;
 111     {
 112         let mut x = Vec::new();
 113         let y = vec![DropCounter { count: &mut count_x }];
 114         x.extend(y);
 115     }
 116     assert_eq!(count_x, 1);
 117 }
 118
 119 #[test]
 120 fn test_extend_ref() {
 121     let mut v = vec![1, 2];
 122     v.extend(&[3, 4, 5]);
 123
 124     assert_eq!(v.len(), 5);
 125     assert_eq!(v, [1, 2, 3, 4, 5]);
 126
 127     let w = vec![6, 7];
 128     v.extend(&w);
 129
 130     assert_eq!(v.len(), 7);
 131     assert_eq!(v, [1, 2, 3, 4, 5, 6, 7]);
 132 }
 133
 134 #[test]
 135 fn test_remove_item() {
 136     let mut v = vec![1, 2, 3];
 137     v.remove_item(&1);
 138
 139     assert_eq!(v.len(), 2);
 140     assert_eq!(v, [2, 3]);
 141
 142     let mut w = vec![1, 2, 3];
 143     w.remove_item(&4);
 144
 145     assert_eq!(w.len(), 3);
 146     w.remove_item(&4);
 147 }
 148
 149 #[test]
 150 fn test_slice_from_mut() {
 151     let mut values = vec![1, 2, 3, 4, 5];
 152     {
 153         let slice = &mut values[2..];
 154         assert!(slice == [3, 4, 5]);
 155         for p in slice {
 156             *p += 2;
 157         }
 158     }
 159
 160     assert!(values == [1, 2, 5, 6, 7]);
 161 }
 162
 163 #[test]
 164 fn test_slice_to_mut() {
 165     let mut values = vec![1, 2, 3, 4, 5];
 166     {
 167         let slice = &mut values[..2];
 168         assert!(slice == [1, 2]);
 169         for p in slice {
 170             *p += 1;
 171         }
 172     }
 173
 174     assert!(values == [2, 3, 3, 4, 5]);
 175 }
 176
 177 #[test]
 178 fn test_split_at_mut() {
 179     let mut values = vec![1, 2, 3, 4, 5];
 180     {
 181         let (left, right) = values.split_at_mut(2);
 182         {
 183             let left: &[_] = left;
 184             assert!(&left[..left.len()] == &[1, 2]);
 185         }
 186         for p in left {
 187             *p += 1;
 188         }
 189
 190         {
 191             let right: &[_] = right;
 192             assert!(&right[..right.len()] == &[3, 4, 5]);
 193         }
 194         for p in right {
 195             *p += 2;
 196         }
 197     }
 198
 199     assert_eq!(values, [2, 3, 5, 6, 7]);
 200 }
 201
 202 #[test]
 203 fn test_clone() {
 204     let v: Vec<i32> = vec![];
 205     let w = vec![1, 2, 3];
 206
 207     assert_eq!(v, v.clone());
 208
 209     let z = w.clone();
 210     assert_eq!(w, z);
 211     // they should be disjoint in memory.
 212     assert!(w.as_ptr() != z.as_ptr())
 213 }
 214
 215 #[test]
 216 fn test_clone_from() {
 217     let mut v = vec![];
 218     let three: Vec<Box<_>> = vec![box 1, box 2, box 3];
 219     let two: Vec<Box<_>> = vec![box 4, box 5];
 220     // zero, long
 221     v.clone_from(&three);
 222     assert_eq!(v, three);
 223
 224     // equal
 225     v.clone_from(&three);
 226     assert_eq!(v, three);
 227
 228     // long, short
 229     v.clone_from(&two);
 230     assert_eq!(v, two);
 231
 232     // short, long
 233     v.clone_from(&three);
 234     assert_eq!(v, three)
 235 }
 236
 237 #[test]
 238 fn test_retain() {
 239     let mut vec = vec![1, 2, 3, 4];
 240     vec.retain(|&x| x % 2 == 0);
 241     assert_eq!(vec, [2, 4]);
 242 }
 243
 244 #[test]
 245 fn test_dedup() {
 246     fn case(a: Vec<i32>, b: Vec<i32>) {
 247         let mut v = a;
 248         v.dedup();
 249         assert_eq!(v, b);
 250     }
 251     case(vec![], vec![]);
 252     case(vec![1], vec![1]);
 253     case(vec![1, 1], vec![1]);
 254     case(vec![1, 2, 3], vec![1, 2, 3]);
 255     case(vec![1, 1, 2, 3], vec![1, 2, 3]);
 256     case(vec![1, 2, 2, 3], vec![1, 2, 3]);
 257     case(vec![1, 2, 3, 3], vec![1, 2, 3]);
 258     case(vec![1, 1, 2, 2, 2, 3, 3], vec![1, 2, 3]);
 259 }
 260
 261 #[test]
 262 fn test_dedup_by_key() {
 263     fn case(a: Vec<i32>, b: Vec<i32>) {
 264         let mut v = a;
 265         v.dedup_by_key(|i| *i / 10);
 266         assert_eq!(v, b);
 267     }
 268     case(vec![], vec![]);
 269     case(vec![10], vec![10]);
 270     case(vec![10, 11], vec![10]);
 271     case(vec![10, 20, 30], vec![10, 20, 30]);
 272     case(vec![10, 11, 20, 30], vec![10, 20, 30]);
 273     case(vec![10, 20, 21, 30], vec![10, 20, 30]);
 274     case(vec![10, 20, 30, 31], vec![10, 20, 30]);
 275     case(vec![10, 11, 20, 21, 22, 30, 31], vec![10, 20, 30]);
 276 }
 277
 278 #[test]
 279 fn test_dedup_by() {
 280     let mut vec = vec!["foo", "bar", "Bar", "baz", "bar"];
 281     vec.dedup_by(|a, b| a.eq_ignore_ascii_case(b));
 282
 283     assert_eq!(vec, ["foo", "bar", "baz", "bar"]);
 284
 285     let mut vec = vec![("foo", 1), ("foo", 2), ("bar", 3), ("bar", 4), ("bar", 5)];
 286     vec.dedup_by(|a, b| {
 287         a.0 == b.0 && {
 288             b.1 += a.1;
 289             true
 290         }
 291     });
 292
 293     assert_eq!(vec, [("foo", 3), ("bar", 12)]);
 294 }
 295
 296 #[test]
 297 fn test_dedup_unique() {
 298     let mut v0: Vec<Box<_>> = vec![box 1, box 1, box 2, box 3];
 299     v0.dedup();
 300     let mut v1: Vec<Box<_>> = vec![box 1, box 2, box 2, box 3];
 301     v1.dedup();
 302     let mut v2: Vec<Box<_>> = vec![box 1, box 2, box 3, box 3];
 303     v2.dedup();
 304     // If the boxed pointers were leaked or otherwise misused, valgrind
 305     // and/or rt should raise errors.
 306 }
 307
 308 #[test]
 309 fn zero_sized_values() {
 310     let mut v = Vec::new();
 311     assert_eq!(v.len(), 0);
 312     v.push(());
 313     assert_eq!(v.len(), 1);
 314     v.push(());
 315     assert_eq!(v.len(), 2);
 316     assert_eq!(v.pop(), Some(()));
 317     assert_eq!(v.pop(), Some(()));
 318     assert_eq!(v.pop(), None);
 319
 320     assert_eq!(v.iter().count(), 0);
 321     v.push(());
 322     assert_eq!(v.iter().count(), 1);
 323     v.push(());
 324     assert_eq!(v.iter().count(), 2);
 325
 326     for &() in &v {}
 327
 328     assert_eq!(v.iter_mut().count(), 2);
 329     v.push(());
 330     assert_eq!(v.iter_mut().count(), 3);
 331     v.push(());
 332     assert_eq!(v.iter_mut().count(), 4);
 333
 334     for &mut () in &mut v {}
 335     unsafe {
 336         v.set_len(0);
 337     }
 338     assert_eq!(v.iter_mut().count(), 0);
 339 }
 340
 341 #[test]
 342 fn test_partition() {
 343     assert_eq!(vec![].into_iter().partition(|x: &i32| *x < 3), (vec![], vec![]));
 344     assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 4), (vec![1, 2, 3], vec![]));
 345     assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 2), (vec![1], vec![2, 3]));
 346     assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 0), (vec![], vec![1, 2, 3]));
 347 }
 348
 349 #[test]
 350 fn test_zip_unzip() {
 351     let z1 = vec![(1, 4), (2, 5), (3, 6)];
 352
 353     let (left, right): (Vec<_>, Vec<_>) = z1.iter().cloned().unzip();
 354
 355     assert_eq!((1, 4), (left[0], right[0]));
 356     assert_eq!((2, 5), (left[1], right[1]));
 357     assert_eq!((3, 6), (left[2], right[2]));
 358 }
 359
 360 #[test]
 361 fn test_vec_truncate_drop() {
 362     static mut DROPS: u32 = 0;
 363     struct Elem(i32);
 364     impl Drop for Elem {
 365         fn drop(&mut self) {
 366             unsafe {
 367                 DROPS += 1;
 368             }
 369         }
 370     }
 371
 372     let mut v = vec![Elem(1), Elem(2), Elem(3), Elem(4), Elem(5)];
 373     assert_eq!(unsafe { DROPS }, 0);
 374     v.truncate(3);
 375     assert_eq!(unsafe { DROPS }, 2);
 376     v.truncate(0);
 377     assert_eq!(unsafe { DROPS }, 5);
 378 }
 379
 380 #[test]
 381 #[should_panic]
 382 fn test_vec_truncate_fail() {
 383     struct BadElem(i32);
 384     impl Drop for BadElem {
 385         fn drop(&mut self) {
 386             let BadElem(ref mut x) = *self;
 387             if *x == 0xbadbeef {
 388                 panic!("BadElem panic: 0xbadbeef")
 389             }
 390         }
 391     }
 392
 393     let mut v = vec![BadElem(1), BadElem(2), BadElem(0xbadbeef), BadElem(4)];
 394     v.truncate(0);
 395 }
 396
 397 #[test]
 398 fn test_index() {
 399     let vec = vec![1, 2, 3];
 400     assert!(vec[1] == 2);
 401 }
 402
 403 #[test]
 404 #[should_panic]
 405 fn test_index_out_of_bounds() {
 406     let vec = vec![1, 2, 3];
 407     let _ = vec[3];
 408 }
 409
 410 #[test]
 411 #[should_panic]
 412 fn test_slice_out_of_bounds_1() {
 413     let x = vec![1, 2, 3, 4, 5];
 414     &x[!0..];
 415 }
 416
 417 #[test]
 418 #[should_panic]
 419 fn test_slice_out_of_bounds_2() {
 420     let x = vec![1, 2, 3, 4, 5];
 421     &x[..6];
 422 }
 423
 424 #[test]
 425 #[should_panic]
 426 fn test_slice_out_of_bounds_3() {
 427     let x = vec![1, 2, 3, 4, 5];
 428     &x[!0..4];
 429 }
 430
 431 #[test]
 432 #[should_panic]
 433 fn test_slice_out_of_bounds_4() {
 434     let x = vec![1, 2, 3, 4, 5];
 435     &x[1..6];
 436 }
 437
 438 #[test]
 439 #[should_panic]
 440 fn test_slice_out_of_bounds_5() {
 441     let x = vec![1, 2, 3, 4, 5];
 442     &x[3..2];
 443 }
 444
 445 #[test]
 446 #[should_panic]
 447 fn test_swap_remove_empty() {
 448     let mut vec = Vec::<i32>::new();
 449     vec.swap_remove(0);
 450 }
 451
 452 #[test]
 453 fn test_move_items() {
 454     let vec = vec![1, 2, 3];
 455     let mut vec2 = vec![];
 456     for i in vec {
 457         vec2.push(i);
 458     }
 459     assert_eq!(vec2, [1, 2, 3]);
 460 }
 461
 462 #[test]
 463 fn test_move_items_reverse() {
 464     let vec = vec![1, 2, 3];
 465     let mut vec2 = vec![];
 466     for i in vec.into_iter().rev() {
 467         vec2.push(i);
 468     }
 469     assert_eq!(vec2, [3, 2, 1]);
 470 }
 471
 472 #[test]
 473 fn test_move_items_zero_sized() {
 474     let vec = vec![(), (), ()];
 475     let mut vec2 = vec![];
 476     for i in vec {
 477         vec2.push(i);
 478     }
 479     assert_eq!(vec2, [(), (), ()]);
 480 }
 481
 482 #[test]
 483 fn test_drain_items() {
 484     let mut vec = vec![1, 2, 3];
 485     let mut vec2 = vec![];
 486     for i in vec.drain(..) {
 487         vec2.push(i);
 488     }
 489     assert_eq!(vec, []);
 490     assert_eq!(vec2, [1, 2, 3]);
 491 }
 492
 493 #[test]
 494 fn test_drain_items_reverse() {
 495     let mut vec = vec![1, 2, 3];
 496     let mut vec2 = vec![];
 497     for i in vec.drain(..).rev() {
 498         vec2.push(i);
 499     }
 500     assert_eq!(vec, []);
 501     assert_eq!(vec2, [3, 2, 1]);
 502 }
 503
 504 #[test]
 505 fn test_drain_items_zero_sized() {
 506     let mut vec = vec![(), (), ()];
 507     let mut vec2 = vec![];
 508     for i in vec.drain(..) {
 509         vec2.push(i);
 510     }
 511     assert_eq!(vec, []);
 512     assert_eq!(vec2, [(), (), ()]);
 513 }
 514
 515 #[test]
 516 #[should_panic]
 517 fn test_drain_out_of_bounds() {
 518     let mut v = vec![1, 2, 3, 4, 5];
 519     v.drain(5..6);
 520 }
 521
 522 #[test]
 523 fn test_drain_range() {
 524     let mut v = vec![1, 2, 3, 4, 5];
 525     for _ in v.drain(4..) {}
 526     assert_eq!(v, &[1, 2, 3, 4]);
 527
 528     let mut v: Vec<_> = (1..6).map(|x| x.to_string()).collect();
 529     for _ in v.drain(1..4) {}
 530     assert_eq!(v, &[1.to_string(), 5.to_string()]);
 531
 532     let mut v: Vec<_> = (1..6).map(|x| x.to_string()).collect();
 533     for _ in v.drain(1..4).rev() {}
 534     assert_eq!(v, &[1.to_string(), 5.to_string()]);
 535
 536     let mut v: Vec<_> = vec![(); 5];
 537     for _ in v.drain(1..4).rev() {}
 538     assert_eq!(v, &[(), ()]);
 539 }
 540
 541 #[test]
 542 fn test_drain_inclusive_range() {
 543     let mut v = vec!['a', 'b', 'c', 'd', 'e'];
 544     for _ in v.drain(1..=3) {}
 545     assert_eq!(v, &['a', 'e']);
 546
 547     let mut v: Vec<_> = (0..=5).map(|x| x.to_string()).collect();
 548     for _ in v.drain(1..=5) {}
 549     assert_eq!(v, &["0".to_string()]);
 550
 551     let mut v: Vec<String> = (0..=5).map(|x| x.to_string()).collect();
 552     for _ in v.drain(0..=5) {}
 553     assert_eq!(v, Vec::<String>::new());
 554
 555     let mut v: Vec<_> = (0..=5).map(|x| x.to_string()).collect();
 556     for _ in v.drain(0..=3) {}
 557     assert_eq!(v, &["4".to_string(), "5".to_string()]);
 558
 559     let mut v: Vec<_> = (0..=1).map(|x| x.to_string()).collect();
 560     for _ in v.drain(..=0) {}
 561     assert_eq!(v, &["1".to_string()]);
 562 }
 563
 564 #[test]
 565 fn test_drain_max_vec_size() {
 566     let mut v = Vec::<()>::with_capacity(usize::max_value());
 567     unsafe {
 568         v.set_len(usize::max_value());
 569     }
 570     for _ in v.drain(usize::max_value() - 1..) {}
 571     assert_eq!(v.len(), usize::max_value() - 1);
 572
 573     let mut v = Vec::<()>::with_capacity(usize::max_value());
 574     unsafe {
 575         v.set_len(usize::max_value());
 576     }
 577     for _ in v.drain(usize::max_value() - 1..=usize::max_value() - 1) {}
 578     assert_eq!(v.len(), usize::max_value() - 1);
 579 }
 580
 581 #[test]
 582 #[should_panic]
 583 fn test_drain_inclusive_out_of_bounds() {
 584     let mut v = vec![1, 2, 3, 4, 5];
 585     v.drain(5..=5);
 586 }
 587
 588 #[test]
 589 fn test_splice() {
 590     let mut v = vec![1, 2, 3, 4, 5];
 591     let a = [10, 11, 12];
 592     v.splice(2..4, a.iter().cloned());
 593     assert_eq!(v, &[1, 2, 10, 11, 12, 5]);
 594     v.splice(1..3, Some(20));
 595     assert_eq!(v, &[1, 20, 11, 12, 5]);
 596 }
 597
 598 #[test]
 599 fn test_splice_inclusive_range() {
 600     let mut v = vec![1, 2, 3, 4, 5];
 601     let a = [10, 11, 12];
 602     let t1: Vec<_> = v.splice(2..=3, a.iter().cloned()).collect();
 603     assert_eq!(v, &[1, 2, 10, 11, 12, 5]);
 604     assert_eq!(t1, &[3, 4]);
 605     let t2: Vec<_> = v.splice(1..=2, Some(20)).collect();
 606     assert_eq!(v, &[1, 20, 11, 12, 5]);
 607     assert_eq!(t2, &[2, 10]);
 608 }
 609
 610 #[test]
 611 #[should_panic]
 612 fn test_splice_out_of_bounds() {
 613     let mut v = vec![1, 2, 3, 4, 5];
 614     let a = [10, 11, 12];
 615     v.splice(5..6, a.iter().cloned());
 616 }
 617
 618 #[test]
 619 #[should_panic]
 620 fn test_splice_inclusive_out_of_bounds() {
 621     let mut v = vec![1, 2, 3, 4, 5];
 622     let a = [10, 11, 12];
 623     v.splice(5..=5, a.iter().cloned());
 624 }
 625
 626 #[test]
 627 fn test_splice_items_zero_sized() {
 628     let mut vec = vec![(), (), ()];
 629     let vec2 = vec![];
 630     let t: Vec<_> = vec.splice(1..2, vec2.iter().cloned()).collect();
 631     assert_eq!(vec, &[(), ()]);
 632     assert_eq!(t, &[()]);
 633 }
 634
 635 #[test]
 636 fn test_splice_unbounded() {
 637     let mut vec = vec![1, 2, 3, 4, 5];
 638     let t: Vec<_> = vec.splice(.., None).collect();
 639     assert_eq!(vec, &[]);
 640     assert_eq!(t, &[1, 2, 3, 4, 5]);
 641 }
 642
 643 #[test]
 644 fn test_splice_forget() {
 645     let mut v = vec![1, 2, 3, 4, 5];
 646     let a = [10, 11, 12];
 647     std::mem::forget(v.splice(2..4, a.iter().cloned()));
 648     assert_eq!(v, &[1, 2]);
 649 }
 650
 651 #[test]
 652 fn test_into_boxed_slice() {
 653     let xs = vec![1, 2, 3];
 654     let ys = xs.into_boxed_slice();
 655     assert_eq!(&*ys, [1, 2, 3]);
 656 }
 657
 658 #[test]
 659 fn test_append() {
 660     let mut vec = vec![1, 2, 3];
 661     let mut vec2 = vec![4, 5, 6];
 662     vec.append(&mut vec2);
 663     assert_eq!(vec, [1, 2, 3, 4, 5, 6]);
 664     assert_eq!(vec2, []);
 665 }
 666
 667 #[test]
 668 fn test_split_off() {
 669     let mut vec = vec![1, 2, 3, 4, 5, 6];
 670     let vec2 = vec.split_off(4);
 671     assert_eq!(vec, [1, 2, 3, 4]);
 672     assert_eq!(vec2, [5, 6]);
 673 }
 674
 675 #[test]
 676 fn test_into_iter_as_slice() {
 677     let vec = vec!['a', 'b', 'c'];
 678     let mut into_iter = vec.into_iter();
 679     assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']);
 680     let _ = into_iter.next().unwrap();
 681     assert_eq!(into_iter.as_slice(), &['b', 'c']);
 682     let _ = into_iter.next().unwrap();
 683     let _ = into_iter.next().unwrap();
 684     assert_eq!(into_iter.as_slice(), &[]);
 685 }
 686
 687 #[test]
 688 fn test_into_iter_as_mut_slice() {
 689     let vec = vec!['a', 'b', 'c'];
 690     let mut into_iter = vec.into_iter();
 691     assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']);
 692     into_iter.as_mut_slice()[0] = 'x';
 693     into_iter.as_mut_slice()[1] = 'y';
 694     assert_eq!(into_iter.next().unwrap(), 'x');
 695     assert_eq!(into_iter.as_slice(), &['y', 'c']);
 696 }
 697
 698 #[test]
 699 fn test_into_iter_debug() {
 700     let vec = vec!['a', 'b', 'c'];
 701     let into_iter = vec.into_iter();
 702     let debug = format!("{:?}", into_iter);
 703     assert_eq!(debug, "IntoIter(['a', 'b', 'c'])");
 704 }
 705
 706 #[test]
 707 fn test_into_iter_count() {
 708     assert_eq!(vec![1, 2, 3].into_iter().count(), 3);
 709 }
 710
 711 #[test]
 712 fn test_into_iter_clone() {
 713     fn iter_equal<I: Iterator<Item = i32>>(it: I, slice: &[i32]) {
 714         let v: Vec<i32> = it.collect();
 715         assert_eq!(&v[..], slice);
 716     }
 717     let mut it = vec![1, 2, 3].into_iter();
 718     iter_equal(it.clone(), &[1, 2, 3]);
 719     assert_eq!(it.next(), Some(1));
 720     let mut it = it.rev();
 721     iter_equal(it.clone(), &[3, 2]);
 722     assert_eq!(it.next(), Some(3));
 723     iter_equal(it.clone(), &[2]);
 724     assert_eq!(it.next(), Some(2));
 725     iter_equal(it.clone(), &[]);
 726     assert_eq!(it.next(), None);
 727 }
 728
 729 #[test]
 730 fn test_cow_from() {
 731     let borrowed: &[_] = &["borrowed", "(slice)"];
 732     let owned = vec!["owned", "(vec)"];
 733     match (Cow::from(owned.clone()), Cow::from(borrowed)) {
 734         (Cow::Owned(o), Cow::Borrowed(b)) => assert!(o == owned && b == borrowed),
 735         _ => panic!("invalid `Cow::from`"),
 736     }
 737 }
 738
 739 #[test]
 740 fn test_from_cow() {
 741     let borrowed: &[_] = &["borrowed", "(slice)"];
 742     let owned = vec!["owned", "(vec)"];
 743     assert_eq!(Vec::from(Cow::Borrowed(borrowed)), vec!["borrowed", "(slice)"]);
 744     assert_eq!(Vec::from(Cow::Owned(owned)), vec!["owned", "(vec)"]);
 745 }
 746
 747 #[allow(dead_code)]
 748 fn assert_covariance() {
 749     fn drain<'new>(d: Drain<'static, &'static str>) -> Drain<'new, &'new str> {
 750         d
 751     }
 752     fn into_iter<'new>(i: IntoIter<&'static str>) -> IntoIter<&'new str> {
 753         i
 754     }
 755 }
 756
 757 #[test]
 758 fn from_into_inner() {
 759     let vec = vec![1, 2, 3];
 760     let ptr = vec.as_ptr();
 761     let vec = vec.into_iter().collect::<Vec<_>>();
 762     assert_eq!(vec, [1, 2, 3]);
 763     assert_eq!(vec.as_ptr(), ptr);
 764
 765     let ptr = &vec[1] as *const _;
 766     let mut it = vec.into_iter();
 767     it.next().unwrap();
 768     let vec = it.collect::<Vec<_>>();
 769     assert_eq!(vec, [2, 3]);
 770     assert!(ptr != vec.as_ptr());
 771 }
 772
 773 #[test]
 774 fn overaligned_allocations() {
 775     #[repr(align(256))]
 776     struct Foo(usize);
 777     let mut v = vec![Foo(273)];
 778     for i in 0..0x1000 {
 779         v.reserve_exact(i);
 780         assert!(v[0].0 == 273);
 781         assert!(v.as_ptr() as usize & 0xff == 0);
 782         v.shrink_to_fit();
 783         assert!(v[0].0 == 273);
 784         assert!(v.as_ptr() as usize & 0xff == 0);
 785     }
 786 }
 787
 788 #[test]
 789 fn drain_filter_empty() {
 790     let mut vec: Vec<i32> = vec![];
 791
 792     {
 793         let mut iter = vec.drain_filter(|_| true);
 794         assert_eq!(iter.size_hint(), (0, Some(0)));
 795         assert_eq!(iter.next(), None);
 796         assert_eq!(iter.size_hint(), (0, Some(0)));
 797         assert_eq!(iter.next(), None);
 798         assert_eq!(iter.size_hint(), (0, Some(0)));
 799     }
 800     assert_eq!(vec.len(), 0);
 801     assert_eq!(vec, vec![]);
 802 }
 803
 804 #[test]
 805 fn drain_filter_zst() {
 806     let mut vec = vec![(), (), (), (), ()];
 807     let initial_len = vec.len();
 808     let mut count = 0;
 809     {
 810         let mut iter = vec.drain_filter(|_| true);
 811         assert_eq!(iter.size_hint(), (0, Some(initial_len)));
 812         while let Some(_) = iter.next() {
 813             count += 1;
 814             assert_eq!(iter.size_hint(), (0, Some(initial_len - count)));
 815         }
 816         assert_eq!(iter.size_hint(), (0, Some(0)));
 817         assert_eq!(iter.next(), None);
 818         assert_eq!(iter.size_hint(), (0, Some(0)));
 819     }
 820
 821     assert_eq!(count, initial_len);
 822     assert_eq!(vec.len(), 0);
 823     assert_eq!(vec, vec![]);
 824 }
 825
 826 #[test]
 827 fn drain_filter_false() {
 828     let mut vec = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 829
 830     let initial_len = vec.len();
 831     let mut count = 0;
 832     {
 833         let mut iter = vec.drain_filter(|_| false);
 834         assert_eq!(iter.size_hint(), (0, Some(initial_len)));
 835         for _ in iter.by_ref() {
 836             count += 1;
 837         }
 838         assert_eq!(iter.size_hint(), (0, Some(0)));
 839         assert_eq!(iter.next(), None);
 840         assert_eq!(iter.size_hint(), (0, Some(0)));
 841     }
 842
 843     assert_eq!(count, 0);
 844     assert_eq!(vec.len(), initial_len);
 845     assert_eq!(vec, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 846 }
 847
 848 #[test]
 849 fn drain_filter_true() {
 850     let mut vec = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 851
 852     let initial_len = vec.len();
 853     let mut count = 0;
 854     {
 855         let mut iter = vec.drain_filter(|_| true);
 856         assert_eq!(iter.size_hint(), (0, Some(initial_len)));
 857         while let Some(_) = iter.next() {
 858             count += 1;
 859             assert_eq!(iter.size_hint(), (0, Some(initial_len - count)));
 860         }
 861         assert_eq!(iter.size_hint(), (0, Some(0)));
 862         assert_eq!(iter.next(), None);
 863         assert_eq!(iter.size_hint(), (0, Some(0)));
 864     }
 865
 866     assert_eq!(count, initial_len);
 867     assert_eq!(vec.len(), 0);
 868     assert_eq!(vec, vec![]);
 869 }
 870
 871 #[test]
 872 fn drain_filter_complex() {
 873     {
 874         //                [+xxx++++++xxxxx++++x+x++]
 875         let mut vec = vec![
 876             1, 2, 4, 6, 7, 9, 11, 13, 15, 17, 18, 20, 22, 24, 26, 27, 29, 31, 33, 34, 35, 36, 37,
 877             39,
 878         ];
 879
 880         let removed = vec.drain_filter(|x| *x % 2 == 0).collect::<Vec<_>>();
 881         assert_eq!(removed.len(), 10);
 882         assert_eq!(removed, vec![2, 4, 6, 18, 20, 22, 24, 26, 34, 36]);
 883
 884         assert_eq!(vec.len(), 14);
 885         assert_eq!(vec, vec![1, 7, 9, 11, 13, 15, 17, 27, 29, 31, 33, 35, 37, 39]);
 886     }
 887
 888     {
 889         //                [xxx++++++xxxxx++++x+x++]
 890         let mut vec = vec![
 891             2, 4, 6, 7, 9, 11, 13, 15, 17, 18, 20, 22, 24, 26, 27, 29, 31, 33, 34, 35, 36, 37, 39,
 892         ];
 893
 894         let removed = vec.drain_filter(|x| *x % 2 == 0).collect::<Vec<_>>();
 895         assert_eq!(removed.len(), 10);
 896         assert_eq!(removed, vec![2, 4, 6, 18, 20, 22, 24, 26, 34, 36]);
 897
 898         assert_eq!(vec.len(), 13);
 899         assert_eq!(vec, vec![7, 9, 11, 13, 15, 17, 27, 29, 31, 33, 35, 37, 39]);
 900     }
 901
 902     {
 903         //                [xxx++++++xxxxx++++x+x]
 904         let mut vec =
 905             vec![2, 4, 6, 7, 9, 11, 13, 15, 17, 18, 20, 22, 24, 26, 27, 29, 31, 33, 34, 35, 36];
 906
 907         let removed = vec.drain_filter(|x| *x % 2 == 0).collect::<Vec<_>>();
 908         assert_eq!(removed.len(), 10);
 909         assert_eq!(removed, vec![2, 4, 6, 18, 20, 22, 24, 26, 34, 36]);
 910
 911         assert_eq!(vec.len(), 11);
 912         assert_eq!(vec, vec![7, 9, 11, 13, 15, 17, 27, 29, 31, 33, 35]);
 913     }
 914
 915     {
 916         //                [xxxxxxxxxx+++++++++++]
 917         let mut vec = vec![2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19];
 918
 919         let removed = vec.drain_filter(|x| *x % 2 == 0).collect::<Vec<_>>();
 920         assert_eq!(removed.len(), 10);
 921         assert_eq!(removed, vec![2, 4, 6, 8, 10, 12, 14, 16, 18, 20]);
 922
 923         assert_eq!(vec.len(), 10);
 924         assert_eq!(vec, vec![1, 3, 5, 7, 9, 11, 13, 15, 17, 19]);
 925     }
 926
 927     {
 928         //                [+++++++++++xxxxxxxxxx]
 929         let mut vec = vec![1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20];
 930
 931         let removed = vec.drain_filter(|x| *x % 2 == 0).collect::<Vec<_>>();
 932         assert_eq!(removed.len(), 10);
 933         assert_eq!(removed, vec![2, 4, 6, 8, 10, 12, 14, 16, 18, 20]);
 934
 935         assert_eq!(vec.len(), 10);
 936         assert_eq!(vec, vec![1, 3, 5, 7, 9, 11, 13, 15, 17, 19]);
 937     }
 938 }
 939
 940 // FIXME: re-enable emscripten once it can unwind again
 941 #[test]
 942 #[cfg(not(target_os = "emscripten"))]
 943 fn drain_filter_consumed_panic() {
 944     use std::rc::Rc;
 945     use std::sync::Mutex;
 946
 947     struct Check {
 948         index: usize,
 949         drop_counts: Rc<Mutex<Vec<usize>>>,
 950     };
 951
 952     impl Drop for Check {
 953         fn drop(&mut self) {
 954             self.drop_counts.lock().unwrap()[self.index] += 1;
 955             println!("drop: {}", self.index);
 956         }
 957     }
 958
 959     let check_count = 10;
 960     let drop_counts = Rc::new(Mutex::new(vec![0_usize; check_count]));
 961     let mut data: Vec<Check> = (0..check_count)
 962         .map(|index| Check { index, drop_counts: Rc::clone(&drop_counts) })
 963         .collect();
 964
 965     let _ = std::panic::catch_unwind(move || {
 966         let filter = |c: &mut Check| {
 967             if c.index == 2 {
 968                 panic!("panic at index: {}", c.index);
 969             }
 970             // Verify that if the filter could panic again on another element
 971             // that it would not cause a double panic and all elements of the
 972             // vec would still be dropped exactly once.
 973             if c.index == 4 {
 974                 panic!("panic at index: {}", c.index);
 975             }
 976             c.index < 6
 977         };
 978         let drain = data.drain_filter(filter);
 979
 980         // NOTE: The DrainFilter is explicitly consumed
 981         drain.for_each(drop);
 982     });
 983
 984     let drop_counts = drop_counts.lock().unwrap();
 985     assert_eq!(check_count, drop_counts.len());
 986
 987     for (index, count) in drop_counts.iter().cloned().enumerate() {
 988         assert_eq!(1, count, "unexpected drop count at index: {} (count: {})", index, count);
 989     }
 990 }
 991
 992 // FIXME: Re-enable emscripten once it can catch panics
 993 #[test]
 994 #[cfg(not(target_os = "emscripten"))]
 995 fn drain_filter_unconsumed_panic() {
 996     use std::rc::Rc;
 997     use std::sync::Mutex;
 998
 999     struct Check {
1000         index: usize,
1001         drop_counts: Rc<Mutex<Vec<usize>>>,
1002     };
1003
1004     impl Drop for Check {
1005         fn drop(&mut self) {
1006             self.drop_counts.lock().unwrap()[self.index] += 1;
1007             println!("drop: {}", self.index);
1008         }
1009     }
1010
1011     let check_count = 10;
1012     let drop_counts = Rc::new(Mutex::new(vec![0_usize; check_count]));
1013     let mut data: Vec<Check> = (0..check_count)
1014         .map(|index| Check { index, drop_counts: Rc::clone(&drop_counts) })
1015         .collect();
1016
1017     let _ = std::panic::catch_unwind(move || {
1018         let filter = |c: &mut Check| {
1019             if c.index == 2 {
1020                 panic!("panic at index: {}", c.index);
1021             }
1022             // Verify that if the filter could panic again on another element
1023             // that it would not cause a double panic and all elements of the
1024             // vec would still be dropped exactly once.
1025             if c.index == 4 {
1026                 panic!("panic at index: {}", c.index);
1027             }
1028             c.index < 6
1029         };
1030         let _drain = data.drain_filter(filter);
1031
1032         // NOTE: The DrainFilter is dropped without being consumed
1033     });
1034
1035     let drop_counts = drop_counts.lock().unwrap();
1036     assert_eq!(check_count, drop_counts.len());
1037
1038     for (index, count) in drop_counts.iter().cloned().enumerate() {
1039         assert_eq!(1, count, "unexpected drop count at index: {} (count: {})", index, count);
1040     }
1041 }
1042
1043 #[test]
1044 fn drain_filter_unconsumed() {
1045     let mut vec = vec![1, 2, 3, 4];
1046     let drain = vec.drain_filter(|&mut x| x % 2 != 0);
1047     drop(drain);
1048     assert_eq!(vec, [2, 4]);
1049 }
1050
1051 #[test]
1052 fn test_reserve_exact() {
1053     // This is all the same as test_reserve
1054
1055     let mut v = Vec::new();
1056     assert_eq!(v.capacity(), 0);
1057
1058     v.reserve_exact(2);
1059     assert!(v.capacity() >= 2);
1060
1061     for i in 0..16 {
1062         v.push(i);
1063     }
1064
1065     assert!(v.capacity() >= 16);
1066     v.reserve_exact(16);
1067     assert!(v.capacity() >= 32);
1068
1069     v.push(16);
1070
1071     v.reserve_exact(16);
1072     assert!(v.capacity() >= 33)
1073 }
1074
1075 #[test]
1076 #[cfg_attr(miri, ignore)] // Miri does not support signalling OOM
1077 fn test_try_reserve() {
1078     // These are the interesting cases:
1079     // * exactly isize::MAX should never trigger a CapacityOverflow (can be OOM)
1080     // * > isize::MAX should always fail
1081     //    * On 16/32-bit should CapacityOverflow
1082     //    * On 64-bit should OOM
1083     // * overflow may trigger when adding `len` to `cap` (in number of elements)
1084     // * overflow may trigger when multiplying `new_cap` by size_of::<T> (to get bytes)
1085
1086     const MAX_CAP: usize = isize::MAX as usize;
1087     const MAX_USIZE: usize = usize::MAX;
1088
1089     // On 16/32-bit, we check that allocations don't exceed isize::MAX,
1090     // on 64-bit, we assume the OS will give an OOM for such a ridiculous size.
1091     // Any platform that succeeds for these requests is technically broken with
1092     // ptr::offset because LLVM is the worst.
1093     let guards_against_isize = size_of::<usize>() < 8;
1094
1095     {
1096         // Note: basic stuff is checked by test_reserve
1097         let mut empty_bytes: Vec<u8> = Vec::new();
1098
1099         // Check isize::MAX doesn't count as an overflow
1100         if let Err(CapacityOverflow) = empty_bytes.try_reserve(MAX_CAP) {
1101             panic!("isize::MAX shouldn't trigger an overflow!");
1102         }
1103         // Play it again, frank! (just to be sure)
1104         if let Err(CapacityOverflow) = empty_bytes.try_reserve(MAX_CAP) {
1105             panic!("isize::MAX shouldn't trigger an overflow!");
1106         }
1107
1108         if guards_against_isize {
1109             // Check isize::MAX + 1 does count as overflow
1110             if let Err(CapacityOverflow) = empty_bytes.try_reserve(MAX_CAP + 1) {
1111             } else {
1112                 panic!("isize::MAX + 1 should trigger an overflow!")
1113             }
1114
1115             // Check usize::MAX does count as overflow
1116             if let Err(CapacityOverflow) = empty_bytes.try_reserve(MAX_USIZE) {
1117             } else {
1118                 panic!("usize::MAX should trigger an overflow!")
1119             }
1120         } else {
1121             // Check isize::MAX + 1 is an OOM
1122             if let Err(AllocError { .. }) = empty_bytes.try_reserve(MAX_CAP + 1) {
1123             } else {
1124                 panic!("isize::MAX + 1 should trigger an OOM!")
1125             }
1126
1127             // Check usize::MAX is an OOM
1128             if let Err(AllocError { .. }) = empty_bytes.try_reserve(MAX_USIZE) {
1129             } else {
1130                 panic!("usize::MAX should trigger an OOM!")
1131             }
1132         }
1133     }
1134
1135     {
1136         // Same basic idea, but with non-zero len
1137         let mut ten_bytes: Vec<u8> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1138
1139         if let Err(CapacityOverflow) = ten_bytes.try_reserve(MAX_CAP - 10) {
1140             panic!("isize::MAX shouldn't trigger an overflow!");
1141         }
1142         if let Err(CapacityOverflow) = ten_bytes.try_reserve(MAX_CAP - 10) {
1143             panic!("isize::MAX shouldn't trigger an overflow!");
1144         }
1145         if guards_against_isize {
1146             if let Err(CapacityOverflow) = ten_bytes.try_reserve(MAX_CAP - 9) {
1147             } else {
1148                 panic!("isize::MAX + 1 should trigger an overflow!");
1149             }
1150         } else {
1151             if let Err(AllocError { .. }) = ten_bytes.try_reserve(MAX_CAP - 9) {
1152             } else {
1153                 panic!("isize::MAX + 1 should trigger an OOM!")
1154             }
1155         }
1156         // Should always overflow in the add-to-len
1157         if let Err(CapacityOverflow) = ten_bytes.try_reserve(MAX_USIZE) {
1158         } else {
1159             panic!("usize::MAX should trigger an overflow!")
1160         }
1161     }
1162
1163     {
1164         // Same basic idea, but with interesting type size
1165         let mut ten_u32s: Vec<u32> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1166
1167         if let Err(CapacityOverflow) = ten_u32s.try_reserve(MAX_CAP / 4 - 10) {
1168             panic!("isize::MAX shouldn't trigger an overflow!");
1169         }
1170         if let Err(CapacityOverflow) = ten_u32s.try_reserve(MAX_CAP / 4 - 10) {
1171             panic!("isize::MAX shouldn't trigger an overflow!");
1172         }
1173         if guards_against_isize {
1174             if let Err(CapacityOverflow) = ten_u32s.try_reserve(MAX_CAP / 4 - 9) {
1175             } else {
1176                 panic!("isize::MAX + 1 should trigger an overflow!");
1177             }
1178         } else {
1179             if let Err(AllocError { .. }) = ten_u32s.try_reserve(MAX_CAP / 4 - 9) {
1180             } else {
1181                 panic!("isize::MAX + 1 should trigger an OOM!")
1182             }
1183         }
1184         // Should fail in the mul-by-size
1185         if let Err(CapacityOverflow) = ten_u32s.try_reserve(MAX_USIZE - 20) {
1186         } else {
1187             panic!("usize::MAX should trigger an overflow!");
1188         }
1189     }
1190 }
1191
1192 #[test]
1193 #[cfg_attr(miri, ignore)] // Miri does not support signalling OOM
1194 fn test_try_reserve_exact() {
1195     // This is exactly the same as test_try_reserve with the method changed.
1196     // See that test for comments.
1197
1198     const MAX_CAP: usize = isize::MAX as usize;
1199     const MAX_USIZE: usize = usize::MAX;
1200
1201     let guards_against_isize = size_of::<usize>() < 8;
1202
1203     {
1204         let mut empty_bytes: Vec<u8> = Vec::new();
1205
1206         if let Err(CapacityOverflow) = empty_bytes.try_reserve_exact(MAX_CAP) {
1207             panic!("isize::MAX shouldn't trigger an overflow!");
1208         }
1209         if let Err(CapacityOverflow) = empty_bytes.try_reserve_exact(MAX_CAP) {
1210             panic!("isize::MAX shouldn't trigger an overflow!");
1211         }
1212
1213         if guards_against_isize {
1214             if let Err(CapacityOverflow) = empty_bytes.try_reserve_exact(MAX_CAP + 1) {
1215             } else {
1216                 panic!("isize::MAX + 1 should trigger an overflow!")
1217             }
1218
1219             if let Err(CapacityOverflow) = empty_bytes.try_reserve_exact(MAX_USIZE) {
1220             } else {
1221                 panic!("usize::MAX should trigger an overflow!")
1222             }
1223         } else {
1224             if let Err(AllocError { .. }) = empty_bytes.try_reserve_exact(MAX_CAP + 1) {
1225             } else {
1226                 panic!("isize::MAX + 1 should trigger an OOM!")
1227             }
1228
1229             if let Err(AllocError { .. }) = empty_bytes.try_reserve_exact(MAX_USIZE) {
1230             } else {
1231                 panic!("usize::MAX should trigger an OOM!")
1232             }
1233         }
1234     }
1235
1236     {
1237         let mut ten_bytes: Vec<u8> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1238
1239         if let Err(CapacityOverflow) = ten_bytes.try_reserve_exact(MAX_CAP - 10) {
1240             panic!("isize::MAX shouldn't trigger an overflow!");
1241         }
1242         if let Err(CapacityOverflow) = ten_bytes.try_reserve_exact(MAX_CAP - 10) {
1243             panic!("isize::MAX shouldn't trigger an overflow!");
1244         }
1245         if guards_against_isize {
1246             if let Err(CapacityOverflow) = ten_bytes.try_reserve_exact(MAX_CAP - 9) {
1247             } else {
1248                 panic!("isize::MAX + 1 should trigger an overflow!");
1249             }
1250         } else {
1251             if let Err(AllocError { .. }) = ten_bytes.try_reserve_exact(MAX_CAP - 9) {
1252             } else {
1253                 panic!("isize::MAX + 1 should trigger an OOM!")
1254             }
1255         }
1256         if let Err(CapacityOverflow) = ten_bytes.try_reserve_exact(MAX_USIZE) {
1257         } else {
1258             panic!("usize::MAX should trigger an overflow!")
1259         }
1260     }
1261
1262     {
1263         let mut ten_u32s: Vec<u32> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1264
1265         if let Err(CapacityOverflow) = ten_u32s.try_reserve_exact(MAX_CAP / 4 - 10) {
1266             panic!("isize::MAX shouldn't trigger an overflow!");
1267         }
1268         if let Err(CapacityOverflow) = ten_u32s.try_reserve_exact(MAX_CAP / 4 - 10) {
1269             panic!("isize::MAX shouldn't trigger an overflow!");
1270         }
1271         if guards_against_isize {
1272             if let Err(CapacityOverflow) = ten_u32s.try_reserve_exact(MAX_CAP / 4 - 9) {
1273             } else {
1274                 panic!("isize::MAX + 1 should trigger an overflow!");
1275             }
1276         } else {
1277             if let Err(AllocError { .. }) = ten_u32s.try_reserve_exact(MAX_CAP / 4 - 9) {
1278             } else {
1279                 panic!("isize::MAX + 1 should trigger an OOM!")
1280             }
1281         }
1282         if let Err(CapacityOverflow) = ten_u32s.try_reserve_exact(MAX_USIZE - 20) {
1283         } else {
1284             panic!("usize::MAX should trigger an overflow!")
1285         }
1286     }
1287 }
1288
1289 #[test]
1290 fn test_stable_push_pop() {
1291     // Test that, if we reserved enough space, adding and removing elements does not
1292     // invalidate references into the vector (such as `v0`).  This test also
1293     // runs in Miri, which would detect such problems.
1294     let mut v = Vec::with_capacity(10);
1295     v.push(13);
1296
1297     // laundering the lifetime -- we take care that `v` does not reallocate, so that's okay.
1298     let v0 = unsafe { &*(&v[0] as *const _) };
1299
1300     // Now do a bunch of things and occasionally use `v0` again to assert it is still valid.
1301     v.push(1);
1302     v.push(2);
1303     v.insert(1, 1);
1304     assert_eq!(*v0, 13);
1305     v.remove(1);
1306     v.pop().unwrap();
1307     assert_eq!(*v0, 13);
1308 }
1309
1310 // https://github.com/rust-lang/rust/pull/49496 introduced specialization based on:
1311 //
1312 // ```
1313 // unsafe impl<T: ?Sized> IsZero for *mut T {
1314 //     fn is_zero(&self) -> bool {
1315 //         (*self).is_null()
1316 //     }
1317 // }
1318 // ```
1319 //
1320 // … to call `RawVec::with_capacity_zeroed` for creating `Vec<*mut T>`,
1321 // which is incorrect for fat pointers since `<*mut T>::is_null` only looks at the data component.
1322 // That is, a fat pointer can be “null” without being made entirely of zero bits.
1323 #[test]
1324 fn vec_macro_repeating_null_raw_fat_pointer() {
1325     let raw_dyn = &mut (|| ()) as &mut dyn Fn() as *mut dyn Fn();
1326     let vtable = dbg!(ptr_metadata(raw_dyn));
1327     let null_raw_dyn = ptr_from_raw_parts(std::ptr::null_mut(), vtable);
1328     assert!(null_raw_dyn.is_null());
1329
1330     let vec = vec![null_raw_dyn; 1];
1331     dbg!(ptr_metadata(vec[0]));
1332     assert!(vec[0] == null_raw_dyn);
1333
1334     // Polyfill for https://github.com/rust-lang/rfcs/pull/2580
1335
1336     fn ptr_metadata(ptr: *mut dyn Fn()) -> *mut () {
1337         unsafe { std::mem::transmute::<*mut dyn Fn(), DynRepr>(ptr).vtable }
1338     }
1339
1340     fn ptr_from_raw_parts(data: *mut (), vtable: *mut ()) -> *mut dyn Fn() {
1341         unsafe { std::mem::transmute::<DynRepr, *mut dyn Fn()>(DynRepr { data, vtable }) }
1342     }
1343
1344     #[repr(C)]
1345     struct DynRepr {
1346         data: *mut (),
1347         vtable: *mut (),
1348     }
1349 }