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