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     let mut vec = vec![("foo", 1), ("foo", 2), ("bar", 3), ("bar", 4), ("bar", 5)];
 279     vec.dedup_by(|a, b| a.0 == b.0 && { b.1 += a.1; true });
 280
 281     assert_eq!(vec, [("foo", 3), ("bar", 12)]);
 282 }
 283
 284 #[test]
 285 fn test_dedup_unique() {
 286     let mut v0: Vec<Box<_>> = vec![box 1, box 1, box 2, box 3];
 287     v0.dedup();
 288     let mut v1: Vec<Box<_>> = vec![box 1, box 2, box 2, box 3];
 289     v1.dedup();
 290     let mut v2: Vec<Box<_>> = vec![box 1, box 2, box 3, box 3];
 291     v2.dedup();
 292     // If the boxed pointers were leaked or otherwise misused, valgrind
 293     // and/or rt should raise errors.
 294 }
 295
 296 #[test]
 297 fn zero_sized_values() {
 298     let mut v = Vec::new();
 299     assert_eq!(v.len(), 0);
 300     v.push(());
 301     assert_eq!(v.len(), 1);
 302     v.push(());
 303     assert_eq!(v.len(), 2);
 304     assert_eq!(v.pop(), Some(()));
 305     assert_eq!(v.pop(), Some(()));
 306     assert_eq!(v.pop(), None);
 307
 308     assert_eq!(v.iter().count(), 0);
 309     v.push(());
 310     assert_eq!(v.iter().count(), 1);
 311     v.push(());
 312     assert_eq!(v.iter().count(), 2);
 313
 314     for &() in &v {}
 315
 316     assert_eq!(v.iter_mut().count(), 2);
 317     v.push(());
 318     assert_eq!(v.iter_mut().count(), 3);
 319     v.push(());
 320     assert_eq!(v.iter_mut().count(), 4);
 321
 322     for &mut () in &mut v {}
 323     unsafe {
 324         v.set_len(0);
 325     }
 326     assert_eq!(v.iter_mut().count(), 0);
 327 }
 328
 329 #[test]
 330 fn test_partition() {
 331     assert_eq!(vec![].into_iter().partition(|x: &i32| *x < 3),
 332                (vec![], vec![]));
 333     assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 4),
 334                (vec![1, 2, 3], vec![]));
 335     assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 2),
 336                (vec![1], vec![2, 3]));
 337     assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 0),
 338                (vec![], vec![1, 2, 3]));
 339 }
 340
 341 #[test]
 342 fn test_zip_unzip() {
 343     let z1 = vec![(1, 4), (2, 5), (3, 6)];
 344
 345     let (left, right): (Vec<_>, Vec<_>) = z1.iter().cloned().unzip();
 346
 347     assert_eq!((1, 4), (left[0], right[0]));
 348     assert_eq!((2, 5), (left[1], right[1]));
 349     assert_eq!((3, 6), (left[2], right[2]));
 350 }
 351
 352 #[test]
 353 fn test_vec_truncate_drop() {
 354     static mut DROPS: u32 = 0;
 355     struct Elem(i32);
 356     impl Drop for Elem {
 357         fn drop(&mut self) {
 358             unsafe {
 359                 DROPS += 1;
 360             }
 361         }
 362     }
 363
 364     let mut v = vec![Elem(1), Elem(2), Elem(3), Elem(4), Elem(5)];
 365     assert_eq!(unsafe { DROPS }, 0);
 366     v.truncate(3);
 367     assert_eq!(unsafe { DROPS }, 2);
 368     v.truncate(0);
 369     assert_eq!(unsafe { DROPS }, 5);
 370 }
 371
 372 #[test]
 373 #[should_panic]
 374 fn test_vec_truncate_fail() {
 375     struct BadElem(i32);
 376     impl Drop for BadElem {
 377         fn drop(&mut self) {
 378             let BadElem(ref mut x) = *self;
 379             if *x == 0xbadbeef {
 380                 panic!("BadElem panic: 0xbadbeef")
 381             }
 382         }
 383     }
 384
 385     let mut v = vec![BadElem(1), BadElem(2), BadElem(0xbadbeef), BadElem(4)];
 386     v.truncate(0);
 387 }
 388
 389 #[test]
 390 fn test_index() {
 391     let vec = vec![1, 2, 3];
 392     assert!(vec[1] == 2);
 393 }
 394
 395 #[test]
 396 #[should_panic]
 397 fn test_index_out_of_bounds() {
 398     let vec = vec![1, 2, 3];
 399     let _ = vec[3];
 400 }
 401
 402 #[test]
 403 #[should_panic]
 404 fn test_slice_out_of_bounds_1() {
 405     let x = vec![1, 2, 3, 4, 5];
 406     &x[!0..];
 407 }
 408
 409 #[test]
 410 #[should_panic]
 411 fn test_slice_out_of_bounds_2() {
 412     let x = vec![1, 2, 3, 4, 5];
 413     &x[..6];
 414 }
 415
 416 #[test]
 417 #[should_panic]
 418 fn test_slice_out_of_bounds_3() {
 419     let x = vec![1, 2, 3, 4, 5];
 420     &x[!0..4];
 421 }
 422
 423 #[test]
 424 #[should_panic]
 425 fn test_slice_out_of_bounds_4() {
 426     let x = vec![1, 2, 3, 4, 5];
 427     &x[1..6];
 428 }
 429
 430 #[test]
 431 #[should_panic]
 432 fn test_slice_out_of_bounds_5() {
 433     let x = vec![1, 2, 3, 4, 5];
 434     &x[3..2];
 435 }
 436
 437 #[test]
 438 #[should_panic]
 439 fn test_swap_remove_empty() {
 440     let mut vec = Vec::<i32>::new();
 441     vec.swap_remove(0);
 442 }
 443
 444 #[test]
 445 fn test_move_items() {
 446     let vec = vec![1, 2, 3];
 447     let mut vec2 = vec![];
 448     for i in vec {
 449         vec2.push(i);
 450     }
 451     assert_eq!(vec2, [1, 2, 3]);
 452 }
 453
 454 #[test]
 455 fn test_move_items_reverse() {
 456     let vec = vec![1, 2, 3];
 457     let mut vec2 = vec![];
 458     for i in vec.into_iter().rev() {
 459         vec2.push(i);
 460     }
 461     assert_eq!(vec2, [3, 2, 1]);
 462 }
 463
 464 #[test]
 465 fn test_move_items_zero_sized() {
 466     let vec = vec![(), (), ()];
 467     let mut vec2 = vec![];
 468     for i in vec {
 469         vec2.push(i);
 470     }
 471     assert_eq!(vec2, [(), (), ()]);
 472 }
 473
 474 #[test]
 475 fn test_drain_items() {
 476     let mut vec = vec![1, 2, 3];
 477     let mut vec2 = vec![];
 478     for i in vec.drain(..) {
 479         vec2.push(i);
 480     }
 481     assert_eq!(vec, []);
 482     assert_eq!(vec2, [1, 2, 3]);
 483 }
 484
 485 #[test]
 486 fn test_drain_items_reverse() {
 487     let mut vec = vec![1, 2, 3];
 488     let mut vec2 = vec![];
 489     for i in vec.drain(..).rev() {
 490         vec2.push(i);
 491     }
 492     assert_eq!(vec, []);
 493     assert_eq!(vec2, [3, 2, 1]);
 494 }
 495
 496 #[test]
 497 fn test_drain_items_zero_sized() {
 498     let mut vec = vec![(), (), ()];
 499     let mut vec2 = vec![];
 500     for i in vec.drain(..) {
 501         vec2.push(i);
 502     }
 503     assert_eq!(vec, []);
 504     assert_eq!(vec2, [(), (), ()]);
 505 }
 506
 507 #[test]
 508 #[should_panic]
 509 fn test_drain_out_of_bounds() {
 510     let mut v = vec![1, 2, 3, 4, 5];
 511     v.drain(5..6);
 512 }
 513
 514 #[test]
 515 fn test_drain_range() {
 516     let mut v = vec![1, 2, 3, 4, 5];
 517     for _ in v.drain(4..) {
 518     }
 519     assert_eq!(v, &[1, 2, 3, 4]);
 520
 521     let mut v: Vec<_> = (1..6).map(|x| x.to_string()).collect();
 522     for _ in v.drain(1..4) {
 523     }
 524     assert_eq!(v, &[1.to_string(), 5.to_string()]);
 525
 526     let mut v: Vec<_> = (1..6).map(|x| x.to_string()).collect();
 527     for _ in v.drain(1..4).rev() {
 528     }
 529     assert_eq!(v, &[1.to_string(), 5.to_string()]);
 530
 531     let mut v: Vec<_> = vec![(); 5];
 532     for _ in v.drain(1..4).rev() {
 533     }
 534     assert_eq!(v, &[(), ()]);
 535 }
 536
 537 #[test]
 538 fn test_drain_inclusive_range() {
 539     let mut v = vec!['a', 'b', 'c', 'd', 'e'];
 540     for _ in v.drain(1...3) {
 541     }
 542     assert_eq!(v, &['a', 'e']);
 543
 544     let mut v: Vec<_> = (0...5).map(|x| x.to_string()).collect();
 545     for _ in v.drain(1...5) {
 546     }
 547     assert_eq!(v, &["0".to_string()]);
 548
 549     let mut v: Vec<String> = (0...5).map(|x| x.to_string()).collect();
 550     for _ in v.drain(0...5) {
 551     }
 552     assert_eq!(v, Vec::<String>::new());
 553
 554     let mut v: Vec<_> = (0...5).map(|x| x.to_string()).collect();
 555     for _ in v.drain(0...3) {
 556     }
 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     }
 562     assert_eq!(v, &["1".to_string()]);
 563 }
 564
 565 #[test]
 566 fn test_drain_max_vec_size() {
 567     let mut v = Vec::<()>::with_capacity(usize::max_value());
 568     unsafe { v.set_len(usize::max_value()); }
 569     for _ in v.drain(usize::max_value() - 1..) {
 570     }
 571     assert_eq!(v.len(), usize::max_value() - 1);
 572
 573     let mut v = Vec::<()>::with_capacity(usize::max_value());
 574     unsafe { v.set_len(usize::max_value()); }
 575     for _ in v.drain(usize::max_value() - 1...usize::max_value() - 1) {
 576     }
 577     assert_eq!(v.len(), usize::max_value() - 1);
 578 }
 579
 580 #[test]
 581 #[should_panic]
 582 fn test_drain_inclusive_out_of_bounds() {
 583     let mut v = vec![1, 2, 3, 4, 5];
 584     v.drain(5...5);
 585 }
 586
 587 #[test]
 588 fn test_splice() {
 589     let mut v = vec![1, 2, 3, 4, 5];
 590     let a = [10, 11, 12];
 591     v.splice(2..4, a.iter().cloned());
 592     assert_eq!(v, &[1, 2, 10, 11, 12, 5]);
 593     v.splice(1..3, Some(20));
 594     assert_eq!(v, &[1, 20, 11, 12, 5]);
 595 }
 596
 597 #[test]
 598 fn test_splice_inclusive_range() {
 599     let mut v = vec![1, 2, 3, 4, 5];
 600     let a = [10, 11, 12];
 601     let t1: Vec<_> = v.splice(2...3, a.iter().cloned()).collect();
 602     assert_eq!(v, &[1, 2, 10, 11, 12, 5]);
 603     assert_eq!(t1, &[3, 4]);
 604     let t2: Vec<_> = v.splice(1...2, Some(20)).collect();
 605     assert_eq!(v, &[1, 20, 11, 12, 5]);
 606     assert_eq!(t2, &[2, 10]);
 607 }
 608
 609 #[test]
 610 #[should_panic]
 611 fn test_splice_out_of_bounds() {
 612     let mut v = vec![1, 2, 3, 4, 5];
 613     let a = [10, 11, 12];
 614     v.splice(5..6, a.iter().cloned());
 615 }
 616
 617 #[test]
 618 #[should_panic]
 619 fn test_splice_inclusive_out_of_bounds() {
 620     let mut v = vec![1, 2, 3, 4, 5];
 621     let a = [10, 11, 12];
 622     v.splice(5...5, a.iter().cloned());
 623 }
 624
 625 #[test]
 626 fn test_splice_items_zero_sized() {
 627     let mut vec = vec![(), (), ()];
 628     let vec2 = vec![];
 629     let t: Vec<_> = vec.splice(1..2, vec2.iter().cloned()).collect();
 630     assert_eq!(vec, &[(), ()]);
 631     assert_eq!(t, &[()]);
 632 }
 633
 634 #[test]
 635 fn test_splice_unbounded() {
 636     let mut vec = vec![1, 2, 3, 4, 5];
 637     let t: Vec<_> = vec.splice(.., None).collect();
 638     assert_eq!(vec, &[]);
 639     assert_eq!(t, &[1, 2, 3, 4, 5]);
 640 }
 641
 642 #[test]
 643 fn test_splice_forget() {
 644     let mut v = vec![1, 2, 3, 4, 5];
 645     let a = [10, 11, 12];
 646     ::std::mem::forget(v.splice(2..4, a.iter().cloned()));
 647     assert_eq!(v, &[1, 2]);
 648 }
 649
 650 #[test]
 651 fn test_into_boxed_slice() {
 652     let xs = vec![1, 2, 3];
 653     let ys = xs.into_boxed_slice();
 654     assert_eq!(&*ys, [1, 2, 3]);
 655 }
 656
 657 #[test]
 658 fn test_append() {
 659     let mut vec = vec![1, 2, 3];
 660     let mut vec2 = vec![4, 5, 6];
 661     vec.append(&mut vec2);
 662     assert_eq!(vec, [1, 2, 3, 4, 5, 6]);
 663     assert_eq!(vec2, []);
 664 }
 665
 666 #[test]
 667 fn test_split_off() {
 668     let mut vec = vec![1, 2, 3, 4, 5, 6];
 669     let vec2 = vec.split_off(4);
 670     assert_eq!(vec, [1, 2, 3, 4]);
 671     assert_eq!(vec2, [5, 6]);
 672 }
 673
 674 #[test]
 675 fn test_into_iter_as_slice() {
 676     let vec = vec!['a', 'b', 'c'];
 677     let mut into_iter = vec.into_iter();
 678     assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']);
 679     let _ = into_iter.next().unwrap();
 680     assert_eq!(into_iter.as_slice(), &['b', 'c']);
 681     let _ = into_iter.next().unwrap();
 682     let _ = into_iter.next().unwrap();
 683     assert_eq!(into_iter.as_slice(), &[]);
 684 }
 685
 686 #[test]
 687 fn test_into_iter_as_mut_slice() {
 688     let vec = vec!['a', 'b', 'c'];
 689     let mut into_iter = vec.into_iter();
 690     assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']);
 691     into_iter.as_mut_slice()[0] = 'x';
 692     into_iter.as_mut_slice()[1] = 'y';
 693     assert_eq!(into_iter.next().unwrap(), 'x');
 694     assert_eq!(into_iter.as_slice(), &['y', 'c']);
 695 }
 696
 697 #[test]
 698 fn test_into_iter_debug() {
 699     let vec = vec!['a', 'b', 'c'];
 700     let into_iter = vec.into_iter();
 701     let debug = format!("{:?}", into_iter);
 702     assert_eq!(debug, "IntoIter(['a', 'b', 'c'])");
 703 }
 704
 705 #[test]
 706 fn test_into_iter_count() {
 707     assert_eq!(vec![1, 2, 3].into_iter().count(), 3);
 708 }
 709
 710 #[test]
 711 fn test_into_iter_clone() {
 712     fn iter_equal<I: Iterator<Item = i32>>(it: I, slice: &[i32]) {
 713         let v: Vec<i32> = it.collect();
 714         assert_eq!(&v[..], slice);
 715     }
 716     let mut it = vec![1, 2, 3].into_iter();
 717     iter_equal(it.clone(), &[1, 2, 3]);
 718     assert_eq!(it.next(), Some(1));
 719     let mut it = it.rev();
 720     iter_equal(it.clone(), &[3, 2]);
 721     assert_eq!(it.next(), Some(3));
 722     iter_equal(it.clone(), &[2]);
 723     assert_eq!(it.next(), Some(2));
 724     iter_equal(it.clone(), &[]);
 725     assert_eq!(it.next(), None);
 726 }
 727
 728 #[test]
 729 fn test_cow_from() {
 730     let borrowed: &[_] = &["borrowed", "(slice)"];
 731     let owned = vec!["owned", "(vec)"];
 732     match (Cow::from(owned.clone()), Cow::from(borrowed)) {
 733         (Cow::Owned(o), Cow::Borrowed(b)) => assert!(o == owned && b == borrowed),
 734         _ => panic!("invalid `Cow::from`"),
 735     }
 736 }
 737
 738 #[test]
 739 fn test_from_cow() {
 740     let borrowed: &[_] = &["borrowed", "(slice)"];
 741     let owned = vec!["owned", "(vec)"];
 742     assert_eq!(Vec::from(Cow::Borrowed(borrowed)), vec!["borrowed", "(slice)"]);
 743     assert_eq!(Vec::from(Cow::Owned(owned)), vec!["owned", "(vec)"]);
 744 }
 745
 746 #[allow(dead_code)]
 747 fn assert_covariance() {
 748     fn drain<'new>(d: Drain<'static, &'static str>) -> Drain<'new, &'new str> {
 749         d
 750     }
 751     fn into_iter<'new>(i: IntoIter<&'static str>) -> IntoIter<&'new str> {
 752         i
 753     }
 754 }
 755
 756 #[test]
 757 fn test_placement() {
 758     let mut vec = vec![1];
 759     assert_eq!(vec.place_back() <- 2, &2);
 760     assert_eq!(vec.len(), 2);
 761     assert_eq!(vec.place_back() <- 3, &3);
 762     assert_eq!(vec.len(), 3);
 763     assert_eq!(&vec, &[1, 2, 3]);
 764 }
 765
 766 #[test]
 767 fn test_placement_panic() {
 768     let mut vec = vec![1, 2, 3];
 769     fn mkpanic() -> usize { panic!() }
 770     let _ = panic::catch_unwind(panic::AssertUnwindSafe(|| { vec.place_back() <- mkpanic(); }));
 771     assert_eq!(vec.len(), 3);
 772 }
 773
 774 #[test]
 775 fn from_into_inner() {
 776     let vec = vec![1, 2, 3];
 777     let ptr = vec.as_ptr();
 778     let vec = vec.into_iter().collect::<Vec<_>>();
 779     assert_eq!(vec, [1, 2, 3]);
 780     assert_eq!(vec.as_ptr(), ptr);
 781
 782     let ptr = &vec[1] as *const _;
 783     let mut it = vec.into_iter();
 784     it.next().unwrap();
 785     let vec = it.collect::<Vec<_>>();
 786     assert_eq!(vec, [2, 3]);
 787     assert!(ptr != vec.as_ptr());
 788 }
 789
 790 #[test]
 791 fn overaligned_allocations() {
 792     #[repr(align(256))]
 793     struct Foo(usize);
 794     let mut v = vec![Foo(273)];
 795     for i in 0..0x1000 {
 796         v.reserve_exact(i);
 797         assert!(v[0].0 == 273);
 798         assert!(v.as_ptr() as usize & 0xff == 0);
 799         v.shrink_to_fit();
 800         assert!(v[0].0 == 273);
 801         assert!(v.as_ptr() as usize & 0xff == 0);
 802     }
 803 }