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