src/liballoc/tests/vec.rs

   1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 use std::ascii::AsciiExt;
  12 use std::borrow::Cow;
  13 use std::mem::size_of;
  14 use std::panic;
  15 use std::vec::{Drain, IntoIter};
  16
  17 struct DropCounter<'a> {
  18     count: &'a mut u32,
  19 }
  20
  21 impl<'a> Drop for DropCounter<'a> {
  22     fn drop(&mut self) {
  23         *self.count += 1;
  24     }
  25 }
  26
  27 #[test]
  28 fn test_small_vec_struct() {
  29     assert!(size_of::<Vec<u8>>() == size_of::<usize>() * 3);
  30 }
  31
  32 #[test]
  33 fn test_double_drop() {
  34     struct TwoVec<T> {
  35         x: Vec<T>,
  36         y: Vec<T>,
  37     }
  38
  39     let (mut count_x, mut count_y) = (0, 0);
  40     {
  41         let mut tv = TwoVec {
  42             x: Vec::new(),
  43             y: Vec::new(),
  44         };
  45         tv.x.push(DropCounter { count: &mut count_x });
  46         tv.y.push(DropCounter { count: &mut count_y });
  47
  48         // If Vec had a drop flag, here is where it would be zeroed.
  49         // Instead, it should rely on its internal state to prevent
  50         // doing anything significant when dropped multiple times.
  51         drop(tv.x);
  52
  53         // Here tv goes out of scope, tv.y should be dropped, but not tv.x.
  54     }
  55
  56     assert_eq!(count_x, 1);
  57     assert_eq!(count_y, 1);
  58 }
  59
  60 #[test]
  61 fn test_reserve() {
  62     let mut v = Vec::new();
  63     assert_eq!(v.capacity(), 0);
  64
  65     v.reserve(2);
  66     assert!(v.capacity() >= 2);
  67
  68     for i in 0..16 {
  69         v.push(i);
  70     }
  71
  72     assert!(v.capacity() >= 16);
  73     v.reserve(16);
  74     assert!(v.capacity() >= 32);
  75
  76     v.push(16);
  77
  78     v.reserve(16);
  79     assert!(v.capacity() >= 33)
  80 }
  81
  82 #[test]
  83 fn test_extend() {
  84     let mut v = Vec::new();
  85     let mut w = Vec::new();
  86
  87     v.extend(w.clone());
  88     assert_eq!(v, &[]);
  89
  90     v.extend(0..3);
  91     for i in 0..3 {
  92         w.push(i)
  93     }
  94
  95     assert_eq!(v, w);
  96
  97     v.extend(3..10);
  98     for i in 3..10 {
  99         w.push(i)
 100     }
 101
 102     assert_eq!(v, w);
 103
 104     v.extend(w.clone()); // specializes to `append`
 105     assert!(v.iter().eq(w.iter().chain(w.iter())));
 106
 107     // Zero sized types
 108     #[derive(PartialEq, Debug)]
 109     struct Foo;
 110
 111     let mut a = Vec::new();
 112     let b = vec![Foo, Foo];
 113
 114     a.extend(b);
 115     assert_eq!(a, &[Foo, Foo]);
 116
 117     // Double drop
 118     let mut count_x = 0;
 119     {
 120         let mut x = Vec::new();
 121         let y = vec![DropCounter { count: &mut count_x }];
 122         x.extend(y);
 123     }
 124     assert_eq!(count_x, 1);
 125 }
 126
 127 #[test]
 128 fn test_extend_ref() {
 129     let mut v = vec![1, 2];
 130     v.extend(&[3, 4, 5]);
 131
 132     assert_eq!(v.len(), 5);
 133     assert_eq!(v, [1, 2, 3, 4, 5]);
 134
 135     let w = vec![6, 7];
 136     v.extend(&w);
 137
 138     assert_eq!(v.len(), 7);
 139     assert_eq!(v, [1, 2, 3, 4, 5, 6, 7]);
 140 }
 141
 142 #[test]
 143 fn test_slice_from_mut() {
 144     let mut values = vec![1, 2, 3, 4, 5];
 145     {
 146         let slice = &mut values[2..];
 147         assert!(slice == [3, 4, 5]);
 148         for p in slice {
 149             *p += 2;
 150         }
 151     }
 152
 153     assert!(values == [1, 2, 5, 6, 7]);
 154 }
 155
 156 #[test]
 157 fn test_slice_to_mut() {
 158     let mut values = vec![1, 2, 3, 4, 5];
 159     {
 160         let slice = &mut values[..2];
 161         assert!(slice == [1, 2]);
 162         for p in slice {
 163             *p += 1;
 164         }
 165     }
 166
 167     assert!(values == [2, 3, 3, 4, 5]);
 168 }
 169
 170 #[test]
 171 fn test_split_at_mut() {
 172     let mut values = vec![1, 2, 3, 4, 5];
 173     {
 174         let (left, right) = values.split_at_mut(2);
 175         {
 176             let left: &[_] = left;
 177             assert!(&left[..left.len()] == &[1, 2]);
 178         }
 179         for p in left {
 180             *p += 1;
 181         }
 182
 183         {
 184             let right: &[_] = right;
 185             assert!(&right[..right.len()] == &[3, 4, 5]);
 186         }
 187         for p in right {
 188             *p += 2;
 189         }
 190     }
 191
 192     assert_eq!(values, [2, 3, 5, 6, 7]);
 193 }
 194
 195 #[test]
 196 fn test_clone() {
 197     let v: Vec<i32> = vec![];
 198     let w = vec![1, 2, 3];
 199
 200     assert_eq!(v, v.clone());
 201
 202     let z = w.clone();
 203     assert_eq!(w, z);
 204     // they should be disjoint in memory.
 205     assert!(w.as_ptr() != z.as_ptr())
 206 }
 207
 208 #[test]
 209 fn test_clone_from() {
 210     let mut v = vec![];
 211     let three: Vec<Box<_>> = vec![box 1, box 2, box 3];
 212     let two: Vec<Box<_>> = vec![box 4, box 5];
 213     // zero, long
 214     v.clone_from(&three);
 215     assert_eq!(v, three);
 216
 217     // equal
 218     v.clone_from(&three);
 219     assert_eq!(v, three);
 220
 221     // long, short
 222     v.clone_from(&two);
 223     assert_eq!(v, two);
 224
 225     // short, long
 226     v.clone_from(&three);
 227     assert_eq!(v, three)
 228 }
 229
 230 #[test]
 231 fn test_retain() {
 232     let mut vec = vec![1, 2, 3, 4];
 233     vec.retain(|&x| x % 2 == 0);
 234     assert_eq!(vec, [2, 4]);
 235 }
 236
 237 #[test]
 238 fn test_dedup() {
 239     fn case(a: Vec<i32>, b: Vec<i32>) {
 240         let mut v = a;
 241         v.dedup();
 242         assert_eq!(v, b);
 243     }
 244     case(vec![], vec![]);
 245     case(vec![1], vec![1]);
 246     case(vec![1, 1], vec![1]);
 247     case(vec![1, 2, 3], vec![1, 2, 3]);
 248     case(vec![1, 1, 2, 3], vec![1, 2, 3]);
 249     case(vec![1, 2, 2, 3], vec![1, 2, 3]);
 250     case(vec![1, 2, 3, 3], vec![1, 2, 3]);
 251     case(vec![1, 1, 2, 2, 2, 3, 3], vec![1, 2, 3]);
 252 }
 253
 254 #[test]
 255 fn test_dedup_by_key() {
 256     fn case(a: Vec<i32>, b: Vec<i32>) {
 257         let mut v = a;
 258         v.dedup_by_key(|i| *i / 10);
 259         assert_eq!(v, b);
 260     }
 261     case(vec![], vec![]);
 262     case(vec![10], vec![10]);
 263     case(vec![10, 11], vec![10]);
 264     case(vec![10, 20, 30], vec![10, 20, 30]);
 265     case(vec![10, 11, 20, 30], vec![10, 20, 30]);
 266     case(vec![10, 20, 21, 30], vec![10, 20, 30]);
 267     case(vec![10, 20, 30, 31], vec![10, 20, 30]);
 268     case(vec![10, 11, 20, 21, 22, 30, 31], vec![10, 20, 30]);
 269 }
 270
 271 #[test]
 272 fn test_dedup_by() {
 273     let mut vec = vec!["foo", "bar", "Bar", "baz", "bar"];
 274     vec.dedup_by(|a, b| a.eq_ignore_ascii_case(b));
 275
 276     assert_eq!(vec, ["foo", "bar", "baz", "bar"]);
 277 }
 278
 279 #[test]
 280 fn test_dedup_unique() {
 281     let mut v0: Vec<Box<_>> = vec![box 1, box 1, box 2, box 3];
 282     v0.dedup();
 283     let mut v1: Vec<Box<_>> = vec![box 1, box 2, box 2, box 3];
 284     v1.dedup();
 285     let mut v2: Vec<Box<_>> = vec![box 1, box 2, box 3, box 3];
 286     v2.dedup();
 287     // If the boxed pointers were leaked or otherwise misused, valgrind
 288     // and/or rt should raise errors.
 289 }
 290
 291 #[test]
 292 fn zero_sized_values() {
 293     let mut v = Vec::new();
 294     assert_eq!(v.len(), 0);
 295     v.push(());
 296     assert_eq!(v.len(), 1);
 297     v.push(());
 298     assert_eq!(v.len(), 2);
 299     assert_eq!(v.pop(), Some(()));
 300     assert_eq!(v.pop(), Some(()));
 301     assert_eq!(v.pop(), None);
 302
 303     assert_eq!(v.iter().count(), 0);
 304     v.push(());
 305     assert_eq!(v.iter().count(), 1);
 306     v.push(());
 307     assert_eq!(v.iter().count(), 2);
 308
 309     for &() in &v {}
 310
 311     assert_eq!(v.iter_mut().count(), 2);
 312     v.push(());
 313     assert_eq!(v.iter_mut().count(), 3);
 314     v.push(());
 315     assert_eq!(v.iter_mut().count(), 4);
 316
 317     for &mut () in &mut v {}
 318     unsafe {
 319         v.set_len(0);
 320     }
 321     assert_eq!(v.iter_mut().count(), 0);
 322 }
 323
 324 #[test]
 325 fn test_partition() {
 326     assert_eq!(vec![].into_iter().partition(|x: &i32| *x < 3),
 327                (vec![], vec![]));
 328     assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 4),
 329                (vec![1, 2, 3], vec![]));
 330     assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 2),
 331                (vec![1], vec![2, 3]));
 332     assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 0),
 333                (vec![], vec![1, 2, 3]));
 334 }
 335
 336 #[test]
 337 fn test_zip_unzip() {
 338     let z1 = vec![(1, 4), (2, 5), (3, 6)];
 339
 340     let (left, right): (Vec<_>, Vec<_>) = z1.iter().cloned().unzip();
 341
 342     assert_eq!((1, 4), (left[0], right[0]));
 343     assert_eq!((2, 5), (left[1], right[1]));
 344     assert_eq!((3, 6), (left[2], right[2]));
 345 }
 346
 347 #[test]
 348 fn test_vec_truncate_drop() {
 349     static mut DROPS: u32 = 0;
 350     struct Elem(i32);
 351     impl Drop for Elem {
 352         fn drop(&mut self) {
 353             unsafe {
 354                 DROPS += 1;
 355             }
 356         }
 357     }
 358
 359     let mut v = vec![Elem(1), Elem(2), Elem(3), Elem(4), Elem(5)];
 360     assert_eq!(unsafe { DROPS }, 0);
 361     v.truncate(3);
 362     assert_eq!(unsafe { DROPS }, 2);
 363     v.truncate(0);
 364     assert_eq!(unsafe { DROPS }, 5);
 365 }
 366
 367 #[test]
 368 #[should_panic]
 369 fn test_vec_truncate_fail() {
 370     struct BadElem(i32);
 371     impl Drop for BadElem {
 372         fn drop(&mut self) {
 373             let BadElem(ref mut x) = *self;
 374             if *x == 0xbadbeef {
 375                 panic!("BadElem panic: 0xbadbeef")
 376             }
 377         }
 378     }
 379
 380     let mut v = vec![BadElem(1), BadElem(2), BadElem(0xbadbeef), BadElem(4)];
 381     v.truncate(0);
 382 }
 383
 384 #[test]
 385 fn test_index() {
 386     let vec = vec![1, 2, 3];
 387     assert!(vec[1] == 2);
 388 }
 389
 390 #[test]
 391 #[should_panic]
 392 fn test_index_out_of_bounds() {
 393     let vec = vec![1, 2, 3];
 394     let _ = vec[3];
 395 }
 396
 397 #[test]
 398 #[should_panic]
 399 fn test_slice_out_of_bounds_1() {
 400     let x = vec![1, 2, 3, 4, 5];
 401     &x[!0..];
 402 }
 403
 404 #[test]
 405 #[should_panic]
 406 fn test_slice_out_of_bounds_2() {
 407     let x = vec![1, 2, 3, 4, 5];
 408     &x[..6];
 409 }
 410
 411 #[test]
 412 #[should_panic]
 413 fn test_slice_out_of_bounds_3() {
 414     let x = vec![1, 2, 3, 4, 5];
 415     &x[!0..4];
 416 }
 417
 418 #[test]
 419 #[should_panic]
 420 fn test_slice_out_of_bounds_4() {
 421     let x = vec![1, 2, 3, 4, 5];
 422     &x[1..6];
 423 }
 424
 425 #[test]
 426 #[should_panic]
 427 fn test_slice_out_of_bounds_5() {
 428     let x = vec![1, 2, 3, 4, 5];
 429     &x[3..2];
 430 }
 431
 432 #[test]
 433 #[should_panic]
 434 fn test_swap_remove_empty() {
 435     let mut vec = Vec::<i32>::new();
 436     vec.swap_remove(0);
 437 }
 438
 439 #[test]
 440 fn test_move_items() {
 441     let vec = vec![1, 2, 3];
 442     let mut vec2 = vec![];
 443     for i in vec {
 444         vec2.push(i);
 445     }
 446     assert_eq!(vec2, [1, 2, 3]);
 447 }
 448
 449 #[test]
 450 fn test_move_items_reverse() {
 451     let vec = vec![1, 2, 3];
 452     let mut vec2 = vec![];
 453     for i in vec.into_iter().rev() {
 454         vec2.push(i);
 455     }
 456     assert_eq!(vec2, [3, 2, 1]);
 457 }
 458
 459 #[test]
 460 fn test_move_items_zero_sized() {
 461     let vec = vec![(), (), ()];
 462     let mut vec2 = vec![];
 463     for i in vec {
 464         vec2.push(i);
 465     }
 466     assert_eq!(vec2, [(), (), ()]);
 467 }
 468
 469 #[test]
 470 fn test_drain_items() {
 471     let mut vec = vec![1, 2, 3];
 472     let mut vec2 = vec![];
 473     for i in vec.drain(..) {
 474         vec2.push(i);
 475     }
 476     assert_eq!(vec, []);
 477     assert_eq!(vec2, [1, 2, 3]);
 478 }
 479
 480 #[test]
 481 fn test_drain_items_reverse() {
 482     let mut vec = vec![1, 2, 3];
 483     let mut vec2 = vec![];
 484     for i in vec.drain(..).rev() {
 485         vec2.push(i);
 486     }
 487     assert_eq!(vec, []);
 488     assert_eq!(vec2, [3, 2, 1]);
 489 }
 490
 491 #[test]
 492 fn test_drain_items_zero_sized() {
 493     let mut vec = vec![(), (), ()];
 494     let mut vec2 = vec![];
 495     for i in vec.drain(..) {
 496         vec2.push(i);
 497     }
 498     assert_eq!(vec, []);
 499     assert_eq!(vec2, [(), (), ()]);
 500 }
 501
 502 #[test]
 503 #[should_panic]
 504 fn test_drain_out_of_bounds() {
 505     let mut v = vec![1, 2, 3, 4, 5];
 506     v.drain(5..6);
 507 }
 508
 509 #[test]
 510 fn test_drain_range() {
 511     let mut v = vec![1, 2, 3, 4, 5];
 512     for _ in v.drain(4..) {
 513     }
 514     assert_eq!(v, &[1, 2, 3, 4]);
 515
 516     let mut v: Vec<_> = (1..6).map(|x| x.to_string()).collect();
 517     for _ in v.drain(1..4) {
 518     }
 519     assert_eq!(v, &[1.to_string(), 5.to_string()]);
 520
 521     let mut v: Vec<_> = (1..6).map(|x| x.to_string()).collect();
 522     for _ in v.drain(1..4).rev() {
 523     }
 524     assert_eq!(v, &[1.to_string(), 5.to_string()]);
 525
 526     let mut v: Vec<_> = vec![(); 5];
 527     for _ in v.drain(1..4).rev() {
 528     }
 529     assert_eq!(v, &[(), ()]);
 530 }
 531
 532 #[test]
 533 fn test_drain_inclusive_range() {
 534     let mut v = vec!['a', 'b', 'c', 'd', 'e'];
 535     for _ in v.drain(1...3) {
 536     }
 537     assert_eq!(v, &['a', 'e']);
 538
 539     let mut v: Vec<_> = (0...5).map(|x| x.to_string()).collect();
 540     for _ in v.drain(1...5) {
 541     }
 542     assert_eq!(v, &["0".to_string()]);
 543
 544     let mut v: Vec<String> = (0...5).map(|x| x.to_string()).collect();
 545     for _ in v.drain(0...5) {
 546     }
 547     assert_eq!(v, Vec::<String>::new());
 548
 549     let mut v: Vec<_> = (0...5).map(|x| x.to_string()).collect();
 550     for _ in v.drain(0...3) {
 551     }
 552     assert_eq!(v, &["4".to_string(), "5".to_string()]);
 553
 554     let mut v: Vec<_> = (0...1).map(|x| x.to_string()).collect();
 555     for _ in v.drain(...0) {
 556     }
 557     assert_eq!(v, &["1".to_string()]);
 558 }
 559
 560 #[test]
 561 fn test_drain_max_vec_size() {
 562     let mut v = Vec::<()>::with_capacity(usize::max_value());
 563     unsafe { v.set_len(usize::max_value()); }
 564     for _ in v.drain(usize::max_value() - 1..) {
 565     }
 566     assert_eq!(v.len(), usize::max_value() - 1);
 567
 568     let mut v = Vec::<()>::with_capacity(usize::max_value());
 569     unsafe { v.set_len(usize::max_value()); }
 570     for _ in v.drain(usize::max_value() - 1...usize::max_value() - 1) {
 571     }
 572     assert_eq!(v.len(), usize::max_value() - 1);
 573 }
 574
 575 #[test]
 576 #[should_panic]
 577 fn test_drain_inclusive_out_of_bounds() {
 578     let mut v = vec![1, 2, 3, 4, 5];
 579     v.drain(5...5);
 580 }
 581
 582 #[test]
 583 fn test_splice() {
 584     let mut v = vec![1, 2, 3, 4, 5];
 585     let a = [10, 11, 12];
 586     v.splice(2..4, a.iter().cloned());
 587     assert_eq!(v, &[1, 2, 10, 11, 12, 5]);
 588     v.splice(1..3, Some(20));
 589     assert_eq!(v, &[1, 20, 11, 12, 5]);
 590 }
 591
 592 #[test]
 593 fn test_splice_inclusive_range() {
 594     let mut v = vec![1, 2, 3, 4, 5];
 595     let a = [10, 11, 12];
 596     let t1: Vec<_> = v.splice(2...3, a.iter().cloned()).collect();
 597     assert_eq!(v, &[1, 2, 10, 11, 12, 5]);
 598     assert_eq!(t1, &[3, 4]);
 599     let t2: Vec<_> = v.splice(1...2, Some(20)).collect();
 600     assert_eq!(v, &[1, 20, 11, 12, 5]);
 601     assert_eq!(t2, &[2, 10]);
 602 }
 603
 604 #[test]
 605 #[should_panic]
 606 fn test_splice_out_of_bounds() {
 607     let mut v = vec![1, 2, 3, 4, 5];
 608     let a = [10, 11, 12];
 609     v.splice(5..6, a.iter().cloned());
 610 }
 611
 612 #[test]
 613 #[should_panic]
 614 fn test_splice_inclusive_out_of_bounds() {
 615     let mut v = vec![1, 2, 3, 4, 5];
 616     let a = [10, 11, 12];
 617     v.splice(5...5, a.iter().cloned());
 618 }
 619
 620 #[test]
 621 fn test_splice_items_zero_sized() {
 622     let mut vec = vec![(), (), ()];
 623     let vec2 = vec![];
 624     let t: Vec<_> = vec.splice(1..2, vec2.iter().cloned()).collect();
 625     assert_eq!(vec, &[(), ()]);
 626     assert_eq!(t, &[()]);
 627 }
 628
 629 #[test]
 630 fn test_splice_unbounded() {
 631     let mut vec = vec![1, 2, 3, 4, 5];
 632     let t: Vec<_> = vec.splice(.., None).collect();
 633     assert_eq!(vec, &[]);
 634     assert_eq!(t, &[1, 2, 3, 4, 5]);
 635 }
 636
 637 #[test]
 638 fn test_splice_forget() {
 639     let mut v = vec![1, 2, 3, 4, 5];
 640     let a = [10, 11, 12];
 641     ::std::mem::forget(v.splice(2..4, a.iter().cloned()));
 642     assert_eq!(v, &[1, 2]);
 643 }
 644
 645 #[test]
 646 fn test_into_boxed_slice() {
 647     let xs = vec![1, 2, 3];
 648     let ys = xs.into_boxed_slice();
 649     assert_eq!(&*ys, [1, 2, 3]);
 650 }
 651
 652 #[test]
 653 fn test_append() {
 654     let mut vec = vec![1, 2, 3];
 655     let mut vec2 = vec![4, 5, 6];
 656     vec.append(&mut vec2);
 657     assert_eq!(vec, [1, 2, 3, 4, 5, 6]);
 658     assert_eq!(vec2, []);
 659 }
 660
 661 #[test]
 662 fn test_split_off() {
 663     let mut vec = vec![1, 2, 3, 4, 5, 6];
 664     let vec2 = vec.split_off(4);
 665     assert_eq!(vec, [1, 2, 3, 4]);
 666     assert_eq!(vec2, [5, 6]);
 667 }
 668
 669 #[test]
 670 fn test_into_iter_as_slice() {
 671     let vec = vec!['a', 'b', 'c'];
 672     let mut into_iter = vec.into_iter();
 673     assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']);
 674     let _ = into_iter.next().unwrap();
 675     assert_eq!(into_iter.as_slice(), &['b', 'c']);
 676     let _ = into_iter.next().unwrap();
 677     let _ = into_iter.next().unwrap();
 678     assert_eq!(into_iter.as_slice(), &[]);
 679 }
 680
 681 #[test]
 682 fn test_into_iter_as_mut_slice() {
 683     let vec = vec!['a', 'b', 'c'];
 684     let mut into_iter = vec.into_iter();
 685     assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']);
 686     into_iter.as_mut_slice()[0] = 'x';
 687     into_iter.as_mut_slice()[1] = 'y';
 688     assert_eq!(into_iter.next().unwrap(), 'x');
 689     assert_eq!(into_iter.as_slice(), &['y', 'c']);
 690 }
 691
 692 #[test]
 693 fn test_into_iter_debug() {
 694     let vec = vec!['a', 'b', 'c'];
 695     let into_iter = vec.into_iter();
 696     let debug = format!("{:?}", into_iter);
 697     assert_eq!(debug, "IntoIter(['a', 'b', 'c'])");
 698 }
 699
 700 #[test]
 701 fn test_into_iter_count() {
 702     assert_eq!(vec![1, 2, 3].into_iter().count(), 3);
 703 }
 704
 705 #[test]
 706 fn test_into_iter_clone() {
 707     fn iter_equal<I: Iterator<Item = i32>>(it: I, slice: &[i32]) {
 708         let v: Vec<i32> = it.collect();
 709         assert_eq!(&v[..], slice);
 710     }
 711     let mut it = vec![1, 2, 3].into_iter();
 712     iter_equal(it.clone(), &[1, 2, 3]);
 713     assert_eq!(it.next(), Some(1));
 714     let mut it = it.rev();
 715     iter_equal(it.clone(), &[3, 2]);
 716     assert_eq!(it.next(), Some(3));
 717     iter_equal(it.clone(), &[2]);
 718     assert_eq!(it.next(), Some(2));
 719     iter_equal(it.clone(), &[]);
 720     assert_eq!(it.next(), None);
 721 }
 722
 723 #[test]
 724 fn test_cow_from() {
 725     let borrowed: &[_] = &["borrowed", "(slice)"];
 726     let owned = vec!["owned", "(vec)"];
 727     match (Cow::from(owned.clone()), Cow::from(borrowed)) {
 728         (Cow::Owned(o), Cow::Borrowed(b)) => assert!(o == owned && b == borrowed),
 729         _ => panic!("invalid `Cow::from`"),
 730     }
 731 }
 732
 733 #[test]
 734 fn test_from_cow() {
 735     let borrowed: &[_] = &["borrowed", "(slice)"];
 736     let owned = vec!["owned", "(vec)"];
 737     assert_eq!(Vec::from(Cow::Borrowed(borrowed)), vec!["borrowed", "(slice)"]);
 738     assert_eq!(Vec::from(Cow::Owned(owned)), vec!["owned", "(vec)"]);
 739 }
 740
 741 #[allow(dead_code)]
 742 fn assert_covariance() {
 743     fn drain<'new>(d: Drain<'static, &'static str>) -> Drain<'new, &'new str> {
 744         d
 745     }
 746     fn into_iter<'new>(i: IntoIter<&'static str>) -> IntoIter<&'new str> {
 747         i
 748     }
 749 }
 750
 751 #[test]
 752 fn test_placement() {
 753     let mut vec = vec![1];
 754     assert_eq!(vec.place_back() <- 2, &2);
 755     assert_eq!(vec.len(), 2);
 756     assert_eq!(vec.place_back() <- 3, &3);
 757     assert_eq!(vec.len(), 3);
 758     assert_eq!(&vec, &[1, 2, 3]);
 759 }
 760
 761 #[test]
 762 fn test_placement_panic() {
 763     let mut vec = vec![1, 2, 3];
 764     fn mkpanic() -> usize { panic!() }
 765     let _ = panic::catch_unwind(panic::AssertUnwindSafe(|| { vec.place_back() <- mkpanic(); }));
 766     assert_eq!(vec.len(), 3);
 767 }
 768
 769 #[test]
 770 fn from_into_inner() {
 771     let vec = vec![1, 2, 3];
 772     let ptr = vec.as_ptr();
 773     let vec = vec.into_iter().collect::<Vec<_>>();
 774     assert_eq!(vec, [1, 2, 3]);
 775     assert_eq!(vec.as_ptr(), ptr);
 776
 777     let ptr = &vec[1] as *const _;
 778     let mut it = vec.into_iter();
 779     it.next().unwrap();
 780     let vec = it.collect::<Vec<_>>();
 781     assert_eq!(vec, [2, 3]);
 782     assert!(ptr != vec.as_ptr());
 783 }
 784
 785 #[test]
 786 fn overaligned_allocations() {
 787     #[repr(align(256))]
 788     struct Foo(usize);
 789     let mut v = vec![Foo(273)];
 790     for i in 0..0x1000 {
 791         v.reserve_exact(i);
 792         assert!(v[0].0 == 273);
 793         assert!(v.as_ptr() as usize & 0xff == 0);
 794         v.shrink_to_fit();
 795         assert!(v[0].0 == 273);
 796         assert!(v.as_ptr() as usize & 0xff == 0);
 797     }
 798 }