src/libcollectionstest/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::iter::{FromIterator, repeat};
  14 use std::mem::size_of;
  15 use std::panic;
  16 use std::vec::{Drain, IntoIter};
  17
  18 use test::Bencher;
  19
  20 struct DropCounter<'a> {
  21     count: &'a mut u32,
  22 }
  23
  24 impl<'a> Drop for DropCounter<'a> {
  25     fn drop(&mut self) {
  26         *self.count += 1;
  27     }
  28 }
  29
  30 #[test]
  31 fn test_small_vec_struct() {
  32     assert!(size_of::<Vec<u8>>() == size_of::<usize>() * 3);
  33 }
  34
  35 #[test]
  36 fn test_double_drop() {
  37     struct TwoVec<T> {
  38         x: Vec<T>,
  39         y: Vec<T>,
  40     }
  41
  42     let (mut count_x, mut count_y) = (0, 0);
  43     {
  44         let mut tv = TwoVec {
  45             x: Vec::new(),
  46             y: Vec::new(),
  47         };
  48         tv.x.push(DropCounter { count: &mut count_x });
  49         tv.y.push(DropCounter { count: &mut count_y });
  50
  51         // If Vec had a drop flag, here is where it would be zeroed.
  52         // Instead, it should rely on its internal state to prevent
  53         // doing anything significant when dropped multiple times.
  54         drop(tv.x);
  55
  56         // Here tv goes out of scope, tv.y should be dropped, but not tv.x.
  57     }
  58
  59     assert_eq!(count_x, 1);
  60     assert_eq!(count_y, 1);
  61 }
  62
  63 #[test]
  64 fn test_reserve() {
  65     let mut v = Vec::new();
  66     assert_eq!(v.capacity(), 0);
  67
  68     v.reserve(2);
  69     assert!(v.capacity() >= 2);
  70
  71     for i in 0..16 {
  72         v.push(i);
  73     }
  74
  75     assert!(v.capacity() >= 16);
  76     v.reserve(16);
  77     assert!(v.capacity() >= 32);
  78
  79     v.push(16);
  80
  81     v.reserve(16);
  82     assert!(v.capacity() >= 33)
  83 }
  84
  85 #[test]
  86 fn test_extend() {
  87     let mut v = Vec::new();
  88     let mut w = Vec::new();
  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
 108 #[test]
 109 fn test_extend_ref() {
 110     let mut v = vec![1, 2];
 111     v.extend(&[3, 4, 5]);
 112
 113     assert_eq!(v.len(), 5);
 114     assert_eq!(v, [1, 2, 3, 4, 5]);
 115
 116     let w = vec![6, 7];
 117     v.extend(&w);
 118
 119     assert_eq!(v.len(), 7);
 120     assert_eq!(v, [1, 2, 3, 4, 5, 6, 7]);
 121 }
 122
 123 #[test]
 124 fn test_slice_from_mut() {
 125     let mut values = vec![1, 2, 3, 4, 5];
 126     {
 127         let slice = &mut values[2..];
 128         assert!(slice == [3, 4, 5]);
 129         for p in slice {
 130             *p += 2;
 131         }
 132     }
 133
 134     assert!(values == [1, 2, 5, 6, 7]);
 135 }
 136
 137 #[test]
 138 fn test_slice_to_mut() {
 139     let mut values = vec![1, 2, 3, 4, 5];
 140     {
 141         let slice = &mut values[..2];
 142         assert!(slice == [1, 2]);
 143         for p in slice {
 144             *p += 1;
 145         }
 146     }
 147
 148     assert!(values == [2, 3, 3, 4, 5]);
 149 }
 150
 151 #[test]
 152 fn test_split_at_mut() {
 153     let mut values = vec![1, 2, 3, 4, 5];
 154     {
 155         let (left, right) = values.split_at_mut(2);
 156         {
 157             let left: &[_] = left;
 158             assert!(&left[..left.len()] == &[1, 2]);
 159         }
 160         for p in left {
 161             *p += 1;
 162         }
 163
 164         {
 165             let right: &[_] = right;
 166             assert!(&right[..right.len()] == &[3, 4, 5]);
 167         }
 168         for p in right {
 169             *p += 2;
 170         }
 171     }
 172
 173     assert_eq!(values, [2, 3, 5, 6, 7]);
 174 }
 175
 176 #[test]
 177 fn test_clone() {
 178     let v: Vec<i32> = vec![];
 179     let w = vec![1, 2, 3];
 180
 181     assert_eq!(v, v.clone());
 182
 183     let z = w.clone();
 184     assert_eq!(w, z);
 185     // they should be disjoint in memory.
 186     assert!(w.as_ptr() != z.as_ptr())
 187 }
 188
 189 #[test]
 190 fn test_clone_from() {
 191     let mut v = vec![];
 192     let three: Vec<Box<_>> = vec![box 1, box 2, box 3];
 193     let two: Vec<Box<_>> = vec![box 4, box 5];
 194     // zero, long
 195     v.clone_from(&three);
 196     assert_eq!(v, three);
 197
 198     // equal
 199     v.clone_from(&three);
 200     assert_eq!(v, three);
 201
 202     // long, short
 203     v.clone_from(&two);
 204     assert_eq!(v, two);
 205
 206     // short, long
 207     v.clone_from(&three);
 208     assert_eq!(v, three)
 209 }
 210
 211 #[test]
 212 fn test_retain() {
 213     let mut vec = vec![1, 2, 3, 4];
 214     vec.retain(|&x| x % 2 == 0);
 215     assert_eq!(vec, [2, 4]);
 216 }
 217
 218 #[test]
 219 fn test_dedup() {
 220     fn case(a: Vec<i32>, b: Vec<i32>) {
 221         let mut v = a;
 222         v.dedup();
 223         assert_eq!(v, b);
 224     }
 225     case(vec![], vec![]);
 226     case(vec![1], vec![1]);
 227     case(vec![1, 1], vec![1]);
 228     case(vec![1, 2, 3], vec![1, 2, 3]);
 229     case(vec![1, 1, 2, 3], vec![1, 2, 3]);
 230     case(vec![1, 2, 2, 3], vec![1, 2, 3]);
 231     case(vec![1, 2, 3, 3], vec![1, 2, 3]);
 232     case(vec![1, 1, 2, 2, 2, 3, 3], vec![1, 2, 3]);
 233 }
 234
 235 #[test]
 236 fn test_dedup_by_key() {
 237     fn case(a: Vec<i32>, b: Vec<i32>) {
 238         let mut v = a;
 239         v.dedup_by_key(|i| *i / 10);
 240         assert_eq!(v, b);
 241     }
 242     case(vec![], vec![]);
 243     case(vec![10], vec![10]);
 244     case(vec![10, 11], vec![10]);
 245     case(vec![10, 20, 30], vec![10, 20, 30]);
 246     case(vec![10, 11, 20, 30], vec![10, 20, 30]);
 247     case(vec![10, 20, 21, 30], vec![10, 20, 30]);
 248     case(vec![10, 20, 30, 31], vec![10, 20, 30]);
 249     case(vec![10, 11, 20, 21, 22, 30, 31], vec![10, 20, 30]);
 250 }
 251
 252 #[test]
 253 fn test_dedup_by() {
 254     let mut vec = vec!["foo", "bar", "Bar", "baz", "bar"];
 255     vec.dedup_by(|a, b| a.eq_ignore_ascii_case(b));
 256
 257     assert_eq!(vec, ["foo", "bar", "baz", "bar"]);
 258 }
 259
 260 #[test]
 261 fn test_dedup_unique() {
 262     let mut v0: Vec<Box<_>> = vec![box 1, box 1, box 2, box 3];
 263     v0.dedup();
 264     let mut v1: Vec<Box<_>> = vec![box 1, box 2, box 2, box 3];
 265     v1.dedup();
 266     let mut v2: Vec<Box<_>> = vec![box 1, box 2, box 3, box 3];
 267     v2.dedup();
 268     // If the boxed pointers were leaked or otherwise misused, valgrind
 269     // and/or rt should raise errors.
 270 }
 271
 272 #[test]
 273 fn zero_sized_values() {
 274     let mut v = Vec::new();
 275     assert_eq!(v.len(), 0);
 276     v.push(());
 277     assert_eq!(v.len(), 1);
 278     v.push(());
 279     assert_eq!(v.len(), 2);
 280     assert_eq!(v.pop(), Some(()));
 281     assert_eq!(v.pop(), Some(()));
 282     assert_eq!(v.pop(), None);
 283
 284     assert_eq!(v.iter().count(), 0);
 285     v.push(());
 286     assert_eq!(v.iter().count(), 1);
 287     v.push(());
 288     assert_eq!(v.iter().count(), 2);
 289
 290     for &() in &v {}
 291
 292     assert_eq!(v.iter_mut().count(), 2);
 293     v.push(());
 294     assert_eq!(v.iter_mut().count(), 3);
 295     v.push(());
 296     assert_eq!(v.iter_mut().count(), 4);
 297
 298     for &mut () in &mut v {}
 299     unsafe {
 300         v.set_len(0);
 301     }
 302     assert_eq!(v.iter_mut().count(), 0);
 303 }
 304
 305 #[test]
 306 fn test_partition() {
 307     assert_eq!(vec![].into_iter().partition(|x: &i32| *x < 3),
 308                (vec![], vec![]));
 309     assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 4),
 310                (vec![1, 2, 3], vec![]));
 311     assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 2),
 312                (vec![1], vec![2, 3]));
 313     assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 0),
 314                (vec![], vec![1, 2, 3]));
 315 }
 316
 317 #[test]
 318 fn test_zip_unzip() {
 319     let z1 = vec![(1, 4), (2, 5), (3, 6)];
 320
 321     let (left, right): (Vec<_>, Vec<_>) = z1.iter().cloned().unzip();
 322
 323     assert_eq!((1, 4), (left[0], right[0]));
 324     assert_eq!((2, 5), (left[1], right[1]));
 325     assert_eq!((3, 6), (left[2], right[2]));
 326 }
 327
 328 #[test]
 329 fn test_vec_truncate_drop() {
 330     static mut DROPS: u32 = 0;
 331     struct Elem(i32);
 332     impl Drop for Elem {
 333         fn drop(&mut self) {
 334             unsafe {
 335                 DROPS += 1;
 336             }
 337         }
 338     }
 339
 340     let mut v = vec![Elem(1), Elem(2), Elem(3), Elem(4), Elem(5)];
 341     assert_eq!(unsafe { DROPS }, 0);
 342     v.truncate(3);
 343     assert_eq!(unsafe { DROPS }, 2);
 344     v.truncate(0);
 345     assert_eq!(unsafe { DROPS }, 5);
 346 }
 347
 348 #[test]
 349 #[should_panic]
 350 fn test_vec_truncate_fail() {
 351     struct BadElem(i32);
 352     impl Drop for BadElem {
 353         fn drop(&mut self) {
 354             let BadElem(ref mut x) = *self;
 355             if *x == 0xbadbeef {
 356                 panic!("BadElem panic: 0xbadbeef")
 357             }
 358         }
 359     }
 360
 361     let mut v = vec![BadElem(1), BadElem(2), BadElem(0xbadbeef), BadElem(4)];
 362     v.truncate(0);
 363 }
 364
 365 #[test]
 366 fn test_index() {
 367     let vec = vec![1, 2, 3];
 368     assert!(vec[1] == 2);
 369 }
 370
 371 #[test]
 372 #[should_panic]
 373 fn test_index_out_of_bounds() {
 374     let vec = vec![1, 2, 3];
 375     let _ = vec[3];
 376 }
 377
 378 #[test]
 379 #[should_panic]
 380 fn test_slice_out_of_bounds_1() {
 381     let x = vec![1, 2, 3, 4, 5];
 382     &x[!0..];
 383 }
 384
 385 #[test]
 386 #[should_panic]
 387 fn test_slice_out_of_bounds_2() {
 388     let x = vec![1, 2, 3, 4, 5];
 389     &x[..6];
 390 }
 391
 392 #[test]
 393 #[should_panic]
 394 fn test_slice_out_of_bounds_3() {
 395     let x = vec![1, 2, 3, 4, 5];
 396     &x[!0..4];
 397 }
 398
 399 #[test]
 400 #[should_panic]
 401 fn test_slice_out_of_bounds_4() {
 402     let x = vec![1, 2, 3, 4, 5];
 403     &x[1..6];
 404 }
 405
 406 #[test]
 407 #[should_panic]
 408 fn test_slice_out_of_bounds_5() {
 409     let x = vec![1, 2, 3, 4, 5];
 410     &x[3..2];
 411 }
 412
 413 #[test]
 414 #[should_panic]
 415 fn test_swap_remove_empty() {
 416     let mut vec = Vec::<i32>::new();
 417     vec.swap_remove(0);
 418 }
 419
 420 #[test]
 421 fn test_move_items() {
 422     let vec = vec![1, 2, 3];
 423     let mut vec2 = vec![];
 424     for i in vec {
 425         vec2.push(i);
 426     }
 427     assert_eq!(vec2, [1, 2, 3]);
 428 }
 429
 430 #[test]
 431 fn test_move_items_reverse() {
 432     let vec = vec![1, 2, 3];
 433     let mut vec2 = vec![];
 434     for i in vec.into_iter().rev() {
 435         vec2.push(i);
 436     }
 437     assert_eq!(vec2, [3, 2, 1]);
 438 }
 439
 440 #[test]
 441 fn test_move_items_zero_sized() {
 442     let vec = vec![(), (), ()];
 443     let mut vec2 = vec![];
 444     for i in vec {
 445         vec2.push(i);
 446     }
 447     assert_eq!(vec2, [(), (), ()]);
 448 }
 449
 450 #[test]
 451 fn test_drain_items() {
 452     let mut vec = vec![1, 2, 3];
 453     let mut vec2 = vec![];
 454     for i in vec.drain(..) {
 455         vec2.push(i);
 456     }
 457     assert_eq!(vec, []);
 458     assert_eq!(vec2, [1, 2, 3]);
 459 }
 460
 461 #[test]
 462 fn test_drain_items_reverse() {
 463     let mut vec = vec![1, 2, 3];
 464     let mut vec2 = vec![];
 465     for i in vec.drain(..).rev() {
 466         vec2.push(i);
 467     }
 468     assert_eq!(vec, []);
 469     assert_eq!(vec2, [3, 2, 1]);
 470 }
 471
 472 #[test]
 473 fn test_drain_items_zero_sized() {
 474     let mut vec = vec![(), (), ()];
 475     let mut vec2 = vec![];
 476     for i in vec.drain(..) {
 477         vec2.push(i);
 478     }
 479     assert_eq!(vec, []);
 480     assert_eq!(vec2, [(), (), ()]);
 481 }
 482
 483 #[test]
 484 #[should_panic]
 485 fn test_drain_out_of_bounds() {
 486     let mut v = vec![1, 2, 3, 4, 5];
 487     v.drain(5..6);
 488 }
 489
 490 #[test]
 491 fn test_drain_range() {
 492     let mut v = vec![1, 2, 3, 4, 5];
 493     for _ in v.drain(4..) {
 494     }
 495     assert_eq!(v, &[1, 2, 3, 4]);
 496
 497     let mut v: Vec<_> = (1..6).map(|x| x.to_string()).collect();
 498     for _ in v.drain(1..4) {
 499     }
 500     assert_eq!(v, &[1.to_string(), 5.to_string()]);
 501
 502     let mut v: Vec<_> = (1..6).map(|x| x.to_string()).collect();
 503     for _ in v.drain(1..4).rev() {
 504     }
 505     assert_eq!(v, &[1.to_string(), 5.to_string()]);
 506
 507     let mut v: Vec<_> = vec![(); 5];
 508     for _ in v.drain(1..4).rev() {
 509     }
 510     assert_eq!(v, &[(), ()]);
 511 }
 512
 513 #[test]
 514 fn test_into_boxed_slice() {
 515     let xs = vec![1, 2, 3];
 516     let ys = xs.into_boxed_slice();
 517     assert_eq!(&*ys, [1, 2, 3]);
 518 }
 519
 520 #[test]
 521 fn test_append() {
 522     let mut vec = vec![1, 2, 3];
 523     let mut vec2 = vec![4, 5, 6];
 524     vec.append(&mut vec2);
 525     assert_eq!(vec, [1, 2, 3, 4, 5, 6]);
 526     assert_eq!(vec2, []);
 527 }
 528
 529 #[test]
 530 fn test_split_off() {
 531     let mut vec = vec![1, 2, 3, 4, 5, 6];
 532     let vec2 = vec.split_off(4);
 533     assert_eq!(vec, [1, 2, 3, 4]);
 534     assert_eq!(vec2, [5, 6]);
 535 }
 536
 537 #[test]
 538 fn test_into_iter_as_slice() {
 539     let vec = vec!['a', 'b', 'c'];
 540     let mut into_iter = vec.into_iter();
 541     assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']);
 542     let _ = into_iter.next().unwrap();
 543     assert_eq!(into_iter.as_slice(), &['b', 'c']);
 544     let _ = into_iter.next().unwrap();
 545     let _ = into_iter.next().unwrap();
 546     assert_eq!(into_iter.as_slice(), &[]);
 547 }
 548
 549 #[test]
 550 fn test_into_iter_as_mut_slice() {
 551     let vec = vec!['a', 'b', 'c'];
 552     let mut into_iter = vec.into_iter();
 553     assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']);
 554     into_iter.as_mut_slice()[0] = 'x';
 555     into_iter.as_mut_slice()[1] = 'y';
 556     assert_eq!(into_iter.next().unwrap(), 'x');
 557     assert_eq!(into_iter.as_slice(), &['y', 'c']);
 558 }
 559
 560 #[test]
 561 fn test_into_iter_debug() {
 562     let vec = vec!['a', 'b', 'c'];
 563     let into_iter = vec.into_iter();
 564     let debug = format!("{:?}", into_iter);
 565     assert_eq!(debug, "IntoIter(['a', 'b', 'c'])");
 566 }
 567
 568 #[test]
 569 fn test_into_iter_count() {
 570     assert_eq!(vec![1, 2, 3].into_iter().count(), 3);
 571 }
 572
 573 #[test]
 574 fn test_into_iter_clone() {
 575     fn iter_equal<I: Iterator<Item = i32>>(it: I, slice: &[i32]) {
 576         let v: Vec<i32> = it.collect();
 577         assert_eq!(&v[..], slice);
 578     }
 579     let mut it = vec![1, 2, 3].into_iter();
 580     iter_equal(it.clone(), &[1, 2, 3]);
 581     assert_eq!(it.next(), Some(1));
 582     let mut it = it.rev();
 583     iter_equal(it.clone(), &[3, 2]);
 584     assert_eq!(it.next(), Some(3));
 585     iter_equal(it.clone(), &[2]);
 586     assert_eq!(it.next(), Some(2));
 587     iter_equal(it.clone(), &[]);
 588     assert_eq!(it.next(), None);
 589 }
 590
 591 #[test]
 592 fn test_cow_from() {
 593     let borrowed: &[_] = &["borrowed", "(slice)"];
 594     let owned = vec!["owned", "(vec)"];
 595     match (Cow::from(owned.clone()), Cow::from(borrowed)) {
 596         (Cow::Owned(o), Cow::Borrowed(b)) => assert!(o == owned && b == borrowed),
 597         _ => panic!("invalid `Cow::from`"),
 598     }
 599 }
 600
 601 #[test]
 602 fn test_from_cow() {
 603     let borrowed: &[_] = &["borrowed", "(slice)"];
 604     let owned = vec!["owned", "(vec)"];
 605     assert_eq!(Vec::from(Cow::Borrowed(borrowed)), vec!["borrowed", "(slice)"]);
 606     assert_eq!(Vec::from(Cow::Owned(owned)), vec!["owned", "(vec)"]);
 607 }
 608
 609 #[allow(dead_code)]
 610 fn assert_covariance() {
 611     fn drain<'new>(d: Drain<'static, &'static str>) -> Drain<'new, &'new str> {
 612         d
 613     }
 614     fn into_iter<'new>(i: IntoIter<&'static str>) -> IntoIter<&'new str> {
 615         i
 616     }
 617 }
 618
 619 #[test]
 620 fn test_placement() {
 621     let mut vec = vec![1];
 622     assert_eq!(vec.place_back() <- 2, &2);
 623     assert_eq!(vec.len(), 2);
 624     assert_eq!(vec.place_back() <- 3, &3);
 625     assert_eq!(vec.len(), 3);
 626     assert_eq!(&vec, &[1, 2, 3]);
 627 }
 628
 629 #[test]
 630 fn test_placement_panic() {
 631     let mut vec = vec![1, 2, 3];
 632     fn mkpanic() -> usize { panic!() }
 633     let _ = panic::catch_unwind(panic::AssertUnwindSafe(|| { vec.place_back() <- mkpanic(); }));
 634     assert_eq!(vec.len(), 3);
 635 }
 636
 637 #[bench]
 638 fn bench_new(b: &mut Bencher) {
 639     b.iter(|| {
 640         let v: Vec<u32> = Vec::new();
 641         assert_eq!(v.len(), 0);
 642         assert_eq!(v.capacity(), 0);
 643     })
 644 }
 645
 646 fn do_bench_with_capacity(b: &mut Bencher, src_len: usize) {
 647     b.bytes = src_len as u64;
 648
 649     b.iter(|| {
 650         let v: Vec<u32> = Vec::with_capacity(src_len);
 651         assert_eq!(v.len(), 0);
 652         assert_eq!(v.capacity(), src_len);
 653     })
 654 }
 655
 656 #[bench]
 657 fn bench_with_capacity_0000(b: &mut Bencher) {
 658     do_bench_with_capacity(b, 0)
 659 }
 660
 661 #[bench]
 662 fn bench_with_capacity_0010(b: &mut Bencher) {
 663     do_bench_with_capacity(b, 10)
 664 }
 665
 666 #[bench]
 667 fn bench_with_capacity_0100(b: &mut Bencher) {
 668     do_bench_with_capacity(b, 100)
 669 }
 670
 671 #[bench]
 672 fn bench_with_capacity_1000(b: &mut Bencher) {
 673     do_bench_with_capacity(b, 1000)
 674 }
 675
 676 fn do_bench_from_fn(b: &mut Bencher, src_len: usize) {
 677     b.bytes = src_len as u64;
 678
 679     b.iter(|| {
 680         let dst = (0..src_len).collect::<Vec<_>>();
 681         assert_eq!(dst.len(), src_len);
 682         assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
 683     })
 684 }
 685
 686 #[bench]
 687 fn bench_from_fn_0000(b: &mut Bencher) {
 688     do_bench_from_fn(b, 0)
 689 }
 690
 691 #[bench]
 692 fn bench_from_fn_0010(b: &mut Bencher) {
 693     do_bench_from_fn(b, 10)
 694 }
 695
 696 #[bench]
 697 fn bench_from_fn_0100(b: &mut Bencher) {
 698     do_bench_from_fn(b, 100)
 699 }
 700
 701 #[bench]
 702 fn bench_from_fn_1000(b: &mut Bencher) {
 703     do_bench_from_fn(b, 1000)
 704 }
 705
 706 fn do_bench_from_elem(b: &mut Bencher, src_len: usize) {
 707     b.bytes = src_len as u64;
 708
 709     b.iter(|| {
 710         let dst: Vec<usize> = repeat(5).take(src_len).collect();
 711         assert_eq!(dst.len(), src_len);
 712         assert!(dst.iter().all(|x| *x == 5));
 713     })
 714 }
 715
 716 #[bench]
 717 fn bench_from_elem_0000(b: &mut Bencher) {
 718     do_bench_from_elem(b, 0)
 719 }
 720
 721 #[bench]
 722 fn bench_from_elem_0010(b: &mut Bencher) {
 723     do_bench_from_elem(b, 10)
 724 }
 725
 726 #[bench]
 727 fn bench_from_elem_0100(b: &mut Bencher) {
 728     do_bench_from_elem(b, 100)
 729 }
 730
 731 #[bench]
 732 fn bench_from_elem_1000(b: &mut Bencher) {
 733     do_bench_from_elem(b, 1000)
 734 }
 735
 736 fn do_bench_from_slice(b: &mut Bencher, src_len: usize) {
 737     let src: Vec<_> = FromIterator::from_iter(0..src_len);
 738
 739     b.bytes = src_len as u64;
 740
 741     b.iter(|| {
 742         let dst = src.clone()[..].to_vec();
 743         assert_eq!(dst.len(), src_len);
 744         assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
 745     });
 746 }
 747
 748 #[bench]
 749 fn bench_from_slice_0000(b: &mut Bencher) {
 750     do_bench_from_slice(b, 0)
 751 }
 752
 753 #[bench]
 754 fn bench_from_slice_0010(b: &mut Bencher) {
 755     do_bench_from_slice(b, 10)
 756 }
 757
 758 #[bench]
 759 fn bench_from_slice_0100(b: &mut Bencher) {
 760     do_bench_from_slice(b, 100)
 761 }
 762
 763 #[bench]
 764 fn bench_from_slice_1000(b: &mut Bencher) {
 765     do_bench_from_slice(b, 1000)
 766 }
 767
 768 fn do_bench_from_iter(b: &mut Bencher, src_len: usize) {
 769     let src: Vec<_> = FromIterator::from_iter(0..src_len);
 770
 771     b.bytes = src_len as u64;
 772
 773     b.iter(|| {
 774         let dst: Vec<_> = FromIterator::from_iter(src.clone());
 775         assert_eq!(dst.len(), src_len);
 776         assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
 777     });
 778 }
 779
 780 #[bench]
 781 fn bench_from_iter_0000(b: &mut Bencher) {
 782     do_bench_from_iter(b, 0)
 783 }
 784
 785 #[bench]
 786 fn bench_from_iter_0010(b: &mut Bencher) {
 787     do_bench_from_iter(b, 10)
 788 }
 789
 790 #[bench]
 791 fn bench_from_iter_0100(b: &mut Bencher) {
 792     do_bench_from_iter(b, 100)
 793 }
 794
 795 #[bench]
 796 fn bench_from_iter_1000(b: &mut Bencher) {
 797     do_bench_from_iter(b, 1000)
 798 }
 799
 800 fn do_bench_extend(b: &mut Bencher, dst_len: usize, src_len: usize) {
 801     let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
 802     let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
 803
 804     b.bytes = src_len as u64;
 805
 806     b.iter(|| {
 807         let mut dst = dst.clone();
 808         dst.extend(src.clone());
 809         assert_eq!(dst.len(), dst_len + src_len);
 810         assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
 811     });
 812 }
 813
 814 #[bench]
 815 fn bench_extend_0000_0000(b: &mut Bencher) {
 816     do_bench_extend(b, 0, 0)
 817 }
 818
 819 #[bench]
 820 fn bench_extend_0000_0010(b: &mut Bencher) {
 821     do_bench_extend(b, 0, 10)
 822 }
 823
 824 #[bench]
 825 fn bench_extend_0000_0100(b: &mut Bencher) {
 826     do_bench_extend(b, 0, 100)
 827 }
 828
 829 #[bench]
 830 fn bench_extend_0000_1000(b: &mut Bencher) {
 831     do_bench_extend(b, 0, 1000)
 832 }
 833
 834 #[bench]
 835 fn bench_extend_0010_0010(b: &mut Bencher) {
 836     do_bench_extend(b, 10, 10)
 837 }
 838
 839 #[bench]
 840 fn bench_extend_0100_0100(b: &mut Bencher) {
 841     do_bench_extend(b, 100, 100)
 842 }
 843
 844 #[bench]
 845 fn bench_extend_1000_1000(b: &mut Bencher) {
 846     do_bench_extend(b, 1000, 1000)
 847 }
 848
 849 fn do_bench_push_all(b: &mut Bencher, dst_len: usize, src_len: usize) {
 850     let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
 851     let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
 852
 853     b.bytes = src_len as u64;
 854
 855     b.iter(|| {
 856         let mut dst = dst.clone();
 857         dst.extend_from_slice(&src);
 858         assert_eq!(dst.len(), dst_len + src_len);
 859         assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
 860     });
 861 }
 862
 863 #[bench]
 864 fn bench_push_all_0000_0000(b: &mut Bencher) {
 865     do_bench_push_all(b, 0, 0)
 866 }
 867
 868 #[bench]
 869 fn bench_push_all_0000_0010(b: &mut Bencher) {
 870     do_bench_push_all(b, 0, 10)
 871 }
 872
 873 #[bench]
 874 fn bench_push_all_0000_0100(b: &mut Bencher) {
 875     do_bench_push_all(b, 0, 100)
 876 }
 877
 878 #[bench]
 879 fn bench_push_all_0000_1000(b: &mut Bencher) {
 880     do_bench_push_all(b, 0, 1000)
 881 }
 882
 883 #[bench]
 884 fn bench_push_all_0010_0010(b: &mut Bencher) {
 885     do_bench_push_all(b, 10, 10)
 886 }
 887
 888 #[bench]
 889 fn bench_push_all_0100_0100(b: &mut Bencher) {
 890     do_bench_push_all(b, 100, 100)
 891 }
 892
 893 #[bench]
 894 fn bench_push_all_1000_1000(b: &mut Bencher) {
 895     do_bench_push_all(b, 1000, 1000)
 896 }
 897
 898 fn do_bench_push_all_move(b: &mut Bencher, dst_len: usize, src_len: usize) {
 899     let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
 900     let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
 901
 902     b.bytes = src_len as u64;
 903
 904     b.iter(|| {
 905         let mut dst = dst.clone();
 906         dst.extend(src.clone());
 907         assert_eq!(dst.len(), dst_len + src_len);
 908         assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
 909     });
 910 }
 911
 912 #[bench]
 913 fn bench_push_all_move_0000_0000(b: &mut Bencher) {
 914     do_bench_push_all_move(b, 0, 0)
 915 }
 916
 917 #[bench]
 918 fn bench_push_all_move_0000_0010(b: &mut Bencher) {
 919     do_bench_push_all_move(b, 0, 10)
 920 }
 921
 922 #[bench]
 923 fn bench_push_all_move_0000_0100(b: &mut Bencher) {
 924     do_bench_push_all_move(b, 0, 100)
 925 }
 926
 927 #[bench]
 928 fn bench_push_all_move_0000_1000(b: &mut Bencher) {
 929     do_bench_push_all_move(b, 0, 1000)
 930 }
 931
 932 #[bench]
 933 fn bench_push_all_move_0010_0010(b: &mut Bencher) {
 934     do_bench_push_all_move(b, 10, 10)
 935 }
 936
 937 #[bench]
 938 fn bench_push_all_move_0100_0100(b: &mut Bencher) {
 939     do_bench_push_all_move(b, 100, 100)
 940 }
 941
 942 #[bench]
 943 fn bench_push_all_move_1000_1000(b: &mut Bencher) {
 944     do_bench_push_all_move(b, 1000, 1000)
 945 }
 946
 947 fn do_bench_clone(b: &mut Bencher, src_len: usize) {
 948     let src: Vec<usize> = FromIterator::from_iter(0..src_len);
 949
 950     b.bytes = src_len as u64;
 951
 952     b.iter(|| {
 953         let dst = src.clone();
 954         assert_eq!(dst.len(), src_len);
 955         assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
 956     });
 957 }
 958
 959 #[bench]
 960 fn bench_clone_0000(b: &mut Bencher) {
 961     do_bench_clone(b, 0)
 962 }
 963
 964 #[bench]
 965 fn bench_clone_0010(b: &mut Bencher) {
 966     do_bench_clone(b, 10)
 967 }
 968
 969 #[bench]
 970 fn bench_clone_0100(b: &mut Bencher) {
 971     do_bench_clone(b, 100)
 972 }
 973
 974 #[bench]
 975 fn bench_clone_1000(b: &mut Bencher) {
 976     do_bench_clone(b, 1000)
 977 }
 978
 979 fn do_bench_clone_from(b: &mut Bencher, times: usize, dst_len: usize, src_len: usize) {
 980     let dst: Vec<_> = FromIterator::from_iter(0..src_len);
 981     let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
 982
 983     b.bytes = (times * src_len) as u64;
 984
 985     b.iter(|| {
 986         let mut dst = dst.clone();
 987
 988         for _ in 0..times {
 989             dst.clone_from(&src);
 990
 991             assert_eq!(dst.len(), src_len);
 992             assert!(dst.iter().enumerate().all(|(i, x)| dst_len + i == *x));
 993         }
 994     });
 995 }
 996
 997 #[bench]
 998 fn bench_clone_from_01_0000_0000(b: &mut Bencher) {
 999     do_bench_clone_from(b, 1, 0, 0)
1000 }
1001
1002 #[bench]
1003 fn bench_clone_from_01_0000_0010(b: &mut Bencher) {
1004     do_bench_clone_from(b, 1, 0, 10)
1005 }
1006
1007 #[bench]
1008 fn bench_clone_from_01_0000_0100(b: &mut Bencher) {
1009     do_bench_clone_from(b, 1, 0, 100)
1010 }
1011
1012 #[bench]
1013 fn bench_clone_from_01_0000_1000(b: &mut Bencher) {
1014     do_bench_clone_from(b, 1, 0, 1000)
1015 }
1016
1017 #[bench]
1018 fn bench_clone_from_01_0010_0010(b: &mut Bencher) {
1019     do_bench_clone_from(b, 1, 10, 10)
1020 }
1021
1022 #[bench]
1023 fn bench_clone_from_01_0100_0100(b: &mut Bencher) {
1024     do_bench_clone_from(b, 1, 100, 100)
1025 }
1026
1027 #[bench]
1028 fn bench_clone_from_01_1000_1000(b: &mut Bencher) {
1029     do_bench_clone_from(b, 1, 1000, 1000)
1030 }
1031
1032 #[bench]
1033 fn bench_clone_from_01_0010_0100(b: &mut Bencher) {
1034     do_bench_clone_from(b, 1, 10, 100)
1035 }
1036
1037 #[bench]
1038 fn bench_clone_from_01_0100_1000(b: &mut Bencher) {
1039     do_bench_clone_from(b, 1, 100, 1000)
1040 }
1041
1042 #[bench]
1043 fn bench_clone_from_01_0010_0000(b: &mut Bencher) {
1044     do_bench_clone_from(b, 1, 10, 0)
1045 }
1046
1047 #[bench]
1048 fn bench_clone_from_01_0100_0010(b: &mut Bencher) {
1049     do_bench_clone_from(b, 1, 100, 10)
1050 }
1051
1052 #[bench]
1053 fn bench_clone_from_01_1000_0100(b: &mut Bencher) {
1054     do_bench_clone_from(b, 1, 1000, 100)
1055 }
1056
1057 #[bench]
1058 fn bench_clone_from_10_0000_0000(b: &mut Bencher) {
1059     do_bench_clone_from(b, 10, 0, 0)
1060 }
1061
1062 #[bench]
1063 fn bench_clone_from_10_0000_0010(b: &mut Bencher) {
1064     do_bench_clone_from(b, 10, 0, 10)
1065 }
1066
1067 #[bench]
1068 fn bench_clone_from_10_0000_0100(b: &mut Bencher) {
1069     do_bench_clone_from(b, 10, 0, 100)
1070 }
1071
1072 #[bench]
1073 fn bench_clone_from_10_0000_1000(b: &mut Bencher) {
1074     do_bench_clone_from(b, 10, 0, 1000)
1075 }
1076
1077 #[bench]
1078 fn bench_clone_from_10_0010_0010(b: &mut Bencher) {
1079     do_bench_clone_from(b, 10, 10, 10)
1080 }
1081
1082 #[bench]
1083 fn bench_clone_from_10_0100_0100(b: &mut Bencher) {
1084     do_bench_clone_from(b, 10, 100, 100)
1085 }
1086
1087 #[bench]
1088 fn bench_clone_from_10_1000_1000(b: &mut Bencher) {
1089     do_bench_clone_from(b, 10, 1000, 1000)
1090 }
1091
1092 #[bench]
1093 fn bench_clone_from_10_0010_0100(b: &mut Bencher) {
1094     do_bench_clone_from(b, 10, 10, 100)
1095 }
1096
1097 #[bench]
1098 fn bench_clone_from_10_0100_1000(b: &mut Bencher) {
1099     do_bench_clone_from(b, 10, 100, 1000)
1100 }
1101
1102 #[bench]
1103 fn bench_clone_from_10_0010_0000(b: &mut Bencher) {
1104     do_bench_clone_from(b, 10, 10, 0)
1105 }
1106
1107 #[bench]
1108 fn bench_clone_from_10_0100_0010(b: &mut Bencher) {
1109     do_bench_clone_from(b, 10, 100, 10)
1110 }
1111
1112 #[bench]
1113 fn bench_clone_from_10_1000_0100(b: &mut Bencher) {
1114     do_bench_clone_from(b, 10, 1000, 100)
1115 }