src/libcollectionstest/slice.rs

   1 // Copyright 2012-2015 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::cmp::Ordering::{Equal, Greater, Less};
  12 use std::default::Default;
  13 use std::iter::RandomAccessIterator;
  14 use std::mem;
  15 use std::__rand::{Rng, thread_rng};
  16 use std::rc::Rc;
  17 use std::slice::ElementSwaps;
  18
  19 fn square(n: usize) -> usize { n * n }
  20
  21 fn is_odd(n: &usize) -> bool { *n % 2 == 1 }
  22
  23 #[test]
  24 fn test_from_fn() {
  25     // Test on-stack from_fn.
  26     let mut v: Vec<_> = (0..3).map(square).collect();
  27     {
  28         let v = v;
  29         assert_eq!(v.len(), 3);
  30         assert_eq!(v[0], 0);
  31         assert_eq!(v[1], 1);
  32         assert_eq!(v[2], 4);
  33     }
  34
  35     // Test on-heap from_fn.
  36     v = (0..5).map(square).collect();
  37     {
  38         let v = v;
  39         assert_eq!(v.len(), 5);
  40         assert_eq!(v[0], 0);
  41         assert_eq!(v[1], 1);
  42         assert_eq!(v[2], 4);
  43         assert_eq!(v[3], 9);
  44         assert_eq!(v[4], 16);
  45     }
  46 }
  47
  48 #[test]
  49 fn test_from_elem() {
  50     // Test on-stack from_elem.
  51     let mut v = vec![10, 10];
  52     {
  53         let v = v;
  54         assert_eq!(v.len(), 2);
  55         assert_eq!(v[0], 10);
  56         assert_eq!(v[1], 10);
  57     }
  58
  59     // Test on-heap from_elem.
  60     v = vec![20; 6];
  61     {
  62         let v = &v[..];
  63         assert_eq!(v[0], 20);
  64         assert_eq!(v[1], 20);
  65         assert_eq!(v[2], 20);
  66         assert_eq!(v[3], 20);
  67         assert_eq!(v[4], 20);
  68         assert_eq!(v[5], 20);
  69     }
  70 }
  71
  72 #[test]
  73 fn test_is_empty() {
  74     let xs: [i32; 0] = [];
  75     assert!(xs.is_empty());
  76     assert!(![0].is_empty());
  77 }
  78
  79 #[test]
  80 fn test_len_divzero() {
  81     type Z = [i8; 0];
  82     let v0 : &[Z] = &[];
  83     let v1 : &[Z] = &[[]];
  84     let v2 : &[Z] = &[[], []];
  85     assert_eq!(mem::size_of::<Z>(), 0);
  86     assert_eq!(v0.len(), 0);
  87     assert_eq!(v1.len(), 1);
  88     assert_eq!(v2.len(), 2);
  89 }
  90
  91 #[test]
  92 fn test_get() {
  93     let mut a = vec![11];
  94     assert_eq!(a.get(1), None);
  95     a = vec![11, 12];
  96     assert_eq!(a.get(1).unwrap(), &12);
  97     a = vec![11, 12, 13];
  98     assert_eq!(a.get(1).unwrap(), &12);
  99 }
 100
 101 #[test]
 102 fn test_first() {
 103     let mut a = vec![];
 104     assert_eq!(a.first(), None);
 105     a = vec![11];
 106     assert_eq!(a.first().unwrap(), &11);
 107     a = vec![11, 12];
 108     assert_eq!(a.first().unwrap(), &11);
 109 }
 110
 111 #[test]
 112 fn test_first_mut() {
 113     let mut a = vec![];
 114     assert_eq!(a.first_mut(), None);
 115     a = vec![11];
 116     assert_eq!(*a.first_mut().unwrap(), 11);
 117     a = vec![11, 12];
 118     assert_eq!(*a.first_mut().unwrap(), 11);
 119 }
 120
 121 #[test]
 122 fn test_tail() {
 123     let mut a = vec![11];
 124     let b: &[i32] = &[];
 125     assert_eq!(a.tail(), b);
 126     a = vec![11, 12];
 127     let b: &[i32] = &[12];
 128     assert_eq!(a.tail(), b);
 129 }
 130
 131 #[test]
 132 fn test_tail_mut() {
 133     let mut a = vec![11];
 134     let b: &mut [i32] = &mut [];
 135     assert!(a.tail_mut() == b);
 136     a = vec![11, 12];
 137     let b: &mut [_] = &mut [12];
 138     assert!(a.tail_mut() == b);
 139 }
 140
 141 #[test]
 142 #[should_panic]
 143 fn test_tail_empty() {
 144     let a = Vec::<i32>::new();
 145     a.tail();
 146 }
 147
 148 #[test]
 149 #[should_panic]
 150 fn test_tail_mut_empty() {
 151     let mut a = Vec::<i32>::new();
 152     a.tail_mut();
 153 }
 154
 155 #[test]
 156 fn test_init() {
 157     let mut a = vec![11];
 158     let b: &[i32] = &[];
 159     assert_eq!(a.init(), b);
 160     a = vec![11, 12];
 161     let b: &[_] = &[11];
 162     assert_eq!(a.init(), b);
 163 }
 164
 165 #[test]
 166 fn test_init_mut() {
 167     let mut a = vec![11];
 168     let b: &mut [i32] = &mut [];
 169     assert!(a.init_mut() == b);
 170     a = vec![11, 12];
 171     let b: &mut [_] = &mut [11];
 172     assert!(a.init_mut() == b);
 173 }
 174
 175 #[test]
 176 #[should_panic]
 177 fn test_init_empty() {
 178     let a = Vec::<i32>::new();
 179     a.init();
 180 }
 181
 182 #[test]
 183 #[should_panic]
 184 fn test_init_mut_empty() {
 185     let mut a = Vec::<i32>::new();
 186     a.init_mut();
 187 }
 188
 189 #[test]
 190 fn test_last() {
 191     let mut a = vec![];
 192     assert_eq!(a.last(), None);
 193     a = vec![11];
 194     assert_eq!(a.last().unwrap(), &11);
 195     a = vec![11, 12];
 196     assert_eq!(a.last().unwrap(), &12);
 197 }
 198
 199 #[test]
 200 fn test_last_mut() {
 201     let mut a = vec![];
 202     assert_eq!(a.last_mut(), None);
 203     a = vec![11];
 204     assert_eq!(*a.last_mut().unwrap(), 11);
 205     a = vec![11, 12];
 206     assert_eq!(*a.last_mut().unwrap(), 12);
 207 }
 208
 209 #[test]
 210 fn test_slice() {
 211     // Test fixed length vector.
 212     let vec_fixed = [1, 2, 3, 4];
 213     let v_a = vec_fixed[1..vec_fixed.len()].to_vec();
 214     assert_eq!(v_a.len(), 3);
 215
 216     assert_eq!(v_a[0], 2);
 217     assert_eq!(v_a[1], 3);
 218     assert_eq!(v_a[2], 4);
 219
 220     // Test on stack.
 221     let vec_stack: &[_] = &[1, 2, 3];
 222     let v_b = vec_stack[1..3].to_vec();
 223     assert_eq!(v_b.len(), 2);
 224
 225     assert_eq!(v_b[0], 2);
 226     assert_eq!(v_b[1], 3);
 227
 228     // Test `Box<[T]>`
 229     let vec_unique = vec![1, 2, 3, 4, 5, 6];
 230     let v_d = vec_unique[1..6].to_vec();
 231     assert_eq!(v_d.len(), 5);
 232
 233     assert_eq!(v_d[0], 2);
 234     assert_eq!(v_d[1], 3);
 235     assert_eq!(v_d[2], 4);
 236     assert_eq!(v_d[3], 5);
 237     assert_eq!(v_d[4], 6);
 238 }
 239
 240 #[test]
 241 fn test_slice_from() {
 242     let vec: &[_] = &[1, 2, 3, 4];
 243     assert_eq!(&vec[..], vec);
 244     let b: &[_] = &[3, 4];
 245     assert_eq!(&vec[2..], b);
 246     let b: &[_] = &[];
 247     assert_eq!(&vec[4..], b);
 248 }
 249
 250 #[test]
 251 fn test_slice_to() {
 252     let vec: &[_] = &[1, 2, 3, 4];
 253     assert_eq!(&vec[..4], vec);
 254     let b: &[_] = &[1, 2];
 255     assert_eq!(&vec[..2], b);
 256     let b: &[_] = &[];
 257     assert_eq!(&vec[..0], b);
 258 }
 259
 260
 261 #[test]
 262 fn test_pop() {
 263     let mut v = vec![5];
 264     let e = v.pop();
 265     assert_eq!(v.len(), 0);
 266     assert_eq!(e, Some(5));
 267     let f = v.pop();
 268     assert_eq!(f, None);
 269     let g = v.pop();
 270     assert_eq!(g, None);
 271 }
 272
 273 #[test]
 274 fn test_swap_remove() {
 275     let mut v = vec![1, 2, 3, 4, 5];
 276     let mut e = v.swap_remove(0);
 277     assert_eq!(e, 1);
 278     assert_eq!(v, [5, 2, 3, 4]);
 279     e = v.swap_remove(3);
 280     assert_eq!(e, 4);
 281     assert_eq!(v, [5, 2, 3]);
 282 }
 283
 284 #[test]
 285 #[should_panic]
 286 fn test_swap_remove_fail() {
 287     let mut v = vec![1];
 288     let _ = v.swap_remove(0);
 289     let _ = v.swap_remove(0);
 290 }
 291
 292 #[test]
 293 fn test_swap_remove_noncopyable() {
 294     // Tests that we don't accidentally run destructors twice.
 295     let mut v: Vec<Box<_>> = Vec::new();
 296     v.push(box 0u8);
 297     v.push(box 0u8);
 298     v.push(box 0u8);
 299     let mut _e = v.swap_remove(0);
 300     assert_eq!(v.len(), 2);
 301     _e = v.swap_remove(1);
 302     assert_eq!(v.len(), 1);
 303     _e = v.swap_remove(0);
 304     assert_eq!(v.len(), 0);
 305 }
 306
 307 #[test]
 308 fn test_push() {
 309     // Test on-stack push().
 310     let mut v = vec![];
 311     v.push(1);
 312     assert_eq!(v.len(), 1);
 313     assert_eq!(v[0], 1);
 314
 315     // Test on-heap push().
 316     v.push(2);
 317     assert_eq!(v.len(), 2);
 318     assert_eq!(v[0], 1);
 319     assert_eq!(v[1], 2);
 320 }
 321
 322 #[test]
 323 fn test_truncate() {
 324     let mut v: Vec<Box<_>> = vec![box 6,box 5,box 4];
 325     v.truncate(1);
 326     let v = v;
 327     assert_eq!(v.len(), 1);
 328     assert_eq!(*(v[0]), 6);
 329     // If the unsafe block didn't drop things properly, we blow up here.
 330 }
 331
 332 #[test]
 333 fn test_clear() {
 334     let mut v: Vec<Box<_>> = vec![box 6,box 5,box 4];
 335     v.clear();
 336     assert_eq!(v.len(), 0);
 337     // If the unsafe block didn't drop things properly, we blow up here.
 338 }
 339
 340 #[test]
 341 fn test_dedup() {
 342     fn case(a: Vec<i32>, b: Vec<i32>) {
 343         let mut v = a;
 344         v.dedup();
 345         assert_eq!(v, b);
 346     }
 347     case(vec![], vec![]);
 348     case(vec![1], vec![1]);
 349     case(vec![1,1], vec![1]);
 350     case(vec![1,2,3], vec![1,2,3]);
 351     case(vec![1,1,2,3], vec![1,2,3]);
 352     case(vec![1,2,2,3], vec![1,2,3]);
 353     case(vec![1,2,3,3], vec![1,2,3]);
 354     case(vec![1,1,2,2,2,3,3], vec![1,2,3]);
 355 }
 356
 357 #[test]
 358 fn test_dedup_unique() {
 359     let mut v0: Vec<Box<_>> = vec![box 1, box 1, box 2, box 3];
 360     v0.dedup();
 361     let mut v1: Vec<Box<_>> = vec![box 1, box 2, box 2, box 3];
 362     v1.dedup();
 363     let mut v2: Vec<Box<_>> = vec![box 1, box 2, box 3, box 3];
 364     v2.dedup();
 365     /*
 366      * If the boxed pointers were leaked or otherwise misused, valgrind
 367      * and/or rt should raise errors.
 368      */
 369 }
 370
 371 #[test]
 372 fn test_dedup_shared() {
 373     let mut v0: Vec<Box<_>> = vec![box 1, box 1, box 2, box 3];
 374     v0.dedup();
 375     let mut v1: Vec<Box<_>> = vec![box 1, box 2, box 2, box 3];
 376     v1.dedup();
 377     let mut v2: Vec<Box<_>> = vec![box 1, box 2, box 3, box 3];
 378     v2.dedup();
 379     /*
 380      * If the pointers were leaked or otherwise misused, valgrind and/or
 381      * rt should raise errors.
 382      */
 383 }
 384
 385 #[test]
 386 fn test_retain() {
 387     let mut v = vec![1, 2, 3, 4, 5];
 388     v.retain(is_odd);
 389     assert_eq!(v, [1, 3, 5]);
 390 }
 391
 392 #[test]
 393 fn test_element_swaps() {
 394     let mut v = [1, 2, 3];
 395     for (i, (a, b)) in ElementSwaps::new(v.len()).enumerate() {
 396         v.swap(a, b);
 397         match i {
 398             0 => assert!(v == [1, 3, 2]),
 399             1 => assert!(v == [3, 1, 2]),
 400             2 => assert!(v == [3, 2, 1]),
 401             3 => assert!(v == [2, 3, 1]),
 402             4 => assert!(v == [2, 1, 3]),
 403             5 => assert!(v == [1, 2, 3]),
 404             _ => panic!(),
 405         }
 406     }
 407 }
 408
 409 #[test]
 410 fn test_lexicographic_permutations() {
 411     let v : &mut[_] = &mut[1, 2, 3, 4, 5];
 412     assert!(v.prev_permutation() == false);
 413     assert!(v.next_permutation());
 414     let b: &mut[_] = &mut[1, 2, 3, 5, 4];
 415     assert!(v == b);
 416     assert!(v.prev_permutation());
 417     let b: &mut[_] = &mut[1, 2, 3, 4, 5];
 418     assert!(v == b);
 419     assert!(v.next_permutation());
 420     assert!(v.next_permutation());
 421     let b: &mut[_] = &mut[1, 2, 4, 3, 5];
 422     assert!(v == b);
 423     assert!(v.next_permutation());
 424     let b: &mut[_] = &mut[1, 2, 4, 5, 3];
 425     assert!(v == b);
 426
 427     let v : &mut[_] = &mut[1, 0, 0, 0];
 428     assert!(v.next_permutation() == false);
 429     assert!(v.prev_permutation());
 430     let b: &mut[_] = &mut[0, 1, 0, 0];
 431     assert!(v == b);
 432     assert!(v.prev_permutation());
 433     let b: &mut[_] = &mut[0, 0, 1, 0];
 434     assert!(v == b);
 435     assert!(v.prev_permutation());
 436     let b: &mut[_] = &mut[0, 0, 0, 1];
 437     assert!(v == b);
 438     assert!(v.prev_permutation() == false);
 439 }
 440
 441 #[test]
 442 fn test_lexicographic_permutations_empty_and_short() {
 443     let empty : &mut[i32] = &mut[];
 444     assert!(empty.next_permutation() == false);
 445     let b: &mut[i32] = &mut[];
 446     assert!(empty == b);
 447     assert!(empty.prev_permutation() == false);
 448     assert!(empty == b);
 449
 450     let one_elem : &mut[_] = &mut[4];
 451     assert!(one_elem.prev_permutation() == false);
 452     let b: &mut[_] = &mut[4];
 453     assert!(one_elem == b);
 454     assert!(one_elem.next_permutation() == false);
 455     assert!(one_elem == b);
 456
 457     let two_elem : &mut[_] = &mut[1, 2];
 458     assert!(two_elem.prev_permutation() == false);
 459     let b : &mut[_] = &mut[1, 2];
 460     let c : &mut[_] = &mut[2, 1];
 461     assert!(two_elem == b);
 462     assert!(two_elem.next_permutation());
 463     assert!(two_elem == c);
 464     assert!(two_elem.next_permutation() == false);
 465     assert!(two_elem == c);
 466     assert!(two_elem.prev_permutation());
 467     assert!(two_elem == b);
 468     assert!(two_elem.prev_permutation() == false);
 469     assert!(two_elem == b);
 470 }
 471
 472 #[test]
 473 fn test_position_elem() {
 474     assert!([].position_elem(&1).is_none());
 475
 476     let v1 = vec![1, 2, 3, 3, 2, 5];
 477     assert_eq!(v1.position_elem(&1), Some(0));
 478     assert_eq!(v1.position_elem(&2), Some(1));
 479     assert_eq!(v1.position_elem(&5), Some(5));
 480     assert!(v1.position_elem(&4).is_none());
 481 }
 482
 483 #[test]
 484 fn test_binary_search() {
 485     assert_eq!([1,2,3,4,5].binary_search(&5).ok(), Some(4));
 486     assert_eq!([1,2,3,4,5].binary_search(&4).ok(), Some(3));
 487     assert_eq!([1,2,3,4,5].binary_search(&3).ok(), Some(2));
 488     assert_eq!([1,2,3,4,5].binary_search(&2).ok(), Some(1));
 489     assert_eq!([1,2,3,4,5].binary_search(&1).ok(), Some(0));
 490
 491     assert_eq!([2,4,6,8,10].binary_search(&1).ok(), None);
 492     assert_eq!([2,4,6,8,10].binary_search(&5).ok(), None);
 493     assert_eq!([2,4,6,8,10].binary_search(&4).ok(), Some(1));
 494     assert_eq!([2,4,6,8,10].binary_search(&10).ok(), Some(4));
 495
 496     assert_eq!([2,4,6,8].binary_search(&1).ok(), None);
 497     assert_eq!([2,4,6,8].binary_search(&5).ok(), None);
 498     assert_eq!([2,4,6,8].binary_search(&4).ok(), Some(1));
 499     assert_eq!([2,4,6,8].binary_search(&8).ok(), Some(3));
 500
 501     assert_eq!([2,4,6].binary_search(&1).ok(), None);
 502     assert_eq!([2,4,6].binary_search(&5).ok(), None);
 503     assert_eq!([2,4,6].binary_search(&4).ok(), Some(1));
 504     assert_eq!([2,4,6].binary_search(&6).ok(), Some(2));
 505
 506     assert_eq!([2,4].binary_search(&1).ok(), None);
 507     assert_eq!([2,4].binary_search(&5).ok(), None);
 508     assert_eq!([2,4].binary_search(&2).ok(), Some(0));
 509     assert_eq!([2,4].binary_search(&4).ok(), Some(1));
 510
 511     assert_eq!([2].binary_search(&1).ok(), None);
 512     assert_eq!([2].binary_search(&5).ok(), None);
 513     assert_eq!([2].binary_search(&2).ok(), Some(0));
 514
 515     assert_eq!([].binary_search(&1).ok(), None);
 516     assert_eq!([].binary_search(&5).ok(), None);
 517
 518     assert!([1,1,1,1,1].binary_search(&1).ok() != None);
 519     assert!([1,1,1,1,2].binary_search(&1).ok() != None);
 520     assert!([1,1,1,2,2].binary_search(&1).ok() != None);
 521     assert!([1,1,2,2,2].binary_search(&1).ok() != None);
 522     assert_eq!([1,2,2,2,2].binary_search(&1).ok(), Some(0));
 523
 524     assert_eq!([1,2,3,4,5].binary_search(&6).ok(), None);
 525     assert_eq!([1,2,3,4,5].binary_search(&0).ok(), None);
 526 }
 527
 528 #[test]
 529 fn test_reverse() {
 530     let mut v = vec![10, 20];
 531     assert_eq!(v[0], 10);
 532     assert_eq!(v[1], 20);
 533     v.reverse();
 534     assert_eq!(v[0], 20);
 535     assert_eq!(v[1], 10);
 536
 537     let mut v3 = Vec::<i32>::new();
 538     v3.reverse();
 539     assert!(v3.is_empty());
 540 }
 541
 542 #[test]
 543 fn test_sort() {
 544     for len in 4..25 {
 545         for _ in 0..100 {
 546             let mut v: Vec<_> = thread_rng().gen_iter::<i32>().take(len).collect();
 547             let mut v1 = v.clone();
 548
 549             v.sort();
 550             assert!(v.windows(2).all(|w| w[0] <= w[1]));
 551
 552             v1.sort_by(|a, b| a.cmp(b));
 553             assert!(v1.windows(2).all(|w| w[0] <= w[1]));
 554
 555             v1.sort_by(|a, b| b.cmp(a));
 556             assert!(v1.windows(2).all(|w| w[0] >= w[1]));
 557         }
 558     }
 559
 560     // shouldn't panic
 561     let mut v: [i32; 0] = [];
 562     v.sort();
 563
 564     let mut v = [0xDEADBEEFu64];
 565     v.sort();
 566     assert!(v == [0xDEADBEEF]);
 567 }
 568
 569 #[test]
 570 fn test_sort_stability() {
 571     for len in 4..25 {
 572         for _ in 0..10 {
 573             let mut counts = [0; 10];
 574
 575             // create a vector like [(6, 1), (5, 1), (6, 2), ...],
 576             // where the first item of each tuple is random, but
 577             // the second item represents which occurrence of that
 578             // number this element is, i.e. the second elements
 579             // will occur in sorted order.
 580             let mut v: Vec<_> = (0..len).map(|_| {
 581                     let n = thread_rng().gen::<usize>() % 10;
 582                     counts[n] += 1;
 583                     (n, counts[n])
 584                 }).collect();
 585
 586             // only sort on the first element, so an unstable sort
 587             // may mix up the counts.
 588             v.sort_by(|&(a,_), &(b,_)| a.cmp(&b));
 589
 590             // this comparison includes the count (the second item
 591             // of the tuple), so elements with equal first items
 592             // will need to be ordered with increasing
 593             // counts... i.e. exactly asserting that this sort is
 594             // stable.
 595             assert!(v.windows(2).all(|w| w[0] <= w[1]));
 596         }
 597     }
 598 }
 599
 600 #[test]
 601 fn test_concat() {
 602     let v: [Vec<i32>; 0] = [];
 603     let c = v.concat();
 604     assert_eq!(c, []);
 605     let d = [vec![1], vec![2, 3]].concat();
 606     assert_eq!(d, [1, 2, 3]);
 607
 608     let v: &[&[_]] = &[&[1], &[2, 3]];
 609     assert_eq!(v.connect(&0), [1, 0, 2, 3]);
 610     let v: &[&[_]] = &[&[1], &[2], &[3]];
 611     assert_eq!(v.connect(&0), [1, 0, 2, 0, 3]);
 612 }
 613
 614 #[test]
 615 fn test_connect() {
 616     let v: [Vec<i32>; 0] = [];
 617     assert_eq!(v.connect(&0), []);
 618     assert_eq!([vec![1], vec![2, 3]].connect(&0), [1, 0, 2, 3]);
 619     assert_eq!([vec![1], vec![2], vec![3]].connect(&0), [1, 0, 2, 0, 3]);
 620
 621     let v: [&[_]; 2] = [&[1], &[2, 3]];
 622     assert_eq!(v.connect(&0), [1, 0, 2, 3]);
 623     let v: [&[_]; 3] = [&[1], &[2], &[3]];
 624     assert_eq!(v.connect(&0), [1, 0, 2, 0, 3]);
 625 }
 626
 627 #[test]
 628 fn test_insert() {
 629     let mut a = vec![1, 2, 4];
 630     a.insert(2, 3);
 631     assert_eq!(a, [1, 2, 3, 4]);
 632
 633     let mut a = vec![1, 2, 3];
 634     a.insert(0, 0);
 635     assert_eq!(a, [0, 1, 2, 3]);
 636
 637     let mut a = vec![1, 2, 3];
 638     a.insert(3, 4);
 639     assert_eq!(a, [1, 2, 3, 4]);
 640
 641     let mut a = vec![];
 642     a.insert(0, 1);
 643     assert_eq!(a, [1]);
 644 }
 645
 646 #[test]
 647 #[should_panic]
 648 fn test_insert_oob() {
 649     let mut a = vec![1, 2, 3];
 650     a.insert(4, 5);
 651 }
 652
 653 #[test]
 654 fn test_remove() {
 655     let mut a = vec![1, 2, 3, 4];
 656
 657     assert_eq!(a.remove(2), 3);
 658     assert_eq!(a, [1, 2, 4]);
 659
 660     assert_eq!(a.remove(2), 4);
 661     assert_eq!(a, [1, 2]);
 662
 663     assert_eq!(a.remove(0), 1);
 664     assert_eq!(a, [2]);
 665
 666     assert_eq!(a.remove(0), 2);
 667     assert_eq!(a, []);
 668 }
 669
 670 #[test]
 671 #[should_panic]
 672 fn test_remove_fail() {
 673     let mut a = vec![1];
 674     let _ = a.remove(0);
 675     let _ = a.remove(0);
 676 }
 677
 678 #[test]
 679 fn test_capacity() {
 680     let mut v = vec![0];
 681     v.reserve_exact(10);
 682     assert!(v.capacity() >= 11);
 683 }
 684
 685 #[test]
 686 fn test_slice_2() {
 687     let v = vec![1, 2, 3, 4, 5];
 688     let v = &v[1..3];
 689     assert_eq!(v.len(), 2);
 690     assert_eq!(v[0], 2);
 691     assert_eq!(v[1], 3);
 692 }
 693
 694 #[test]
 695 #[should_panic]
 696 fn test_permute_fail() {
 697     let v: [(Box<_>, Rc<_>); 4] =
 698         [(box 0, Rc::new(0)), (box 0, Rc::new(0)),
 699          (box 0, Rc::new(0)), (box 0, Rc::new(0))];
 700     let mut i = 0;
 701     for _ in v.permutations() {
 702         if i == 2 {
 703             panic!()
 704         }
 705         i += 1;
 706     }
 707 }
 708
 709 #[test]
 710 fn test_total_ord() {
 711     let c = &[1, 2, 3];
 712     [1, 2, 3, 4][..].cmp(c) == Greater;
 713     let c = &[1, 2, 3, 4];
 714     [1, 2, 3][..].cmp(c) == Less;
 715     let c = &[1, 2, 3, 6];
 716     [1, 2, 3, 4][..].cmp(c) == Equal;
 717     let c = &[1, 2, 3, 4, 5, 6];
 718     [1, 2, 3, 4, 5, 5, 5, 5][..].cmp(c) == Less;
 719     let c = &[1, 2, 3, 4];
 720     [2, 2][..].cmp(c) == Greater;
 721 }
 722
 723 #[test]
 724 fn test_iterator() {
 725     let xs = [1, 2, 5, 10, 11];
 726     let mut it = xs.iter();
 727     assert_eq!(it.size_hint(), (5, Some(5)));
 728     assert_eq!(it.next().unwrap(), &1);
 729     assert_eq!(it.size_hint(), (4, Some(4)));
 730     assert_eq!(it.next().unwrap(), &2);
 731     assert_eq!(it.size_hint(), (3, Some(3)));
 732     assert_eq!(it.next().unwrap(), &5);
 733     assert_eq!(it.size_hint(), (2, Some(2)));
 734     assert_eq!(it.next().unwrap(), &10);
 735     assert_eq!(it.size_hint(), (1, Some(1)));
 736     assert_eq!(it.next().unwrap(), &11);
 737     assert_eq!(it.size_hint(), (0, Some(0)));
 738     assert!(it.next().is_none());
 739 }
 740
 741 #[test]
 742 fn test_random_access_iterator() {
 743     let xs = [1, 2, 5, 10, 11];
 744     let mut it = xs.iter();
 745
 746     assert_eq!(it.indexable(), 5);
 747     assert_eq!(it.idx(0).unwrap(), &1);
 748     assert_eq!(it.idx(2).unwrap(), &5);
 749     assert_eq!(it.idx(4).unwrap(), &11);
 750     assert!(it.idx(5).is_none());
 751
 752     assert_eq!(it.next().unwrap(), &1);
 753     assert_eq!(it.indexable(), 4);
 754     assert_eq!(it.idx(0).unwrap(), &2);
 755     assert_eq!(it.idx(3).unwrap(), &11);
 756     assert!(it.idx(4).is_none());
 757
 758     assert_eq!(it.next().unwrap(), &2);
 759     assert_eq!(it.indexable(), 3);
 760     assert_eq!(it.idx(1).unwrap(), &10);
 761     assert!(it.idx(3).is_none());
 762
 763     assert_eq!(it.next().unwrap(), &5);
 764     assert_eq!(it.indexable(), 2);
 765     assert_eq!(it.idx(1).unwrap(), &11);
 766
 767     assert_eq!(it.next().unwrap(), &10);
 768     assert_eq!(it.indexable(), 1);
 769     assert_eq!(it.idx(0).unwrap(), &11);
 770     assert!(it.idx(1).is_none());
 771
 772     assert_eq!(it.next().unwrap(), &11);
 773     assert_eq!(it.indexable(), 0);
 774     assert!(it.idx(0).is_none());
 775
 776     assert!(it.next().is_none());
 777 }
 778
 779 #[test]
 780 fn test_iter_size_hints() {
 781     let mut xs = [1, 2, 5, 10, 11];
 782     assert_eq!(xs.iter().size_hint(), (5, Some(5)));
 783     assert_eq!(xs.iter_mut().size_hint(), (5, Some(5)));
 784 }
 785
 786 #[test]
 787 fn test_iter_clone() {
 788     let xs = [1, 2, 5];
 789     let mut it = xs.iter();
 790     it.next();
 791     let mut jt = it.clone();
 792     assert_eq!(it.next(), jt.next());
 793     assert_eq!(it.next(), jt.next());
 794     assert_eq!(it.next(), jt.next());
 795 }
 796
 797 #[test]
 798 fn test_mut_iterator() {
 799     let mut xs = [1, 2, 3, 4, 5];
 800     for x in &mut xs {
 801         *x += 1;
 802     }
 803     assert!(xs == [2, 3, 4, 5, 6])
 804 }
 805
 806 #[test]
 807 fn test_rev_iterator() {
 808
 809     let xs = [1, 2, 5, 10, 11];
 810     let ys = [11, 10, 5, 2, 1];
 811     let mut i = 0;
 812     for &x in xs.iter().rev() {
 813         assert_eq!(x, ys[i]);
 814         i += 1;
 815     }
 816     assert_eq!(i, 5);
 817 }
 818
 819 #[test]
 820 fn test_mut_rev_iterator() {
 821     let mut xs = [1, 2, 3, 4, 5];
 822     for (i,x) in xs.iter_mut().rev().enumerate() {
 823         *x += i;
 824     }
 825     assert!(xs == [5, 5, 5, 5, 5])
 826 }
 827
 828 #[test]
 829 fn test_move_iterator() {
 830     let xs = vec![1,2,3,4,5];
 831     assert_eq!(xs.into_iter().fold(0, |a: usize, b: usize| 10*a + b), 12345);
 832 }
 833
 834 #[test]
 835 fn test_move_rev_iterator() {
 836     let xs = vec![1,2,3,4,5];
 837     assert_eq!(xs.into_iter().rev().fold(0, |a: usize, b: usize| 10*a + b), 54321);
 838 }
 839
 840 #[test]
 841 fn test_splitator() {
 842     let xs = &[1,2,3,4,5];
 843
 844     let splits: &[&[_]] = &[&[1], &[3], &[5]];
 845     assert_eq!(xs.split(|x| *x % 2 == 0).collect::<Vec<_>>(),
 846                splits);
 847     let splits: &[&[_]] = &[&[], &[2,3,4,5]];
 848     assert_eq!(xs.split(|x| *x == 1).collect::<Vec<_>>(),
 849                splits);
 850     let splits: &[&[_]] = &[&[1,2,3,4], &[]];
 851     assert_eq!(xs.split(|x| *x == 5).collect::<Vec<_>>(),
 852                splits);
 853     let splits: &[&[_]] = &[&[1,2,3,4,5]];
 854     assert_eq!(xs.split(|x| *x == 10).collect::<Vec<_>>(),
 855                splits);
 856     let splits: &[&[_]] = &[&[], &[], &[], &[], &[], &[]];
 857     assert_eq!(xs.split(|_| true).collect::<Vec<&[i32]>>(),
 858                splits);
 859
 860     let xs: &[i32] = &[];
 861     let splits: &[&[i32]] = &[&[]];
 862     assert_eq!(xs.split(|x| *x == 5).collect::<Vec<&[i32]>>(), splits);
 863 }
 864
 865 #[test]
 866 fn test_splitnator() {
 867     let xs = &[1,2,3,4,5];
 868
 869     let splits: &[&[_]] = &[&[1,2,3,4,5]];
 870     assert_eq!(xs.splitn(1, |x| *x % 2 == 0).collect::<Vec<_>>(),
 871                splits);
 872     let splits: &[&[_]] = &[&[1], &[3,4,5]];
 873     assert_eq!(xs.splitn(2, |x| *x % 2 == 0).collect::<Vec<_>>(),
 874                splits);
 875     let splits: &[&[_]] = &[&[], &[], &[], &[4,5]];
 876     assert_eq!(xs.splitn(4, |_| true).collect::<Vec<_>>(),
 877                splits);
 878
 879     let xs: &[i32] = &[];
 880     let splits: &[&[i32]] = &[&[]];
 881     assert_eq!(xs.splitn(2, |x| *x == 5).collect::<Vec<_>>(), splits);
 882 }
 883
 884 #[test]
 885 fn test_splitnator_mut() {
 886     let xs = &mut [1,2,3,4,5];
 887
 888     let splits: &[&mut[_]] = &[&mut [1,2,3,4,5]];
 889     assert_eq!(xs.splitn_mut(1, |x| *x % 2 == 0).collect::<Vec<_>>(),
 890                splits);
 891     let splits: &[&mut[_]] = &[&mut [1], &mut [3,4,5]];
 892     assert_eq!(xs.splitn_mut(2, |x| *x % 2 == 0).collect::<Vec<_>>(),
 893                splits);
 894     let splits: &[&mut[_]] = &[&mut [], &mut [], &mut [], &mut [4,5]];
 895     assert_eq!(xs.splitn_mut(4, |_| true).collect::<Vec<_>>(),
 896                splits);
 897
 898     let xs: &mut [i32] = &mut [];
 899     let splits: &[&mut[i32]] = &[&mut []];
 900     assert_eq!(xs.splitn_mut(2, |x| *x == 5).collect::<Vec<_>>(),
 901                splits);
 902 }
 903
 904 #[test]
 905 fn test_rsplitator() {
 906     let xs = &[1,2,3,4,5];
 907
 908     let splits: &[&[_]] = &[&[5], &[3], &[1]];
 909     assert_eq!(xs.split(|x| *x % 2 == 0).rev().collect::<Vec<_>>(),
 910                splits);
 911     let splits: &[&[_]] = &[&[2,3,4,5], &[]];
 912     assert_eq!(xs.split(|x| *x == 1).rev().collect::<Vec<_>>(),
 913                splits);
 914     let splits: &[&[_]] = &[&[], &[1,2,3,4]];
 915     assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<_>>(),
 916                splits);
 917     let splits: &[&[_]] = &[&[1,2,3,4,5]];
 918     assert_eq!(xs.split(|x| *x == 10).rev().collect::<Vec<_>>(),
 919                splits);
 920
 921     let xs: &[i32] = &[];
 922     let splits: &[&[i32]] = &[&[]];
 923     assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<&[i32]>>(), splits);
 924 }
 925
 926 #[test]
 927 fn test_rsplitnator() {
 928     let xs = &[1,2,3,4,5];
 929
 930     let splits: &[&[_]] = &[&[1,2,3,4,5]];
 931     assert_eq!(xs.rsplitn(1, |x| *x % 2 == 0).collect::<Vec<_>>(),
 932                splits);
 933     let splits: &[&[_]] = &[&[5], &[1,2,3]];
 934     assert_eq!(xs.rsplitn(2, |x| *x % 2 == 0).collect::<Vec<_>>(),
 935                splits);
 936     let splits: &[&[_]] = &[&[], &[], &[], &[1,2]];
 937     assert_eq!(xs.rsplitn(4, |_| true).collect::<Vec<_>>(),
 938                splits);
 939
 940     let xs: &[i32]  = &[];
 941     let splits: &[&[i32]] = &[&[]];
 942     assert_eq!(xs.rsplitn(2, |x| *x == 5).collect::<Vec<&[i32]>>(), splits);
 943     assert!(xs.rsplitn(0, |x| *x % 2 == 0).next().is_none());
 944 }
 945
 946 #[test]
 947 fn test_windowsator() {
 948     let v = &[1,2,3,4];
 949
 950     let wins: &[&[_]] = &[&[1,2], &[2,3], &[3,4]];
 951     assert_eq!(v.windows(2).collect::<Vec<_>>(), wins);
 952
 953     let wins: &[&[_]] = &[&[1,2,3], &[2,3,4]];
 954     assert_eq!(v.windows(3).collect::<Vec<_>>(), wins);
 955     assert!(v.windows(6).next().is_none());
 956
 957     let wins: &[&[_]] = &[&[3,4], &[2,3], &[1,2]];
 958     assert_eq!(v.windows(2).rev().collect::<Vec<&[_]>>(), wins);
 959     let mut it = v.windows(2);
 960     assert_eq!(it.indexable(), 3);
 961     let win: &[_] = &[1,2];
 962     assert_eq!(it.idx(0).unwrap(), win);
 963     let win: &[_] = &[2,3];
 964     assert_eq!(it.idx(1).unwrap(), win);
 965     let win: &[_] = &[3,4];
 966     assert_eq!(it.idx(2).unwrap(), win);
 967     assert_eq!(it.idx(3), None);
 968 }
 969
 970 #[test]
 971 #[should_panic]
 972 fn test_windowsator_0() {
 973     let v = &[1,2,3,4];
 974     let _it = v.windows(0);
 975 }
 976
 977 #[test]
 978 fn test_chunksator() {
 979     let v = &[1,2,3,4,5];
 980
 981     assert_eq!(v.chunks(2).len(), 3);
 982
 983     let chunks: &[&[_]] = &[&[1,2], &[3,4], &[5]];
 984     assert_eq!(v.chunks(2).collect::<Vec<_>>(), chunks);
 985     let chunks: &[&[_]] = &[&[1,2,3], &[4,5]];
 986     assert_eq!(v.chunks(3).collect::<Vec<_>>(), chunks);
 987     let chunks: &[&[_]] = &[&[1,2,3,4,5]];
 988     assert_eq!(v.chunks(6).collect::<Vec<_>>(), chunks);
 989
 990     let chunks: &[&[_]] = &[&[5], &[3,4], &[1,2]];
 991     assert_eq!(v.chunks(2).rev().collect::<Vec<_>>(), chunks);
 992     let mut it = v.chunks(2);
 993     assert_eq!(it.indexable(), 3);
 994
 995     let chunk: &[_] = &[1,2];
 996     assert_eq!(it.idx(0).unwrap(), chunk);
 997     let chunk: &[_] = &[3,4];
 998     assert_eq!(it.idx(1).unwrap(), chunk);
 999     let chunk: &[_] = &[5];
1000     assert_eq!(it.idx(2).unwrap(), chunk);
1001     assert_eq!(it.idx(3), None);
1002 }
1003
1004 #[test]
1005 #[should_panic]
1006 fn test_chunksator_0() {
1007     let v = &[1,2,3,4];
1008     let _it = v.chunks(0);
1009 }
1010
1011 #[test]
1012 fn test_move_from() {
1013     let mut a = [1,2,3,4,5];
1014     let b = vec![6,7,8];
1015     assert_eq!(a.move_from(b, 0, 3), 3);
1016     assert!(a == [6,7,8,4,5]);
1017     let mut a = [7,2,8,1];
1018     let b = vec![3,1,4,1,5,9];
1019     assert_eq!(a.move_from(b, 0, 6), 4);
1020     assert!(a == [3,1,4,1]);
1021     let mut a = [1,2,3,4];
1022     let b = vec![5,6,7,8,9,0];
1023     assert_eq!(a.move_from(b, 2, 3), 1);
1024     assert!(a == [7,2,3,4]);
1025     let mut a = [1,2,3,4,5];
1026     let b = vec![5,6,7,8,9,0];
1027     assert_eq!(a[2..4].move_from(b,1,6), 2);
1028     assert!(a == [1,2,6,7,5]);
1029 }
1030
1031 #[test]
1032 fn test_reverse_part() {
1033     let mut values = [1,2,3,4,5];
1034     values[1..4].reverse();
1035     assert!(values == [1,4,3,2,5]);
1036 }
1037
1038 #[test]
1039 fn test_show() {
1040     macro_rules! test_show_vec {
1041         ($x:expr, $x_str:expr) => ({
1042             let (x, x_str) = ($x, $x_str);
1043             assert_eq!(format!("{:?}", x), x_str);
1044             assert_eq!(format!("{:?}", x), x_str);
1045         })
1046     }
1047     let empty = Vec::<i32>::new();
1048     test_show_vec!(empty, "[]");
1049     test_show_vec!(vec![1], "[1]");
1050     test_show_vec!(vec![1, 2, 3], "[1, 2, 3]");
1051     test_show_vec!(vec![vec![], vec![1], vec![1, 1]],
1052                    "[[], [1], [1, 1]]");
1053
1054     let empty_mut: &mut [i32] = &mut[];
1055     test_show_vec!(empty_mut, "[]");
1056     let v = &mut[1];
1057     test_show_vec!(v, "[1]");
1058     let v = &mut[1, 2, 3];
1059     test_show_vec!(v, "[1, 2, 3]");
1060     let v: &mut[&mut[_]] = &mut[&mut[], &mut[1], &mut[1, 1]];
1061     test_show_vec!(v, "[[], [1], [1, 1]]");
1062 }
1063
1064 #[test]
1065 fn test_vec_default() {
1066     macro_rules! t {
1067         ($ty:ty) => {{
1068             let v: $ty = Default::default();
1069             assert!(v.is_empty());
1070         }}
1071     }
1072
1073     t!(&[i32]);
1074     t!(Vec<i32>);
1075 }
1076
1077 #[test]
1078 fn test_bytes_set_memory() {
1079     use std::slice::bytes::MutableByteVector;
1080
1081     let mut values = [1,2,3,4,5];
1082     values[0..5].set_memory(0xAB);
1083     assert!(values == [0xAB, 0xAB, 0xAB, 0xAB, 0xAB]);
1084     values[2..4].set_memory(0xFF);
1085     assert!(values == [0xAB, 0xAB, 0xFF, 0xFF, 0xAB]);
1086 }
1087
1088 #[test]
1089 #[should_panic]
1090 fn test_overflow_does_not_cause_segfault() {
1091     let mut v = vec![];
1092     v.reserve_exact(!0);
1093     v.push(1);
1094     v.push(2);
1095 }
1096
1097 #[test]
1098 #[should_panic]
1099 fn test_overflow_does_not_cause_segfault_managed() {
1100     let mut v = vec![Rc::new(1)];
1101     v.reserve_exact(!0);
1102     v.push(Rc::new(2));
1103 }
1104
1105 #[test]
1106 fn test_mut_split_at() {
1107     let mut values = [1u8,2,3,4,5];
1108     {
1109         let (left, right) = values.split_at_mut(2);
1110         {
1111             let left: &[_] = left;
1112             assert!(left[..left.len()] == [1, 2]);
1113         }
1114         for p in left {
1115             *p += 1;
1116         }
1117
1118         {
1119             let right: &[_] = right;
1120             assert!(right[..right.len()] == [3, 4, 5]);
1121         }
1122         for p in right {
1123             *p += 2;
1124         }
1125     }
1126
1127     assert!(values == [2, 3, 5, 6, 7]);
1128 }
1129
1130 #[derive(Clone, PartialEq)]
1131 struct Foo;
1132
1133 #[test]
1134 fn test_iter_zero_sized() {
1135     let mut v = vec![Foo, Foo, Foo];
1136     assert_eq!(v.len(), 3);
1137     let mut cnt = 0;
1138
1139     for f in &v {
1140         assert!(*f == Foo);
1141         cnt += 1;
1142     }
1143     assert_eq!(cnt, 3);
1144
1145     for f in &v[1..3] {
1146         assert!(*f == Foo);
1147         cnt += 1;
1148     }
1149     assert_eq!(cnt, 5);
1150
1151     for f in &mut v {
1152         assert!(*f == Foo);
1153         cnt += 1;
1154     }
1155     assert_eq!(cnt, 8);
1156
1157     for f in v {
1158         assert!(f == Foo);
1159         cnt += 1;
1160     }
1161     assert_eq!(cnt, 11);
1162
1163     let xs: [Foo; 3] = [Foo, Foo, Foo];
1164     cnt = 0;
1165     for f in &xs {
1166         assert!(*f == Foo);
1167         cnt += 1;
1168     }
1169     assert!(cnt == 3);
1170 }
1171
1172 #[test]
1173 fn test_shrink_to_fit() {
1174     let mut xs = vec![0, 1, 2, 3];
1175     for i in 4..100 {
1176         xs.push(i)
1177     }
1178     assert_eq!(xs.capacity(), 128);
1179     xs.shrink_to_fit();
1180     assert_eq!(xs.capacity(), 100);
1181     assert_eq!(xs, (0..100).collect::<Vec<_>>());
1182 }
1183
1184 #[test]
1185 fn test_starts_with() {
1186     assert!(b"foobar".starts_with(b"foo"));
1187     assert!(!b"foobar".starts_with(b"oob"));
1188     assert!(!b"foobar".starts_with(b"bar"));
1189     assert!(!b"foo".starts_with(b"foobar"));
1190     assert!(!b"bar".starts_with(b"foobar"));
1191     assert!(b"foobar".starts_with(b"foobar"));
1192     let empty: &[u8] = &[];
1193     assert!(empty.starts_with(empty));
1194     assert!(!empty.starts_with(b"foo"));
1195     assert!(b"foobar".starts_with(empty));
1196 }
1197
1198 #[test]
1199 fn test_ends_with() {
1200     assert!(b"foobar".ends_with(b"bar"));
1201     assert!(!b"foobar".ends_with(b"oba"));
1202     assert!(!b"foobar".ends_with(b"foo"));
1203     assert!(!b"foo".ends_with(b"foobar"));
1204     assert!(!b"bar".ends_with(b"foobar"));
1205     assert!(b"foobar".ends_with(b"foobar"));
1206     let empty: &[u8] = &[];
1207     assert!(empty.ends_with(empty));
1208     assert!(!empty.ends_with(b"foo"));
1209     assert!(b"foobar".ends_with(empty));
1210 }
1211
1212 #[test]
1213 fn test_mut_splitator() {
1214     let mut xs = [0,1,0,2,3,0,0,4,5,0];
1215     assert_eq!(xs.split_mut(|x| *x == 0).count(), 6);
1216     for slice in xs.split_mut(|x| *x == 0) {
1217         slice.reverse();
1218     }
1219     assert!(xs == [0,1,0,3,2,0,0,5,4,0]);
1220
1221     let mut xs = [0,1,0,2,3,0,0,4,5,0,6,7];
1222     for slice in xs.split_mut(|x| *x == 0).take(5) {
1223         slice.reverse();
1224     }
1225     assert!(xs == [0,1,0,3,2,0,0,5,4,0,6,7]);
1226 }
1227
1228 #[test]
1229 fn test_mut_splitator_rev() {
1230     let mut xs = [1,2,0,3,4,0,0,5,6,0];
1231     for slice in xs.split_mut(|x| *x == 0).rev().take(4) {
1232         slice.reverse();
1233     }
1234     assert!(xs == [1,2,0,4,3,0,0,6,5,0]);
1235 }
1236
1237 #[test]
1238 fn test_get_mut() {
1239     let mut v = [0,1,2];
1240     assert_eq!(v.get_mut(3), None);
1241     v.get_mut(1).map(|e| *e = 7);
1242     assert_eq!(v[1], 7);
1243     let mut x = 2;
1244     assert_eq!(v.get_mut(2), Some(&mut x));
1245 }
1246
1247 #[test]
1248 fn test_mut_chunks() {
1249     let mut v = [0, 1, 2, 3, 4, 5, 6];
1250     assert_eq!(v.chunks_mut(2).len(), 4);
1251     for (i, chunk) in v.chunks_mut(3).enumerate() {
1252         for x in chunk {
1253             *x = i as u8;
1254         }
1255     }
1256     let result = [0, 0, 0, 1, 1, 1, 2];
1257     assert!(v == result);
1258 }
1259
1260 #[test]
1261 fn test_mut_chunks_rev() {
1262     let mut v = [0, 1, 2, 3, 4, 5, 6];
1263     for (i, chunk) in v.chunks_mut(3).rev().enumerate() {
1264         for x in chunk {
1265             *x = i as u8;
1266         }
1267     }
1268     let result = [2, 2, 2, 1, 1, 1, 0];
1269     assert!(v == result);
1270 }
1271
1272 #[test]
1273 #[should_panic]
1274 fn test_mut_chunks_0() {
1275     let mut v = [1, 2, 3, 4];
1276     let _it = v.chunks_mut(0);
1277 }
1278
1279 #[test]
1280 fn test_mut_last() {
1281     let mut x = [1, 2, 3, 4, 5];
1282     let h = x.last_mut();
1283     assert_eq!(*h.unwrap(), 5);
1284
1285     let y: &mut [i32] = &mut [];
1286     assert!(y.last_mut().is_none());
1287 }
1288
1289 #[test]
1290 fn test_to_vec() {
1291     let xs: Box<_> = box [1, 2, 3];
1292     let ys = xs.to_vec();
1293     assert_eq!(ys, [1, 2, 3]);
1294 }
1295
1296 mod bench {
1297     use std::iter::repeat;
1298     use std::{mem, ptr};
1299     use std::__rand::{Rng, thread_rng};
1300
1301     use test::{Bencher, black_box};
1302
1303     #[bench]
1304     fn iterator(b: &mut Bencher) {
1305         // peculiar numbers to stop LLVM from optimising the summation
1306         // out.
1307         let v: Vec<_> = (0..100).map(|i| i ^ (i << 1) ^ (i >> 1)).collect();
1308
1309         b.iter(|| {
1310             let mut sum = 0;
1311             for x in &v {
1312                 sum += *x;
1313             }
1314             // sum == 11806, to stop dead code elimination.
1315             if sum == 0 {panic!()}
1316         })
1317     }
1318
1319     #[bench]
1320     fn mut_iterator(b: &mut Bencher) {
1321         let mut v: Vec<_> = repeat(0).take(100).collect();
1322
1323         b.iter(|| {
1324             let mut i = 0;
1325             for x in &mut v {
1326                 *x = i;
1327                 i += 1;
1328             }
1329         })
1330     }
1331
1332     #[bench]
1333     fn concat(b: &mut Bencher) {
1334         let xss: Vec<Vec<i32>> =
1335             (0..100).map(|i| (0..i).collect()).collect();
1336         b.iter(|| {
1337             xss.concat();
1338         });
1339     }
1340
1341     #[bench]
1342     fn connect(b: &mut Bencher) {
1343         let xss: Vec<Vec<i32>> =
1344             (0..100).map(|i| (0..i).collect()).collect();
1345         b.iter(|| {
1346             xss.connect(&0)
1347         });
1348     }
1349
1350     #[bench]
1351     fn push(b: &mut Bencher) {
1352         let mut vec = Vec::<i32>::new();
1353         b.iter(|| {
1354             vec.push(0);
1355             black_box(&vec);
1356         });
1357     }
1358
1359     #[bench]
1360     fn starts_with_same_vector(b: &mut Bencher) {
1361         let vec: Vec<_> = (0..100).collect();
1362         b.iter(|| {
1363             vec.starts_with(&vec)
1364         })
1365     }
1366
1367     #[bench]
1368     fn starts_with_single_element(b: &mut Bencher) {
1369         let vec: Vec<_> = vec![0];
1370         b.iter(|| {
1371             vec.starts_with(&vec)
1372         })
1373     }
1374
1375     #[bench]
1376     fn starts_with_diff_one_element_at_end(b: &mut Bencher) {
1377         let vec: Vec<_> = (0..100).collect();
1378         let mut match_vec: Vec<_> = (0..99).collect();
1379         match_vec.push(0);
1380         b.iter(|| {
1381             vec.starts_with(&match_vec)
1382         })
1383     }
1384
1385     #[bench]
1386     fn ends_with_same_vector(b: &mut Bencher) {
1387         let vec: Vec<_> = (0..100).collect();
1388         b.iter(|| {
1389             vec.ends_with(&vec)
1390         })
1391     }
1392
1393     #[bench]
1394     fn ends_with_single_element(b: &mut Bencher) {
1395         let vec: Vec<_> = vec![0];
1396         b.iter(|| {
1397             vec.ends_with(&vec)
1398         })
1399     }
1400
1401     #[bench]
1402     fn ends_with_diff_one_element_at_beginning(b: &mut Bencher) {
1403         let vec: Vec<_> = (0..100).collect();
1404         let mut match_vec: Vec<_> = (0..100).collect();
1405         match_vec[0] = 200;
1406         b.iter(|| {
1407             vec.starts_with(&match_vec)
1408         })
1409     }
1410
1411     #[bench]
1412     fn contains_last_element(b: &mut Bencher) {
1413         let vec: Vec<_> = (0..100).collect();
1414         b.iter(|| {
1415             vec.contains(&99)
1416         })
1417     }
1418
1419     #[bench]
1420     fn zero_1kb_from_elem(b: &mut Bencher) {
1421         b.iter(|| {
1422             repeat(0u8).take(1024).collect::<Vec<_>>()
1423         });
1424     }
1425
1426     #[bench]
1427     fn zero_1kb_set_memory(b: &mut Bencher) {
1428         b.iter(|| {
1429             let mut v = Vec::<u8>::with_capacity(1024);
1430             unsafe {
1431                 let vp = v.as_mut_ptr();
1432                 ptr::write_bytes(vp, 0, 1024);
1433                 v.set_len(1024);
1434             }
1435             v
1436         });
1437     }
1438
1439     #[bench]
1440     fn zero_1kb_loop_set(b: &mut Bencher) {
1441         b.iter(|| {
1442             let mut v = Vec::<u8>::with_capacity(1024);
1443             unsafe {
1444                 v.set_len(1024);
1445             }
1446             for i in 0..1024 {
1447                 v[i] = 0;
1448             }
1449         });
1450     }
1451
1452     #[bench]
1453     fn zero_1kb_mut_iter(b: &mut Bencher) {
1454         b.iter(|| {
1455             let mut v = Vec::<u8>::with_capacity(1024);
1456             unsafe {
1457                 v.set_len(1024);
1458             }
1459             for x in &mut v {
1460                 *x = 0;
1461             }
1462             v
1463         });
1464     }
1465
1466     #[bench]
1467     fn random_inserts(b: &mut Bencher) {
1468         let mut rng = thread_rng();
1469         b.iter(|| {
1470             let mut v: Vec<_> = repeat((0, 0)).take(30).collect();
1471             for _ in 0..100 {
1472                 let l = v.len();
1473                 v.insert(rng.gen::<usize>() % (l + 1),
1474                          (1, 1));
1475             }
1476         })
1477     }
1478     #[bench]
1479     fn random_removes(b: &mut Bencher) {
1480         let mut rng = thread_rng();
1481         b.iter(|| {
1482             let mut v: Vec<_> = repeat((0, 0)).take(130).collect();
1483             for _ in 0..100 {
1484                 let l = v.len();
1485                 v.remove(rng.gen::<usize>() % l);
1486             }
1487         })
1488     }
1489
1490     #[bench]
1491     fn sort_random_small(b: &mut Bencher) {
1492         let mut rng = thread_rng();
1493         b.iter(|| {
1494             let mut v: Vec<_> = rng.gen_iter::<u64>().take(5).collect();
1495             v.sort();
1496         });
1497         b.bytes = 5 * mem::size_of::<u64>() as u64;
1498     }
1499
1500     #[bench]
1501     fn sort_random_medium(b: &mut Bencher) {
1502         let mut rng = thread_rng();
1503         b.iter(|| {
1504             let mut v: Vec<_> = rng.gen_iter::<u64>().take(100).collect();
1505             v.sort();
1506         });
1507         b.bytes = 100 * mem::size_of::<u64>() as u64;
1508     }
1509
1510     #[bench]
1511     fn sort_random_large(b: &mut Bencher) {
1512         let mut rng = thread_rng();
1513         b.iter(|| {
1514             let mut v: Vec<_> = rng.gen_iter::<u64>().take(10000).collect();
1515             v.sort();
1516         });
1517         b.bytes = 10000 * mem::size_of::<u64>() as u64;
1518     }
1519
1520     #[bench]
1521     fn sort_sorted(b: &mut Bencher) {
1522         let mut v: Vec<_> = (0..10000).collect();
1523         b.iter(|| {
1524             v.sort();
1525         });
1526         b.bytes = (v.len() * mem::size_of_val(&v[0])) as u64;
1527     }
1528
1529     type BigSortable = (u64, u64, u64, u64);
1530
1531     #[bench]
1532     fn sort_big_random_small(b: &mut Bencher) {
1533         let mut rng = thread_rng();
1534         b.iter(|| {
1535             let mut v = rng.gen_iter::<BigSortable>().take(5)
1536                            .collect::<Vec<BigSortable>>();
1537             v.sort();
1538         });
1539         b.bytes = 5 * mem::size_of::<BigSortable>() as u64;
1540     }
1541
1542     #[bench]
1543     fn sort_big_random_medium(b: &mut Bencher) {
1544         let mut rng = thread_rng();
1545         b.iter(|| {
1546             let mut v = rng.gen_iter::<BigSortable>().take(100)
1547                            .collect::<Vec<BigSortable>>();
1548             v.sort();
1549         });
1550         b.bytes = 100 * mem::size_of::<BigSortable>() as u64;
1551     }
1552
1553     #[bench]
1554     fn sort_big_random_large(b: &mut Bencher) {
1555         let mut rng = thread_rng();
1556         b.iter(|| {
1557             let mut v = rng.gen_iter::<BigSortable>().take(10000)
1558                            .collect::<Vec<BigSortable>>();
1559             v.sort();
1560         });
1561         b.bytes = 10000 * mem::size_of::<BigSortable>() as u64;
1562     }
1563
1564     #[bench]
1565     fn sort_big_sorted(b: &mut Bencher) {
1566         let mut v: Vec<BigSortable> = (0..10000).map(|i| (i, i, i, i)).collect();
1567         b.iter(|| {
1568             v.sort();
1569         });
1570         b.bytes = (v.len() * mem::size_of_val(&v[0])) as u64;
1571     }
1572 }