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