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_debug() {
 506     let vec = vec!['a', 'b', 'c'];
 507     let into_iter = vec.into_iter();
 508     let debug = format!("{:?}", into_iter);
 509     assert_eq!(debug, "IntoIter(['a', 'b', 'c'])");
 510 }
 511
 512 #[test]
 513 fn test_into_iter_count() {
 514     assert_eq!(vec![1, 2, 3].into_iter().count(), 3);
 515 }
 516
 517 #[test]
 518 fn test_into_iter_clone() {
 519     fn iter_equal<I: Iterator<Item = i32>>(it: I, slice: &[i32]) {
 520         let v: Vec<i32> = it.collect();
 521         assert_eq!(&v[..], slice);
 522     }
 523     let mut it = vec![1, 2, 3].into_iter();
 524     iter_equal(it.clone(), &[1, 2, 3]);
 525     assert_eq!(it.next(), Some(1));
 526     let mut it = it.rev();
 527     iter_equal(it.clone(), &[3, 2]);
 528     assert_eq!(it.next(), Some(3));
 529     iter_equal(it.clone(), &[2]);
 530     assert_eq!(it.next(), Some(2));
 531     iter_equal(it.clone(), &[]);
 532     assert_eq!(it.next(), None);
 533 }
 534
 535 #[test]
 536 fn test_cow_from() {
 537     let borrowed: &[_] = &["borrowed", "(slice)"];
 538     let owned = vec!["owned", "(vec)"];
 539     match (Cow::from(owned.clone()), Cow::from(borrowed)) {
 540         (Cow::Owned(o), Cow::Borrowed(b)) => assert!(o == owned && b == borrowed),
 541         _ => panic!("invalid `Cow::from`"),
 542     }
 543 }
 544
 545 #[allow(dead_code)]
 546 fn assert_covariance() {
 547     fn drain<'new>(d: Drain<'static, &'static str>) -> Drain<'new, &'new str> { d }
 548     fn into_iter<'new>(i: IntoIter<&'static str>) -> IntoIter<&'new str> { i }
 549 }
 550
 551 #[bench]
 552 fn bench_new(b: &mut Bencher) {
 553     b.iter(|| {
 554         let v: Vec<u32> = Vec::new();
 555         assert_eq!(v.len(), 0);
 556         assert_eq!(v.capacity(), 0);
 557     })
 558 }
 559
 560 fn do_bench_with_capacity(b: &mut Bencher, src_len: usize) {
 561     b.bytes = src_len as u64;
 562
 563     b.iter(|| {
 564         let v: Vec<u32> = Vec::with_capacity(src_len);
 565         assert_eq!(v.len(), 0);
 566         assert_eq!(v.capacity(), src_len);
 567     })
 568 }
 569
 570 #[bench]
 571 fn bench_with_capacity_0000(b: &mut Bencher) {
 572     do_bench_with_capacity(b, 0)
 573 }
 574
 575 #[bench]
 576 fn bench_with_capacity_0010(b: &mut Bencher) {
 577     do_bench_with_capacity(b, 10)
 578 }
 579
 580 #[bench]
 581 fn bench_with_capacity_0100(b: &mut Bencher) {
 582     do_bench_with_capacity(b, 100)
 583 }
 584
 585 #[bench]
 586 fn bench_with_capacity_1000(b: &mut Bencher) {
 587     do_bench_with_capacity(b, 1000)
 588 }
 589
 590 fn do_bench_from_fn(b: &mut Bencher, src_len: usize) {
 591     b.bytes = src_len as u64;
 592
 593     b.iter(|| {
 594         let dst = (0..src_len).collect::<Vec<_>>();
 595         assert_eq!(dst.len(), src_len);
 596         assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
 597     })
 598 }
 599
 600 #[bench]
 601 fn bench_from_fn_0000(b: &mut Bencher) {
 602     do_bench_from_fn(b, 0)
 603 }
 604
 605 #[bench]
 606 fn bench_from_fn_0010(b: &mut Bencher) {
 607     do_bench_from_fn(b, 10)
 608 }
 609
 610 #[bench]
 611 fn bench_from_fn_0100(b: &mut Bencher) {
 612     do_bench_from_fn(b, 100)
 613 }
 614
 615 #[bench]
 616 fn bench_from_fn_1000(b: &mut Bencher) {
 617     do_bench_from_fn(b, 1000)
 618 }
 619
 620 fn do_bench_from_elem(b: &mut Bencher, src_len: usize) {
 621     b.bytes = src_len as u64;
 622
 623     b.iter(|| {
 624         let dst: Vec<usize> = repeat(5).take(src_len).collect();
 625         assert_eq!(dst.len(), src_len);
 626         assert!(dst.iter().all(|x| *x == 5));
 627     })
 628 }
 629
 630 #[bench]
 631 fn bench_from_elem_0000(b: &mut Bencher) {
 632     do_bench_from_elem(b, 0)
 633 }
 634
 635 #[bench]
 636 fn bench_from_elem_0010(b: &mut Bencher) {
 637     do_bench_from_elem(b, 10)
 638 }
 639
 640 #[bench]
 641 fn bench_from_elem_0100(b: &mut Bencher) {
 642     do_bench_from_elem(b, 100)
 643 }
 644
 645 #[bench]
 646 fn bench_from_elem_1000(b: &mut Bencher) {
 647     do_bench_from_elem(b, 1000)
 648 }
 649
 650 fn do_bench_from_slice(b: &mut Bencher, src_len: usize) {
 651     let src: Vec<_> = FromIterator::from_iter(0..src_len);
 652
 653     b.bytes = src_len as u64;
 654
 655     b.iter(|| {
 656         let dst = src.clone()[..].to_vec();
 657         assert_eq!(dst.len(), src_len);
 658         assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
 659     });
 660 }
 661
 662 #[bench]
 663 fn bench_from_slice_0000(b: &mut Bencher) {
 664     do_bench_from_slice(b, 0)
 665 }
 666
 667 #[bench]
 668 fn bench_from_slice_0010(b: &mut Bencher) {
 669     do_bench_from_slice(b, 10)
 670 }
 671
 672 #[bench]
 673 fn bench_from_slice_0100(b: &mut Bencher) {
 674     do_bench_from_slice(b, 100)
 675 }
 676
 677 #[bench]
 678 fn bench_from_slice_1000(b: &mut Bencher) {
 679     do_bench_from_slice(b, 1000)
 680 }
 681
 682 fn do_bench_from_iter(b: &mut Bencher, src_len: usize) {
 683     let src: Vec<_> = FromIterator::from_iter(0..src_len);
 684
 685     b.bytes = src_len as u64;
 686
 687     b.iter(|| {
 688         let dst: Vec<_> = FromIterator::from_iter(src.clone());
 689         assert_eq!(dst.len(), src_len);
 690         assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
 691     });
 692 }
 693
 694 #[bench]
 695 fn bench_from_iter_0000(b: &mut Bencher) {
 696     do_bench_from_iter(b, 0)
 697 }
 698
 699 #[bench]
 700 fn bench_from_iter_0010(b: &mut Bencher) {
 701     do_bench_from_iter(b, 10)
 702 }
 703
 704 #[bench]
 705 fn bench_from_iter_0100(b: &mut Bencher) {
 706     do_bench_from_iter(b, 100)
 707 }
 708
 709 #[bench]
 710 fn bench_from_iter_1000(b: &mut Bencher) {
 711     do_bench_from_iter(b, 1000)
 712 }
 713
 714 fn do_bench_extend(b: &mut Bencher, dst_len: usize, src_len: usize) {
 715     let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
 716     let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
 717
 718     b.bytes = src_len as u64;
 719
 720     b.iter(|| {
 721         let mut dst = dst.clone();
 722         dst.extend(src.clone());
 723         assert_eq!(dst.len(), dst_len + src_len);
 724         assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
 725     });
 726 }
 727
 728 #[bench]
 729 fn bench_extend_0000_0000(b: &mut Bencher) {
 730     do_bench_extend(b, 0, 0)
 731 }
 732
 733 #[bench]
 734 fn bench_extend_0000_0010(b: &mut Bencher) {
 735     do_bench_extend(b, 0, 10)
 736 }
 737
 738 #[bench]
 739 fn bench_extend_0000_0100(b: &mut Bencher) {
 740     do_bench_extend(b, 0, 100)
 741 }
 742
 743 #[bench]
 744 fn bench_extend_0000_1000(b: &mut Bencher) {
 745     do_bench_extend(b, 0, 1000)
 746 }
 747
 748 #[bench]
 749 fn bench_extend_0010_0010(b: &mut Bencher) {
 750     do_bench_extend(b, 10, 10)
 751 }
 752
 753 #[bench]
 754 fn bench_extend_0100_0100(b: &mut Bencher) {
 755     do_bench_extend(b, 100, 100)
 756 }
 757
 758 #[bench]
 759 fn bench_extend_1000_1000(b: &mut Bencher) {
 760     do_bench_extend(b, 1000, 1000)
 761 }
 762
 763 fn do_bench_push_all(b: &mut Bencher, dst_len: usize, src_len: usize) {
 764     let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
 765     let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
 766
 767     b.bytes = src_len as u64;
 768
 769     b.iter(|| {
 770         let mut dst = dst.clone();
 771         dst.extend_from_slice(&src);
 772         assert_eq!(dst.len(), dst_len + src_len);
 773         assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
 774     });
 775 }
 776
 777 #[bench]
 778 fn bench_push_all_0000_0000(b: &mut Bencher) {
 779     do_bench_push_all(b, 0, 0)
 780 }
 781
 782 #[bench]
 783 fn bench_push_all_0000_0010(b: &mut Bencher) {
 784     do_bench_push_all(b, 0, 10)
 785 }
 786
 787 #[bench]
 788 fn bench_push_all_0000_0100(b: &mut Bencher) {
 789     do_bench_push_all(b, 0, 100)
 790 }
 791
 792 #[bench]
 793 fn bench_push_all_0000_1000(b: &mut Bencher) {
 794     do_bench_push_all(b, 0, 1000)
 795 }
 796
 797 #[bench]
 798 fn bench_push_all_0010_0010(b: &mut Bencher) {
 799     do_bench_push_all(b, 10, 10)
 800 }
 801
 802 #[bench]
 803 fn bench_push_all_0100_0100(b: &mut Bencher) {
 804     do_bench_push_all(b, 100, 100)
 805 }
 806
 807 #[bench]
 808 fn bench_push_all_1000_1000(b: &mut Bencher) {
 809     do_bench_push_all(b, 1000, 1000)
 810 }
 811
 812 fn do_bench_push_all_move(b: &mut Bencher, dst_len: usize, src_len: usize) {
 813     let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
 814     let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
 815
 816     b.bytes = src_len as u64;
 817
 818     b.iter(|| {
 819         let mut dst = dst.clone();
 820         dst.extend(src.clone());
 821         assert_eq!(dst.len(), dst_len + src_len);
 822         assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
 823     });
 824 }
 825
 826 #[bench]
 827 fn bench_push_all_move_0000_0000(b: &mut Bencher) {
 828     do_bench_push_all_move(b, 0, 0)
 829 }
 830
 831 #[bench]
 832 fn bench_push_all_move_0000_0010(b: &mut Bencher) {
 833     do_bench_push_all_move(b, 0, 10)
 834 }
 835
 836 #[bench]
 837 fn bench_push_all_move_0000_0100(b: &mut Bencher) {
 838     do_bench_push_all_move(b, 0, 100)
 839 }
 840
 841 #[bench]
 842 fn bench_push_all_move_0000_1000(b: &mut Bencher) {
 843     do_bench_push_all_move(b, 0, 1000)
 844 }
 845
 846 #[bench]
 847 fn bench_push_all_move_0010_0010(b: &mut Bencher) {
 848     do_bench_push_all_move(b, 10, 10)
 849 }
 850
 851 #[bench]
 852 fn bench_push_all_move_0100_0100(b: &mut Bencher) {
 853     do_bench_push_all_move(b, 100, 100)
 854 }
 855
 856 #[bench]
 857 fn bench_push_all_move_1000_1000(b: &mut Bencher) {
 858     do_bench_push_all_move(b, 1000, 1000)
 859 }
 860
 861 fn do_bench_clone(b: &mut Bencher, src_len: usize) {
 862     let src: Vec<usize> = FromIterator::from_iter(0..src_len);
 863
 864     b.bytes = src_len as u64;
 865
 866     b.iter(|| {
 867         let dst = src.clone();
 868         assert_eq!(dst.len(), src_len);
 869         assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
 870     });
 871 }
 872
 873 #[bench]
 874 fn bench_clone_0000(b: &mut Bencher) {
 875     do_bench_clone(b, 0)
 876 }
 877
 878 #[bench]
 879 fn bench_clone_0010(b: &mut Bencher) {
 880     do_bench_clone(b, 10)
 881 }
 882
 883 #[bench]
 884 fn bench_clone_0100(b: &mut Bencher) {
 885     do_bench_clone(b, 100)
 886 }
 887
 888 #[bench]
 889 fn bench_clone_1000(b: &mut Bencher) {
 890     do_bench_clone(b, 1000)
 891 }
 892
 893 fn do_bench_clone_from(b: &mut Bencher, times: usize, dst_len: usize, src_len: usize) {
 894     let dst: Vec<_> = FromIterator::from_iter(0..src_len);
 895     let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
 896
 897     b.bytes = (times * src_len) as u64;
 898
 899     b.iter(|| {
 900         let mut dst = dst.clone();
 901
 902         for _ in 0..times {
 903             dst.clone_from(&src);
 904
 905             assert_eq!(dst.len(), src_len);
 906             assert!(dst.iter().enumerate().all(|(i, x)| dst_len + i == *x));
 907         }
 908     });
 909 }
 910
 911 #[bench]
 912 fn bench_clone_from_01_0000_0000(b: &mut Bencher) {
 913     do_bench_clone_from(b, 1, 0, 0)
 914 }
 915
 916 #[bench]
 917 fn bench_clone_from_01_0000_0010(b: &mut Bencher) {
 918     do_bench_clone_from(b, 1, 0, 10)
 919 }
 920
 921 #[bench]
 922 fn bench_clone_from_01_0000_0100(b: &mut Bencher) {
 923     do_bench_clone_from(b, 1, 0, 100)
 924 }
 925
 926 #[bench]
 927 fn bench_clone_from_01_0000_1000(b: &mut Bencher) {
 928     do_bench_clone_from(b, 1, 0, 1000)
 929 }
 930
 931 #[bench]
 932 fn bench_clone_from_01_0010_0010(b: &mut Bencher) {
 933     do_bench_clone_from(b, 1, 10, 10)
 934 }
 935
 936 #[bench]
 937 fn bench_clone_from_01_0100_0100(b: &mut Bencher) {
 938     do_bench_clone_from(b, 1, 100, 100)
 939 }
 940
 941 #[bench]
 942 fn bench_clone_from_01_1000_1000(b: &mut Bencher) {
 943     do_bench_clone_from(b, 1, 1000, 1000)
 944 }
 945
 946 #[bench]
 947 fn bench_clone_from_01_0010_0100(b: &mut Bencher) {
 948     do_bench_clone_from(b, 1, 10, 100)
 949 }
 950
 951 #[bench]
 952 fn bench_clone_from_01_0100_1000(b: &mut Bencher) {
 953     do_bench_clone_from(b, 1, 100, 1000)
 954 }
 955
 956 #[bench]
 957 fn bench_clone_from_01_0010_0000(b: &mut Bencher) {
 958     do_bench_clone_from(b, 1, 10, 0)
 959 }
 960
 961 #[bench]
 962 fn bench_clone_from_01_0100_0010(b: &mut Bencher) {
 963     do_bench_clone_from(b, 1, 100, 10)
 964 }
 965
 966 #[bench]
 967 fn bench_clone_from_01_1000_0100(b: &mut Bencher) {
 968     do_bench_clone_from(b, 1, 1000, 100)
 969 }
 970
 971 #[bench]
 972 fn bench_clone_from_10_0000_0000(b: &mut Bencher) {
 973     do_bench_clone_from(b, 10, 0, 0)
 974 }
 975
 976 #[bench]
 977 fn bench_clone_from_10_0000_0010(b: &mut Bencher) {
 978     do_bench_clone_from(b, 10, 0, 10)
 979 }
 980
 981 #[bench]
 982 fn bench_clone_from_10_0000_0100(b: &mut Bencher) {
 983     do_bench_clone_from(b, 10, 0, 100)
 984 }
 985
 986 #[bench]
 987 fn bench_clone_from_10_0000_1000(b: &mut Bencher) {
 988     do_bench_clone_from(b, 10, 0, 1000)
 989 }
 990
 991 #[bench]
 992 fn bench_clone_from_10_0010_0010(b: &mut Bencher) {
 993     do_bench_clone_from(b, 10, 10, 10)
 994 }
 995
 996 #[bench]
 997 fn bench_clone_from_10_0100_0100(b: &mut Bencher) {
 998     do_bench_clone_from(b, 10, 100, 100)
 999 }
1000
1001 #[bench]
1002 fn bench_clone_from_10_1000_1000(b: &mut Bencher) {
1003     do_bench_clone_from(b, 10, 1000, 1000)
1004 }
1005
1006 #[bench]
1007 fn bench_clone_from_10_0010_0100(b: &mut Bencher) {
1008     do_bench_clone_from(b, 10, 10, 100)
1009 }
1010
1011 #[bench]
1012 fn bench_clone_from_10_0100_1000(b: &mut Bencher) {
1013     do_bench_clone_from(b, 10, 100, 1000)
1014 }
1015
1016 #[bench]
1017 fn bench_clone_from_10_0010_0000(b: &mut Bencher) {
1018     do_bench_clone_from(b, 10, 10, 0)
1019 }
1020
1021 #[bench]
1022 fn bench_clone_from_10_0100_0010(b: &mut Bencher) {
1023     do_bench_clone_from(b, 10, 100, 10)
1024 }
1025
1026 #[bench]
1027 fn bench_clone_from_10_1000_0100(b: &mut Bencher) {
1028     do_bench_clone_from(b, 10, 1000, 100)
1029 }