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