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