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