src/libcollectionstest/vec.rs

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