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.
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.
11 use std::cmp::Ordering::{Equal, Greater, Less};
12 use std::default::Default;
14 use std::__rand::{Rng, thread_rng};
17 fn square(n: usize) -> usize { n * n }
19 fn is_odd(n: &usize) -> bool { *n % 2 == 1 }
23 // Test on-stack from_fn.
24 let mut v: Vec<_> = (0..3).map(square).collect();
27 assert_eq!(v.len(), 3);
33 // Test on-heap from_fn.
34 v = (0..5).map(square).collect();
37 assert_eq!(v.len(), 5);
48 // Test on-stack from_elem.
49 let mut v = vec![10, 10];
52 assert_eq!(v.len(), 2);
57 // Test on-heap from_elem.
72 let xs: [i32; 0] = [];
73 assert!(xs.is_empty());
74 assert!(![0].is_empty());
78 fn test_len_divzero() {
81 let v1 : &[Z] = &[[]];
82 let v2 : &[Z] = &[[], []];
83 assert_eq!(mem::size_of::<Z>(), 0);
84 assert_eq!(v0.len(), 0);
85 assert_eq!(v1.len(), 1);
86 assert_eq!(v2.len(), 2);
92 assert_eq!(a.get(1), None);
94 assert_eq!(a.get(1).unwrap(), &12);
96 assert_eq!(a.get(1).unwrap(), &12);
102 assert_eq!(a.first(), None);
104 assert_eq!(a.first().unwrap(), &11);
106 assert_eq!(a.first().unwrap(), &11);
110 fn test_first_mut() {
112 assert_eq!(a.first_mut(), None);
114 assert_eq!(*a.first_mut().unwrap(), 11);
116 assert_eq!(*a.first_mut().unwrap(), 11);
120 fn test_split_first() {
121 let mut a = vec![11];
123 assert!(b.split_first().is_none());
124 assert_eq!(a.split_first(), Some((&11, b)));
126 let b: &[i32] = &[12];
127 assert_eq!(a.split_first(), Some((&11, b)));
131 fn test_split_first_mut() {
132 let mut a = vec![11];
133 let b: &mut [i32] = &mut [];
134 assert!(b.split_first_mut().is_none());
135 assert!(a.split_first_mut() == Some((&mut 11, b)));
137 let b: &mut [_] = &mut [12];
138 assert!(a.split_first_mut() == Some((&mut 11, b)));
142 fn test_split_last() {
143 let mut a = vec![11];
145 assert!(b.split_last().is_none());
146 assert_eq!(a.split_last(), Some((&11, b)));
149 assert_eq!(a.split_last(), Some((&12, b)));
153 fn test_split_last_mut() {
154 let mut a = vec![11];
155 let b: &mut [i32] = &mut [];
156 assert!(b.split_last_mut().is_none());
157 assert!(a.split_last_mut() == Some((&mut 11, b)));
160 let b: &mut [_] = &mut [11];
161 assert!(a.split_last_mut() == Some((&mut 12, b)));
167 assert_eq!(a.last(), None);
169 assert_eq!(a.last().unwrap(), &11);
171 assert_eq!(a.last().unwrap(), &12);
177 assert_eq!(a.last_mut(), None);
179 assert_eq!(*a.last_mut().unwrap(), 11);
181 assert_eq!(*a.last_mut().unwrap(), 12);
186 // Test fixed length vector.
187 let vec_fixed = [1, 2, 3, 4];
188 let v_a = vec_fixed[1..vec_fixed.len()].to_vec();
189 assert_eq!(v_a.len(), 3);
191 assert_eq!(v_a[0], 2);
192 assert_eq!(v_a[1], 3);
193 assert_eq!(v_a[2], 4);
196 let vec_stack: &[_] = &[1, 2, 3];
197 let v_b = vec_stack[1..3].to_vec();
198 assert_eq!(v_b.len(), 2);
200 assert_eq!(v_b[0], 2);
201 assert_eq!(v_b[1], 3);
204 let vec_unique = vec![1, 2, 3, 4, 5, 6];
205 let v_d = vec_unique[1..6].to_vec();
206 assert_eq!(v_d.len(), 5);
208 assert_eq!(v_d[0], 2);
209 assert_eq!(v_d[1], 3);
210 assert_eq!(v_d[2], 4);
211 assert_eq!(v_d[3], 5);
212 assert_eq!(v_d[4], 6);
216 fn test_slice_from() {
217 let vec: &[_] = &[1, 2, 3, 4];
218 assert_eq!(&vec[..], vec);
219 let b: &[_] = &[3, 4];
220 assert_eq!(&vec[2..], b);
222 assert_eq!(&vec[4..], b);
227 let vec: &[_] = &[1, 2, 3, 4];
228 assert_eq!(&vec[..4], vec);
229 let b: &[_] = &[1, 2];
230 assert_eq!(&vec[..2], b);
232 assert_eq!(&vec[..0], b);
240 assert_eq!(v.len(), 0);
241 assert_eq!(e, Some(5));
249 fn test_swap_remove() {
250 let mut v = vec![1, 2, 3, 4, 5];
251 let mut e = v.swap_remove(0);
253 assert_eq!(v, [5, 2, 3, 4]);
254 e = v.swap_remove(3);
256 assert_eq!(v, [5, 2, 3]);
261 fn test_swap_remove_fail() {
263 let _ = v.swap_remove(0);
264 let _ = v.swap_remove(0);
268 fn test_swap_remove_noncopyable() {
269 // Tests that we don't accidentally run destructors twice.
270 let mut v: Vec<Box<_>> = Vec::new();
274 let mut _e = v.swap_remove(0);
275 assert_eq!(v.len(), 2);
276 _e = v.swap_remove(1);
277 assert_eq!(v.len(), 1);
278 _e = v.swap_remove(0);
279 assert_eq!(v.len(), 0);
284 // Test on-stack push().
287 assert_eq!(v.len(), 1);
290 // Test on-heap push().
292 assert_eq!(v.len(), 2);
299 let mut v: Vec<Box<_>> = vec![box 6,box 5,box 4];
302 assert_eq!(v.len(), 1);
303 assert_eq!(*(v[0]), 6);
304 // If the unsafe block didn't drop things properly, we blow up here.
309 let mut v: Vec<Box<_>> = vec![box 6,box 5,box 4];
311 assert_eq!(v.len(), 0);
312 // If the unsafe block didn't drop things properly, we blow up here.
317 fn case(a: Vec<i32>, b: Vec<i32>) {
322 case(vec![], vec![]);
323 case(vec![1], vec![1]);
324 case(vec![1,1], vec![1]);
325 case(vec![1,2,3], vec![1,2,3]);
326 case(vec![1,1,2,3], vec![1,2,3]);
327 case(vec![1,2,2,3], vec![1,2,3]);
328 case(vec![1,2,3,3], vec![1,2,3]);
329 case(vec![1,1,2,2,2,3,3], vec![1,2,3]);
333 fn test_dedup_unique() {
334 let mut v0: Vec<Box<_>> = vec![box 1, box 1, box 2, box 3];
336 let mut v1: Vec<Box<_>> = vec![box 1, box 2, box 2, box 3];
338 let mut v2: Vec<Box<_>> = vec![box 1, box 2, box 3, box 3];
341 * If the boxed pointers were leaked or otherwise misused, valgrind
342 * and/or rt should raise errors.
347 fn test_dedup_shared() {
348 let mut v0: Vec<Box<_>> = vec![box 1, box 1, box 2, box 3];
350 let mut v1: Vec<Box<_>> = vec![box 1, box 2, box 2, box 3];
352 let mut v2: Vec<Box<_>> = vec![box 1, box 2, box 3, box 3];
355 * If the pointers were leaked or otherwise misused, valgrind and/or
356 * rt should raise errors.
362 let mut v = vec![1, 2, 3, 4, 5];
364 assert_eq!(v, [1, 3, 5]);
368 fn test_binary_search() {
369 assert_eq!([1,2,3,4,5].binary_search(&5).ok(), Some(4));
370 assert_eq!([1,2,3,4,5].binary_search(&4).ok(), Some(3));
371 assert_eq!([1,2,3,4,5].binary_search(&3).ok(), Some(2));
372 assert_eq!([1,2,3,4,5].binary_search(&2).ok(), Some(1));
373 assert_eq!([1,2,3,4,5].binary_search(&1).ok(), Some(0));
375 assert_eq!([2,4,6,8,10].binary_search(&1).ok(), None);
376 assert_eq!([2,4,6,8,10].binary_search(&5).ok(), None);
377 assert_eq!([2,4,6,8,10].binary_search(&4).ok(), Some(1));
378 assert_eq!([2,4,6,8,10].binary_search(&10).ok(), Some(4));
380 assert_eq!([2,4,6,8].binary_search(&1).ok(), None);
381 assert_eq!([2,4,6,8].binary_search(&5).ok(), None);
382 assert_eq!([2,4,6,8].binary_search(&4).ok(), Some(1));
383 assert_eq!([2,4,6,8].binary_search(&8).ok(), Some(3));
385 assert_eq!([2,4,6].binary_search(&1).ok(), None);
386 assert_eq!([2,4,6].binary_search(&5).ok(), None);
387 assert_eq!([2,4,6].binary_search(&4).ok(), Some(1));
388 assert_eq!([2,4,6].binary_search(&6).ok(), Some(2));
390 assert_eq!([2,4].binary_search(&1).ok(), None);
391 assert_eq!([2,4].binary_search(&5).ok(), None);
392 assert_eq!([2,4].binary_search(&2).ok(), Some(0));
393 assert_eq!([2,4].binary_search(&4).ok(), Some(1));
395 assert_eq!([2].binary_search(&1).ok(), None);
396 assert_eq!([2].binary_search(&5).ok(), None);
397 assert_eq!([2].binary_search(&2).ok(), Some(0));
399 assert_eq!([].binary_search(&1).ok(), None);
400 assert_eq!([].binary_search(&5).ok(), None);
402 assert!([1,1,1,1,1].binary_search(&1).ok() != None);
403 assert!([1,1,1,1,2].binary_search(&1).ok() != None);
404 assert!([1,1,1,2,2].binary_search(&1).ok() != None);
405 assert!([1,1,2,2,2].binary_search(&1).ok() != None);
406 assert_eq!([1,2,2,2,2].binary_search(&1).ok(), Some(0));
408 assert_eq!([1,2,3,4,5].binary_search(&6).ok(), None);
409 assert_eq!([1,2,3,4,5].binary_search(&0).ok(), None);
414 let mut v = vec![10, 20];
415 assert_eq!(v[0], 10);
416 assert_eq!(v[1], 20);
418 assert_eq!(v[0], 20);
419 assert_eq!(v[1], 10);
421 let mut v3 = Vec::<i32>::new();
423 assert!(v3.is_empty());
430 let mut v: Vec<_> = thread_rng().gen_iter::<i32>().take(len).collect();
431 let mut v1 = v.clone();
434 assert!(v.windows(2).all(|w| w[0] <= w[1]));
436 v1.sort_by(|a, b| a.cmp(b));
437 assert!(v1.windows(2).all(|w| w[0] <= w[1]));
439 v1.sort_by(|a, b| b.cmp(a));
440 assert!(v1.windows(2).all(|w| w[0] >= w[1]));
445 let mut v: [i32; 0] = [];
448 let mut v = [0xDEADBEEFu64];
450 assert!(v == [0xDEADBEEF]);
454 fn test_sort_stability() {
457 let mut counts = [0; 10];
459 // create a vector like [(6, 1), (5, 1), (6, 2), ...],
460 // where the first item of each tuple is random, but
461 // the second item represents which occurrence of that
462 // number this element is, i.e. the second elements
463 // will occur in sorted order.
464 let mut v: Vec<_> = (0..len).map(|_| {
465 let n = thread_rng().gen::<usize>() % 10;
470 // only sort on the first element, so an unstable sort
471 // may mix up the counts.
472 v.sort_by(|&(a,_), &(b,_)| a.cmp(&b));
474 // this comparison includes the count (the second item
475 // of the tuple), so elements with equal first items
476 // will need to be ordered with increasing
477 // counts... i.e. exactly asserting that this sort is
479 assert!(v.windows(2).all(|w| w[0] <= w[1]));
486 let v: [Vec<i32>; 0] = [];
489 let d = [vec![1], vec![2, 3]].concat();
490 assert_eq!(d, [1, 2, 3]);
492 let v: &[&[_]] = &[&[1], &[2, 3]];
493 assert_eq!(v.join(&0), [1, 0, 2, 3]);
494 let v: &[&[_]] = &[&[1], &[2], &[3]];
495 assert_eq!(v.join(&0), [1, 0, 2, 0, 3]);
500 let v: [Vec<i32>; 0] = [];
501 assert_eq!(v.join(&0), []);
502 assert_eq!([vec![1], vec![2, 3]].join(&0), [1, 0, 2, 3]);
503 assert_eq!([vec![1], vec![2], vec![3]].join(&0), [1, 0, 2, 0, 3]);
505 let v: [&[_]; 2] = [&[1], &[2, 3]];
506 assert_eq!(v.join(&0), [1, 0, 2, 3]);
507 let v: [&[_]; 3] = [&[1], &[2], &[3]];
508 assert_eq!(v.join(&0), [1, 0, 2, 0, 3]);
513 let mut a = vec![1, 2, 4];
515 assert_eq!(a, [1, 2, 3, 4]);
517 let mut a = vec![1, 2, 3];
519 assert_eq!(a, [0, 1, 2, 3]);
521 let mut a = vec![1, 2, 3];
523 assert_eq!(a, [1, 2, 3, 4]);
532 fn test_insert_oob() {
533 let mut a = vec![1, 2, 3];
539 let mut a = vec![1, 2, 3, 4];
541 assert_eq!(a.remove(2), 3);
542 assert_eq!(a, [1, 2, 4]);
544 assert_eq!(a.remove(2), 4);
545 assert_eq!(a, [1, 2]);
547 assert_eq!(a.remove(0), 1);
550 assert_eq!(a.remove(0), 2);
556 fn test_remove_fail() {
566 assert!(v.capacity() >= 11);
571 let v = vec![1, 2, 3, 4, 5];
573 assert_eq!(v.len(), 2);
579 fn test_total_ord() {
581 [1, 2, 3, 4][..].cmp(c) == Greater;
582 let c = &[1, 2, 3, 4];
583 [1, 2, 3][..].cmp(c) == Less;
584 let c = &[1, 2, 3, 6];
585 [1, 2, 3, 4][..].cmp(c) == Equal;
586 let c = &[1, 2, 3, 4, 5, 6];
587 [1, 2, 3, 4, 5, 5, 5, 5][..].cmp(c) == Less;
588 let c = &[1, 2, 3, 4];
589 [2, 2][..].cmp(c) == Greater;
594 let xs = [1, 2, 5, 10, 11];
595 let mut it = xs.iter();
596 assert_eq!(it.size_hint(), (5, Some(5)));
597 assert_eq!(it.next().unwrap(), &1);
598 assert_eq!(it.size_hint(), (4, Some(4)));
599 assert_eq!(it.next().unwrap(), &2);
600 assert_eq!(it.size_hint(), (3, Some(3)));
601 assert_eq!(it.next().unwrap(), &5);
602 assert_eq!(it.size_hint(), (2, Some(2)));
603 assert_eq!(it.next().unwrap(), &10);
604 assert_eq!(it.size_hint(), (1, Some(1)));
605 assert_eq!(it.next().unwrap(), &11);
606 assert_eq!(it.size_hint(), (0, Some(0)));
607 assert!(it.next().is_none());
611 fn test_iter_size_hints() {
612 let mut xs = [1, 2, 5, 10, 11];
613 assert_eq!(xs.iter().size_hint(), (5, Some(5)));
614 assert_eq!(xs.iter_mut().size_hint(), (5, Some(5)));
618 fn test_iter_clone() {
620 let mut it = xs.iter();
622 let mut jt = it.clone();
623 assert_eq!(it.next(), jt.next());
624 assert_eq!(it.next(), jt.next());
625 assert_eq!(it.next(), jt.next());
629 fn test_mut_iterator() {
630 let mut xs = [1, 2, 3, 4, 5];
634 assert!(xs == [2, 3, 4, 5, 6])
638 fn test_rev_iterator() {
640 let xs = [1, 2, 5, 10, 11];
641 let ys = [11, 10, 5, 2, 1];
643 for &x in xs.iter().rev() {
644 assert_eq!(x, ys[i]);
651 fn test_mut_rev_iterator() {
652 let mut xs = [1, 2, 3, 4, 5];
653 for (i,x) in xs.iter_mut().rev().enumerate() {
656 assert!(xs == [5, 5, 5, 5, 5])
660 fn test_move_iterator() {
661 let xs = vec![1,2,3,4,5];
662 assert_eq!(xs.into_iter().fold(0, |a: usize, b: usize| 10*a + b), 12345);
666 fn test_move_rev_iterator() {
667 let xs = vec![1,2,3,4,5];
668 assert_eq!(xs.into_iter().rev().fold(0, |a: usize, b: usize| 10*a + b), 54321);
672 fn test_splitator() {
673 let xs = &[1,2,3,4,5];
675 let splits: &[&[_]] = &[&[1], &[3], &[5]];
676 assert_eq!(xs.split(|x| *x % 2 == 0).collect::<Vec<_>>(),
678 let splits: &[&[_]] = &[&[], &[2,3,4,5]];
679 assert_eq!(xs.split(|x| *x == 1).collect::<Vec<_>>(),
681 let splits: &[&[_]] = &[&[1,2,3,4], &[]];
682 assert_eq!(xs.split(|x| *x == 5).collect::<Vec<_>>(),
684 let splits: &[&[_]] = &[&[1,2,3,4,5]];
685 assert_eq!(xs.split(|x| *x == 10).collect::<Vec<_>>(),
687 let splits: &[&[_]] = &[&[], &[], &[], &[], &[], &[]];
688 assert_eq!(xs.split(|_| true).collect::<Vec<&[i32]>>(),
691 let xs: &[i32] = &[];
692 let splits: &[&[i32]] = &[&[]];
693 assert_eq!(xs.split(|x| *x == 5).collect::<Vec<&[i32]>>(), splits);
697 fn test_splitnator() {
698 let xs = &[1,2,3,4,5];
700 let splits: &[&[_]] = &[&[1,2,3,4,5]];
701 assert_eq!(xs.splitn(1, |x| *x % 2 == 0).collect::<Vec<_>>(),
703 let splits: &[&[_]] = &[&[1], &[3,4,5]];
704 assert_eq!(xs.splitn(2, |x| *x % 2 == 0).collect::<Vec<_>>(),
706 let splits: &[&[_]] = &[&[], &[], &[], &[4,5]];
707 assert_eq!(xs.splitn(4, |_| true).collect::<Vec<_>>(),
710 let xs: &[i32] = &[];
711 let splits: &[&[i32]] = &[&[]];
712 assert_eq!(xs.splitn(2, |x| *x == 5).collect::<Vec<_>>(), splits);
716 fn test_splitnator_mut() {
717 let xs = &mut [1,2,3,4,5];
719 let splits: &[&mut[_]] = &[&mut [1,2,3,4,5]];
720 assert_eq!(xs.splitn_mut(1, |x| *x % 2 == 0).collect::<Vec<_>>(),
722 let splits: &[&mut[_]] = &[&mut [1], &mut [3,4,5]];
723 assert_eq!(xs.splitn_mut(2, |x| *x % 2 == 0).collect::<Vec<_>>(),
725 let splits: &[&mut[_]] = &[&mut [], &mut [], &mut [], &mut [4,5]];
726 assert_eq!(xs.splitn_mut(4, |_| true).collect::<Vec<_>>(),
729 let xs: &mut [i32] = &mut [];
730 let splits: &[&mut[i32]] = &[&mut []];
731 assert_eq!(xs.splitn_mut(2, |x| *x == 5).collect::<Vec<_>>(),
736 fn test_rsplitator() {
737 let xs = &[1,2,3,4,5];
739 let splits: &[&[_]] = &[&[5], &[3], &[1]];
740 assert_eq!(xs.split(|x| *x % 2 == 0).rev().collect::<Vec<_>>(),
742 let splits: &[&[_]] = &[&[2,3,4,5], &[]];
743 assert_eq!(xs.split(|x| *x == 1).rev().collect::<Vec<_>>(),
745 let splits: &[&[_]] = &[&[], &[1,2,3,4]];
746 assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<_>>(),
748 let splits: &[&[_]] = &[&[1,2,3,4,5]];
749 assert_eq!(xs.split(|x| *x == 10).rev().collect::<Vec<_>>(),
752 let xs: &[i32] = &[];
753 let splits: &[&[i32]] = &[&[]];
754 assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<&[i32]>>(), splits);
758 fn test_rsplitnator() {
759 let xs = &[1,2,3,4,5];
761 let splits: &[&[_]] = &[&[1,2,3,4,5]];
762 assert_eq!(xs.rsplitn(1, |x| *x % 2 == 0).collect::<Vec<_>>(),
764 let splits: &[&[_]] = &[&[5], &[1,2,3]];
765 assert_eq!(xs.rsplitn(2, |x| *x % 2 == 0).collect::<Vec<_>>(),
767 let splits: &[&[_]] = &[&[], &[], &[], &[1,2]];
768 assert_eq!(xs.rsplitn(4, |_| true).collect::<Vec<_>>(),
771 let xs: &[i32] = &[];
772 let splits: &[&[i32]] = &[&[]];
773 assert_eq!(xs.rsplitn(2, |x| *x == 5).collect::<Vec<&[i32]>>(), splits);
774 assert!(xs.rsplitn(0, |x| *x % 2 == 0).next().is_none());
778 fn test_windowsator() {
781 let wins: &[&[_]] = &[&[1,2], &[2,3], &[3,4]];
782 assert_eq!(v.windows(2).collect::<Vec<_>>(), wins);
784 let wins: &[&[_]] = &[&[1,2,3], &[2,3,4]];
785 assert_eq!(v.windows(3).collect::<Vec<_>>(), wins);
786 assert!(v.windows(6).next().is_none());
788 let wins: &[&[_]] = &[&[3,4], &[2,3], &[1,2]];
789 assert_eq!(v.windows(2).rev().collect::<Vec<&[_]>>(), wins);
794 fn test_windowsator_0() {
796 let _it = v.windows(0);
800 fn test_chunksator() {
801 let v = &[1,2,3,4,5];
803 assert_eq!(v.chunks(2).len(), 3);
805 let chunks: &[&[_]] = &[&[1,2], &[3,4], &[5]];
806 assert_eq!(v.chunks(2).collect::<Vec<_>>(), chunks);
807 let chunks: &[&[_]] = &[&[1,2,3], &[4,5]];
808 assert_eq!(v.chunks(3).collect::<Vec<_>>(), chunks);
809 let chunks: &[&[_]] = &[&[1,2,3,4,5]];
810 assert_eq!(v.chunks(6).collect::<Vec<_>>(), chunks);
812 let chunks: &[&[_]] = &[&[5], &[3,4], &[1,2]];
813 assert_eq!(v.chunks(2).rev().collect::<Vec<_>>(), chunks);
818 fn test_chunksator_0() {
820 let _it = v.chunks(0);
824 fn test_reverse_part() {
825 let mut values = [1,2,3,4,5];
826 values[1..4].reverse();
827 assert!(values == [1,4,3,2,5]);
832 macro_rules! test_show_vec {
833 ($x:expr, $x_str:expr) => ({
834 let (x, x_str) = ($x, $x_str);
835 assert_eq!(format!("{:?}", x), x_str);
836 assert_eq!(format!("{:?}", x), x_str);
839 let empty = Vec::<i32>::new();
840 test_show_vec!(empty, "[]");
841 test_show_vec!(vec![1], "[1]");
842 test_show_vec!(vec![1, 2, 3], "[1, 2, 3]");
843 test_show_vec!(vec![vec![], vec![1], vec![1, 1]],
844 "[[], [1], [1, 1]]");
846 let empty_mut: &mut [i32] = &mut[];
847 test_show_vec!(empty_mut, "[]");
849 test_show_vec!(v, "[1]");
850 let v = &mut[1, 2, 3];
851 test_show_vec!(v, "[1, 2, 3]");
852 let v: &mut[&mut[_]] = &mut[&mut[], &mut[1], &mut[1, 1]];
853 test_show_vec!(v, "[[], [1], [1, 1]]");
857 fn test_vec_default() {
860 let v: $ty = Default::default();
861 assert!(v.is_empty());
871 fn test_overflow_does_not_cause_segfault() {
880 fn test_overflow_does_not_cause_segfault_managed() {
881 let mut v = vec![Rc::new(1)];
887 fn test_mut_split_at() {
888 let mut values = [1u8,2,3,4,5];
890 let (left, right) = values.split_at_mut(2);
892 let left: &[_] = left;
893 assert!(left[..left.len()] == [1, 2]);
900 let right: &[_] = right;
901 assert!(right[..right.len()] == [3, 4, 5]);
908 assert!(values == [2, 3, 5, 6, 7]);
911 #[derive(Clone, PartialEq)]
915 fn test_iter_zero_sized() {
916 let mut v = vec![Foo, Foo, Foo];
917 assert_eq!(v.len(), 3);
944 let xs: [Foo; 3] = [Foo, Foo, Foo];
954 fn test_shrink_to_fit() {
955 let mut xs = vec![0, 1, 2, 3];
959 assert_eq!(xs.capacity(), 128);
961 assert_eq!(xs.capacity(), 100);
962 assert_eq!(xs, (0..100).collect::<Vec<_>>());
966 fn test_starts_with() {
967 assert!(b"foobar".starts_with(b"foo"));
968 assert!(!b"foobar".starts_with(b"oob"));
969 assert!(!b"foobar".starts_with(b"bar"));
970 assert!(!b"foo".starts_with(b"foobar"));
971 assert!(!b"bar".starts_with(b"foobar"));
972 assert!(b"foobar".starts_with(b"foobar"));
973 let empty: &[u8] = &[];
974 assert!(empty.starts_with(empty));
975 assert!(!empty.starts_with(b"foo"));
976 assert!(b"foobar".starts_with(empty));
980 fn test_ends_with() {
981 assert!(b"foobar".ends_with(b"bar"));
982 assert!(!b"foobar".ends_with(b"oba"));
983 assert!(!b"foobar".ends_with(b"foo"));
984 assert!(!b"foo".ends_with(b"foobar"));
985 assert!(!b"bar".ends_with(b"foobar"));
986 assert!(b"foobar".ends_with(b"foobar"));
987 let empty: &[u8] = &[];
988 assert!(empty.ends_with(empty));
989 assert!(!empty.ends_with(b"foo"));
990 assert!(b"foobar".ends_with(empty));
994 fn test_mut_splitator() {
995 let mut xs = [0,1,0,2,3,0,0,4,5,0];
996 assert_eq!(xs.split_mut(|x| *x == 0).count(), 6);
997 for slice in xs.split_mut(|x| *x == 0) {
1000 assert!(xs == [0,1,0,3,2,0,0,5,4,0]);
1002 let mut xs = [0,1,0,2,3,0,0,4,5,0,6,7];
1003 for slice in xs.split_mut(|x| *x == 0).take(5) {
1006 assert!(xs == [0,1,0,3,2,0,0,5,4,0,6,7]);
1010 fn test_mut_splitator_rev() {
1011 let mut xs = [1,2,0,3,4,0,0,5,6,0];
1012 for slice in xs.split_mut(|x| *x == 0).rev().take(4) {
1015 assert!(xs == [1,2,0,4,3,0,0,6,5,0]);
1020 let mut v = [0,1,2];
1021 assert_eq!(v.get_mut(3), None);
1022 v.get_mut(1).map(|e| *e = 7);
1023 assert_eq!(v[1], 7);
1025 assert_eq!(v.get_mut(2), Some(&mut x));
1029 fn test_mut_chunks() {
1030 let mut v = [0, 1, 2, 3, 4, 5, 6];
1031 assert_eq!(v.chunks_mut(2).len(), 4);
1032 for (i, chunk) in v.chunks_mut(3).enumerate() {
1037 let result = [0, 0, 0, 1, 1, 1, 2];
1038 assert!(v == result);
1042 fn test_mut_chunks_rev() {
1043 let mut v = [0, 1, 2, 3, 4, 5, 6];
1044 for (i, chunk) in v.chunks_mut(3).rev().enumerate() {
1049 let result = [2, 2, 2, 1, 1, 1, 0];
1050 assert!(v == result);
1055 fn test_mut_chunks_0() {
1056 let mut v = [1, 2, 3, 4];
1057 let _it = v.chunks_mut(0);
1061 fn test_mut_last() {
1062 let mut x = [1, 2, 3, 4, 5];
1063 let h = x.last_mut();
1064 assert_eq!(*h.unwrap(), 5);
1066 let y: &mut [i32] = &mut [];
1067 assert!(y.last_mut().is_none());
1072 let xs: Box<_> = box [1, 2, 3];
1073 let ys = xs.to_vec();
1074 assert_eq!(ys, [1, 2, 3]);
1078 fn test_box_slice_clone() {
1079 let data = vec![vec![0, 1], vec![0], vec![1]];
1080 let data2 = data.clone().into_boxed_slice().clone().to_vec();
1082 assert_eq!(data, data2);
1086 fn test_box_slice_clone_panics() {
1088 use std::sync::atomic::{AtomicUsize, Ordering};
1089 use std::thread::spawn;
1092 count: Arc<AtomicUsize>,
1096 impl Drop for Canary {
1097 fn drop(&mut self) {
1098 self.count.fetch_add(1, Ordering::SeqCst);
1102 impl Clone for Canary {
1103 fn clone(&self) -> Self {
1104 if self.panics { panic!() }
1107 count: self.count.clone(),
1113 let drop_count = Arc::new(AtomicUsize::new(0));
1114 let canary = Canary { count: drop_count.clone(), panics: false };
1115 let panic = Canary { count: drop_count.clone(), panics: true };
1118 // When xs is dropped, +5.
1119 let xs = vec![canary.clone(), canary.clone(), canary.clone(),
1120 panic, canary].into_boxed_slice();
1122 // When panic is cloned, +3.
1124 }).join().unwrap_err();
1127 assert_eq!(drop_count.load(Ordering::SeqCst), 8);
1131 use std::{mem, ptr};
1132 use std::__rand::{Rng, thread_rng};
1134 use test::{Bencher, black_box};
1137 fn iterator(b: &mut Bencher) {
1138 // peculiar numbers to stop LLVM from optimising the summation
1140 let v: Vec<_> = (0..100).map(|i| i ^ (i << 1) ^ (i >> 1)).collect();
1147 // sum == 11806, to stop dead code elimination.
1148 if sum == 0 {panic!()}
1153 fn mut_iterator(b: &mut Bencher) {
1154 let mut v = vec![0; 100];
1166 fn concat(b: &mut Bencher) {
1167 let xss: Vec<Vec<i32>> =
1168 (0..100).map(|i| (0..i).collect()).collect();
1175 fn join(b: &mut Bencher) {
1176 let xss: Vec<Vec<i32>> =
1177 (0..100).map(|i| (0..i).collect()).collect();
1184 fn push(b: &mut Bencher) {
1185 let mut vec = Vec::<i32>::new();
1193 fn starts_with_same_vector(b: &mut Bencher) {
1194 let vec: Vec<_> = (0..100).collect();
1196 vec.starts_with(&vec)
1201 fn starts_with_single_element(b: &mut Bencher) {
1202 let vec: Vec<_> = vec![0];
1204 vec.starts_with(&vec)
1209 fn starts_with_diff_one_element_at_end(b: &mut Bencher) {
1210 let vec: Vec<_> = (0..100).collect();
1211 let mut match_vec: Vec<_> = (0..99).collect();
1214 vec.starts_with(&match_vec)
1219 fn ends_with_same_vector(b: &mut Bencher) {
1220 let vec: Vec<_> = (0..100).collect();
1227 fn ends_with_single_element(b: &mut Bencher) {
1228 let vec: Vec<_> = vec![0];
1235 fn ends_with_diff_one_element_at_beginning(b: &mut Bencher) {
1236 let vec: Vec<_> = (0..100).collect();
1237 let mut match_vec: Vec<_> = (0..100).collect();
1240 vec.starts_with(&match_vec)
1245 fn contains_last_element(b: &mut Bencher) {
1246 let vec: Vec<_> = (0..100).collect();
1253 fn zero_1kb_from_elem(b: &mut Bencher) {
1260 fn zero_1kb_set_memory(b: &mut Bencher) {
1262 let mut v = Vec::<u8>::with_capacity(1024);
1264 let vp = v.as_mut_ptr();
1265 ptr::write_bytes(vp, 0, 1024);
1273 fn zero_1kb_loop_set(b: &mut Bencher) {
1275 let mut v = Vec::<u8>::with_capacity(1024);
1286 fn zero_1kb_mut_iter(b: &mut Bencher) {
1288 let mut v = Vec::<u8>::with_capacity(1024);
1300 fn random_inserts(b: &mut Bencher) {
1301 let mut rng = thread_rng();
1303 let mut v = vec![(0, 0); 30];
1306 v.insert(rng.gen::<usize>() % (l + 1),
1312 fn random_removes(b: &mut Bencher) {
1313 let mut rng = thread_rng();
1315 let mut v = vec![(0, 0); 130];
1318 v.remove(rng.gen::<usize>() % l);
1324 fn sort_random_small(b: &mut Bencher) {
1325 let mut rng = thread_rng();
1327 let mut v: Vec<_> = rng.gen_iter::<u64>().take(5).collect();
1330 b.bytes = 5 * mem::size_of::<u64>() as u64;
1334 fn sort_random_medium(b: &mut Bencher) {
1335 let mut rng = thread_rng();
1337 let mut v: Vec<_> = rng.gen_iter::<u64>().take(100).collect();
1340 b.bytes = 100 * mem::size_of::<u64>() as u64;
1344 fn sort_random_large(b: &mut Bencher) {
1345 let mut rng = thread_rng();
1347 let mut v: Vec<_> = rng.gen_iter::<u64>().take(10000).collect();
1350 b.bytes = 10000 * mem::size_of::<u64>() as u64;
1354 fn sort_sorted(b: &mut Bencher) {
1355 let mut v: Vec<_> = (0..10000).collect();
1359 b.bytes = (v.len() * mem::size_of_val(&v[0])) as u64;
1362 type BigSortable = (u64, u64, u64, u64);
1365 fn sort_big_random_small(b: &mut Bencher) {
1366 let mut rng = thread_rng();
1368 let mut v = rng.gen_iter::<BigSortable>().take(5)
1369 .collect::<Vec<BigSortable>>();
1372 b.bytes = 5 * mem::size_of::<BigSortable>() as u64;
1376 fn sort_big_random_medium(b: &mut Bencher) {
1377 let mut rng = thread_rng();
1379 let mut v = rng.gen_iter::<BigSortable>().take(100)
1380 .collect::<Vec<BigSortable>>();
1383 b.bytes = 100 * mem::size_of::<BigSortable>() as u64;
1387 fn sort_big_random_large(b: &mut Bencher) {
1388 let mut rng = thread_rng();
1390 let mut v = rng.gen_iter::<BigSortable>().take(10000)
1391 .collect::<Vec<BigSortable>>();
1394 b.bytes = 10000 * mem::size_of::<BigSortable>() as u64;
1398 fn sort_big_sorted(b: &mut Bencher) {
1399 let mut v: Vec<BigSortable> = (0..10000).map(|i| (i, i, i, i)).collect();
1403 b.bytes = (v.len() * mem::size_of_val(&v[0])) as u64;