driver \
etc \
$(foreach crate,$(CRATES),lib$(crate)) \
+ libcollectionstest \
libcoretest \
libbacktrace \
rt \
DEPS_coretest :=
$(eval $(call RUST_CRATE,coretest))
-TEST_TARGET_CRATES = $(filter-out core unicode,$(TARGET_CRATES)) coretest
+DEPS_collectionstest :=
+$(eval $(call RUST_CRATE,collectionstest))
+
+TEST_TARGET_CRATES = $(filter-out collections core unicode,$(TARGET_CRATES)) \
+ collectionstest coretest
TEST_DOC_CRATES = $(DOC_CRATES)
TEST_HOST_CRATES = $(filter-out rustc_typeck rustc_borrowck rustc_resolve rustc_trans rustc_lint,\
$(HOST_CRATES))
+++ /dev/null
-// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-macro_rules! map_insert_rand_bench {
- ($name: ident, $n: expr, $map: ident) => (
- #[bench]
- pub fn $name(b: &mut ::test::Bencher) {
- use std::rand;
- use std::rand::Rng;
- use test::black_box;
-
- let n: usize = $n;
- let mut map = $map::new();
- // setup
- let mut rng = rand::weak_rng();
-
- for _ in 0..n {
- let i = rng.gen() % n;
- map.insert(i, i);
- }
-
- // measure
- b.iter(|| {
- let k = rng.gen() % n;
- map.insert(k, k);
- map.remove(&k);
- });
- black_box(map);
- }
- )
-}
-
-macro_rules! map_insert_seq_bench {
- ($name: ident, $n: expr, $map: ident) => (
- #[bench]
- pub fn $name(b: &mut ::test::Bencher) {
- use test::black_box;
-
- let mut map = $map::new();
- let n: usize = $n;
- // setup
- for i in 0..n {
- map.insert(i * 2, i * 2);
- }
-
- // measure
- let mut i = 1;
- b.iter(|| {
- map.insert(i, i);
- map.remove(&i);
- i = (i + 2) % n;
- });
- black_box(map);
- }
- )
-}
-
-macro_rules! map_find_rand_bench {
- ($name: ident, $n: expr, $map: ident) => (
- #[bench]
- pub fn $name(b: &mut ::test::Bencher) {
- use std::rand;
- use std::iter::IteratorExt;
- use std::rand::Rng;
- use test::black_box;
- use vec::Vec;
-
- let mut map = $map::new();
- let n: usize = $n;
-
- // setup
- let mut rng = rand::weak_rng();
- let mut keys: Vec<_> = (0..n).map(|_| rng.gen() % n).collect();
-
- for &k in &keys {
- map.insert(k, k);
- }
-
- rng.shuffle(&mut keys);
-
- // measure
- let mut i = 0;
- b.iter(|| {
- let t = map.get(&keys[i]);
- i = (i + 1) % n;
- black_box(t);
- })
- }
- )
-}
-
-macro_rules! map_find_seq_bench {
- ($name: ident, $n: expr, $map: ident) => (
- #[bench]
- pub fn $name(b: &mut ::test::Bencher) {
- use test::black_box;
-
- let mut map = $map::new();
- let n: usize = $n;
-
- // setup
- for i in 0..n {
- map.insert(i, i);
- }
-
- // measure
- let mut i = 0;
- b.iter(|| {
- let x = map.get(&i);
- i = (i + 1) % n;
- black_box(x);
- })
- }
- )
-}
}
}
}
-
-#[cfg(test)]
-mod tests {
- use prelude::*;
-
- use super::BinaryHeap;
-
- #[test]
- fn test_iterator() {
- let data = vec![5, 9, 3];
- let iterout = [9, 5, 3];
- let heap = BinaryHeap::from_vec(data);
- let mut i = 0;
- for el in &heap {
- assert_eq!(*el, iterout[i]);
- i += 1;
- }
- }
-
- #[test]
- fn test_iterator_reverse() {
- let data = vec![5, 9, 3];
- let iterout = vec![3, 5, 9];
- let pq = BinaryHeap::from_vec(data);
-
- let v: Vec<_> = pq.iter().rev().cloned().collect();
- assert_eq!(v, iterout);
- }
-
- #[test]
- fn test_move_iter() {
- let data = vec![5, 9, 3];
- let iterout = vec![9, 5, 3];
- let pq = BinaryHeap::from_vec(data);
-
- let v: Vec<_> = pq.into_iter().collect();
- assert_eq!(v, iterout);
- }
-
- #[test]
- fn test_move_iter_size_hint() {
- let data = vec![5, 9];
- let pq = BinaryHeap::from_vec(data);
-
- let mut it = pq.into_iter();
-
- assert_eq!(it.size_hint(), (2, Some(2)));
- assert_eq!(it.next(), Some(9));
-
- assert_eq!(it.size_hint(), (1, Some(1)));
- assert_eq!(it.next(), Some(5));
-
- assert_eq!(it.size_hint(), (0, Some(0)));
- assert_eq!(it.next(), None);
- }
-
- #[test]
- fn test_move_iter_reverse() {
- let data = vec![5, 9, 3];
- let iterout = vec![3, 5, 9];
- let pq = BinaryHeap::from_vec(data);
-
- let v: Vec<_> = pq.into_iter().rev().collect();
- assert_eq!(v, iterout);
- }
-
- #[test]
- fn test_peek_and_pop() {
- let data = vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1];
- let mut sorted = data.clone();
- sorted.sort();
- let mut heap = BinaryHeap::from_vec(data);
- while !heap.is_empty() {
- assert_eq!(heap.peek().unwrap(), sorted.last().unwrap());
- assert_eq!(heap.pop().unwrap(), sorted.pop().unwrap());
- }
- }
-
- #[test]
- fn test_push() {
- let mut heap = BinaryHeap::from_vec(vec![2, 4, 9]);
- assert_eq!(heap.len(), 3);
- assert!(*heap.peek().unwrap() == 9);
- heap.push(11);
- assert_eq!(heap.len(), 4);
- assert!(*heap.peek().unwrap() == 11);
- heap.push(5);
- assert_eq!(heap.len(), 5);
- assert!(*heap.peek().unwrap() == 11);
- heap.push(27);
- assert_eq!(heap.len(), 6);
- assert!(*heap.peek().unwrap() == 27);
- heap.push(3);
- assert_eq!(heap.len(), 7);
- assert!(*heap.peek().unwrap() == 27);
- heap.push(103);
- assert_eq!(heap.len(), 8);
- assert!(*heap.peek().unwrap() == 103);
- }
-
- #[test]
- fn test_push_unique() {
- let mut heap = BinaryHeap::<Box<_>>::from_vec(vec![box 2, box 4, box 9]);
- assert_eq!(heap.len(), 3);
- assert!(*heap.peek().unwrap() == box 9);
- heap.push(box 11);
- assert_eq!(heap.len(), 4);
- assert!(*heap.peek().unwrap() == box 11);
- heap.push(box 5);
- assert_eq!(heap.len(), 5);
- assert!(*heap.peek().unwrap() == box 11);
- heap.push(box 27);
- assert_eq!(heap.len(), 6);
- assert!(*heap.peek().unwrap() == box 27);
- heap.push(box 3);
- assert_eq!(heap.len(), 7);
- assert!(*heap.peek().unwrap() == box 27);
- heap.push(box 103);
- assert_eq!(heap.len(), 8);
- assert!(*heap.peek().unwrap() == box 103);
- }
-
- #[test]
- fn test_push_pop() {
- let mut heap = BinaryHeap::from_vec(vec![5, 5, 2, 1, 3]);
- assert_eq!(heap.len(), 5);
- assert_eq!(heap.push_pop(6), 6);
- assert_eq!(heap.len(), 5);
- assert_eq!(heap.push_pop(0), 5);
- assert_eq!(heap.len(), 5);
- assert_eq!(heap.push_pop(4), 5);
- assert_eq!(heap.len(), 5);
- assert_eq!(heap.push_pop(1), 4);
- assert_eq!(heap.len(), 5);
- }
-
- #[test]
- fn test_replace() {
- let mut heap = BinaryHeap::from_vec(vec![5, 5, 2, 1, 3]);
- assert_eq!(heap.len(), 5);
- assert_eq!(heap.replace(6).unwrap(), 5);
- assert_eq!(heap.len(), 5);
- assert_eq!(heap.replace(0).unwrap(), 6);
- assert_eq!(heap.len(), 5);
- assert_eq!(heap.replace(4).unwrap(), 5);
- assert_eq!(heap.len(), 5);
- assert_eq!(heap.replace(1).unwrap(), 4);
- assert_eq!(heap.len(), 5);
- }
-
- fn check_to_vec(mut data: Vec<i32>) {
- let heap = BinaryHeap::from_vec(data.clone());
- let mut v = heap.clone().into_vec();
- v.sort();
- data.sort();
-
- assert_eq!(v, data);
- assert_eq!(heap.into_sorted_vec(), data);
- }
-
- #[test]
- fn test_to_vec() {
- check_to_vec(vec![]);
- check_to_vec(vec![5]);
- check_to_vec(vec![3, 2]);
- check_to_vec(vec![2, 3]);
- check_to_vec(vec![5, 1, 2]);
- check_to_vec(vec![1, 100, 2, 3]);
- check_to_vec(vec![1, 3, 5, 7, 9, 2, 4, 6, 8, 0]);
- check_to_vec(vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1]);
- check_to_vec(vec![9, 11, 9, 9, 9, 9, 11, 2, 3, 4, 11, 9, 0, 0, 0, 0]);
- check_to_vec(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
- check_to_vec(vec![10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]);
- check_to_vec(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 1, 2]);
- check_to_vec(vec![5, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2, 1]);
- }
-
- #[test]
- fn test_empty_pop() {
- let mut heap = BinaryHeap::<i32>::new();
- assert!(heap.pop().is_none());
- }
-
- #[test]
- fn test_empty_peek() {
- let empty = BinaryHeap::<i32>::new();
- assert!(empty.peek().is_none());
- }
-
- #[test]
- fn test_empty_replace() {
- let mut heap = BinaryHeap::new();
- assert!(heap.replace(5).is_none());
- }
-
- #[test]
- fn test_from_iter() {
- let xs = vec![9, 8, 7, 6, 5, 4, 3, 2, 1];
-
- let mut q: BinaryHeap<_> = xs.iter().rev().cloned().collect();
-
- for &x in &xs {
- assert_eq!(q.pop().unwrap(), x);
- }
- }
-
- #[test]
- fn test_drain() {
- let mut q: BinaryHeap<_> = [9, 8, 7, 6, 5, 4, 3, 2, 1].iter().cloned().collect();
-
- assert_eq!(q.drain().take(5).count(), 5);
-
- assert!(q.is_empty());
- }
-}
self.iter()
}
}
-
-#[cfg(test)]
-mod tests {
- use prelude::*;
- use core::u32;
-
- use super::BitVec;
-
- #[test]
- fn test_to_str() {
- let zerolen = BitVec::new();
- assert_eq!(format!("{:?}", zerolen), "");
-
- let eightbits = BitVec::from_elem(8, false);
- assert_eq!(format!("{:?}", eightbits), "00000000")
- }
-
- #[test]
- fn test_0_elements() {
- let act = BitVec::new();
- let exp = Vec::new();
- assert!(act.eq_vec(&exp));
- assert!(act.none() && act.all());
- }
-
- #[test]
- fn test_1_element() {
- let mut act = BitVec::from_elem(1, false);
- assert!(act.eq_vec(&[false]));
- assert!(act.none() && !act.all());
- act = BitVec::from_elem(1, true);
- assert!(act.eq_vec(&[true]));
- assert!(!act.none() && act.all());
- }
-
- #[test]
- fn test_2_elements() {
- let mut b = BitVec::from_elem(2, false);
- b.set(0, true);
- b.set(1, false);
- assert_eq!(format!("{:?}", b), "10");
- assert!(!b.none() && !b.all());
- }
-
- #[test]
- fn test_10_elements() {
- let mut act;
- // all 0
-
- act = BitVec::from_elem(10, false);
- assert!((act.eq_vec(
- &[false, false, false, false, false, false, false, false, false, false])));
- assert!(act.none() && !act.all());
- // all 1
-
- act = BitVec::from_elem(10, true);
- assert!((act.eq_vec(&[true, true, true, true, true, true, true, true, true, true])));
- assert!(!act.none() && act.all());
- // mixed
-
- act = BitVec::from_elem(10, false);
- act.set(0, true);
- act.set(1, true);
- act.set(2, true);
- act.set(3, true);
- act.set(4, true);
- assert!((act.eq_vec(&[true, true, true, true, true, false, false, false, false, false])));
- assert!(!act.none() && !act.all());
- // mixed
-
- act = BitVec::from_elem(10, false);
- act.set(5, true);
- act.set(6, true);
- act.set(7, true);
- act.set(8, true);
- act.set(9, true);
- assert!((act.eq_vec(&[false, false, false, false, false, true, true, true, true, true])));
- assert!(!act.none() && !act.all());
- // mixed
-
- act = BitVec::from_elem(10, false);
- act.set(0, true);
- act.set(3, true);
- act.set(6, true);
- act.set(9, true);
- assert!((act.eq_vec(&[true, false, false, true, false, false, true, false, false, true])));
- assert!(!act.none() && !act.all());
- }
-
- #[test]
- fn test_31_elements() {
- let mut act;
- // all 0
-
- act = BitVec::from_elem(31, false);
- assert!(act.eq_vec(
- &[false, false, false, false, false, false, false, false, false, false, false,
- false, false, false, false, false, false, false, false, false, false, false,
- false, false, false, false, false, false, false, false, false]));
- assert!(act.none() && !act.all());
- // all 1
-
- act = BitVec::from_elem(31, true);
- assert!(act.eq_vec(
- &[true, true, true, true, true, true, true, true, true, true, true, true, true,
- true, true, true, true, true, true, true, true, true, true, true, true, true,
- true, true, true, true, true]));
- assert!(!act.none() && act.all());
- // mixed
-
- act = BitVec::from_elem(31, false);
- act.set(0, true);
- act.set(1, true);
- act.set(2, true);
- act.set(3, true);
- act.set(4, true);
- act.set(5, true);
- act.set(6, true);
- act.set(7, true);
- assert!(act.eq_vec(
- &[true, true, true, true, true, true, true, true, false, false, false, false, false,
- false, false, false, false, false, false, false, false, false, false, false,
- false, false, false, false, false, false, false]));
- assert!(!act.none() && !act.all());
- // mixed
-
- act = BitVec::from_elem(31, false);
- act.set(16, true);
- act.set(17, true);
- act.set(18, true);
- act.set(19, true);
- act.set(20, true);
- act.set(21, true);
- act.set(22, true);
- act.set(23, true);
- assert!(act.eq_vec(
- &[false, false, false, false, false, false, false, false, false, false, false,
- false, false, false, false, false, true, true, true, true, true, true, true, true,
- false, false, false, false, false, false, false]));
- assert!(!act.none() && !act.all());
- // mixed
-
- act = BitVec::from_elem(31, false);
- act.set(24, true);
- act.set(25, true);
- act.set(26, true);
- act.set(27, true);
- act.set(28, true);
- act.set(29, true);
- act.set(30, true);
- assert!(act.eq_vec(
- &[false, false, false, false, false, false, false, false, false, false, false,
- false, false, false, false, false, false, false, false, false, false, false,
- false, false, true, true, true, true, true, true, true]));
- assert!(!act.none() && !act.all());
- // mixed
-
- act = BitVec::from_elem(31, false);
- act.set(3, true);
- act.set(17, true);
- act.set(30, true);
- assert!(act.eq_vec(
- &[false, false, false, true, false, false, false, false, false, false, false, false,
- false, false, false, false, false, true, false, false, false, false, false, false,
- false, false, false, false, false, false, true]));
- assert!(!act.none() && !act.all());
- }
-
- #[test]
- fn test_32_elements() {
- let mut act;
- // all 0
-
- act = BitVec::from_elem(32, false);
- assert!(act.eq_vec(
- &[false, false, false, false, false, false, false, false, false, false, false,
- false, false, false, false, false, false, false, false, false, false, false,
- false, false, false, false, false, false, false, false, false, false]));
- assert!(act.none() && !act.all());
- // all 1
-
- act = BitVec::from_elem(32, true);
- assert!(act.eq_vec(
- &[true, true, true, true, true, true, true, true, true, true, true, true, true,
- true, true, true, true, true, true, true, true, true, true, true, true, true,
- true, true, true, true, true, true]));
- assert!(!act.none() && act.all());
- // mixed
-
- act = BitVec::from_elem(32, false);
- act.set(0, true);
- act.set(1, true);
- act.set(2, true);
- act.set(3, true);
- act.set(4, true);
- act.set(5, true);
- act.set(6, true);
- act.set(7, true);
- assert!(act.eq_vec(
- &[true, true, true, true, true, true, true, true, false, false, false, false, false,
- false, false, false, false, false, false, false, false, false, false, false,
- false, false, false, false, false, false, false, false]));
- assert!(!act.none() && !act.all());
- // mixed
-
- act = BitVec::from_elem(32, false);
- act.set(16, true);
- act.set(17, true);
- act.set(18, true);
- act.set(19, true);
- act.set(20, true);
- act.set(21, true);
- act.set(22, true);
- act.set(23, true);
- assert!(act.eq_vec(
- &[false, false, false, false, false, false, false, false, false, false, false,
- false, false, false, false, false, true, true, true, true, true, true, true, true,
- false, false, false, false, false, false, false, false]));
- assert!(!act.none() && !act.all());
- // mixed
-
- act = BitVec::from_elem(32, false);
- act.set(24, true);
- act.set(25, true);
- act.set(26, true);
- act.set(27, true);
- act.set(28, true);
- act.set(29, true);
- act.set(30, true);
- act.set(31, true);
- assert!(act.eq_vec(
- &[false, false, false, false, false, false, false, false, false, false, false,
- false, false, false, false, false, false, false, false, false, false, false,
- false, false, true, true, true, true, true, true, true, true]));
- assert!(!act.none() && !act.all());
- // mixed
-
- act = BitVec::from_elem(32, false);
- act.set(3, true);
- act.set(17, true);
- act.set(30, true);
- act.set(31, true);
- assert!(act.eq_vec(
- &[false, false, false, true, false, false, false, false, false, false, false, false,
- false, false, false, false, false, true, false, false, false, false, false, false,
- false, false, false, false, false, false, true, true]));
- assert!(!act.none() && !act.all());
- }
-
- #[test]
- fn test_33_elements() {
- let mut act;
- // all 0
-
- act = BitVec::from_elem(33, false);
- assert!(act.eq_vec(
- &[false, false, false, false, false, false, false, false, false, false, false,
- false, false, false, false, false, false, false, false, false, false, false,
- false, false, false, false, false, false, false, false, false, false, false]));
- assert!(act.none() && !act.all());
- // all 1
-
- act = BitVec::from_elem(33, true);
- assert!(act.eq_vec(
- &[true, true, true, true, true, true, true, true, true, true, true, true, true,
- true, true, true, true, true, true, true, true, true, true, true, true, true,
- true, true, true, true, true, true, true]));
- assert!(!act.none() && act.all());
- // mixed
-
- act = BitVec::from_elem(33, false);
- act.set(0, true);
- act.set(1, true);
- act.set(2, true);
- act.set(3, true);
- act.set(4, true);
- act.set(5, true);
- act.set(6, true);
- act.set(7, true);
- assert!(act.eq_vec(
- &[true, true, true, true, true, true, true, true, false, false, false, false, false,
- false, false, false, false, false, false, false, false, false, false, false,
- false, false, false, false, false, false, false, false, false]));
- assert!(!act.none() && !act.all());
- // mixed
-
- act = BitVec::from_elem(33, false);
- act.set(16, true);
- act.set(17, true);
- act.set(18, true);
- act.set(19, true);
- act.set(20, true);
- act.set(21, true);
- act.set(22, true);
- act.set(23, true);
- assert!(act.eq_vec(
- &[false, false, false, false, false, false, false, false, false, false, false,
- false, false, false, false, false, true, true, true, true, true, true, true, true,
- false, false, false, false, false, false, false, false, false]));
- assert!(!act.none() && !act.all());
- // mixed
-
- act = BitVec::from_elem(33, false);
- act.set(24, true);
- act.set(25, true);
- act.set(26, true);
- act.set(27, true);
- act.set(28, true);
- act.set(29, true);
- act.set(30, true);
- act.set(31, true);
- assert!(act.eq_vec(
- &[false, false, false, false, false, false, false, false, false, false, false,
- false, false, false, false, false, false, false, false, false, false, false,
- false, false, true, true, true, true, true, true, true, true, false]));
- assert!(!act.none() && !act.all());
- // mixed
-
- act = BitVec::from_elem(33, false);
- act.set(3, true);
- act.set(17, true);
- act.set(30, true);
- act.set(31, true);
- act.set(32, true);
- assert!(act.eq_vec(
- &[false, false, false, true, false, false, false, false, false, false, false, false,
- false, false, false, false, false, true, false, false, false, false, false, false,
- false, false, false, false, false, false, true, true, true]));
- assert!(!act.none() && !act.all());
- }
-
- #[test]
- fn test_equal_differing_sizes() {
- let v0 = BitVec::from_elem(10, false);
- let v1 = BitVec::from_elem(11, false);
- assert!(v0 != v1);
- }
-
- #[test]
- fn test_equal_greatly_differing_sizes() {
- let v0 = BitVec::from_elem(10, false);
- let v1 = BitVec::from_elem(110, false);
- assert!(v0 != v1);
- }
-
- #[test]
- fn test_equal_sneaky_small() {
- let mut a = BitVec::from_elem(1, false);
- a.set(0, true);
-
- let mut b = BitVec::from_elem(1, true);
- b.set(0, true);
-
- assert_eq!(a, b);
- }
-
- #[test]
- fn test_equal_sneaky_big() {
- let mut a = BitVec::from_elem(100, false);
- for i in 0..100 {
- a.set(i, true);
- }
-
- let mut b = BitVec::from_elem(100, true);
- for i in 0..100 {
- b.set(i, true);
- }
-
- assert_eq!(a, b);
- }
-
- #[test]
- fn test_from_bytes() {
- let bit_vec = BitVec::from_bytes(&[0b10110110, 0b00000000, 0b11111111]);
- let str = concat!("10110110", "00000000", "11111111");
- assert_eq!(format!("{:?}", bit_vec), str);
- }
-
- #[test]
- fn test_to_bytes() {
- let mut bv = BitVec::from_elem(3, true);
- bv.set(1, false);
- assert_eq!(bv.to_bytes(), [0b10100000]);
-
- let mut bv = BitVec::from_elem(9, false);
- bv.set(2, true);
- bv.set(8, true);
- assert_eq!(bv.to_bytes(), [0b00100000, 0b10000000]);
- }
-
- #[test]
- fn test_from_bools() {
- let bools = vec![true, false, true, true];
- let bit_vec: BitVec = bools.iter().map(|n| *n).collect();
- assert_eq!(format!("{:?}", bit_vec), "1011");
- }
-
- #[test]
- fn test_to_bools() {
- let bools = vec![false, false, true, false, false, true, true, false];
- assert_eq!(BitVec::from_bytes(&[0b00100110]).iter().collect::<Vec<bool>>(), bools);
- }
-
- #[test]
- fn test_bit_vec_iterator() {
- let bools = vec![true, false, true, true];
- let bit_vec: BitVec = bools.iter().map(|n| *n).collect();
-
- assert_eq!(bit_vec.iter().collect::<Vec<bool>>(), bools);
-
- let long: Vec<_> = (0..10000).map(|i| i % 2 == 0).collect();
- let bit_vec: BitVec = long.iter().map(|n| *n).collect();
- assert_eq!(bit_vec.iter().collect::<Vec<bool>>(), long)
- }
-
- #[test]
- fn test_small_difference() {
- let mut b1 = BitVec::from_elem(3, false);
- let mut b2 = BitVec::from_elem(3, false);
- b1.set(0, true);
- b1.set(1, true);
- b2.set(1, true);
- b2.set(2, true);
- assert!(b1.difference(&b2));
- assert!(b1[0]);
- assert!(!b1[1]);
- assert!(!b1[2]);
- }
-
- #[test]
- fn test_big_difference() {
- let mut b1 = BitVec::from_elem(100, false);
- let mut b2 = BitVec::from_elem(100, false);
- b1.set(0, true);
- b1.set(40, true);
- b2.set(40, true);
- b2.set(80, true);
- assert!(b1.difference(&b2));
- assert!(b1[0]);
- assert!(!b1[40]);
- assert!(!b1[80]);
- }
-
- #[test]
- fn test_small_clear() {
- let mut b = BitVec::from_elem(14, true);
- assert!(!b.none() && b.all());
- b.clear();
- assert!(b.none() && !b.all());
- }
-
- #[test]
- fn test_big_clear() {
- let mut b = BitVec::from_elem(140, true);
- assert!(!b.none() && b.all());
- b.clear();
- assert!(b.none() && !b.all());
- }
-
- #[test]
- fn test_bit_vec_lt() {
- let mut a = BitVec::from_elem(5, false);
- let mut b = BitVec::from_elem(5, false);
-
- assert!(!(a < b) && !(b < a));
- b.set(2, true);
- assert!(a < b);
- a.set(3, true);
- assert!(a < b);
- a.set(2, true);
- assert!(!(a < b) && b < a);
- b.set(0, true);
- assert!(a < b);
- }
-
- #[test]
- fn test_ord() {
- let mut a = BitVec::from_elem(5, false);
- let mut b = BitVec::from_elem(5, false);
-
- assert!(a <= b && a >= b);
- a.set(1, true);
- assert!(a > b && a >= b);
- assert!(b < a && b <= a);
- b.set(1, true);
- b.set(2, true);
- assert!(b > a && b >= a);
- assert!(a < b && a <= b);
- }
-
-
- #[test]
- fn test_small_bit_vec_tests() {
- let v = BitVec::from_bytes(&[0]);
- assert!(!v.all());
- assert!(!v.any());
- assert!(v.none());
-
- let v = BitVec::from_bytes(&[0b00010100]);
- assert!(!v.all());
- assert!(v.any());
- assert!(!v.none());
-
- let v = BitVec::from_bytes(&[0xFF]);
- assert!(v.all());
- assert!(v.any());
- assert!(!v.none());
- }
-
- #[test]
- fn test_big_bit_vec_tests() {
- let v = BitVec::from_bytes(&[ // 88 bits
- 0, 0, 0, 0,
- 0, 0, 0, 0,
- 0, 0, 0]);
- assert!(!v.all());
- assert!(!v.any());
- assert!(v.none());
-
- let v = BitVec::from_bytes(&[ // 88 bits
- 0, 0, 0b00010100, 0,
- 0, 0, 0, 0b00110100,
- 0, 0, 0]);
- assert!(!v.all());
- assert!(v.any());
- assert!(!v.none());
-
- let v = BitVec::from_bytes(&[ // 88 bits
- 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF]);
- assert!(v.all());
- assert!(v.any());
- assert!(!v.none());
- }
-
- #[test]
- fn test_bit_vec_push_pop() {
- let mut s = BitVec::from_elem(5 * u32::BITS as usize - 2, false);
- assert_eq!(s.len(), 5 * u32::BITS as usize - 2);
- assert_eq!(s[5 * u32::BITS as usize - 3], false);
- s.push(true);
- s.push(true);
- assert_eq!(s[5 * u32::BITS as usize - 2], true);
- assert_eq!(s[5 * u32::BITS as usize - 1], true);
- // Here the internal vector will need to be extended
- s.push(false);
- assert_eq!(s[5 * u32::BITS as usize], false);
- s.push(false);
- assert_eq!(s[5 * u32::BITS as usize + 1], false);
- assert_eq!(s.len(), 5 * u32::BITS as usize + 2);
- // Pop it all off
- assert_eq!(s.pop(), Some(false));
- assert_eq!(s.pop(), Some(false));
- assert_eq!(s.pop(), Some(true));
- assert_eq!(s.pop(), Some(true));
- assert_eq!(s.len(), 5 * u32::BITS as usize - 2);
- }
-
- #[test]
- fn test_bit_vec_truncate() {
- let mut s = BitVec::from_elem(5 * u32::BITS as usize, true);
-
- assert_eq!(s, BitVec::from_elem(5 * u32::BITS as usize, true));
- assert_eq!(s.len(), 5 * u32::BITS as usize);
- s.truncate(4 * u32::BITS as usize);
- assert_eq!(s, BitVec::from_elem(4 * u32::BITS as usize, true));
- assert_eq!(s.len(), 4 * u32::BITS as usize);
- // Truncating to a size > s.len() should be a noop
- s.truncate(5 * u32::BITS as usize);
- assert_eq!(s, BitVec::from_elem(4 * u32::BITS as usize, true));
- assert_eq!(s.len(), 4 * u32::BITS as usize);
- s.truncate(3 * u32::BITS as usize - 10);
- assert_eq!(s, BitVec::from_elem(3 * u32::BITS as usize - 10, true));
- assert_eq!(s.len(), 3 * u32::BITS as usize - 10);
- s.truncate(0);
- assert_eq!(s, BitVec::from_elem(0, true));
- assert_eq!(s.len(), 0);
- }
-
- #[test]
- fn test_bit_vec_reserve() {
- let mut s = BitVec::from_elem(5 * u32::BITS as usize, true);
- // Check capacity
- assert!(s.capacity() >= 5 * u32::BITS as usize);
- s.reserve(2 * u32::BITS as usize);
- assert!(s.capacity() >= 7 * u32::BITS as usize);
- s.reserve(7 * u32::BITS as usize);
- assert!(s.capacity() >= 12 * u32::BITS as usize);
- s.reserve_exact(7 * u32::BITS as usize);
- assert!(s.capacity() >= 12 * u32::BITS as usize);
- s.reserve(7 * u32::BITS as usize + 1);
- assert!(s.capacity() >= 12 * u32::BITS as usize + 1);
- // Check that length hasn't changed
- assert_eq!(s.len(), 5 * u32::BITS as usize);
- s.push(true);
- s.push(false);
- s.push(true);
- assert_eq!(s[5 * u32::BITS as usize - 1], true);
- assert_eq!(s[5 * u32::BITS as usize - 0], true);
- assert_eq!(s[5 * u32::BITS as usize + 1], false);
- assert_eq!(s[5 * u32::BITS as usize + 2], true);
- }
-
- #[test]
- fn test_bit_vec_grow() {
- let mut bit_vec = BitVec::from_bytes(&[0b10110110, 0b00000000, 0b10101010]);
- bit_vec.grow(32, true);
- assert_eq!(bit_vec, BitVec::from_bytes(&[0b10110110, 0b00000000, 0b10101010,
- 0xFF, 0xFF, 0xFF, 0xFF]));
- bit_vec.grow(64, false);
- assert_eq!(bit_vec, BitVec::from_bytes(&[0b10110110, 0b00000000, 0b10101010,
- 0xFF, 0xFF, 0xFF, 0xFF, 0, 0, 0, 0, 0, 0, 0, 0]));
- bit_vec.grow(16, true);
- assert_eq!(bit_vec, BitVec::from_bytes(&[0b10110110, 0b00000000, 0b10101010,
- 0xFF, 0xFF, 0xFF, 0xFF, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF]));
- }
-
- #[test]
- fn test_bit_vec_extend() {
- let mut bit_vec = BitVec::from_bytes(&[0b10110110, 0b00000000, 0b11111111]);
- let ext = BitVec::from_bytes(&[0b01001001, 0b10010010, 0b10111101]);
- bit_vec.extend(ext.iter());
- assert_eq!(bit_vec, BitVec::from_bytes(&[0b10110110, 0b00000000, 0b11111111,
- 0b01001001, 0b10010010, 0b10111101]));
- }
-}
-
-
-
-
-#[cfg(test)]
-mod bit_vec_bench {
- use std::prelude::v1::*;
- use std::rand;
- use std::rand::Rng;
- use std::u32;
- use test::{Bencher, black_box};
-
- use super::BitVec;
-
- const BENCH_BITS : usize = 1 << 14;
-
- fn rng() -> rand::IsaacRng {
- let seed: &[_] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
- rand::SeedableRng::from_seed(seed)
- }
-
- #[bench]
- fn bench_usize_small(b: &mut Bencher) {
- let mut r = rng();
- let mut bit_vec = 0 as usize;
- b.iter(|| {
- for _ in 0..100 {
- bit_vec |= 1 << ((r.next_u32() as usize) % u32::BITS as usize);
- }
- black_box(&bit_vec);
- });
- }
-
- #[bench]
- fn bench_bit_set_big_fixed(b: &mut Bencher) {
- let mut r = rng();
- let mut bit_vec = BitVec::from_elem(BENCH_BITS, false);
- b.iter(|| {
- for _ in 0..100 {
- bit_vec.set((r.next_u32() as usize) % BENCH_BITS, true);
- }
- black_box(&bit_vec);
- });
- }
-
- #[bench]
- fn bench_bit_set_big_variable(b: &mut Bencher) {
- let mut r = rng();
- let mut bit_vec = BitVec::from_elem(BENCH_BITS, false);
- b.iter(|| {
- for _ in 0..100 {
- bit_vec.set((r.next_u32() as usize) % BENCH_BITS, r.gen());
- }
- black_box(&bit_vec);
- });
- }
-
- #[bench]
- fn bench_bit_set_small(b: &mut Bencher) {
- let mut r = rng();
- let mut bit_vec = BitVec::from_elem(u32::BITS as usize, false);
- b.iter(|| {
- for _ in 0..100 {
- bit_vec.set((r.next_u32() as usize) % u32::BITS as usize, true);
- }
- black_box(&bit_vec);
- });
- }
-
- #[bench]
- fn bench_bit_vec_big_union(b: &mut Bencher) {
- let mut b1 = BitVec::from_elem(BENCH_BITS, false);
- let b2 = BitVec::from_elem(BENCH_BITS, false);
- b.iter(|| {
- b1.union(&b2)
- })
- }
-
- #[bench]
- fn bench_bit_vec_small_iter(b: &mut Bencher) {
- let bit_vec = BitVec::from_elem(u32::BITS as usize, false);
- b.iter(|| {
- let mut sum = 0;
- for _ in 0..10 {
- for pres in &bit_vec {
- sum += pres as usize;
- }
- }
- sum
- })
- }
-
- #[bench]
- fn bench_bit_vec_big_iter(b: &mut Bencher) {
- let bit_vec = BitVec::from_elem(BENCH_BITS, false);
- b.iter(|| {
- let mut sum = 0;
- for pres in &bit_vec {
- sum += pres as usize;
- }
- sum
- })
- }
-}
-
-
-
-
-
-
-
-#[cfg(test)]
-mod bit_set_test {
- use prelude::*;
- use std::iter::range_step;
-
- use super::{BitVec, BitSet};
-
- #[test]
- fn test_bit_set_show() {
- let mut s = BitSet::new();
- s.insert(1);
- s.insert(10);
- s.insert(50);
- s.insert(2);
- assert_eq!("{1, 2, 10, 50}", format!("{:?}", s));
- }
-
- #[test]
- fn test_bit_set_from_usizes() {
- let usizes = vec![0, 2, 2, 3];
- let a: BitSet = usizes.into_iter().collect();
- let mut b = BitSet::new();
- b.insert(0);
- b.insert(2);
- b.insert(3);
- assert_eq!(a, b);
- }
-
- #[test]
- fn test_bit_set_iterator() {
- let usizes = vec![0, 2, 2, 3];
- let bit_vec: BitSet = usizes.into_iter().collect();
-
- let idxs: Vec<_> = bit_vec.iter().collect();
- assert_eq!(idxs, [0, 2, 3]);
-
- let long: BitSet = (0..10000).filter(|&n| n % 2 == 0).collect();
- let real: Vec<_> = range_step(0, 10000, 2).collect();
-
- let idxs: Vec<_> = long.iter().collect();
- assert_eq!(idxs, real);
- }
-
- #[test]
- fn test_bit_set_frombit_vec_init() {
- let bools = [true, false];
- let lengths = [10, 64, 100];
- for &b in &bools {
- for &l in &lengths {
- let bitset = BitSet::from_bit_vec(BitVec::from_elem(l, b));
- assert_eq!(bitset.contains(&1), b);
- assert_eq!(bitset.contains(&(l-1)), b);
- assert!(!bitset.contains(&l));
- }
- }
- }
-
- #[test]
- fn test_bit_vec_masking() {
- let b = BitVec::from_elem(140, true);
- let mut bs = BitSet::from_bit_vec(b);
- assert!(bs.contains(&139));
- assert!(!bs.contains(&140));
- assert!(bs.insert(150));
- assert!(!bs.contains(&140));
- assert!(!bs.contains(&149));
- assert!(bs.contains(&150));
- assert!(!bs.contains(&151));
- }
-
- #[test]
- fn test_bit_set_basic() {
- let mut b = BitSet::new();
- assert!(b.insert(3));
- assert!(!b.insert(3));
- assert!(b.contains(&3));
- assert!(b.insert(4));
- assert!(!b.insert(4));
- assert!(b.contains(&3));
- assert!(b.insert(400));
- assert!(!b.insert(400));
- assert!(b.contains(&400));
- assert_eq!(b.len(), 3);
- }
-
- #[test]
- fn test_bit_set_intersection() {
- let mut a = BitSet::new();
- let mut b = BitSet::new();
-
- assert!(a.insert(11));
- assert!(a.insert(1));
- assert!(a.insert(3));
- assert!(a.insert(77));
- assert!(a.insert(103));
- assert!(a.insert(5));
-
- assert!(b.insert(2));
- assert!(b.insert(11));
- assert!(b.insert(77));
- assert!(b.insert(5));
- assert!(b.insert(3));
-
- let expected = [3, 5, 11, 77];
- let actual: Vec<_> = a.intersection(&b).collect();
- assert_eq!(actual, expected);
- }
-
- #[test]
- fn test_bit_set_difference() {
- let mut a = BitSet::new();
- let mut b = BitSet::new();
-
- assert!(a.insert(1));
- assert!(a.insert(3));
- assert!(a.insert(5));
- assert!(a.insert(200));
- assert!(a.insert(500));
-
- assert!(b.insert(3));
- assert!(b.insert(200));
-
- let expected = [1, 5, 500];
- let actual: Vec<_> = a.difference(&b).collect();
- assert_eq!(actual, expected);
- }
-
- #[test]
- fn test_bit_set_symmetric_difference() {
- let mut a = BitSet::new();
- let mut b = BitSet::new();
-
- assert!(a.insert(1));
- assert!(a.insert(3));
- assert!(a.insert(5));
- assert!(a.insert(9));
- assert!(a.insert(11));
-
- assert!(b.insert(3));
- assert!(b.insert(9));
- assert!(b.insert(14));
- assert!(b.insert(220));
-
- let expected = [1, 5, 11, 14, 220];
- let actual: Vec<_> = a.symmetric_difference(&b).collect();
- assert_eq!(actual, expected);
- }
-
- #[test]
- fn test_bit_set_union() {
- let mut a = BitSet::new();
- let mut b = BitSet::new();
- assert!(a.insert(1));
- assert!(a.insert(3));
- assert!(a.insert(5));
- assert!(a.insert(9));
- assert!(a.insert(11));
- assert!(a.insert(160));
- assert!(a.insert(19));
- assert!(a.insert(24));
- assert!(a.insert(200));
-
- assert!(b.insert(1));
- assert!(b.insert(5));
- assert!(b.insert(9));
- assert!(b.insert(13));
- assert!(b.insert(19));
-
- let expected = [1, 3, 5, 9, 11, 13, 19, 24, 160, 200];
- let actual: Vec<_> = a.union(&b).collect();
- assert_eq!(actual, expected);
- }
-
- #[test]
- fn test_bit_set_subset() {
- let mut set1 = BitSet::new();
- let mut set2 = BitSet::new();
-
- assert!(set1.is_subset(&set2)); // {} {}
- set2.insert(100);
- assert!(set1.is_subset(&set2)); // {} { 1 }
- set2.insert(200);
- assert!(set1.is_subset(&set2)); // {} { 1, 2 }
- set1.insert(200);
- assert!(set1.is_subset(&set2)); // { 2 } { 1, 2 }
- set1.insert(300);
- assert!(!set1.is_subset(&set2)); // { 2, 3 } { 1, 2 }
- set2.insert(300);
- assert!(set1.is_subset(&set2)); // { 2, 3 } { 1, 2, 3 }
- set2.insert(400);
- assert!(set1.is_subset(&set2)); // { 2, 3 } { 1, 2, 3, 4 }
- set2.remove(&100);
- assert!(set1.is_subset(&set2)); // { 2, 3 } { 2, 3, 4 }
- set2.remove(&300);
- assert!(!set1.is_subset(&set2)); // { 2, 3 } { 2, 4 }
- set1.remove(&300);
- assert!(set1.is_subset(&set2)); // { 2 } { 2, 4 }
- }
-
- #[test]
- fn test_bit_set_is_disjoint() {
- let a = BitSet::from_bit_vec(BitVec::from_bytes(&[0b10100010]));
- let b = BitSet::from_bit_vec(BitVec::from_bytes(&[0b01000000]));
- let c = BitSet::new();
- let d = BitSet::from_bit_vec(BitVec::from_bytes(&[0b00110000]));
-
- assert!(!a.is_disjoint(&d));
- assert!(!d.is_disjoint(&a));
-
- assert!(a.is_disjoint(&b));
- assert!(a.is_disjoint(&c));
- assert!(b.is_disjoint(&a));
- assert!(b.is_disjoint(&c));
- assert!(c.is_disjoint(&a));
- assert!(c.is_disjoint(&b));
- }
-
- #[test]
- fn test_bit_set_union_with() {
- //a should grow to include larger elements
- let mut a = BitSet::new();
- a.insert(0);
- let mut b = BitSet::new();
- b.insert(5);
- let expected = BitSet::from_bit_vec(BitVec::from_bytes(&[0b10000100]));
- a.union_with(&b);
- assert_eq!(a, expected);
-
- // Standard
- let mut a = BitSet::from_bit_vec(BitVec::from_bytes(&[0b10100010]));
- let mut b = BitSet::from_bit_vec(BitVec::from_bytes(&[0b01100010]));
- let c = a.clone();
- a.union_with(&b);
- b.union_with(&c);
- assert_eq!(a.len(), 4);
- assert_eq!(b.len(), 4);
- }
-
- #[test]
- fn test_bit_set_intersect_with() {
- // Explicitly 0'ed bits
- let mut a = BitSet::from_bit_vec(BitVec::from_bytes(&[0b10100010]));
- let mut b = BitSet::from_bit_vec(BitVec::from_bytes(&[0b00000000]));
- let c = a.clone();
- a.intersect_with(&b);
- b.intersect_with(&c);
- assert!(a.is_empty());
- assert!(b.is_empty());
-
- // Uninitialized bits should behave like 0's
- let mut a = BitSet::from_bit_vec(BitVec::from_bytes(&[0b10100010]));
- let mut b = BitSet::new();
- let c = a.clone();
- a.intersect_with(&b);
- b.intersect_with(&c);
- assert!(a.is_empty());
- assert!(b.is_empty());
-
- // Standard
- let mut a = BitSet::from_bit_vec(BitVec::from_bytes(&[0b10100010]));
- let mut b = BitSet::from_bit_vec(BitVec::from_bytes(&[0b01100010]));
- let c = a.clone();
- a.intersect_with(&b);
- b.intersect_with(&c);
- assert_eq!(a.len(), 2);
- assert_eq!(b.len(), 2);
- }
-
- #[test]
- fn test_bit_set_difference_with() {
- // Explicitly 0'ed bits
- let mut a = BitSet::from_bit_vec(BitVec::from_bytes(&[0b00000000]));
- let b = BitSet::from_bit_vec(BitVec::from_bytes(&[0b10100010]));
- a.difference_with(&b);
- assert!(a.is_empty());
-
- // Uninitialized bits should behave like 0's
- let mut a = BitSet::new();
- let b = BitSet::from_bit_vec(BitVec::from_bytes(&[0b11111111]));
- a.difference_with(&b);
- assert!(a.is_empty());
-
- // Standard
- let mut a = BitSet::from_bit_vec(BitVec::from_bytes(&[0b10100010]));
- let mut b = BitSet::from_bit_vec(BitVec::from_bytes(&[0b01100010]));
- let c = a.clone();
- a.difference_with(&b);
- b.difference_with(&c);
- assert_eq!(a.len(), 1);
- assert_eq!(b.len(), 1);
- }
-
- #[test]
- fn test_bit_set_symmetric_difference_with() {
- //a should grow to include larger elements
- let mut a = BitSet::new();
- a.insert(0);
- a.insert(1);
- let mut b = BitSet::new();
- b.insert(1);
- b.insert(5);
- let expected = BitSet::from_bit_vec(BitVec::from_bytes(&[0b10000100]));
- a.symmetric_difference_with(&b);
- assert_eq!(a, expected);
-
- let mut a = BitSet::from_bit_vec(BitVec::from_bytes(&[0b10100010]));
- let b = BitSet::new();
- let c = a.clone();
- a.symmetric_difference_with(&b);
- assert_eq!(a, c);
-
- // Standard
- let mut a = BitSet::from_bit_vec(BitVec::from_bytes(&[0b11100010]));
- let mut b = BitSet::from_bit_vec(BitVec::from_bytes(&[0b01101010]));
- let c = a.clone();
- a.symmetric_difference_with(&b);
- b.symmetric_difference_with(&c);
- assert_eq!(a.len(), 2);
- assert_eq!(b.len(), 2);
- }
-
- #[test]
- fn test_bit_set_eq() {
- let a = BitSet::from_bit_vec(BitVec::from_bytes(&[0b10100010]));
- let b = BitSet::from_bit_vec(BitVec::from_bytes(&[0b00000000]));
- let c = BitSet::new();
-
- assert!(a == a);
- assert!(a != b);
- assert!(a != c);
- assert!(b == b);
- assert!(b == c);
- assert!(c == c);
- }
-
- #[test]
- fn test_bit_set_cmp() {
- let a = BitSet::from_bit_vec(BitVec::from_bytes(&[0b10100010]));
- let b = BitSet::from_bit_vec(BitVec::from_bytes(&[0b00000000]));
- let c = BitSet::new();
-
- assert_eq!(a.cmp(&b), Greater);
- assert_eq!(a.cmp(&c), Greater);
- assert_eq!(b.cmp(&a), Less);
- assert_eq!(b.cmp(&c), Equal);
- assert_eq!(c.cmp(&a), Less);
- assert_eq!(c.cmp(&b), Equal);
- }
-
- #[test]
- fn test_bit_vec_remove() {
- let mut a = BitSet::new();
-
- assert!(a.insert(1));
- assert!(a.remove(&1));
-
- assert!(a.insert(100));
- assert!(a.remove(&100));
-
- assert!(a.insert(1000));
- assert!(a.remove(&1000));
- a.shrink_to_fit();
- }
-
- #[test]
- fn test_bit_vec_clone() {
- let mut a = BitSet::new();
-
- assert!(a.insert(1));
- assert!(a.insert(100));
- assert!(a.insert(1000));
-
- let mut b = a.clone();
-
- assert!(a == b);
-
- assert!(b.remove(&1));
- assert!(a.contains(&1));
-
- assert!(a.remove(&1000));
- assert!(b.contains(&1000));
- }
-}
-
-
-
-
-
-#[cfg(test)]
-mod bit_set_bench {
- use std::prelude::v1::*;
- use std::rand;
- use std::rand::Rng;
- use std::u32;
- use test::{Bencher, black_box};
-
- use super::{BitVec, BitSet};
-
- const BENCH_BITS : usize = 1 << 14;
-
- fn rng() -> rand::IsaacRng {
- let seed: &[_] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
- rand::SeedableRng::from_seed(seed)
- }
-
- #[bench]
- fn bench_bit_vecset_small(b: &mut Bencher) {
- let mut r = rng();
- let mut bit_vec = BitSet::new();
- b.iter(|| {
- for _ in 0..100 {
- bit_vec.insert((r.next_u32() as usize) % u32::BITS as usize);
- }
- black_box(&bit_vec);
- });
- }
-
- #[bench]
- fn bench_bit_vecset_big(b: &mut Bencher) {
- let mut r = rng();
- let mut bit_vec = BitSet::new();
- b.iter(|| {
- for _ in 0..100 {
- bit_vec.insert((r.next_u32() as usize) % BENCH_BITS);
- }
- black_box(&bit_vec);
- });
- }
-
- #[bench]
- fn bench_bit_vecset_iter(b: &mut Bencher) {
- let bit_vec = BitSet::from_bit_vec(BitVec::from_fn(BENCH_BITS,
- |idx| {idx % 3 == 0}));
- b.iter(|| {
- let mut sum = 0;
- for idx in &bit_vec {
- sum += idx as usize;
- }
- sum
- })
- }
-}
}
}
}
-
-
-
-
-
-#[cfg(test)]
-mod test {
- use prelude::*;
- use std::iter::range_inclusive;
-
- use super::BTreeMap;
- use super::Entry::{Occupied, Vacant};
- use Bound::{self, Included, Excluded, Unbounded};
-
- #[test]
- fn test_basic_large() {
- let mut map = BTreeMap::new();
- let size = 10000;
- assert_eq!(map.len(), 0);
-
- for i in 0..size {
- assert_eq!(map.insert(i, 10*i), None);
- assert_eq!(map.len(), i + 1);
- }
-
- for i in 0..size {
- assert_eq!(map.get(&i).unwrap(), &(i*10));
- }
-
- for i in size..size*2 {
- assert_eq!(map.get(&i), None);
- }
-
- for i in 0..size {
- assert_eq!(map.insert(i, 100*i), Some(10*i));
- assert_eq!(map.len(), size);
- }
-
- for i in 0..size {
- assert_eq!(map.get(&i).unwrap(), &(i*100));
- }
-
- for i in 0..size/2 {
- assert_eq!(map.remove(&(i*2)), Some(i*200));
- assert_eq!(map.len(), size - i - 1);
- }
-
- for i in 0..size/2 {
- assert_eq!(map.get(&(2*i)), None);
- assert_eq!(map.get(&(2*i+1)).unwrap(), &(i*200 + 100));
- }
-
- for i in 0..size/2 {
- assert_eq!(map.remove(&(2*i)), None);
- assert_eq!(map.remove(&(2*i+1)), Some(i*200 + 100));
- assert_eq!(map.len(), size/2 - i - 1);
- }
- }
-
- #[test]
- fn test_basic_small() {
- let mut map = BTreeMap::new();
- assert_eq!(map.remove(&1), None);
- assert_eq!(map.get(&1), None);
- assert_eq!(map.insert(1, 1), None);
- assert_eq!(map.get(&1), Some(&1));
- assert_eq!(map.insert(1, 2), Some(1));
- assert_eq!(map.get(&1), Some(&2));
- assert_eq!(map.insert(2, 4), None);
- assert_eq!(map.get(&2), Some(&4));
- assert_eq!(map.remove(&1), Some(2));
- assert_eq!(map.remove(&2), Some(4));
- assert_eq!(map.remove(&1), None);
- }
-
- #[test]
- fn test_iter() {
- let size = 10000;
-
- // Forwards
- let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
-
- fn test<T>(size: usize, mut iter: T) where T: Iterator<Item=(usize, usize)> {
- for i in 0..size {
- assert_eq!(iter.size_hint(), (size - i, Some(size - i)));
- assert_eq!(iter.next().unwrap(), (i, i));
- }
- assert_eq!(iter.size_hint(), (0, Some(0)));
- assert_eq!(iter.next(), None);
- }
- test(size, map.iter().map(|(&k, &v)| (k, v)));
- test(size, map.iter_mut().map(|(&k, &mut v)| (k, v)));
- test(size, map.into_iter());
- }
-
- #[test]
- fn test_iter_rev() {
- let size = 10000;
-
- // Forwards
- let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
-
- fn test<T>(size: usize, mut iter: T) where T: Iterator<Item=(usize, usize)> {
- for i in 0..size {
- assert_eq!(iter.size_hint(), (size - i, Some(size - i)));
- assert_eq!(iter.next().unwrap(), (size - i - 1, size - i - 1));
- }
- assert_eq!(iter.size_hint(), (0, Some(0)));
- assert_eq!(iter.next(), None);
- }
- test(size, map.iter().rev().map(|(&k, &v)| (k, v)));
- test(size, map.iter_mut().rev().map(|(&k, &mut v)| (k, v)));
- test(size, map.into_iter().rev());
- }
-
- #[test]
- fn test_iter_mixed() {
- let size = 10000;
-
- // Forwards
- let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
-
- fn test<T>(size: usize, mut iter: T)
- where T: Iterator<Item=(usize, usize)> + DoubleEndedIterator {
- for i in 0..size / 4 {
- assert_eq!(iter.size_hint(), (size - i * 2, Some(size - i * 2)));
- assert_eq!(iter.next().unwrap(), (i, i));
- assert_eq!(iter.next_back().unwrap(), (size - i - 1, size - i - 1));
- }
- for i in size / 4..size * 3 / 4 {
- assert_eq!(iter.size_hint(), (size * 3 / 4 - i, Some(size * 3 / 4 - i)));
- assert_eq!(iter.next().unwrap(), (i, i));
- }
- assert_eq!(iter.size_hint(), (0, Some(0)));
- assert_eq!(iter.next(), None);
- }
- test(size, map.iter().map(|(&k, &v)| (k, v)));
- test(size, map.iter_mut().map(|(&k, &mut v)| (k, v)));
- test(size, map.into_iter());
- }
-
- #[test]
- fn test_range_small() {
- let size = 5;
-
- // Forwards
- let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
-
- let mut j = 0;
- for ((&k, &v), i) in map.range(Included(&2), Unbounded).zip(2..size) {
- assert_eq!(k, i);
- assert_eq!(v, i);
- j += 1;
- }
- assert_eq!(j, size - 2);
- }
-
- #[test]
- fn test_range_1000() {
- let size = 1000;
- let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
-
- fn test(map: &BTreeMap<u32, u32>, size: u32, min: Bound<&u32>, max: Bound<&u32>) {
- let mut kvs = map.range(min, max).map(|(&k, &v)| (k, v));
- let mut pairs = (0..size).map(|i| (i, i));
-
- for (kv, pair) in kvs.by_ref().zip(pairs.by_ref()) {
- assert_eq!(kv, pair);
- }
- assert_eq!(kvs.next(), None);
- assert_eq!(pairs.next(), None);
- }
- test(&map, size, Included(&0), Excluded(&size));
- test(&map, size, Unbounded, Excluded(&size));
- test(&map, size, Included(&0), Included(&(size - 1)));
- test(&map, size, Unbounded, Included(&(size - 1)));
- test(&map, size, Included(&0), Unbounded);
- test(&map, size, Unbounded, Unbounded);
- }
-
- #[test]
- fn test_range() {
- let size = 200;
- let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
-
- for i in 0..size {
- for j in i..size {
- let mut kvs = map.range(Included(&i), Included(&j)).map(|(&k, &v)| (k, v));
- let mut pairs = range_inclusive(i, j).map(|i| (i, i));
-
- for (kv, pair) in kvs.by_ref().zip(pairs.by_ref()) {
- assert_eq!(kv, pair);
- }
- assert_eq!(kvs.next(), None);
- assert_eq!(pairs.next(), None);
- }
- }
- }
-
- #[test]
- fn test_entry(){
- let xs = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)];
-
- let mut map: BTreeMap<_, _> = xs.iter().cloned().collect();
-
- // Existing key (insert)
- match map.entry(1) {
- Vacant(_) => unreachable!(),
- Occupied(mut view) => {
- assert_eq!(view.get(), &10);
- assert_eq!(view.insert(100), 10);
- }
- }
- assert_eq!(map.get(&1).unwrap(), &100);
- assert_eq!(map.len(), 6);
-
-
- // Existing key (update)
- match map.entry(2) {
- Vacant(_) => unreachable!(),
- Occupied(mut view) => {
- let v = view.get_mut();
- *v *= 10;
- }
- }
- assert_eq!(map.get(&2).unwrap(), &200);
- assert_eq!(map.len(), 6);
-
- // Existing key (take)
- match map.entry(3) {
- Vacant(_) => unreachable!(),
- Occupied(view) => {
- assert_eq!(view.remove(), 30);
- }
- }
- assert_eq!(map.get(&3), None);
- assert_eq!(map.len(), 5);
-
-
- // Inexistent key (insert)
- match map.entry(10) {
- Occupied(_) => unreachable!(),
- Vacant(view) => {
- assert_eq!(*view.insert(1000), 1000);
- }
- }
- assert_eq!(map.get(&10).unwrap(), &1000);
- assert_eq!(map.len(), 6);
- }
-}
-
-
-
-
-
-
-#[cfg(test)]
-mod bench {
- use prelude::*;
- use std::rand::{weak_rng, Rng};
- use test::{Bencher, black_box};
-
- use super::BTreeMap;
-
- map_insert_rand_bench!{insert_rand_100, 100, BTreeMap}
- map_insert_rand_bench!{insert_rand_10_000, 10_000, BTreeMap}
-
- map_insert_seq_bench!{insert_seq_100, 100, BTreeMap}
- map_insert_seq_bench!{insert_seq_10_000, 10_000, BTreeMap}
-
- map_find_rand_bench!{find_rand_100, 100, BTreeMap}
- map_find_rand_bench!{find_rand_10_000, 10_000, BTreeMap}
-
- map_find_seq_bench!{find_seq_100, 100, BTreeMap}
- map_find_seq_bench!{find_seq_10_000, 10_000, BTreeMap}
-
- fn bench_iter(b: &mut Bencher, size: i32) {
- let mut map = BTreeMap::<i32, i32>::new();
- let mut rng = weak_rng();
-
- for _ in 0..size {
- map.insert(rng.gen(), rng.gen());
- }
-
- b.iter(|| {
- for entry in &map {
- black_box(entry);
- }
- });
- }
-
- #[bench]
- pub fn iter_20(b: &mut Bencher) {
- bench_iter(b, 20);
- }
-
- #[bench]
- pub fn iter_1000(b: &mut Bencher) {
- bench_iter(b, 1000);
- }
-
- #[bench]
- pub fn iter_100000(b: &mut Bencher) {
- bench_iter(b, 100000);
- }
-}
}
}
}
-
-
-#[cfg(test)]
-mod test {
- use prelude::*;
-
- use super::BTreeSet;
- use std::hash::{self, SipHasher};
-
- #[test]
- fn test_clone_eq() {
- let mut m = BTreeSet::new();
-
- m.insert(1);
- m.insert(2);
-
- assert!(m.clone() == m);
- }
-
- #[test]
- fn test_hash() {
- let mut x = BTreeSet::new();
- let mut y = BTreeSet::new();
-
- x.insert(1);
- x.insert(2);
- x.insert(3);
-
- y.insert(3);
- y.insert(2);
- y.insert(1);
-
- assert!(hash::hash::<_, SipHasher>(&x) == hash::hash::<_, SipHasher>(&y));
- }
-
- struct Counter<'a, 'b> {
- i: &'a mut usize,
- expected: &'b [i32],
- }
-
- impl<'a, 'b, 'c> FnMut<(&'c i32,)> for Counter<'a, 'b> {
- type Output = bool;
-
- extern "rust-call" fn call_mut(&mut self, (&x,): (&'c i32,)) -> bool {
- assert_eq!(x, self.expected[*self.i]);
- *self.i += 1;
- true
- }
- }
-
- fn check<F>(a: &[i32], b: &[i32], expected: &[i32], f: F) where
- // FIXME Replace Counter with `Box<FnMut(_) -> _>`
- F: FnOnce(&BTreeSet<i32>, &BTreeSet<i32>, Counter) -> bool,
- {
- let mut set_a = BTreeSet::new();
- let mut set_b = BTreeSet::new();
-
- for x in a { assert!(set_a.insert(*x)) }
- for y in b { assert!(set_b.insert(*y)) }
-
- let mut i = 0;
- f(&set_a, &set_b, Counter { i: &mut i, expected: expected });
- assert_eq!(i, expected.len());
- }
-
- #[test]
- fn test_intersection() {
- fn check_intersection(a: &[i32], b: &[i32], expected: &[i32]) {
- check(a, b, expected, |x, y, f| x.intersection(y).all(f))
- }
-
- check_intersection(&[], &[], &[]);
- check_intersection(&[1, 2, 3], &[], &[]);
- check_intersection(&[], &[1, 2, 3], &[]);
- check_intersection(&[2], &[1, 2, 3], &[2]);
- check_intersection(&[1, 2, 3], &[2], &[2]);
- check_intersection(&[11, 1, 3, 77, 103, 5, -5],
- &[2, 11, 77, -9, -42, 5, 3],
- &[3, 5, 11, 77]);
- }
-
- #[test]
- fn test_difference() {
- fn check_difference(a: &[i32], b: &[i32], expected: &[i32]) {
- check(a, b, expected, |x, y, f| x.difference(y).all(f))
- }
-
- check_difference(&[], &[], &[]);
- check_difference(&[1, 12], &[], &[1, 12]);
- check_difference(&[], &[1, 2, 3, 9], &[]);
- check_difference(&[1, 3, 5, 9, 11],
- &[3, 9],
- &[1, 5, 11]);
- check_difference(&[-5, 11, 22, 33, 40, 42],
- &[-12, -5, 14, 23, 34, 38, 39, 50],
- &[11, 22, 33, 40, 42]);
- }
-
- #[test]
- fn test_symmetric_difference() {
- fn check_symmetric_difference(a: &[i32], b: &[i32], expected: &[i32]) {
- check(a, b, expected, |x, y, f| x.symmetric_difference(y).all(f))
- }
-
- check_symmetric_difference(&[], &[], &[]);
- check_symmetric_difference(&[1, 2, 3], &[2], &[1, 3]);
- check_symmetric_difference(&[2], &[1, 2, 3], &[1, 3]);
- check_symmetric_difference(&[1, 3, 5, 9, 11],
- &[-2, 3, 9, 14, 22],
- &[-2, 1, 5, 11, 14, 22]);
- }
-
- #[test]
- fn test_union() {
- fn check_union(a: &[i32], b: &[i32], expected: &[i32]) {
- check(a, b, expected, |x, y, f| x.union(y).all(f))
- }
-
- check_union(&[], &[], &[]);
- check_union(&[1, 2, 3], &[2], &[1, 2, 3]);
- check_union(&[2], &[1, 2, 3], &[1, 2, 3]);
- check_union(&[1, 3, 5, 9, 11, 16, 19, 24],
- &[-2, 1, 5, 9, 13, 19],
- &[-2, 1, 3, 5, 9, 11, 13, 16, 19, 24]);
- }
-
- #[test]
- fn test_zip() {
- let mut x = BTreeSet::new();
- x.insert(5);
- x.insert(12);
- x.insert(11);
-
- let mut y = BTreeSet::new();
- y.insert("foo");
- y.insert("bar");
-
- let x = x;
- let y = y;
- let mut z = x.iter().zip(y.iter());
-
- // FIXME: #5801: this needs a type hint to compile...
- let result: Option<(&usize, & &'static str)> = z.next();
- assert_eq!(result.unwrap(), (&5, &("bar")));
-
- let result: Option<(&usize, & &'static str)> = z.next();
- assert_eq!(result.unwrap(), (&11, &("foo")));
-
- let result: Option<(&usize, & &'static str)> = z.next();
- assert!(result.is_none());
- }
-
- #[test]
- fn test_from_iter() {
- let xs = [1, 2, 3, 4, 5, 6, 7, 8, 9];
-
- let set: BTreeSet<_> = xs.iter().cloned().collect();
-
- for x in &xs {
- assert!(set.contains(x));
- }
- }
-
- #[test]
- fn test_show() {
- let mut set = BTreeSet::new();
- let empty = BTreeSet::<i32>::new();
-
- set.insert(1);
- set.insert(2);
-
- let set_str = format!("{:?}", set);
-
- assert_eq!(set_str, "{1, 2}");
- assert_eq!(format!("{:?}", empty), "{}");
- }
-}
}
}
}
-
-#[cfg(test)]
-mod test {
- use self::Foo::*;
- use prelude::*;
- use core::mem;
-
- use super::{EnumSet, CLike};
-
- #[derive(Copy, PartialEq, Debug)]
- #[repr(usize)]
- enum Foo {
- A, B, C
- }
-
- impl CLike for Foo {
- fn to_usize(&self) -> usize {
- *self as usize
- }
-
- fn from_usize(v: usize) -> Foo {
- unsafe { mem::transmute(v) }
- }
- }
-
- #[test]
- fn test_new() {
- let e: EnumSet<Foo> = EnumSet::new();
- assert!(e.is_empty());
- }
-
- #[test]
- fn test_show() {
- let mut e = EnumSet::new();
- assert!(format!("{:?}", e) == "{}");
- e.insert(A);
- assert!(format!("{:?}", e) == "{A}");
- e.insert(C);
- assert!(format!("{:?}", e) == "{A, C}");
- }
-
- #[test]
- fn test_len() {
- let mut e = EnumSet::new();
- assert_eq!(e.len(), 0);
- e.insert(A);
- e.insert(B);
- e.insert(C);
- assert_eq!(e.len(), 3);
- e.remove(&A);
- assert_eq!(e.len(), 2);
- e.clear();
- assert_eq!(e.len(), 0);
- }
-
- ///////////////////////////////////////////////////////////////////////////
- // intersect
-
- #[test]
- fn test_two_empties_do_not_intersect() {
- let e1: EnumSet<Foo> = EnumSet::new();
- let e2: EnumSet<Foo> = EnumSet::new();
- assert!(e1.is_disjoint(&e2));
- }
-
- #[test]
- fn test_empty_does_not_intersect_with_full() {
- let e1: EnumSet<Foo> = EnumSet::new();
-
- let mut e2: EnumSet<Foo> = EnumSet::new();
- e2.insert(A);
- e2.insert(B);
- e2.insert(C);
-
- assert!(e1.is_disjoint(&e2));
- }
-
- #[test]
- fn test_disjoint_intersects() {
- let mut e1: EnumSet<Foo> = EnumSet::new();
- e1.insert(A);
-
- let mut e2: EnumSet<Foo> = EnumSet::new();
- e2.insert(B);
-
- assert!(e1.is_disjoint(&e2));
- }
-
- #[test]
- fn test_overlapping_intersects() {
- let mut e1: EnumSet<Foo> = EnumSet::new();
- e1.insert(A);
-
- let mut e2: EnumSet<Foo> = EnumSet::new();
- e2.insert(A);
- e2.insert(B);
-
- assert!(!e1.is_disjoint(&e2));
- }
-
- ///////////////////////////////////////////////////////////////////////////
- // contains and contains_elem
-
- #[test]
- fn test_superset() {
- let mut e1: EnumSet<Foo> = EnumSet::new();
- e1.insert(A);
-
- let mut e2: EnumSet<Foo> = EnumSet::new();
- e2.insert(A);
- e2.insert(B);
-
- let mut e3: EnumSet<Foo> = EnumSet::new();
- e3.insert(C);
-
- assert!(e1.is_subset(&e2));
- assert!(e2.is_superset(&e1));
- assert!(!e3.is_superset(&e2));
- assert!(!e2.is_superset(&e3))
- }
-
- #[test]
- fn test_contains() {
- let mut e1: EnumSet<Foo> = EnumSet::new();
- e1.insert(A);
- assert!(e1.contains(&A));
- assert!(!e1.contains(&B));
- assert!(!e1.contains(&C));
-
- e1.insert(A);
- e1.insert(B);
- assert!(e1.contains(&A));
- assert!(e1.contains(&B));
- assert!(!e1.contains(&C));
- }
-
- ///////////////////////////////////////////////////////////////////////////
- // iter
-
- #[test]
- fn test_iterator() {
- let mut e1: EnumSet<Foo> = EnumSet::new();
-
- let elems: ::vec::Vec<Foo> = e1.iter().collect();
- assert!(elems.is_empty());
-
- e1.insert(A);
- let elems: ::vec::Vec<_> = e1.iter().collect();
- assert_eq!([A], elems);
-
- e1.insert(C);
- let elems: ::vec::Vec<_> = e1.iter().collect();
- assert_eq!([A,C], elems);
-
- e1.insert(C);
- let elems: ::vec::Vec<_> = e1.iter().collect();
- assert_eq!([A,C], elems);
-
- e1.insert(B);
- let elems: ::vec::Vec<_> = e1.iter().collect();
- assert_eq!([A,B,C], elems);
- }
-
- ///////////////////////////////////////////////////////////////////////////
- // operators
-
- #[test]
- fn test_operators() {
- let mut e1: EnumSet<Foo> = EnumSet::new();
- e1.insert(A);
- e1.insert(C);
-
- let mut e2: EnumSet<Foo> = EnumSet::new();
- e2.insert(B);
- e2.insert(C);
-
- let e_union = e1 | e2;
- let elems: ::vec::Vec<_> = e_union.iter().collect();
- assert_eq!([A,B,C], elems);
-
- let e_intersection = e1 & e2;
- let elems: ::vec::Vec<_> = e_intersection.iter().collect();
- assert_eq!([C], elems);
-
- // Another way to express intersection
- let e_intersection = e1 - (e1 - e2);
- let elems: ::vec::Vec<_> = e_intersection.iter().collect();
- assert_eq!([C], elems);
-
- let e_subtract = e1 - e2;
- let elems: ::vec::Vec<_> = e_subtract.iter().collect();
- assert_eq!([A], elems);
-
- // Bitwise XOR of two sets, aka symmetric difference
- let e_symmetric_diff = e1 ^ e2;
- let elems: ::vec::Vec<_> = e_symmetric_diff.iter().collect();
- assert_eq!([A,B], elems);
-
- // Another way to express symmetric difference
- let e_symmetric_diff = (e1 - e2) | (e2 - e1);
- let elems: ::vec::Vec<_> = e_symmetric_diff.iter().collect();
- assert_eq!([A,B], elems);
-
- // Yet another way to express symmetric difference
- let e_symmetric_diff = (e1 | e2) - (e1 & e2);
- let elems: ::vec::Vec<_> = e_symmetric_diff.iter().collect();
- assert_eq!([A,B], elems);
- }
-
- #[test]
- #[should_panic]
- fn test_overflow() {
- #[allow(dead_code)]
- #[derive(Copy)]
- #[repr(usize)]
- enum Bar {
- V00, V01, V02, V03, V04, V05, V06, V07, V08, V09,
- V10, V11, V12, V13, V14, V15, V16, V17, V18, V19,
- V20, V21, V22, V23, V24, V25, V26, V27, V28, V29,
- V30, V31, V32, V33, V34, V35, V36, V37, V38, V39,
- V40, V41, V42, V43, V44, V45, V46, V47, V48, V49,
- V50, V51, V52, V53, V54, V55, V56, V57, V58, V59,
- V60, V61, V62, V63, V64, V65, V66, V67, V68, V69,
- }
-
- impl CLike for Bar {
- fn to_usize(&self) -> usize {
- *self as usize
- }
-
- fn from_usize(v: usize) -> Bar {
- unsafe { mem::transmute(v) }
- }
- }
- let mut set = EnumSet::new();
- set.insert(Bar::V64);
- }
-}
let _ = write!(&mut output, "{}", args);
output
}
-
-#[cfg(test)]
-mod tests {
- use prelude::*;
- use fmt;
-
- #[test]
- fn test_format() {
- let s = fmt::format(format_args!("Hello, {}!", "world"));
- assert_eq!(s.as_slice(), "Hello, world!");
- }
-}
extern crate unicode;
extern crate alloc;
-#[cfg(test)] extern crate test;
-#[cfg(test)] #[macro_use] extern crate std;
-#[cfg(test)] #[macro_use] extern crate log;
-
pub use binary_heap::BinaryHeap;
pub use bit_vec::BitVec;
pub use bit_set::BitSet;
#[macro_use]
mod macros;
-#[cfg(test)] #[macro_use] mod bench;
-
pub mod binary_heap;
mod bit;
mod btree;
#[doc(hidden)]
pub fn fixme_14344_be_sure_to_link_to_collections() {}
-#[cfg(not(test))]
mod std {
pub use core::ops; // RangeFull
}
-#[cfg(test)]
-mod prelude {
- // from core.
- pub use core::clone::Clone;
- pub use core::cmp::{PartialEq, Eq, PartialOrd, Ord};
- pub use core::cmp::Ordering::{Less, Equal, Greater};
- pub use core::iter::range;
- pub use core::iter::{FromIterator, Extend, IteratorExt};
- pub use core::iter::{Iterator, DoubleEndedIterator, RandomAccessIterator};
- pub use core::iter::{ExactSizeIterator};
- pub use core::marker::{Copy, Send, Sized, Sync};
- pub use core::mem::drop;
- pub use core::ops::{Drop, Fn, FnMut, FnOnce};
- pub use core::option::Option;
- pub use core::option::Option::{Some, None};
- pub use core::ptr::PtrExt;
- pub use core::result::Result;
- pub use core::result::Result::{Ok, Err};
-
- // in core and collections (may differ).
- pub use slice::{AsSlice, SliceExt};
- #[cfg(stage0)]
- pub use str::{Str, StrExt};
- #[cfg(not(stage0))]
- pub use str::Str;
-
- // from other crates.
- pub use alloc::boxed::Box;
-
- // from collections.
- pub use borrow::IntoCow;
- pub use slice::SliceConcatExt;
- pub use string::{String, ToString};
- pub use vec::Vec;
-}
-
/// An endpoint of a range of keys.
#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
pub enum Bound<T> {
}
}
}
-
-#[cfg(test)]
-mod tests {
- use prelude::*;
- use std::rand;
- use std::hash::{self, SipHasher};
- use std::thread;
- use test::Bencher;
- use test;
-
- use super::{LinkedList, Node};
-
- pub fn check_links<T>(list: &LinkedList<T>) {
- let mut len = 0;
- let mut last_ptr: Option<&Node<T>> = None;
- let mut node_ptr: &Node<T>;
- match list.list_head {
- None => { assert_eq!(0, list.length); return }
- Some(ref node) => node_ptr = &**node,
- }
- loop {
- match (last_ptr, node_ptr.prev.resolve_immut()) {
- (None , None ) => {}
- (None , _ ) => panic!("prev link for list_head"),
- (Some(p), Some(pptr)) => {
- assert_eq!(p as *const Node<T>, pptr as *const Node<T>);
- }
- _ => panic!("prev link is none, not good"),
- }
- match node_ptr.next {
- Some(ref next) => {
- last_ptr = Some(node_ptr);
- node_ptr = &**next;
- len += 1;
- }
- None => {
- len += 1;
- break;
- }
- }
- }
- assert_eq!(len, list.length);
- }
-
- #[test]
- fn test_basic() {
- let mut m = LinkedList::<Box<_>>::new();
- assert_eq!(m.pop_front(), None);
- assert_eq!(m.pop_back(), None);
- assert_eq!(m.pop_front(), None);
- m.push_front(box 1);
- assert_eq!(m.pop_front(), Some(box 1));
- m.push_back(box 2);
- m.push_back(box 3);
- assert_eq!(m.len(), 2);
- assert_eq!(m.pop_front(), Some(box 2));
- assert_eq!(m.pop_front(), Some(box 3));
- assert_eq!(m.len(), 0);
- assert_eq!(m.pop_front(), None);
- m.push_back(box 1);
- m.push_back(box 3);
- m.push_back(box 5);
- m.push_back(box 7);
- assert_eq!(m.pop_front(), Some(box 1));
-
- let mut n = LinkedList::new();
- n.push_front(2);
- n.push_front(3);
- {
- assert_eq!(n.front().unwrap(), &3);
- let x = n.front_mut().unwrap();
- assert_eq!(*x, 3);
- *x = 0;
- }
- {
- assert_eq!(n.back().unwrap(), &2);
- let y = n.back_mut().unwrap();
- assert_eq!(*y, 2);
- *y = 1;
- }
- assert_eq!(n.pop_front(), Some(0));
- assert_eq!(n.pop_front(), Some(1));
- }
-
- #[cfg(test)]
- fn generate_test() -> LinkedList<i32> {
- list_from(&[0,1,2,3,4,5,6])
- }
-
- #[cfg(test)]
- fn list_from<T: Clone>(v: &[T]) -> LinkedList<T> {
- v.iter().cloned().collect()
- }
-
- #[test]
- fn test_append() {
- // Empty to empty
- {
- let mut m = LinkedList::<i32>::new();
- let mut n = LinkedList::new();
- m.append(&mut n);
- check_links(&m);
- assert_eq!(m.len(), 0);
- assert_eq!(n.len(), 0);
- }
- // Non-empty to empty
- {
- let mut m = LinkedList::new();
- let mut n = LinkedList::new();
- n.push_back(2);
- m.append(&mut n);
- check_links(&m);
- assert_eq!(m.len(), 1);
- assert_eq!(m.pop_back(), Some(2));
- assert_eq!(n.len(), 0);
- check_links(&m);
- }
- // Empty to non-empty
- {
- let mut m = LinkedList::new();
- let mut n = LinkedList::new();
- m.push_back(2);
- m.append(&mut n);
- check_links(&m);
- assert_eq!(m.len(), 1);
- assert_eq!(m.pop_back(), Some(2));
- check_links(&m);
- }
-
- // Non-empty to non-empty
- let v = vec![1,2,3,4,5];
- let u = vec![9,8,1,2,3,4,5];
- let mut m = list_from(&v);
- let mut n = list_from(&u);
- m.append(&mut n);
- check_links(&m);
- let mut sum = v;
- sum.push_all(&u);
- assert_eq!(sum.len(), m.len());
- for elt in sum {
- assert_eq!(m.pop_front(), Some(elt))
- }
- assert_eq!(n.len(), 0);
- // let's make sure it's working properly, since we
- // did some direct changes to private members
- n.push_back(3);
- assert_eq!(n.len(), 1);
- assert_eq!(n.pop_front(), Some(3));
- check_links(&n);
- }
-
- #[test]
- fn test_split_off() {
- // singleton
- {
- let mut m = LinkedList::new();
- m.push_back(1);
-
- let p = m.split_off(0);
- assert_eq!(m.len(), 0);
- assert_eq!(p.len(), 1);
- assert_eq!(p.back(), Some(&1));
- assert_eq!(p.front(), Some(&1));
- }
-
- // not singleton, forwards
- {
- let u = vec![1,2,3,4,5];
- let mut m = list_from(&u);
- let mut n = m.split_off(2);
- assert_eq!(m.len(), 2);
- assert_eq!(n.len(), 3);
- for elt in 1..3 {
- assert_eq!(m.pop_front(), Some(elt));
- }
- for elt in 3..6 {
- assert_eq!(n.pop_front(), Some(elt));
- }
- }
- // not singleton, backwards
- {
- let u = vec![1,2,3,4,5];
- let mut m = list_from(&u);
- let mut n = m.split_off(4);
- assert_eq!(m.len(), 4);
- assert_eq!(n.len(), 1);
- for elt in 1..5 {
- assert_eq!(m.pop_front(), Some(elt));
- }
- for elt in 5..6 {
- assert_eq!(n.pop_front(), Some(elt));
- }
- }
-
- // no-op on the last index
- {
- let mut m = LinkedList::new();
- m.push_back(1);
-
- let p = m.split_off(1);
- assert_eq!(m.len(), 1);
- assert_eq!(p.len(), 0);
- assert_eq!(m.back(), Some(&1));
- assert_eq!(m.front(), Some(&1));
- }
-
- }
-
- #[test]
- fn test_iterator() {
- let m = generate_test();
- for (i, elt) in m.iter().enumerate() {
- assert_eq!(i as i32, *elt);
- }
- let mut n = LinkedList::new();
- assert_eq!(n.iter().next(), None);
- n.push_front(4);
- let mut it = n.iter();
- assert_eq!(it.size_hint(), (1, Some(1)));
- assert_eq!(it.next().unwrap(), &4);
- assert_eq!(it.size_hint(), (0, Some(0)));
- assert_eq!(it.next(), None);
- }
-
- #[test]
- fn test_iterator_clone() {
- let mut n = LinkedList::new();
- n.push_back(2);
- n.push_back(3);
- n.push_back(4);
- let mut it = n.iter();
- it.next();
- let mut jt = it.clone();
- assert_eq!(it.next(), jt.next());
- assert_eq!(it.next_back(), jt.next_back());
- assert_eq!(it.next(), jt.next());
- }
-
- #[test]
- fn test_iterator_double_end() {
- let mut n = LinkedList::new();
- assert_eq!(n.iter().next(), None);
- n.push_front(4);
- n.push_front(5);
- n.push_front(6);
- let mut it = n.iter();
- assert_eq!(it.size_hint(), (3, Some(3)));
- assert_eq!(it.next().unwrap(), &6);
- assert_eq!(it.size_hint(), (2, Some(2)));
- assert_eq!(it.next_back().unwrap(), &4);
- assert_eq!(it.size_hint(), (1, Some(1)));
- assert_eq!(it.next_back().unwrap(), &5);
- assert_eq!(it.next_back(), None);
- assert_eq!(it.next(), None);
- }
-
- #[test]
- fn test_rev_iter() {
- let m = generate_test();
- for (i, elt) in m.iter().rev().enumerate() {
- assert_eq!((6 - i) as i32, *elt);
- }
- let mut n = LinkedList::new();
- assert_eq!(n.iter().rev().next(), None);
- n.push_front(4);
- let mut it = n.iter().rev();
- assert_eq!(it.size_hint(), (1, Some(1)));
- assert_eq!(it.next().unwrap(), &4);
- assert_eq!(it.size_hint(), (0, Some(0)));
- assert_eq!(it.next(), None);
- }
-
- #[test]
- fn test_mut_iter() {
- let mut m = generate_test();
- let mut len = m.len();
- for (i, elt) in m.iter_mut().enumerate() {
- assert_eq!(i as i32, *elt);
- len -= 1;
- }
- assert_eq!(len, 0);
- let mut n = LinkedList::new();
- assert!(n.iter_mut().next().is_none());
- n.push_front(4);
- n.push_back(5);
- let mut it = n.iter_mut();
- assert_eq!(it.size_hint(), (2, Some(2)));
- assert!(it.next().is_some());
- assert!(it.next().is_some());
- assert_eq!(it.size_hint(), (0, Some(0)));
- assert!(it.next().is_none());
- }
-
- #[test]
- fn test_iterator_mut_double_end() {
- let mut n = LinkedList::new();
- assert!(n.iter_mut().next_back().is_none());
- n.push_front(4);
- n.push_front(5);
- n.push_front(6);
- let mut it = n.iter_mut();
- assert_eq!(it.size_hint(), (3, Some(3)));
- assert_eq!(*it.next().unwrap(), 6);
- assert_eq!(it.size_hint(), (2, Some(2)));
- assert_eq!(*it.next_back().unwrap(), 4);
- assert_eq!(it.size_hint(), (1, Some(1)));
- assert_eq!(*it.next_back().unwrap(), 5);
- assert!(it.next_back().is_none());
- assert!(it.next().is_none());
- }
-
- #[test]
- fn test_insert_prev() {
- let mut m = list_from(&[0,2,4,6,8]);
- let len = m.len();
- {
- let mut it = m.iter_mut();
- it.insert_next(-2);
- loop {
- match it.next() {
- None => break,
- Some(elt) => {
- it.insert_next(*elt + 1);
- match it.peek_next() {
- Some(x) => assert_eq!(*x, *elt + 2),
- None => assert_eq!(8, *elt),
- }
- }
- }
- }
- it.insert_next(0);
- it.insert_next(1);
- }
- check_links(&m);
- assert_eq!(m.len(), 3 + len * 2);
- assert_eq!(m.into_iter().collect::<Vec<_>>(), [-2,0,1,2,3,4,5,6,7,8,9,0,1]);
- }
-
- #[test]
- fn test_mut_rev_iter() {
- let mut m = generate_test();
- for (i, elt) in m.iter_mut().rev().enumerate() {
- assert_eq!((6 - i) as i32, *elt);
- }
- let mut n = LinkedList::new();
- assert!(n.iter_mut().rev().next().is_none());
- n.push_front(4);
- let mut it = n.iter_mut().rev();
- assert!(it.next().is_some());
- assert!(it.next().is_none());
- }
-
- #[test]
- fn test_send() {
- let n = list_from(&[1,2,3]);
- thread::spawn(move || {
- check_links(&n);
- let a: &[_] = &[&1,&2,&3];
- assert_eq!(a, n.iter().collect::<Vec<_>>());
- }).join().ok().unwrap();
- }
-
- #[test]
- fn test_eq() {
- let mut n = list_from(&[]);
- let mut m = list_from(&[]);
- assert!(n == m);
- n.push_front(1);
- assert!(n != m);
- m.push_back(1);
- assert!(n == m);
-
- let n = list_from(&[2,3,4]);
- let m = list_from(&[1,2,3]);
- assert!(n != m);
- }
-
- #[test]
- fn test_hash() {
- let mut x = LinkedList::new();
- let mut y = LinkedList::new();
-
- assert!(hash::hash::<_, SipHasher>(&x) == hash::hash::<_, SipHasher>(&y));
-
- x.push_back(1);
- x.push_back(2);
- x.push_back(3);
-
- y.push_front(3);
- y.push_front(2);
- y.push_front(1);
-
- assert!(hash::hash::<_, SipHasher>(&x) == hash::hash::<_, SipHasher>(&y));
- }
-
- #[test]
- fn test_ord() {
- let n = list_from(&[]);
- let m = list_from(&[1,2,3]);
- assert!(n < m);
- assert!(m > n);
- assert!(n <= n);
- assert!(n >= n);
- }
-
- #[test]
- fn test_ord_nan() {
- let nan = 0.0f64/0.0;
- let n = list_from(&[nan]);
- let m = list_from(&[nan]);
- assert!(!(n < m));
- assert!(!(n > m));
- assert!(!(n <= m));
- assert!(!(n >= m));
-
- let n = list_from(&[nan]);
- let one = list_from(&[1.0f64]);
- assert!(!(n < one));
- assert!(!(n > one));
- assert!(!(n <= one));
- assert!(!(n >= one));
-
- let u = list_from(&[1.0f64,2.0,nan]);
- let v = list_from(&[1.0f64,2.0,3.0]);
- assert!(!(u < v));
- assert!(!(u > v));
- assert!(!(u <= v));
- assert!(!(u >= v));
-
- let s = list_from(&[1.0f64,2.0,4.0,2.0]);
- let t = list_from(&[1.0f64,2.0,3.0,2.0]);
- assert!(!(s < t));
- assert!(s > one);
- assert!(!(s <= one));
- assert!(s >= one);
- }
-
- #[test]
- fn test_fuzz() {
- for _ in 0..25 {
- fuzz_test(3);
- fuzz_test(16);
- fuzz_test(189);
- }
- }
-
- #[test]
- fn test_show() {
- let list: LinkedList<_> = (0..10).collect();
- assert_eq!(format!("{:?}", list), "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
-
- let list: LinkedList<_> = vec!["just", "one", "test", "more"].iter().cloned().collect();
- assert_eq!(format!("{:?}", list), "[\"just\", \"one\", \"test\", \"more\"]");
- }
-
- #[cfg(test)]
- fn fuzz_test(sz: i32) {
- let mut m: LinkedList<_> = LinkedList::new();
- let mut v = vec![];
- for i in 0..sz {
- check_links(&m);
- let r: u8 = rand::random();
- match r % 6 {
- 0 => {
- m.pop_back();
- v.pop();
- }
- 1 => {
- if !v.is_empty() {
- m.pop_front();
- v.remove(0);
- }
- }
- 2 | 4 => {
- m.push_front(-i);
- v.insert(0, -i);
- }
- 3 | 5 | _ => {
- m.push_back(i);
- v.push(i);
- }
- }
- }
-
- check_links(&m);
-
- let mut i = 0;
- for (a, &b) in m.into_iter().zip(v.iter()) {
- i += 1;
- assert_eq!(a, b);
- }
- assert_eq!(i, v.len());
- }
-
- #[bench]
- fn bench_collect_into(b: &mut test::Bencher) {
- let v = &[0; 64];
- b.iter(|| {
- let _: LinkedList<_> = v.iter().cloned().collect();
- })
- }
-
- #[bench]
- fn bench_push_front(b: &mut test::Bencher) {
- let mut m: LinkedList<_> = LinkedList::new();
- b.iter(|| {
- m.push_front(0);
- })
- }
-
- #[bench]
- fn bench_push_back(b: &mut test::Bencher) {
- let mut m: LinkedList<_> = LinkedList::new();
- b.iter(|| {
- m.push_back(0);
- })
- }
-
- #[bench]
- fn bench_push_back_pop_back(b: &mut test::Bencher) {
- let mut m: LinkedList<_> = LinkedList::new();
- b.iter(|| {
- m.push_back(0);
- m.pop_back();
- })
- }
-
- #[bench]
- fn bench_push_front_pop_front(b: &mut test::Bencher) {
- let mut m: LinkedList<_> = LinkedList::new();
- b.iter(|| {
- m.push_front(0);
- m.pop_front();
- })
- }
-
- #[bench]
- fn bench_iter(b: &mut test::Bencher) {
- let v = &[0; 128];
- let m: LinkedList<_> = v.iter().cloned().collect();
- b.iter(|| {
- assert!(m.iter().count() == 128);
- })
- }
- #[bench]
- fn bench_iter_mut(b: &mut test::Bencher) {
- let v = &[0; 128];
- let mut m: LinkedList<_> = v.iter().cloned().collect();
- b.iter(|| {
- assert!(m.iter_mut().count() == 128);
- })
- }
- #[bench]
- fn bench_iter_rev(b: &mut test::Bencher) {
- let v = &[0; 128];
- let m: LinkedList<_> = v.iter().cloned().collect();
- b.iter(|| {
- assert!(m.iter().rev().count() == 128);
- })
- }
- #[bench]
- fn bench_iter_mut_rev(b: &mut test::Bencher) {
- let v = &[0; 128];
- let mut m: LinkedList<_> = v.iter().cloned().collect();
- b.iter(|| {
- assert!(m.iter_mut().rev().count() == 128);
- })
- }
-}
old
}
}
-
-#[cfg(test)]
-mod tests {
- use alloc::boxed::Box;
- use core::cmp::Ordering::{Greater, Less, Equal};
- use core::prelude::{Some, None, Clone};
- use core::prelude::{Iterator, IteratorExt};
- use core::prelude::{AsSlice};
- use core::prelude::Ord;
- use core::default::Default;
- use core::mem;
- use std::iter::RandomAccessIterator;
- use std::rand::{Rng, thread_rng};
- use std::rc::Rc;
- use string::ToString;
- use vec::Vec;
- use super::{ElementSwaps, SliceConcatExt, SliceExt};
-
- fn square(n: usize) -> usize { n * n }
-
- fn is_odd(n: &usize) -> bool { *n % 2 == 1 }
-
- #[test]
- fn test_from_fn() {
- // Test on-stack from_fn.
- let mut v: Vec<_> = (0..3).map(square).collect();
- {
- let v = v;
- assert_eq!(v.len(), 3);
- assert_eq!(v[0], 0);
- assert_eq!(v[1], 1);
- assert_eq!(v[2], 4);
- }
-
- // Test on-heap from_fn.
- v = (0..5).map(square).collect();
- {
- let v = v;
- assert_eq!(v.len(), 5);
- assert_eq!(v[0], 0);
- assert_eq!(v[1], 1);
- assert_eq!(v[2], 4);
- assert_eq!(v[3], 9);
- assert_eq!(v[4], 16);
- }
- }
-
- #[test]
- fn test_from_elem() {
- // Test on-stack from_elem.
- let mut v = vec![10, 10];
- {
- let v = v;
- assert_eq!(v.len(), 2);
- assert_eq!(v[0], 10);
- assert_eq!(v[1], 10);
- }
-
- // Test on-heap from_elem.
- v = vec![20; 6];
- {
- let v = v.as_slice();
- assert_eq!(v[0], 20);
- assert_eq!(v[1], 20);
- assert_eq!(v[2], 20);
- assert_eq!(v[3], 20);
- assert_eq!(v[4], 20);
- assert_eq!(v[5], 20);
- }
- }
-
- #[test]
- fn test_is_empty() {
- let xs: [i32; 0] = [];
- assert!(xs.is_empty());
- assert!(![0].is_empty());
- }
-
- #[test]
- fn test_len_divzero() {
- type Z = [i8; 0];
- let v0 : &[Z] = &[];
- let v1 : &[Z] = &[[]];
- let v2 : &[Z] = &[[], []];
- assert_eq!(mem::size_of::<Z>(), 0);
- assert_eq!(v0.len(), 0);
- assert_eq!(v1.len(), 1);
- assert_eq!(v2.len(), 2);
- }
-
- #[test]
- fn test_get() {
- let mut a = vec![11];
- assert_eq!(a.get(1), None);
- a = vec![11, 12];
- assert_eq!(a.get(1).unwrap(), &12);
- a = vec![11, 12, 13];
- assert_eq!(a.get(1).unwrap(), &12);
- }
-
- #[test]
- fn test_first() {
- let mut a = vec![];
- assert_eq!(a.first(), None);
- a = vec![11];
- assert_eq!(a.first().unwrap(), &11);
- a = vec![11, 12];
- assert_eq!(a.first().unwrap(), &11);
- }
-
- #[test]
- fn test_first_mut() {
- let mut a = vec![];
- assert_eq!(a.first_mut(), None);
- a = vec![11];
- assert_eq!(*a.first_mut().unwrap(), 11);
- a = vec![11, 12];
- assert_eq!(*a.first_mut().unwrap(), 11);
- }
-
- #[test]
- fn test_tail() {
- let mut a = vec![11];
- let b: &[i32] = &[];
- assert_eq!(a.tail(), b);
- a = vec![11, 12];
- let b: &[i32] = &[12];
- assert_eq!(a.tail(), b);
- }
-
- #[test]
- fn test_tail_mut() {
- let mut a = vec![11];
- let b: &mut [i32] = &mut [];
- assert!(a.tail_mut() == b);
- a = vec![11, 12];
- let b: &mut [_] = &mut [12];
- assert!(a.tail_mut() == b);
- }
-
- #[test]
- #[should_panic]
- fn test_tail_empty() {
- let a = Vec::<i32>::new();
- a.tail();
- }
-
- #[test]
- #[should_panic]
- fn test_tail_mut_empty() {
- let mut a = Vec::<i32>::new();
- a.tail_mut();
- }
-
- #[test]
- fn test_init() {
- let mut a = vec![11];
- let b: &[i32] = &[];
- assert_eq!(a.init(), b);
- a = vec![11, 12];
- let b: &[_] = &[11];
- assert_eq!(a.init(), b);
- }
-
- #[test]
- fn test_init_mut() {
- let mut a = vec![11];
- let b: &mut [i32] = &mut [];
- assert!(a.init_mut() == b);
- a = vec![11, 12];
- let b: &mut [_] = &mut [11];
- assert!(a.init_mut() == b);
- }
-
- #[test]
- #[should_panic]
- fn test_init_empty() {
- let a = Vec::<i32>::new();
- a.init();
- }
-
- #[test]
- #[should_panic]
- fn test_init_mut_empty() {
- let mut a = Vec::<i32>::new();
- a.init_mut();
- }
-
- #[test]
- fn test_last() {
- let mut a = vec![];
- assert_eq!(a.last(), None);
- a = vec![11];
- assert_eq!(a.last().unwrap(), &11);
- a = vec![11, 12];
- assert_eq!(a.last().unwrap(), &12);
- }
-
- #[test]
- fn test_last_mut() {
- let mut a = vec![];
- assert_eq!(a.last_mut(), None);
- a = vec![11];
- assert_eq!(*a.last_mut().unwrap(), 11);
- a = vec![11, 12];
- assert_eq!(*a.last_mut().unwrap(), 12);
- }
-
- #[test]
- fn test_slice() {
- // Test fixed length vector.
- let vec_fixed = [1, 2, 3, 4];
- let v_a = vec_fixed[1..vec_fixed.len()].to_vec();
- assert_eq!(v_a.len(), 3);
-
- assert_eq!(v_a[0], 2);
- assert_eq!(v_a[1], 3);
- assert_eq!(v_a[2], 4);
-
- // Test on stack.
- let vec_stack: &[_] = &[1, 2, 3];
- let v_b = vec_stack[1..3].to_vec();
- assert_eq!(v_b.len(), 2);
-
- assert_eq!(v_b[0], 2);
- assert_eq!(v_b[1], 3);
-
- // Test `Box<[T]>`
- let vec_unique = vec![1, 2, 3, 4, 5, 6];
- let v_d = vec_unique[1..6].to_vec();
- assert_eq!(v_d.len(), 5);
-
- assert_eq!(v_d[0], 2);
- assert_eq!(v_d[1], 3);
- assert_eq!(v_d[2], 4);
- assert_eq!(v_d[3], 5);
- assert_eq!(v_d[4], 6);
- }
-
- #[test]
- fn test_slice_from() {
- let vec: &[_] = &[1, 2, 3, 4];
- assert_eq!(&vec[..], vec);
- let b: &[_] = &[3, 4];
- assert_eq!(&vec[2..], b);
- let b: &[_] = &[];
- assert_eq!(&vec[4..], b);
- }
-
- #[test]
- fn test_slice_to() {
- let vec: &[_] = &[1, 2, 3, 4];
- assert_eq!(&vec[..4], vec);
- let b: &[_] = &[1, 2];
- assert_eq!(&vec[..2], b);
- let b: &[_] = &[];
- assert_eq!(&vec[..0], b);
- }
-
-
- #[test]
- fn test_pop() {
- let mut v = vec![5];
- let e = v.pop();
- assert_eq!(v.len(), 0);
- assert_eq!(e, Some(5));
- let f = v.pop();
- assert_eq!(f, None);
- let g = v.pop();
- assert_eq!(g, None);
- }
-
- #[test]
- fn test_swap_remove() {
- let mut v = vec![1, 2, 3, 4, 5];
- let mut e = v.swap_remove(0);
- assert_eq!(e, 1);
- assert_eq!(v, [5, 2, 3, 4]);
- e = v.swap_remove(3);
- assert_eq!(e, 4);
- assert_eq!(v, [5, 2, 3]);
- }
-
- #[test]
- #[should_panic]
- fn test_swap_remove_fail() {
- let mut v = vec![1];
- let _ = v.swap_remove(0);
- let _ = v.swap_remove(0);
- }
-
- #[test]
- fn test_swap_remove_noncopyable() {
- // Tests that we don't accidentally run destructors twice.
- let mut v: Vec<Box<_>> = Vec::new();
- v.push(box 0u8);
- v.push(box 0u8);
- v.push(box 0u8);
- let mut _e = v.swap_remove(0);
- assert_eq!(v.len(), 2);
- _e = v.swap_remove(1);
- assert_eq!(v.len(), 1);
- _e = v.swap_remove(0);
- assert_eq!(v.len(), 0);
- }
-
- #[test]
- fn test_push() {
- // Test on-stack push().
- let mut v = vec![];
- v.push(1);
- assert_eq!(v.len(), 1);
- assert_eq!(v[0], 1);
-
- // Test on-heap push().
- v.push(2);
- assert_eq!(v.len(), 2);
- assert_eq!(v[0], 1);
- assert_eq!(v[1], 2);
- }
-
- #[test]
- fn test_truncate() {
- let mut v: Vec<Box<_>> = vec![box 6,box 5,box 4];
- v.truncate(1);
- let v = v;
- assert_eq!(v.len(), 1);
- assert_eq!(*(v[0]), 6);
- // If the unsafe block didn't drop things properly, we blow up here.
- }
-
- #[test]
- fn test_clear() {
- let mut v: Vec<Box<_>> = vec![box 6,box 5,box 4];
- v.clear();
- assert_eq!(v.len(), 0);
- // If the unsafe block didn't drop things properly, we blow up here.
- }
-
- #[test]
- fn test_dedup() {
- fn case(a: Vec<i32>, b: Vec<i32>) {
- let mut v = a;
- v.dedup();
- assert_eq!(v, b);
- }
- case(vec![], vec![]);
- case(vec![1], vec![1]);
- case(vec![1,1], vec![1]);
- case(vec![1,2,3], vec![1,2,3]);
- case(vec![1,1,2,3], vec![1,2,3]);
- case(vec![1,2,2,3], vec![1,2,3]);
- case(vec![1,2,3,3], vec![1,2,3]);
- case(vec![1,1,2,2,2,3,3], vec![1,2,3]);
- }
-
- #[test]
- fn test_dedup_unique() {
- let mut v0: Vec<Box<_>> = vec![box 1, box 1, box 2, box 3];
- v0.dedup();
- let mut v1: Vec<Box<_>> = vec![box 1, box 2, box 2, box 3];
- v1.dedup();
- let mut v2: Vec<Box<_>> = vec![box 1, box 2, box 3, box 3];
- v2.dedup();
- /*
- * If the boxed pointers were leaked or otherwise misused, valgrind
- * and/or rt should raise errors.
- */
- }
-
- #[test]
- fn test_dedup_shared() {
- let mut v0: Vec<Box<_>> = vec![box 1, box 1, box 2, box 3];
- v0.dedup();
- let mut v1: Vec<Box<_>> = vec![box 1, box 2, box 2, box 3];
- v1.dedup();
- let mut v2: Vec<Box<_>> = vec![box 1, box 2, box 3, box 3];
- v2.dedup();
- /*
- * If the pointers were leaked or otherwise misused, valgrind and/or
- * rt should raise errors.
- */
- }
-
- #[test]
- fn test_retain() {
- let mut v = vec![1, 2, 3, 4, 5];
- v.retain(is_odd);
- assert_eq!(v, [1, 3, 5]);
- }
-
- #[test]
- fn test_element_swaps() {
- let mut v = [1, 2, 3];
- for (i, (a, b)) in ElementSwaps::new(v.len()).enumerate() {
- v.swap(a, b);
- match i {
- 0 => assert!(v == [1, 3, 2]),
- 1 => assert!(v == [3, 1, 2]),
- 2 => assert!(v == [3, 2, 1]),
- 3 => assert!(v == [2, 3, 1]),
- 4 => assert!(v == [2, 1, 3]),
- 5 => assert!(v == [1, 2, 3]),
- _ => panic!(),
- }
- }
- }
-
- #[test]
- fn test_permutations() {
- {
- let v: [i32; 0] = [];
- let mut it = v.permutations();
- let (min_size, max_opt) = it.size_hint();
- assert_eq!(min_size, 1);
- assert_eq!(max_opt.unwrap(), 1);
- assert_eq!(it.next(), Some(v.to_vec()));
- assert_eq!(it.next(), None);
- }
- {
- let v = ["Hello".to_string()];
- let mut it = v.permutations();
- let (min_size, max_opt) = it.size_hint();
- assert_eq!(min_size, 1);
- assert_eq!(max_opt.unwrap(), 1);
- assert_eq!(it.next(), Some(v.to_vec()));
- assert_eq!(it.next(), None);
- }
- {
- let v = [1, 2, 3];
- let mut it = v.permutations();
- let (min_size, max_opt) = it.size_hint();
- assert_eq!(min_size, 3*2);
- assert_eq!(max_opt.unwrap(), 3*2);
- assert_eq!(it.next(), Some(vec![1,2,3]));
- assert_eq!(it.next(), Some(vec![1,3,2]));
- assert_eq!(it.next(), Some(vec![3,1,2]));
- let (min_size, max_opt) = it.size_hint();
- assert_eq!(min_size, 3);
- assert_eq!(max_opt.unwrap(), 3);
- assert_eq!(it.next(), Some(vec![3,2,1]));
- assert_eq!(it.next(), Some(vec![2,3,1]));
- assert_eq!(it.next(), Some(vec![2,1,3]));
- assert_eq!(it.next(), None);
- }
- {
- // check that we have N! permutations
- let v = ['A', 'B', 'C', 'D', 'E', 'F'];
- let mut amt = 0;
- let mut it = v.permutations();
- let (min_size, max_opt) = it.size_hint();
- for _perm in it.by_ref() {
- amt += 1;
- }
- assert_eq!(amt, it.swaps.swaps_made);
- assert_eq!(amt, min_size);
- assert_eq!(amt, 2 * 3 * 4 * 5 * 6);
- assert_eq!(amt, max_opt.unwrap());
- }
- }
-
- #[test]
- fn test_lexicographic_permutations() {
- let v : &mut[_] = &mut[1, 2, 3, 4, 5];
- assert!(v.prev_permutation() == false);
- assert!(v.next_permutation());
- let b: &mut[_] = &mut[1, 2, 3, 5, 4];
- assert!(v == b);
- assert!(v.prev_permutation());
- let b: &mut[_] = &mut[1, 2, 3, 4, 5];
- assert!(v == b);
- assert!(v.next_permutation());
- assert!(v.next_permutation());
- let b: &mut[_] = &mut[1, 2, 4, 3, 5];
- assert!(v == b);
- assert!(v.next_permutation());
- let b: &mut[_] = &mut[1, 2, 4, 5, 3];
- assert!(v == b);
-
- let v : &mut[_] = &mut[1, 0, 0, 0];
- assert!(v.next_permutation() == false);
- assert!(v.prev_permutation());
- let b: &mut[_] = &mut[0, 1, 0, 0];
- assert!(v == b);
- assert!(v.prev_permutation());
- let b: &mut[_] = &mut[0, 0, 1, 0];
- assert!(v == b);
- assert!(v.prev_permutation());
- let b: &mut[_] = &mut[0, 0, 0, 1];
- assert!(v == b);
- assert!(v.prev_permutation() == false);
- }
-
- #[test]
- fn test_lexicographic_permutations_empty_and_short() {
- let empty : &mut[i32] = &mut[];
- assert!(empty.next_permutation() == false);
- let b: &mut[i32] = &mut[];
- assert!(empty == b);
- assert!(empty.prev_permutation() == false);
- assert!(empty == b);
-
- let one_elem : &mut[_] = &mut[4];
- assert!(one_elem.prev_permutation() == false);
- let b: &mut[_] = &mut[4];
- assert!(one_elem == b);
- assert!(one_elem.next_permutation() == false);
- assert!(one_elem == b);
-
- let two_elem : &mut[_] = &mut[1, 2];
- assert!(two_elem.prev_permutation() == false);
- let b : &mut[_] = &mut[1, 2];
- let c : &mut[_] = &mut[2, 1];
- assert!(two_elem == b);
- assert!(two_elem.next_permutation());
- assert!(two_elem == c);
- assert!(two_elem.next_permutation() == false);
- assert!(two_elem == c);
- assert!(two_elem.prev_permutation());
- assert!(two_elem == b);
- assert!(two_elem.prev_permutation() == false);
- assert!(two_elem == b);
- }
-
- #[test]
- fn test_position_elem() {
- assert!([].position_elem(&1).is_none());
-
- let v1 = vec![1, 2, 3, 3, 2, 5];
- assert_eq!(v1.position_elem(&1), Some(0));
- assert_eq!(v1.position_elem(&2), Some(1));
- assert_eq!(v1.position_elem(&5), Some(5));
- assert!(v1.position_elem(&4).is_none());
- }
-
- #[test]
- fn test_binary_search() {
- assert_eq!([1,2,3,4,5].binary_search(&5).ok(), Some(4));
- assert_eq!([1,2,3,4,5].binary_search(&4).ok(), Some(3));
- assert_eq!([1,2,3,4,5].binary_search(&3).ok(), Some(2));
- assert_eq!([1,2,3,4,5].binary_search(&2).ok(), Some(1));
- assert_eq!([1,2,3,4,5].binary_search(&1).ok(), Some(0));
-
- assert_eq!([2,4,6,8,10].binary_search(&1).ok(), None);
- assert_eq!([2,4,6,8,10].binary_search(&5).ok(), None);
- assert_eq!([2,4,6,8,10].binary_search(&4).ok(), Some(1));
- assert_eq!([2,4,6,8,10].binary_search(&10).ok(), Some(4));
-
- assert_eq!([2,4,6,8].binary_search(&1).ok(), None);
- assert_eq!([2,4,6,8].binary_search(&5).ok(), None);
- assert_eq!([2,4,6,8].binary_search(&4).ok(), Some(1));
- assert_eq!([2,4,6,8].binary_search(&8).ok(), Some(3));
-
- assert_eq!([2,4,6].binary_search(&1).ok(), None);
- assert_eq!([2,4,6].binary_search(&5).ok(), None);
- assert_eq!([2,4,6].binary_search(&4).ok(), Some(1));
- assert_eq!([2,4,6].binary_search(&6).ok(), Some(2));
-
- assert_eq!([2,4].binary_search(&1).ok(), None);
- assert_eq!([2,4].binary_search(&5).ok(), None);
- assert_eq!([2,4].binary_search(&2).ok(), Some(0));
- assert_eq!([2,4].binary_search(&4).ok(), Some(1));
-
- assert_eq!([2].binary_search(&1).ok(), None);
- assert_eq!([2].binary_search(&5).ok(), None);
- assert_eq!([2].binary_search(&2).ok(), Some(0));
-
- assert_eq!([].binary_search(&1).ok(), None);
- assert_eq!([].binary_search(&5).ok(), None);
-
- assert!([1,1,1,1,1].binary_search(&1).ok() != None);
- assert!([1,1,1,1,2].binary_search(&1).ok() != None);
- assert!([1,1,1,2,2].binary_search(&1).ok() != None);
- assert!([1,1,2,2,2].binary_search(&1).ok() != None);
- assert_eq!([1,2,2,2,2].binary_search(&1).ok(), Some(0));
-
- assert_eq!([1,2,3,4,5].binary_search(&6).ok(), None);
- assert_eq!([1,2,3,4,5].binary_search(&0).ok(), None);
- }
-
- #[test]
- fn test_reverse() {
- let mut v = vec![10, 20];
- assert_eq!(v[0], 10);
- assert_eq!(v[1], 20);
- v.reverse();
- assert_eq!(v[0], 20);
- assert_eq!(v[1], 10);
-
- let mut v3 = Vec::<i32>::new();
- v3.reverse();
- assert!(v3.is_empty());
- }
-
- #[test]
- fn test_sort() {
- for len in 4..25 {
- for _ in 0..100 {
- let mut v: Vec<_> = thread_rng().gen_iter::<i32>().take(len).collect();
- let mut v1 = v.clone();
-
- v.sort();
- assert!(v.windows(2).all(|w| w[0] <= w[1]));
-
- v1.sort_by(|a, b| a.cmp(b));
- assert!(v1.windows(2).all(|w| w[0] <= w[1]));
-
- v1.sort_by(|a, b| b.cmp(a));
- assert!(v1.windows(2).all(|w| w[0] >= w[1]));
- }
- }
-
- // shouldn't panic
- let mut v: [i32; 0] = [];
- v.sort();
-
- let mut v = [0xDEADBEEFu64];
- v.sort();
- assert!(v == [0xDEADBEEF]);
- }
-
- #[test]
- fn test_sort_stability() {
- for len in 4..25 {
- for _ in 0..10 {
- let mut counts = [0; 10];
-
- // create a vector like [(6, 1), (5, 1), (6, 2), ...],
- // where the first item of each tuple is random, but
- // the second item represents which occurrence of that
- // number this element is, i.e. the second elements
- // will occur in sorted order.
- let mut v: Vec<_> = (0..len).map(|_| {
- let n = thread_rng().gen::<usize>() % 10;
- counts[n] += 1;
- (n, counts[n])
- }).collect();
-
- // only sort on the first element, so an unstable sort
- // may mix up the counts.
- v.sort_by(|&(a,_), &(b,_)| a.cmp(&b));
-
- // this comparison includes the count (the second item
- // of the tuple), so elements with equal first items
- // will need to be ordered with increasing
- // counts... i.e. exactly asserting that this sort is
- // stable.
- assert!(v.windows(2).all(|w| w[0] <= w[1]));
- }
- }
- }
-
- #[test]
- fn test_concat() {
- let v: [Vec<i32>; 0] = [];
- let c = v.concat();
- assert_eq!(c, []);
- let d = [vec![1], vec![2, 3]].concat();
- assert_eq!(d, [1, 2, 3]);
-
- let v: &[&[_]] = &[&[1], &[2, 3]];
- assert_eq!(v.connect(&0), [1, 0, 2, 3]);
- let v: &[&[_]] = &[&[1], &[2], &[3]];
- assert_eq!(v.connect(&0), [1, 0, 2, 0, 3]);
- }
-
- #[test]
- fn test_connect() {
- let v: [Vec<i32>; 0] = [];
- assert_eq!(v.connect(&0), []);
- assert_eq!([vec![1], vec![2, 3]].connect(&0), [1, 0, 2, 3]);
- assert_eq!([vec![1], vec![2], vec![3]].connect(&0), [1, 0, 2, 0, 3]);
-
- let v: [&[_]; 2] = [&[1], &[2, 3]];
- assert_eq!(v.connect(&0), [1, 0, 2, 3]);
- let v: [&[_]; 3] = [&[1], &[2], &[3]];
- assert_eq!(v.connect(&0), [1, 0, 2, 0, 3]);
- }
-
- #[test]
- fn test_insert() {
- let mut a = vec![1, 2, 4];
- a.insert(2, 3);
- assert_eq!(a, [1, 2, 3, 4]);
-
- let mut a = vec![1, 2, 3];
- a.insert(0, 0);
- assert_eq!(a, [0, 1, 2, 3]);
-
- let mut a = vec![1, 2, 3];
- a.insert(3, 4);
- assert_eq!(a, [1, 2, 3, 4]);
-
- let mut a = vec![];
- a.insert(0, 1);
- assert_eq!(a, [1]);
- }
-
- #[test]
- #[should_panic]
- fn test_insert_oob() {
- let mut a = vec![1, 2, 3];
- a.insert(4, 5);
- }
-
- #[test]
- fn test_remove() {
- let mut a = vec![1, 2, 3, 4];
-
- assert_eq!(a.remove(2), 3);
- assert_eq!(a, [1, 2, 4]);
-
- assert_eq!(a.remove(2), 4);
- assert_eq!(a, [1, 2]);
-
- assert_eq!(a.remove(0), 1);
- assert_eq!(a, [2]);
-
- assert_eq!(a.remove(0), 2);
- assert_eq!(a, []);
- }
-
- #[test]
- #[should_panic]
- fn test_remove_fail() {
- let mut a = vec![1];
- let _ = a.remove(0);
- let _ = a.remove(0);
- }
-
- #[test]
- fn test_capacity() {
- let mut v = vec![0];
- v.reserve_exact(10);
- assert!(v.capacity() >= 11);
- }
-
- #[test]
- fn test_slice_2() {
- let v = vec![1, 2, 3, 4, 5];
- let v = v.slice(1, 3);
- assert_eq!(v.len(), 2);
- assert_eq!(v[0], 2);
- assert_eq!(v[1], 3);
- }
-
- #[test]
- #[should_panic]
- fn test_permute_fail() {
- let v: [(Box<_>, Rc<_>); 4] =
- [(box 0, Rc::new(0)), (box 0, Rc::new(0)),
- (box 0, Rc::new(0)), (box 0, Rc::new(0))];
- let mut i = 0;
- for _ in v.permutations() {
- if i == 2 {
- panic!()
- }
- i += 1;
- }
- }
-
- #[test]
- fn test_total_ord() {
- let c = &[1, 2, 3];
- [1, 2, 3, 4][..].cmp(c) == Greater;
- let c = &[1, 2, 3, 4];
- [1, 2, 3][..].cmp(c) == Less;
- let c = &[1, 2, 3, 6];
- [1, 2, 3, 4][..].cmp(c) == Equal;
- let c = &[1, 2, 3, 4, 5, 6];
- [1, 2, 3, 4, 5, 5, 5, 5][..].cmp(c) == Less;
- let c = &[1, 2, 3, 4];
- [2, 2][..].cmp(c) == Greater;
- }
-
- #[test]
- fn test_iterator() {
- let xs = [1, 2, 5, 10, 11];
- let mut it = xs.iter();
- assert_eq!(it.size_hint(), (5, Some(5)));
- assert_eq!(it.next().unwrap(), &1);
- assert_eq!(it.size_hint(), (4, Some(4)));
- assert_eq!(it.next().unwrap(), &2);
- assert_eq!(it.size_hint(), (3, Some(3)));
- assert_eq!(it.next().unwrap(), &5);
- assert_eq!(it.size_hint(), (2, Some(2)));
- assert_eq!(it.next().unwrap(), &10);
- assert_eq!(it.size_hint(), (1, Some(1)));
- assert_eq!(it.next().unwrap(), &11);
- assert_eq!(it.size_hint(), (0, Some(0)));
- assert!(it.next().is_none());
- }
-
- #[test]
- fn test_random_access_iterator() {
- let xs = [1, 2, 5, 10, 11];
- let mut it = xs.iter();
-
- assert_eq!(it.indexable(), 5);
- assert_eq!(it.idx(0).unwrap(), &1);
- assert_eq!(it.idx(2).unwrap(), &5);
- assert_eq!(it.idx(4).unwrap(), &11);
- assert!(it.idx(5).is_none());
-
- assert_eq!(it.next().unwrap(), &1);
- assert_eq!(it.indexable(), 4);
- assert_eq!(it.idx(0).unwrap(), &2);
- assert_eq!(it.idx(3).unwrap(), &11);
- assert!(it.idx(4).is_none());
-
- assert_eq!(it.next().unwrap(), &2);
- assert_eq!(it.indexable(), 3);
- assert_eq!(it.idx(1).unwrap(), &10);
- assert!(it.idx(3).is_none());
-
- assert_eq!(it.next().unwrap(), &5);
- assert_eq!(it.indexable(), 2);
- assert_eq!(it.idx(1).unwrap(), &11);
-
- assert_eq!(it.next().unwrap(), &10);
- assert_eq!(it.indexable(), 1);
- assert_eq!(it.idx(0).unwrap(), &11);
- assert!(it.idx(1).is_none());
-
- assert_eq!(it.next().unwrap(), &11);
- assert_eq!(it.indexable(), 0);
- assert!(it.idx(0).is_none());
-
- assert!(it.next().is_none());
- }
-
- #[test]
- fn test_iter_size_hints() {
- let mut xs = [1, 2, 5, 10, 11];
- assert_eq!(xs.iter().size_hint(), (5, Some(5)));
- assert_eq!(xs.iter_mut().size_hint(), (5, Some(5)));
- }
-
- #[test]
- fn test_iter_clone() {
- let xs = [1, 2, 5];
- let mut it = xs.iter();
- it.next();
- let mut jt = it.clone();
- assert_eq!(it.next(), jt.next());
- assert_eq!(it.next(), jt.next());
- assert_eq!(it.next(), jt.next());
- }
-
- #[test]
- fn test_mut_iterator() {
- let mut xs = [1, 2, 3, 4, 5];
- for x in &mut xs {
- *x += 1;
- }
- assert!(xs == [2, 3, 4, 5, 6])
- }
-
- #[test]
- fn test_rev_iterator() {
-
- let xs = [1, 2, 5, 10, 11];
- let ys = [11, 10, 5, 2, 1];
- let mut i = 0;
- for &x in xs.iter().rev() {
- assert_eq!(x, ys[i]);
- i += 1;
- }
- assert_eq!(i, 5);
- }
-
- #[test]
- fn test_mut_rev_iterator() {
- let mut xs = [1, 2, 3, 4, 5];
- for (i,x) in xs.iter_mut().rev().enumerate() {
- *x += i;
- }
- assert!(xs == [5, 5, 5, 5, 5])
- }
-
- #[test]
- fn test_move_iterator() {
- let xs = vec![1,2,3,4,5];
- assert_eq!(xs.into_iter().fold(0, |a: usize, b: usize| 10*a + b), 12345);
- }
-
- #[test]
- fn test_move_rev_iterator() {
- let xs = vec![1,2,3,4,5];
- assert_eq!(xs.into_iter().rev().fold(0, |a: usize, b: usize| 10*a + b), 54321);
- }
-
- #[test]
- fn test_splitator() {
- let xs = &[1,2,3,4,5];
-
- let splits: &[&[_]] = &[&[1], &[3], &[5]];
- assert_eq!(xs.split(|x| *x % 2 == 0).collect::<Vec<_>>(),
- splits);
- let splits: &[&[_]] = &[&[], &[2,3,4,5]];
- assert_eq!(xs.split(|x| *x == 1).collect::<Vec<_>>(),
- splits);
- let splits: &[&[_]] = &[&[1,2,3,4], &[]];
- assert_eq!(xs.split(|x| *x == 5).collect::<Vec<_>>(),
- splits);
- let splits: &[&[_]] = &[&[1,2,3,4,5]];
- assert_eq!(xs.split(|x| *x == 10).collect::<Vec<_>>(),
- splits);
- let splits: &[&[_]] = &[&[], &[], &[], &[], &[], &[]];
- assert_eq!(xs.split(|_| true).collect::<Vec<&[i32]>>(),
- splits);
-
- let xs: &[i32] = &[];
- let splits: &[&[i32]] = &[&[]];
- assert_eq!(xs.split(|x| *x == 5).collect::<Vec<&[i32]>>(), splits);
- }
-
- #[test]
- fn test_splitnator() {
- let xs = &[1,2,3,4,5];
-
- let splits: &[&[_]] = &[&[1,2,3,4,5]];
- assert_eq!(xs.splitn(0, |x| *x % 2 == 0).collect::<Vec<_>>(),
- splits);
- let splits: &[&[_]] = &[&[1], &[3,4,5]];
- assert_eq!(xs.splitn(1, |x| *x % 2 == 0).collect::<Vec<_>>(),
- splits);
- let splits: &[&[_]] = &[&[], &[], &[], &[4,5]];
- assert_eq!(xs.splitn(3, |_| true).collect::<Vec<_>>(),
- splits);
-
- let xs: &[i32] = &[];
- let splits: &[&[i32]] = &[&[]];
- assert_eq!(xs.splitn(1, |x| *x == 5).collect::<Vec<_>>(), splits);
- }
-
- #[test]
- fn test_splitnator_mut() {
- let xs = &mut [1,2,3,4,5];
-
- let splits: &[&mut[_]] = &[&mut [1,2,3,4,5]];
- assert_eq!(xs.splitn_mut(0, |x| *x % 2 == 0).collect::<Vec<_>>(),
- splits);
- let splits: &[&mut[_]] = &[&mut [1], &mut [3,4,5]];
- assert_eq!(xs.splitn_mut(1, |x| *x % 2 == 0).collect::<Vec<_>>(),
- splits);
- let splits: &[&mut[_]] = &[&mut [], &mut [], &mut [], &mut [4,5]];
- assert_eq!(xs.splitn_mut(3, |_| true).collect::<Vec<_>>(),
- splits);
-
- let xs: &mut [i32] = &mut [];
- let splits: &[&mut[i32]] = &[&mut []];
- assert_eq!(xs.splitn_mut(1, |x| *x == 5).collect::<Vec<_>>(),
- splits);
- }
-
- #[test]
- fn test_rsplitator() {
- let xs = &[1,2,3,4,5];
-
- let splits: &[&[_]] = &[&[5], &[3], &[1]];
- assert_eq!(xs.split(|x| *x % 2 == 0).rev().collect::<Vec<_>>(),
- splits);
- let splits: &[&[_]] = &[&[2,3,4,5], &[]];
- assert_eq!(xs.split(|x| *x == 1).rev().collect::<Vec<_>>(),
- splits);
- let splits: &[&[_]] = &[&[], &[1,2,3,4]];
- assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<_>>(),
- splits);
- let splits: &[&[_]] = &[&[1,2,3,4,5]];
- assert_eq!(xs.split(|x| *x == 10).rev().collect::<Vec<_>>(),
- splits);
-
- let xs: &[i32] = &[];
- let splits: &[&[i32]] = &[&[]];
- assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<&[i32]>>(), splits);
- }
-
- #[test]
- fn test_rsplitnator() {
- let xs = &[1,2,3,4,5];
-
- let splits: &[&[_]] = &[&[1,2,3,4,5]];
- assert_eq!(xs.rsplitn(0, |x| *x % 2 == 0).collect::<Vec<_>>(),
- splits);
- let splits: &[&[_]] = &[&[5], &[1,2,3]];
- assert_eq!(xs.rsplitn(1, |x| *x % 2 == 0).collect::<Vec<_>>(),
- splits);
- let splits: &[&[_]] = &[&[], &[], &[], &[1,2]];
- assert_eq!(xs.rsplitn(3, |_| true).collect::<Vec<_>>(),
- splits);
-
- let xs: &[i32] = &[];
- let splits: &[&[i32]] = &[&[]];
- assert_eq!(xs.rsplitn(1, |x| *x == 5).collect::<Vec<&[i32]>>(), splits);
- }
-
- #[test]
- fn test_windowsator() {
- let v = &[1,2,3,4];
-
- let wins: &[&[_]] = &[&[1,2], &[2,3], &[3,4]];
- assert_eq!(v.windows(2).collect::<Vec<_>>(), wins);
-
- let wins: &[&[_]] = &[&[1,2,3], &[2,3,4]];
- assert_eq!(v.windows(3).collect::<Vec<_>>(), wins);
- assert!(v.windows(6).next().is_none());
-
- let wins: &[&[_]] = &[&[3,4], &[2,3], &[1,2]];
- assert_eq!(v.windows(2).rev().collect::<Vec<&[_]>>(), wins);
- let mut it = v.windows(2);
- assert_eq!(it.indexable(), 3);
- let win: &[_] = &[1,2];
- assert_eq!(it.idx(0).unwrap(), win);
- let win: &[_] = &[2,3];
- assert_eq!(it.idx(1).unwrap(), win);
- let win: &[_] = &[3,4];
- assert_eq!(it.idx(2).unwrap(), win);
- assert_eq!(it.idx(3), None);
- }
-
- #[test]
- #[should_panic]
- fn test_windowsator_0() {
- let v = &[1,2,3,4];
- let _it = v.windows(0);
- }
-
- #[test]
- fn test_chunksator() {
- use core::iter::ExactSizeIterator;
-
- let v = &[1,2,3,4,5];
-
- assert_eq!(v.chunks(2).len(), 3);
-
- let chunks: &[&[_]] = &[&[1,2], &[3,4], &[5]];
- assert_eq!(v.chunks(2).collect::<Vec<_>>(), chunks);
- let chunks: &[&[_]] = &[&[1,2,3], &[4,5]];
- assert_eq!(v.chunks(3).collect::<Vec<_>>(), chunks);
- let chunks: &[&[_]] = &[&[1,2,3,4,5]];
- assert_eq!(v.chunks(6).collect::<Vec<_>>(), chunks);
-
- let chunks: &[&[_]] = &[&[5], &[3,4], &[1,2]];
- assert_eq!(v.chunks(2).rev().collect::<Vec<_>>(), chunks);
- let mut it = v.chunks(2);
- assert_eq!(it.indexable(), 3);
-
- let chunk: &[_] = &[1,2];
- assert_eq!(it.idx(0).unwrap(), chunk);
- let chunk: &[_] = &[3,4];
- assert_eq!(it.idx(1).unwrap(), chunk);
- let chunk: &[_] = &[5];
- assert_eq!(it.idx(2).unwrap(), chunk);
- assert_eq!(it.idx(3), None);
- }
-
- #[test]
- #[should_panic]
- fn test_chunksator_0() {
- let v = &[1,2,3,4];
- let _it = v.chunks(0);
- }
-
- #[test]
- fn test_move_from() {
- let mut a = [1,2,3,4,5];
- let b = vec![6,7,8];
- assert_eq!(a.move_from(b, 0, 3), 3);
- assert!(a == [6,7,8,4,5]);
- let mut a = [7,2,8,1];
- let b = vec![3,1,4,1,5,9];
- assert_eq!(a.move_from(b, 0, 6), 4);
- assert!(a == [3,1,4,1]);
- let mut a = [1,2,3,4];
- let b = vec![5,6,7,8,9,0];
- assert_eq!(a.move_from(b, 2, 3), 1);
- assert!(a == [7,2,3,4]);
- let mut a = [1,2,3,4,5];
- let b = vec![5,6,7,8,9,0];
- assert_eq!(a[2..4].move_from(b,1,6), 2);
- assert!(a == [1,2,6,7,5]);
- }
-
- #[test]
- fn test_reverse_part() {
- let mut values = [1,2,3,4,5];
- values[1..4].reverse();
- assert!(values == [1,4,3,2,5]);
- }
-
- #[test]
- fn test_show() {
- macro_rules! test_show_vec {
- ($x:expr, $x_str:expr) => ({
- let (x, x_str) = ($x, $x_str);
- assert_eq!(format!("{:?}", x), x_str);
- assert_eq!(format!("{:?}", x), x_str);
- })
- }
- let empty = Vec::<i32>::new();
- test_show_vec!(empty, "[]");
- test_show_vec!(vec![1], "[1]");
- test_show_vec!(vec![1, 2, 3], "[1, 2, 3]");
- test_show_vec!(vec![vec![], vec![1], vec![1, 1]],
- "[[], [1], [1, 1]]");
-
- let empty_mut: &mut [i32] = &mut[];
- test_show_vec!(empty_mut, "[]");
- let v = &mut[1];
- test_show_vec!(v, "[1]");
- let v = &mut[1, 2, 3];
- test_show_vec!(v, "[1, 2, 3]");
- let v: &mut[&mut[_]] = &mut[&mut[], &mut[1], &mut[1, 1]];
- test_show_vec!(v, "[[], [1], [1, 1]]");
- }
-
- #[test]
- fn test_vec_default() {
- macro_rules! t {
- ($ty:ty) => {{
- let v: $ty = Default::default();
- assert!(v.is_empty());
- }}
- }
-
- t!(&[i32]);
- t!(Vec<i32>);
- }
-
- #[test]
- fn test_bytes_set_memory() {
- use slice::bytes::MutableByteVector;
- let mut values = [1,2,3,4,5];
- values[0..5].set_memory(0xAB);
- assert!(values == [0xAB, 0xAB, 0xAB, 0xAB, 0xAB]);
- values[2..4].set_memory(0xFF);
- assert!(values == [0xAB, 0xAB, 0xFF, 0xFF, 0xAB]);
- }
-
- #[test]
- #[should_panic]
- fn test_overflow_does_not_cause_segfault() {
- let mut v = vec![];
- v.reserve_exact(-1);
- v.push(1);
- v.push(2);
- }
-
- #[test]
- #[should_panic]
- fn test_overflow_does_not_cause_segfault_managed() {
- let mut v = vec![Rc::new(1)];
- v.reserve_exact(-1);
- v.push(Rc::new(2));
- }
-
- #[test]
- fn test_mut_split_at() {
- let mut values = [1u8,2,3,4,5];
- {
- let (left, right) = values.split_at_mut(2);
- {
- let left: &[_] = left;
- assert!(left[..left.len()] == [1, 2]);
- }
- for p in left {
- *p += 1;
- }
-
- {
- let right: &[_] = right;
- assert!(right[..right.len()] == [3, 4, 5]);
- }
- for p in right {
- *p += 2;
- }
- }
-
- assert!(values == [2, 3, 5, 6, 7]);
- }
-
- #[derive(Clone, PartialEq)]
- struct Foo;
-
- #[test]
- fn test_iter_zero_sized() {
- let mut v = vec![Foo, Foo, Foo];
- assert_eq!(v.len(), 3);
- let mut cnt = 0;
-
- for f in &v {
- assert!(*f == Foo);
- cnt += 1;
- }
- assert_eq!(cnt, 3);
-
- for f in &v[1..3] {
- assert!(*f == Foo);
- cnt += 1;
- }
- assert_eq!(cnt, 5);
-
- for f in &mut v {
- assert!(*f == Foo);
- cnt += 1;
- }
- assert_eq!(cnt, 8);
-
- for f in v {
- assert!(f == Foo);
- cnt += 1;
- }
- assert_eq!(cnt, 11);
-
- let xs: [Foo; 3] = [Foo, Foo, Foo];
- cnt = 0;
- for f in &xs {
- assert!(*f == Foo);
- cnt += 1;
- }
- assert!(cnt == 3);
- }
-
- #[test]
- fn test_shrink_to_fit() {
- let mut xs = vec![0, 1, 2, 3];
- for i in 4..100 {
- xs.push(i)
- }
- assert_eq!(xs.capacity(), 128);
- xs.shrink_to_fit();
- assert_eq!(xs.capacity(), 100);
- assert_eq!(xs, (0..100).collect::<Vec<_>>());
- }
-
- #[test]
- fn test_starts_with() {
- assert!(b"foobar".starts_with(b"foo"));
- assert!(!b"foobar".starts_with(b"oob"));
- assert!(!b"foobar".starts_with(b"bar"));
- assert!(!b"foo".starts_with(b"foobar"));
- assert!(!b"bar".starts_with(b"foobar"));
- assert!(b"foobar".starts_with(b"foobar"));
- let empty: &[u8] = &[];
- assert!(empty.starts_with(empty));
- assert!(!empty.starts_with(b"foo"));
- assert!(b"foobar".starts_with(empty));
- }
-
- #[test]
- fn test_ends_with() {
- assert!(b"foobar".ends_with(b"bar"));
- assert!(!b"foobar".ends_with(b"oba"));
- assert!(!b"foobar".ends_with(b"foo"));
- assert!(!b"foo".ends_with(b"foobar"));
- assert!(!b"bar".ends_with(b"foobar"));
- assert!(b"foobar".ends_with(b"foobar"));
- let empty: &[u8] = &[];
- assert!(empty.ends_with(empty));
- assert!(!empty.ends_with(b"foo"));
- assert!(b"foobar".ends_with(empty));
- }
-
- #[test]
- fn test_mut_splitator() {
- let mut xs = [0,1,0,2,3,0,0,4,5,0];
- assert_eq!(xs.split_mut(|x| *x == 0).count(), 6);
- for slice in xs.split_mut(|x| *x == 0) {
- slice.reverse();
- }
- assert!(xs == [0,1,0,3,2,0,0,5,4,0]);
-
- let mut xs = [0,1,0,2,3,0,0,4,5,0,6,7];
- for slice in xs.split_mut(|x| *x == 0).take(5) {
- slice.reverse();
- }
- assert!(xs == [0,1,0,3,2,0,0,5,4,0,6,7]);
- }
-
- #[test]
- fn test_mut_splitator_rev() {
- let mut xs = [1,2,0,3,4,0,0,5,6,0];
- for slice in xs.split_mut(|x| *x == 0).rev().take(4) {
- slice.reverse();
- }
- assert!(xs == [1,2,0,4,3,0,0,6,5,0]);
- }
-
- #[test]
- fn test_get_mut() {
- let mut v = [0,1,2];
- assert_eq!(v.get_mut(3), None);
- v.get_mut(1).map(|e| *e = 7);
- assert_eq!(v[1], 7);
- let mut x = 2;
- assert_eq!(v.get_mut(2), Some(&mut x));
- }
-
- #[test]
- fn test_mut_chunks() {
- use core::iter::ExactSizeIterator;
-
- let mut v = [0, 1, 2, 3, 4, 5, 6];
- assert_eq!(v.chunks_mut(2).len(), 4);
- for (i, chunk) in v.chunks_mut(3).enumerate() {
- for x in chunk {
- *x = i as u8;
- }
- }
- let result = [0, 0, 0, 1, 1, 1, 2];
- assert!(v == result);
- }
-
- #[test]
- fn test_mut_chunks_rev() {
- let mut v = [0, 1, 2, 3, 4, 5, 6];
- for (i, chunk) in v.chunks_mut(3).rev().enumerate() {
- for x in chunk {
- *x = i as u8;
- }
- }
- let result = [2, 2, 2, 1, 1, 1, 0];
- assert!(v == result);
- }
-
- #[test]
- #[should_panic]
- fn test_mut_chunks_0() {
- let mut v = [1, 2, 3, 4];
- let _it = v.chunks_mut(0);
- }
-
- #[test]
- fn test_mut_last() {
- let mut x = [1, 2, 3, 4, 5];
- let h = x.last_mut();
- assert_eq!(*h.unwrap(), 5);
-
- let y: &mut [i32] = &mut [];
- assert!(y.last_mut().is_none());
- }
-
- #[test]
- fn test_to_vec() {
- let xs: Box<_> = box [1, 2, 3];
- let ys = xs.to_vec();
- assert_eq!(ys, [1, 2, 3]);
- }
-}
-
-#[cfg(test)]
-mod bench {
- use prelude::*;
- use core::mem;
- use core::ptr;
- use core::iter::repeat;
- use std::rand::{weak_rng, Rng};
- use test::{Bencher, black_box};
-
- #[bench]
- fn iterator(b: &mut Bencher) {
- // peculiar numbers to stop LLVM from optimising the summation
- // out.
- let v: Vec<_> = (0..100).map(|i| i ^ (i << 1) ^ (i >> 1)).collect();
-
- b.iter(|| {
- let mut sum = 0;
- for x in &v {
- sum += *x;
- }
- // sum == 11806, to stop dead code elimination.
- if sum == 0 {panic!()}
- })
- }
-
- #[bench]
- fn mut_iterator(b: &mut Bencher) {
- let mut v: Vec<_> = repeat(0).take(100).collect();
-
- b.iter(|| {
- let mut i = 0;
- for x in &mut v {
- *x = i;
- i += 1;
- }
- })
- }
-
- #[bench]
- fn concat(b: &mut Bencher) {
- let xss: Vec<Vec<i32>> =
- (0..100).map(|i| (0..i).collect()).collect();
- b.iter(|| {
- xss.concat();
- });
- }
-
- #[bench]
- fn connect(b: &mut Bencher) {
- let xss: Vec<Vec<i32>> =
- (0..100).map(|i| (0..i).collect()).collect();
- b.iter(|| {
- xss.connect(&0)
- });
- }
-
- #[bench]
- fn push(b: &mut Bencher) {
- let mut vec = Vec::<i32>::new();
- b.iter(|| {
- vec.push(0);
- black_box(&vec);
- });
- }
-
- #[bench]
- fn starts_with_same_vector(b: &mut Bencher) {
- let vec: Vec<_> = (0..100).collect();
- b.iter(|| {
- vec.starts_with(&vec)
- })
- }
-
- #[bench]
- fn starts_with_single_element(b: &mut Bencher) {
- let vec: Vec<_> = vec![0];
- b.iter(|| {
- vec.starts_with(&vec)
- })
- }
-
- #[bench]
- fn starts_with_diff_one_element_at_end(b: &mut Bencher) {
- let vec: Vec<_> = (0..100).collect();
- let mut match_vec: Vec<_> = (0..99).collect();
- match_vec.push(0);
- b.iter(|| {
- vec.starts_with(&match_vec)
- })
- }
-
- #[bench]
- fn ends_with_same_vector(b: &mut Bencher) {
- let vec: Vec<_> = (0..100).collect();
- b.iter(|| {
- vec.ends_with(&vec)
- })
- }
-
- #[bench]
- fn ends_with_single_element(b: &mut Bencher) {
- let vec: Vec<_> = vec![0];
- b.iter(|| {
- vec.ends_with(&vec)
- })
- }
-
- #[bench]
- fn ends_with_diff_one_element_at_beginning(b: &mut Bencher) {
- let vec: Vec<_> = (0..100).collect();
- let mut match_vec: Vec<_> = (0..100).collect();
- match_vec[0] = 200;
- b.iter(|| {
- vec.starts_with(&match_vec)
- })
- }
-
- #[bench]
- fn contains_last_element(b: &mut Bencher) {
- let vec: Vec<_> = (0..100).collect();
- b.iter(|| {
- vec.contains(&99)
- })
- }
-
- #[bench]
- fn zero_1kb_from_elem(b: &mut Bencher) {
- b.iter(|| {
- repeat(0u8).take(1024).collect::<Vec<_>>()
- });
- }
-
- #[bench]
- fn zero_1kb_set_memory(b: &mut Bencher) {
- b.iter(|| {
- let mut v = Vec::<u8>::with_capacity(1024);
- unsafe {
- let vp = v.as_mut_ptr();
- ptr::set_memory(vp, 0, 1024);
- v.set_len(1024);
- }
- v
- });
- }
-
- #[bench]
- fn zero_1kb_loop_set(b: &mut Bencher) {
- b.iter(|| {
- let mut v = Vec::<u8>::with_capacity(1024);
- unsafe {
- v.set_len(1024);
- }
- for i in 0..1024 {
- v[i] = 0;
- }
- });
- }
-
- #[bench]
- fn zero_1kb_mut_iter(b: &mut Bencher) {
- b.iter(|| {
- let mut v = Vec::<u8>::with_capacity(1024);
- unsafe {
- v.set_len(1024);
- }
- for x in &mut v {
- *x = 0;
- }
- v
- });
- }
-
- #[bench]
- fn random_inserts(b: &mut Bencher) {
- let mut rng = weak_rng();
- b.iter(|| {
- let mut v: Vec<_> = repeat((0, 0)).take(30).collect();
- for _ in 0..100 {
- let l = v.len();
- v.insert(rng.gen::<usize>() % (l + 1),
- (1, 1));
- }
- })
- }
- #[bench]
- fn random_removes(b: &mut Bencher) {
- let mut rng = weak_rng();
- b.iter(|| {
- let mut v: Vec<_> = repeat((0, 0)).take(130).collect();
- for _ in 0..100 {
- let l = v.len();
- v.remove(rng.gen::<usize>() % l);
- }
- })
- }
-
- #[bench]
- fn sort_random_small(b: &mut Bencher) {
- let mut rng = weak_rng();
- b.iter(|| {
- let mut v: Vec<_> = rng.gen_iter::<u64>().take(5).collect();
- v.sort();
- });
- b.bytes = 5 * mem::size_of::<u64>() as u64;
- }
-
- #[bench]
- fn sort_random_medium(b: &mut Bencher) {
- let mut rng = weak_rng();
- b.iter(|| {
- let mut v: Vec<_> = rng.gen_iter::<u64>().take(100).collect();
- v.sort();
- });
- b.bytes = 100 * mem::size_of::<u64>() as u64;
- }
-
- #[bench]
- fn sort_random_large(b: &mut Bencher) {
- let mut rng = weak_rng();
- b.iter(|| {
- let mut v: Vec<_> = rng.gen_iter::<u64>().take(10000).collect();
- v.sort();
- });
- b.bytes = 10000 * mem::size_of::<u64>() as u64;
- }
-
- #[bench]
- fn sort_sorted(b: &mut Bencher) {
- let mut v: Vec<_> = (0..10000).collect();
- b.iter(|| {
- v.sort();
- });
- b.bytes = (v.len() * mem::size_of_val(&v[0])) as u64;
- }
-
- type BigSortable = (u64, u64, u64, u64);
-
- #[bench]
- fn sort_big_random_small(b: &mut Bencher) {
- let mut rng = weak_rng();
- b.iter(|| {
- let mut v = rng.gen_iter::<BigSortable>().take(5)
- .collect::<Vec<BigSortable>>();
- v.sort();
- });
- b.bytes = 5 * mem::size_of::<BigSortable>() as u64;
- }
-
- #[bench]
- fn sort_big_random_medium(b: &mut Bencher) {
- let mut rng = weak_rng();
- b.iter(|| {
- let mut v = rng.gen_iter::<BigSortable>().take(100)
- .collect::<Vec<BigSortable>>();
- v.sort();
- });
- b.bytes = 100 * mem::size_of::<BigSortable>() as u64;
- }
-
- #[bench]
- fn sort_big_random_large(b: &mut Bencher) {
- let mut rng = weak_rng();
- b.iter(|| {
- let mut v = rng.gen_iter::<BigSortable>().take(10000)
- .collect::<Vec<BigSortable>>();
- v.sort();
- });
- b.bytes = 10000 * mem::size_of::<BigSortable>() as u64;
- }
-
- #[bench]
- fn sort_big_sorted(b: &mut Bencher) {
- let mut v: Vec<BigSortable> = (0..10000).map(|i| (i, i, i, i)).collect();
- b.iter(|| {
- v.sort();
- });
- b.bytes = (v.len() * mem::size_of_val(&v[0])) as u64;
- }
-}
return s;
}
}
-
-#[cfg(test)]
-mod tests {
- use prelude::*;
-
- use core::iter::AdditiveIterator;
- use super::from_utf8;
- use super::Utf8Error;
-
- #[test]
- fn test_le() {
- assert!("" <= "");
- assert!("" <= "foo");
- assert!("foo" <= "foo");
- assert!("foo" != "bar");
- }
-
- #[test]
- fn test_len() {
- assert_eq!("".len(), 0);
- assert_eq!("hello world".len(), 11);
- assert_eq!("\x63".len(), 1);
- assert_eq!("\u{a2}".len(), 2);
- assert_eq!("\u{3c0}".len(), 2);
- assert_eq!("\u{2620}".len(), 3);
- assert_eq!("\u{1d11e}".len(), 4);
-
- assert_eq!("".chars().count(), 0);
- assert_eq!("hello world".chars().count(), 11);
- assert_eq!("\x63".chars().count(), 1);
- assert_eq!("\u{a2}".chars().count(), 1);
- assert_eq!("\u{3c0}".chars().count(), 1);
- assert_eq!("\u{2620}".chars().count(), 1);
- assert_eq!("\u{1d11e}".chars().count(), 1);
- assert_eq!("ประเทศไทย中华Việt Nam".chars().count(), 19);
-
- assert_eq!("ｈｅｌｌｏ".width(false), 10);
- assert_eq!("ｈｅｌｌｏ".width(true), 10);
- assert_eq!("\0\0\0\0\0".width(false), 0);
- assert_eq!("\0\0\0\0\0".width(true), 0);
- assert_eq!("".width(false), 0);
- assert_eq!("".width(true), 0);
- assert_eq!("\u{2081}\u{2082}\u{2083}\u{2084}".width(false), 4);
- assert_eq!("\u{2081}\u{2082}\u{2083}\u{2084}".width(true), 8);
- }
-
- #[test]
- fn test_find() {
- assert_eq!("hello".find('l'), Some(2));
- assert_eq!("hello".find(|c:char| c == 'o'), Some(4));
- assert!("hello".find('x').is_none());
- assert!("hello".find(|c:char| c == 'x').is_none());
- assert_eq!("ประเทศไทย中华Việt Nam".find('华'), Some(30));
- assert_eq!("ประเทศไทย中华Việt Nam".find(|c: char| c == '华'), Some(30));
- }
-
- #[test]
- fn test_rfind() {
- assert_eq!("hello".rfind('l'), Some(3));
- assert_eq!("hello".rfind(|c:char| c == 'o'), Some(4));
- assert!("hello".rfind('x').is_none());
- assert!("hello".rfind(|c:char| c == 'x').is_none());
- assert_eq!("ประเทศไทย中华Việt Nam".rfind('华'), Some(30));
- assert_eq!("ประเทศไทย中华Việt Nam".rfind(|c: char| c == '华'), Some(30));
- }
-
- #[test]
- fn test_collect() {
- let empty = String::from_str("");
- let s: String = empty.chars().collect();
- assert_eq!(empty, s);
- let data = String::from_str("ประเทศไทย中");
- let s: String = data.chars().collect();
- assert_eq!(data, s);
- }
-
- #[test]
- fn test_into_bytes() {
- let data = String::from_str("asdf");
- let buf = data.into_bytes();
- assert_eq!(b"asdf", buf);
- }
-
- #[test]
- fn test_find_str() {
- // byte positions
- assert_eq!("".find_str(""), Some(0));
- assert!("banana".find_str("apple pie").is_none());
-
- let data = "abcabc";
- assert_eq!(data[0..6].find_str("ab"), Some(0));
- assert_eq!(data[2..6].find_str("ab"), Some(3 - 2));
- assert!(data[2..4].find_str("ab").is_none());
-
- let string = "ประเทศไทย中华Việt Nam";
- let mut data = String::from_str(string);
- data.push_str(string);
- assert!(data.find_str("ไท华").is_none());
- assert_eq!(data[0..43].find_str(""), Some(0));
- assert_eq!(data[6..43].find_str(""), Some(6 - 6));
-
- assert_eq!(data[0..43].find_str("ประ"), Some( 0));
- assert_eq!(data[0..43].find_str("ทศไ"), Some(12));
- assert_eq!(data[0..43].find_str("ย中"), Some(24));
- assert_eq!(data[0..43].find_str("iệt"), Some(34));
- assert_eq!(data[0..43].find_str("Nam"), Some(40));
-
- assert_eq!(data[43..86].find_str("ประ"), Some(43 - 43));
- assert_eq!(data[43..86].find_str("ทศไ"), Some(55 - 43));
- assert_eq!(data[43..86].find_str("ย中"), Some(67 - 43));
- assert_eq!(data[43..86].find_str("iệt"), Some(77 - 43));
- assert_eq!(data[43..86].find_str("Nam"), Some(83 - 43));
- }
-
- #[test]
- fn test_slice_chars() {
- fn t(a: &str, b: &str, start: usize) {
- assert_eq!(a.slice_chars(start, start + b.chars().count()), b);
- }
- t("", "", 0);
- t("hello", "llo", 2);
- t("hello", "el", 1);
- t("αβλ", "β", 1);
- t("αβλ", "", 3);
- assert_eq!("ะเทศไท", "ประเทศไทย中华Việt Nam".slice_chars(2, 8));
- }
-
- fn s(x: &str) -> String { x.to_string() }
-
- macro_rules! test_concat {
- ($expected: expr, $string: expr) => {
- {
- let s: String = $string.concat();
- assert_eq!($expected, s);
- }
- }
- }
-
- #[test]
- fn test_concat_for_different_types() {
- test_concat!("ab", vec![s("a"), s("b")]);
- test_concat!("ab", vec!["a", "b"]);
- test_concat!("ab", vec!["a", "b"]);
- test_concat!("ab", vec![s("a"), s("b")]);
- }
-
- #[test]
- fn test_concat_for_different_lengths() {
- let empty: &[&str] = &[];
- test_concat!("", empty);
- test_concat!("a", ["a"]);
- test_concat!("ab", ["a", "b"]);
- test_concat!("abc", ["", "a", "bc"]);
- }
-
- macro_rules! test_connect {
- ($expected: expr, $string: expr, $delim: expr) => {
- {
- let s = $string.connect($delim);
- assert_eq!($expected, s);
- }
- }
- }
-
- #[test]
- fn test_connect_for_different_types() {
- test_connect!("a-b", ["a", "b"], "-");
- let hyphen = "-".to_string();
- test_connect!("a-b", [s("a"), s("b")], &*hyphen);
- test_connect!("a-b", vec!["a", "b"], &*hyphen);
- test_connect!("a-b", &*vec!["a", "b"], "-");
- test_connect!("a-b", vec![s("a"), s("b")], "-");
- }
-
- #[test]
- fn test_connect_for_different_lengths() {
- let empty: &[&str] = &[];
- test_connect!("", empty, "-");
- test_connect!("a", ["a"], "-");
- test_connect!("a-b", ["a", "b"], "-");
- test_connect!("-a-bc", ["", "a", "bc"], "-");
- }
-
- #[test]
- fn test_unsafe_slice() {
- assert_eq!("ab", unsafe {"abc".slice_unchecked(0, 2)});
- assert_eq!("bc", unsafe {"abc".slice_unchecked(1, 3)});
- assert_eq!("", unsafe {"abc".slice_unchecked(1, 1)});
- fn a_million_letter_a() -> String {
- let mut i = 0;
- let mut rs = String::new();
- while i < 100000 {
- rs.push_str("aaaaaaaaaa");
- i += 1;
- }
- rs
- }
- fn half_a_million_letter_a() -> String {
- let mut i = 0;
- let mut rs = String::new();
- while i < 100000 {
- rs.push_str("aaaaa");
- i += 1;
- }
- rs
- }
- let letters = a_million_letter_a();
- assert!(half_a_million_letter_a() ==
- unsafe {String::from_str(letters.slice_unchecked(
- 0,
- 500000))});
- }
-
- #[test]
- fn test_starts_with() {
- assert!(("".starts_with("")));
- assert!(("abc".starts_with("")));
- assert!(("abc".starts_with("a")));
- assert!((!"a".starts_with("abc")));
- assert!((!"".starts_with("abc")));
- assert!((!"ödd".starts_with("-")));
- assert!(("ödd".starts_with("öd")));
- }
-
- #[test]
- fn test_ends_with() {
- assert!(("".ends_with("")));
- assert!(("abc".ends_with("")));
- assert!(("abc".ends_with("c")));
- assert!((!"a".ends_with("abc")));
- assert!((!"".ends_with("abc")));
- assert!((!"ddö".ends_with("-")));
- assert!(("ddö".ends_with("dö")));
- }
-
- #[test]
- fn test_is_empty() {
- assert!("".is_empty());
- assert!(!"a".is_empty());
- }
-
- #[test]
- fn test_replace() {
- let a = "a";
- assert_eq!("".replace(a, "b"), String::from_str(""));
- assert_eq!("a".replace(a, "b"), String::from_str("b"));
- assert_eq!("ab".replace(a, "b"), String::from_str("bb"));
- let test = "test";
- assert!(" test test ".replace(test, "toast") ==
- String::from_str(" toast toast "));
- assert_eq!(" test test ".replace(test, ""), String::from_str(" "));
- }
-
- #[test]
- fn test_replace_2a() {
- let data = "ประเทศไทย中华";
- let repl = "دولة الكويت";
-
- let a = "ประเ";
- let a2 = "دولة الكويتทศไทย中华";
- assert_eq!(data.replace(a, repl), a2);
- }
-
- #[test]
- fn test_replace_2b() {
- let data = "ประเทศไทย中华";
- let repl = "دولة الكويت";
-
- let b = "ะเ";
- let b2 = "ปรدولة الكويتทศไทย中华";
- assert_eq!(data.replace(b, repl), b2);
- }
-
- #[test]
- fn test_replace_2c() {
- let data = "ประเทศไทย中华";
- let repl = "دولة الكويت";
-
- let c = "中华";
- let c2 = "ประเทศไทยدولة الكويت";
- assert_eq!(data.replace(c, repl), c2);
- }
-
- #[test]
- fn test_replace_2d() {
- let data = "ประเทศไทย中华";
- let repl = "دولة الكويت";
-
- let d = "ไท华";
- assert_eq!(data.replace(d, repl), data);
- }
-
- #[test]
- fn test_slice() {
- assert_eq!("ab", "abc".slice(0, 2));
- assert_eq!("bc", "abc".slice(1, 3));
- assert_eq!("", "abc".slice(1, 1));
- assert_eq!("\u{65e5}", "\u{65e5}\u{672c}".slice(0, 3));
-
- let data = "ประเทศไทย中华";
- assert_eq!("ป", data.slice(0, 3));
- assert_eq!("ร", data.slice(3, 6));
- assert_eq!("", data.slice(3, 3));
- assert_eq!("华", data.slice(30, 33));
-
- fn a_million_letter_x() -> String {
- let mut i = 0;
- let mut rs = String::new();
- while i < 100000 {
- rs.push_str("华华华华华华华华华华");
- i += 1;
- }
- rs
- }
- fn half_a_million_letter_x() -> String {
- let mut i = 0;
- let mut rs = String::new();
- while i < 100000 {
- rs.push_str("华华华华华");
- i += 1;
- }
- rs
- }
- let letters = a_million_letter_x();
- assert!(half_a_million_letter_x() ==
- String::from_str(letters.slice(0, 3 * 500000)));
- }
-
- #[test]
- fn test_slice_2() {
- let ss = "中华Việt Nam";
-
- assert_eq!("华", ss.slice(3, 6));
- assert_eq!("Việt Nam", ss.slice(6, 16));
-
- assert_eq!("ab", "abc".slice(0, 2));
- assert_eq!("bc", "abc".slice(1, 3));
- assert_eq!("", "abc".slice(1, 1));
-
- assert_eq!("中", ss.slice(0, 3));
- assert_eq!("华V", ss.slice(3, 7));
- assert_eq!("", ss.slice(3, 3));
- /*0: 中
- 3: 华
- 6: V
- 7: i
- 8: ệ
- 11: t
- 12:
- 13: N
- 14: a
- 15: m */
- }
-
- #[test]
- #[should_panic]
- fn test_slice_fail() {
- "中华Việt Nam".slice(0, 2);
- }
-
- #[test]
- fn test_slice_from() {
- assert_eq!("abcd".slice_from(0), "abcd");
- assert_eq!("abcd".slice_from(2), "cd");
- assert_eq!("abcd".slice_from(4), "");
- }
- #[test]
- fn test_slice_to() {
- assert_eq!("abcd".slice_to(0), "");
- assert_eq!("abcd".slice_to(2), "ab");
- assert_eq!("abcd".slice_to(4), "abcd");
- }
-
- #[test]
- fn test_trim_left_matches() {
- let v: &[char] = &[];
- assert_eq!(" *** foo *** ".trim_left_matches(v), " *** foo *** ");
- let chars: &[char] = &['*', ' '];
- assert_eq!(" *** foo *** ".trim_left_matches(chars), "foo *** ");
- assert_eq!(" *** *** ".trim_left_matches(chars), "");
- assert_eq!("foo *** ".trim_left_matches(chars), "foo *** ");
-
- assert_eq!("11foo1bar11".trim_left_matches('1'), "foo1bar11");
- let chars: &[char] = &['1', '2'];
- assert_eq!("12foo1bar12".trim_left_matches(chars), "foo1bar12");
- assert_eq!("123foo1bar123".trim_left_matches(|c: char| c.is_numeric()), "foo1bar123");
- }
-
- #[test]
- fn test_trim_right_matches() {
- let v: &[char] = &[];
- assert_eq!(" *** foo *** ".trim_right_matches(v), " *** foo *** ");
- let chars: &[char] = &['*', ' '];
- assert_eq!(" *** foo *** ".trim_right_matches(chars), " *** foo");
- assert_eq!(" *** *** ".trim_right_matches(chars), "");
- assert_eq!(" *** foo".trim_right_matches(chars), " *** foo");
-
- assert_eq!("11foo1bar11".trim_right_matches('1'), "11foo1bar");
- let chars: &[char] = &['1', '2'];
- assert_eq!("12foo1bar12".trim_right_matches(chars), "12foo1bar");
- assert_eq!("123foo1bar123".trim_right_matches(|c: char| c.is_numeric()), "123foo1bar");
- }
-
- #[test]
- fn test_trim_matches() {
- let v: &[char] = &[];
- assert_eq!(" *** foo *** ".trim_matches(v), " *** foo *** ");
- let chars: &[char] = &['*', ' '];
- assert_eq!(" *** foo *** ".trim_matches(chars), "foo");
- assert_eq!(" *** *** ".trim_matches(chars), "");
- assert_eq!("foo".trim_matches(chars), "foo");
-
- assert_eq!("11foo1bar11".trim_matches('1'), "foo1bar");
- let chars: &[char] = &['1', '2'];
- assert_eq!("12foo1bar12".trim_matches(chars), "foo1bar");
- assert_eq!("123foo1bar123".trim_matches(|c: char| c.is_numeric()), "foo1bar");
- }
-
- #[test]
- fn test_trim_left() {
- assert_eq!("".trim_left(), "");
- assert_eq!("a".trim_left(), "a");
- assert_eq!(" ".trim_left(), "");
- assert_eq!(" blah".trim_left(), "blah");
- assert_eq!(" \u{3000} wut".trim_left(), "wut");
- assert_eq!("hey ".trim_left(), "hey ");
- }
-
- #[test]
- fn test_trim_right() {
- assert_eq!("".trim_right(), "");
- assert_eq!("a".trim_right(), "a");
- assert_eq!(" ".trim_right(), "");
- assert_eq!("blah ".trim_right(), "blah");
- assert_eq!("wut \u{3000} ".trim_right(), "wut");
- assert_eq!(" hey".trim_right(), " hey");
- }
-
- #[test]
- fn test_trim() {
- assert_eq!("".trim(), "");
- assert_eq!("a".trim(), "a");
- assert_eq!(" ".trim(), "");
- assert_eq!(" blah ".trim(), "blah");
- assert_eq!("\nwut \u{3000} ".trim(), "wut");
- assert_eq!(" hey dude ".trim(), "hey dude");
- }
-
- #[test]
- fn test_is_whitespace() {
- assert!("".chars().all(|c| c.is_whitespace()));
- assert!(" ".chars().all(|c| c.is_whitespace()));
- assert!("\u{2009}".chars().all(|c| c.is_whitespace())); // Thin space
- assert!(" \n\t ".chars().all(|c| c.is_whitespace()));
- assert!(!" _ ".chars().all(|c| c.is_whitespace()));
- }
-
- #[test]
- fn test_slice_shift_char() {
- let data = "ประเทศไทย中";
- assert_eq!(data.slice_shift_char(), Some(('ป', "ระเทศไทย中")));
- }
-
- #[test]
- fn test_slice_shift_char_2() {
- let empty = "";
- assert_eq!(empty.slice_shift_char(), None);
- }
-
- #[test]
- fn test_is_utf8() {
- // deny overlong encodings
- assert!(from_utf8(&[0xc0, 0x80]).is_err());
- assert!(from_utf8(&[0xc0, 0xae]).is_err());
- assert!(from_utf8(&[0xe0, 0x80, 0x80]).is_err());
- assert!(from_utf8(&[0xe0, 0x80, 0xaf]).is_err());
- assert!(from_utf8(&[0xe0, 0x81, 0x81]).is_err());
- assert!(from_utf8(&[0xf0, 0x82, 0x82, 0xac]).is_err());
- assert!(from_utf8(&[0xf4, 0x90, 0x80, 0x80]).is_err());
-
- // deny surrogates
- assert!(from_utf8(&[0xED, 0xA0, 0x80]).is_err());
- assert!(from_utf8(&[0xED, 0xBF, 0xBF]).is_err());
-
- assert!(from_utf8(&[0xC2, 0x80]).is_ok());
- assert!(from_utf8(&[0xDF, 0xBF]).is_ok());
- assert!(from_utf8(&[0xE0, 0xA0, 0x80]).is_ok());
- assert!(from_utf8(&[0xED, 0x9F, 0xBF]).is_ok());
- assert!(from_utf8(&[0xEE, 0x80, 0x80]).is_ok());
- assert!(from_utf8(&[0xEF, 0xBF, 0xBF]).is_ok());
- assert!(from_utf8(&[0xF0, 0x90, 0x80, 0x80]).is_ok());
- assert!(from_utf8(&[0xF4, 0x8F, 0xBF, 0xBF]).is_ok());
- }
-
- #[test]
- fn test_is_utf16() {
- use unicode::str::is_utf16;
- macro_rules! pos {
- ($($e:expr),*) => { { $(assert!(is_utf16($e));)* } }
- }
-
- // non-surrogates
- pos!(&[0x0000],
- &[0x0001, 0x0002],
- &[0xD7FF],
- &[0xE000]);
-
- // surrogate pairs (randomly generated with Python 3's
- // .encode('utf-16be'))
- pos!(&[0xdb54, 0xdf16, 0xd880, 0xdee0, 0xdb6a, 0xdd45],
- &[0xd91f, 0xdeb1, 0xdb31, 0xdd84, 0xd8e2, 0xde14],
- &[0xdb9f, 0xdc26, 0xdb6f, 0xde58, 0xd850, 0xdfae]);
-
- // mixtures (also random)
- pos!(&[0xd921, 0xdcc2, 0x002d, 0x004d, 0xdb32, 0xdf65],
- &[0xdb45, 0xdd2d, 0x006a, 0xdacd, 0xddfe, 0x0006],
- &[0x0067, 0xd8ff, 0xddb7, 0x000f, 0xd900, 0xdc80]);
-
- // negative tests
- macro_rules! neg {
- ($($e:expr),*) => { { $(assert!(!is_utf16($e));)* } }
- }
-
- neg!(
- // surrogate + regular unit
- &[0xdb45, 0x0000],
- // surrogate + lead surrogate
- &[0xd900, 0xd900],
- // unterminated surrogate
- &[0xd8ff],
- // trail surrogate without a lead
- &[0xddb7]);
-
- // random byte sequences that Python 3's .decode('utf-16be')
- // failed on
- neg!(&[0x5b3d, 0x0141, 0xde9e, 0x8fdc, 0xc6e7],
- &[0xdf5a, 0x82a5, 0x62b9, 0xb447, 0x92f3],
- &[0xda4e, 0x42bc, 0x4462, 0xee98, 0xc2ca],
- &[0xbe00, 0xb04a, 0x6ecb, 0xdd89, 0xe278],
- &[0x0465, 0xab56, 0xdbb6, 0xa893, 0x665e],
- &[0x6b7f, 0x0a19, 0x40f4, 0xa657, 0xdcc5],
- &[0x9b50, 0xda5e, 0x24ec, 0x03ad, 0x6dee],
- &[0x8d17, 0xcaa7, 0xf4ae, 0xdf6e, 0xbed7],
- &[0xdaee, 0x2584, 0x7d30, 0xa626, 0x121a],
- &[0xd956, 0x4b43, 0x7570, 0xccd6, 0x4f4a],
- &[0x9dcf, 0x1b49, 0x4ba5, 0xfce9, 0xdffe],
- &[0x6572, 0xce53, 0xb05a, 0xf6af, 0xdacf],
- &[0x1b90, 0x728c, 0x9906, 0xdb68, 0xf46e],
- &[0x1606, 0xbeca, 0xbe76, 0x860f, 0xdfa5],
- &[0x8b4f, 0xde7a, 0xd220, 0x9fac, 0x2b6f],
- &[0xb8fe, 0xebbe, 0xda32, 0x1a5f, 0x8b8b],
- &[0x934b, 0x8956, 0xc434, 0x1881, 0xddf7],
- &[0x5a95, 0x13fc, 0xf116, 0xd89b, 0x93f9],
- &[0xd640, 0x71f1, 0xdd7d, 0x77eb, 0x1cd8],
- &[0x348b, 0xaef0, 0xdb2c, 0xebf1, 0x1282],
- &[0x50d7, 0xd824, 0x5010, 0xb369, 0x22ea]);
- }
-
- #[test]
- fn test_as_bytes() {
- // no null
- let v = [
- 224, 184, 168, 224, 185, 132, 224, 184, 151, 224, 184, 162, 228,
- 184, 173, 229, 141, 142, 86, 105, 225, 187, 135, 116, 32, 78, 97,
- 109
- ];
- let b: &[u8] = &[];
- assert_eq!("".as_bytes(), b);
- assert_eq!("abc".as_bytes(), b"abc");
- assert_eq!("ศไทย中华Việt Nam".as_bytes(), v);
- }
-
- #[test]
- #[should_panic]
- fn test_as_bytes_fail() {
- // Don't double free. (I'm not sure if this exercises the
- // original problem code path anymore.)
- let s = String::from_str("");
- let _bytes = s.as_bytes();
- panic!();
- }
-
- #[test]
- fn test_as_ptr() {
- let buf = "hello".as_ptr();
- unsafe {
- assert_eq!(*buf.offset(0), b'h');
- assert_eq!(*buf.offset(1), b'e');
- assert_eq!(*buf.offset(2), b'l');
- assert_eq!(*buf.offset(3), b'l');
- assert_eq!(*buf.offset(4), b'o');
- }
- }
-
- #[test]
- fn test_subslice_offset() {
- let a = "kernelsprite";
- let b = &a[7..a.len()];
- let c = &a[0..a.len() - 6];
- assert_eq!(a.subslice_offset(b), 7);
- assert_eq!(a.subslice_offset(c), 0);
-
- let string = "a\nb\nc";
- let lines: Vec<&str> = string.lines().collect();
- assert_eq!(string.subslice_offset(lines[0]), 0);
- assert_eq!(string.subslice_offset(lines[1]), 2);
- assert_eq!(string.subslice_offset(lines[2]), 4);
- }
-
- #[test]
- #[should_panic]
- fn test_subslice_offset_2() {
- let a = "alchemiter";
- let b = "cruxtruder";
- a.subslice_offset(b);
- }
-
- #[test]
- fn vec_str_conversions() {
- let s1: String = String::from_str("All mimsy were the borogoves");
-
- let v: Vec<u8> = s1.as_bytes().to_vec();
- let s2: String = String::from_str(from_utf8(&v).unwrap());
- let mut i = 0;
- let n1 = s1.len();
- let n2 = v.len();
- assert_eq!(n1, n2);
- while i < n1 {
- let a: u8 = s1.as_bytes()[i];
- let b: u8 = s2.as_bytes()[i];
- debug!("{}", a);
- debug!("{}", b);
- assert_eq!(a, b);
- i += 1;
- }
- }
-
- #[test]
- fn test_contains() {
- assert!("abcde".contains("bcd"));
- assert!("abcde".contains("abcd"));
- assert!("abcde".contains("bcde"));
- assert!("abcde".contains(""));
- assert!("".contains(""));
- assert!(!"abcde".contains("def"));
- assert!(!"".contains("a"));
-
- let data = "ประเทศไทย中华Việt Nam";
- assert!(data.contains("ประเ"));
- assert!(data.contains("ะเ"));
- assert!(data.contains("中华"));
- assert!(!data.contains("ไท华"));
- }
-
- #[test]
- fn test_contains_char() {
- assert!("abc".contains_char('b'));
- assert!("a".contains_char('a'));
- assert!(!"abc".contains_char('d'));
- assert!(!"".contains_char('a'));
- }
-
- #[test]
- fn test_char_at() {
- let s = "ศไทย中华Việt Nam";
- let v = vec!['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
- let mut pos = 0;
- for ch in &v {
- assert!(s.char_at(pos) == *ch);
- pos += ch.to_string().len();
- }
- }
-
- #[test]
- fn test_char_at_reverse() {
- let s = "ศไทย中华Việt Nam";
- let v = vec!['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
- let mut pos = s.len();
- for ch in v.iter().rev() {
- assert!(s.char_at_reverse(pos) == *ch);
- pos -= ch.to_string().len();
- }
- }
-
- #[test]
- fn test_escape_unicode() {
- assert_eq!("abc".escape_unicode(),
- String::from_str("\\u{61}\\u{62}\\u{63}"));
- assert_eq!("a c".escape_unicode(),
- String::from_str("\\u{61}\\u{20}\\u{63}"));
- assert_eq!("\r\n\t".escape_unicode(),
- String::from_str("\\u{d}\\u{a}\\u{9}"));
- assert_eq!("'\"\\".escape_unicode(),
- String::from_str("\\u{27}\\u{22}\\u{5c}"));
- assert_eq!("\x00\x01\u{fe}\u{ff}".escape_unicode(),
- String::from_str("\\u{0}\\u{1}\\u{fe}\\u{ff}"));
- assert_eq!("\u{100}\u{ffff}".escape_unicode(),
- String::from_str("\\u{100}\\u{ffff}"));
- assert_eq!("\u{10000}\u{10ffff}".escape_unicode(),
- String::from_str("\\u{10000}\\u{10ffff}"));
- assert_eq!("ab\u{fb00}".escape_unicode(),
- String::from_str("\\u{61}\\u{62}\\u{fb00}"));
- assert_eq!("\u{1d4ea}\r".escape_unicode(),
- String::from_str("\\u{1d4ea}\\u{d}"));
- }
-
- #[test]
- fn test_escape_default() {
- assert_eq!("abc".escape_default(), String::from_str("abc"));
- assert_eq!("a c".escape_default(), String::from_str("a c"));
- assert_eq!("\r\n\t".escape_default(), String::from_str("\\r\\n\\t"));
- assert_eq!("'\"\\".escape_default(), String::from_str("\\'\\\"\\\\"));
- assert_eq!("\u{100}\u{ffff}".escape_default(),
- String::from_str("\\u{100}\\u{ffff}"));
- assert_eq!("\u{10000}\u{10ffff}".escape_default(),
- String::from_str("\\u{10000}\\u{10ffff}"));
- assert_eq!("ab\u{fb00}".escape_default(),
- String::from_str("ab\\u{fb00}"));
- assert_eq!("\u{1d4ea}\r".escape_default(),
- String::from_str("\\u{1d4ea}\\r"));
- }
-
- #[test]
- fn test_total_ord() {
- "1234".cmp("123") == Greater;
- "123".cmp("1234") == Less;
- "1234".cmp("1234") == Equal;
- "12345555".cmp("123456") == Less;
- "22".cmp("1234") == Greater;
- }
-
- #[test]
- fn test_char_range_at() {
- let data = "b¢€𤭢𤭢€¢b";
- assert_eq!('b', data.char_range_at(0).ch);
- assert_eq!('¢', data.char_range_at(1).ch);
- assert_eq!('€', data.char_range_at(3).ch);
- assert_eq!('𤭢', data.char_range_at(6).ch);
- assert_eq!('𤭢', data.char_range_at(10).ch);
- assert_eq!('€', data.char_range_at(14).ch);
- assert_eq!('¢', data.char_range_at(17).ch);
- assert_eq!('b', data.char_range_at(19).ch);
- }
-
- #[test]
- fn test_char_range_at_reverse_underflow() {
- assert_eq!("abc".char_range_at_reverse(0).next, 0);
- }
-
- #[test]
- fn test_iterator() {
- let s = "ศไทย中华Việt Nam";
- let v = ['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
-
- let mut pos = 0;
- let it = s.chars();
-
- for c in it {
- assert_eq!(c, v[pos]);
- pos += 1;
- }
- assert_eq!(pos, v.len());
- }
-
- #[test]
- fn test_rev_iterator() {
- let s = "ศไทย中华Việt Nam";
- let v = ['m', 'a', 'N', ' ', 't', 'ệ','i','V','华','中','ย','ท','ไ','ศ'];
-
- let mut pos = 0;
- let it = s.chars().rev();
-
- for c in it {
- assert_eq!(c, v[pos]);
- pos += 1;
- }
- assert_eq!(pos, v.len());
- }
-
- #[test]
- fn test_chars_decoding() {
- let mut bytes = [0; 4];
- for c in (0..0x110000).filter_map(|c| ::core::char::from_u32(c)) {
- let len = c.encode_utf8(&mut bytes).unwrap_or(0);
- let s = ::core::str::from_utf8(&bytes[..len]).unwrap();
- if Some(c) != s.chars().next() {
- panic!("character {:x}={} does not decode correctly", c as u32, c);
- }
- }
- }
-
- #[test]
- fn test_chars_rev_decoding() {
- let mut bytes = [0; 4];
- for c in (0..0x110000).filter_map(|c| ::core::char::from_u32(c)) {
- let len = c.encode_utf8(&mut bytes).unwrap_or(0);
- let s = ::core::str::from_utf8(&bytes[..len]).unwrap();
- if Some(c) != s.chars().rev().next() {
- panic!("character {:x}={} does not decode correctly", c as u32, c);
- }
- }
- }
-
- #[test]
- fn test_iterator_clone() {
- let s = "ศไทย中华Việt Nam";
- let mut it = s.chars();
- it.next();
- assert!(it.clone().zip(it).all(|(x,y)| x == y));
- }
-
- #[test]
- fn test_bytesator() {
- let s = "ศไทย中华Việt Nam";
- let v = [
- 224, 184, 168, 224, 185, 132, 224, 184, 151, 224, 184, 162, 228,
- 184, 173, 229, 141, 142, 86, 105, 225, 187, 135, 116, 32, 78, 97,
- 109
- ];
- let mut pos = 0;
-
- for b in s.bytes() {
- assert_eq!(b, v[pos]);
- pos += 1;
- }
- }
-
- #[test]
- fn test_bytes_revator() {
- let s = "ศไทย中华Việt Nam";
- let v = [
- 224, 184, 168, 224, 185, 132, 224, 184, 151, 224, 184, 162, 228,
- 184, 173, 229, 141, 142, 86, 105, 225, 187, 135, 116, 32, 78, 97,
- 109
- ];
- let mut pos = v.len();
-
- for b in s.bytes().rev() {
- pos -= 1;
- assert_eq!(b, v[pos]);
- }
- }
-
- #[test]
- fn test_char_indicesator() {
- let s = "ศไทย中华Việt Nam";
- let p = [0, 3, 6, 9, 12, 15, 18, 19, 20, 23, 24, 25, 26, 27];
- let v = ['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
-
- let mut pos = 0;
- let it = s.char_indices();
-
- for c in it {
- assert_eq!(c, (p[pos], v[pos]));
- pos += 1;
- }
- assert_eq!(pos, v.len());
- assert_eq!(pos, p.len());
- }
-
- #[test]
- fn test_char_indices_revator() {
- let s = "ศไทย中华Việt Nam";
- let p = [27, 26, 25, 24, 23, 20, 19, 18, 15, 12, 9, 6, 3, 0];
- let v = ['m', 'a', 'N', ' ', 't', 'ệ','i','V','华','中','ย','ท','ไ','ศ'];
-
- let mut pos = 0;
- let it = s.char_indices().rev();
-
- for c in it {
- assert_eq!(c, (p[pos], v[pos]));
- pos += 1;
- }
- assert_eq!(pos, v.len());
- assert_eq!(pos, p.len());
- }
-
- #[test]
- fn test_splitn_char_iterator() {
- let data = "\nMäry häd ä little lämb\nLittle lämb\n";
-
- let split: Vec<&str> = data.splitn(3, ' ').collect();
- assert_eq!(split, ["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]);
-
- let split: Vec<&str> = data.splitn(3, |c: char| c == ' ').collect();
- assert_eq!(split, ["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]);
-
- // Unicode
- let split: Vec<&str> = data.splitn(3, 'ä').collect();
- assert_eq!(split, ["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]);
-
- let split: Vec<&str> = data.splitn(3, |c: char| c == 'ä').collect();
- assert_eq!(split, ["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]);
- }
-
- #[test]
- fn test_split_char_iterator_no_trailing() {
- let data = "\nMäry häd ä little lämb\nLittle lämb\n";
-
- let split: Vec<&str> = data.split('\n').collect();
- assert_eq!(split, ["", "Märy häd ä little lämb", "Little lämb", ""]);
-
- let split: Vec<&str> = data.split_terminator('\n').collect();
- assert_eq!(split, ["", "Märy häd ä little lämb", "Little lämb"]);
- }
-
- #[test]
- fn test_words() {
- let data = "\n \tMäry häd\tä little lämb\nLittle lämb\n";
- let words: Vec<&str> = data.words().collect();
- assert_eq!(words, ["Märy", "häd", "ä", "little", "lämb", "Little", "lämb"])
- }
-
- #[test]
- fn test_nfd_chars() {
- macro_rules! t {
- ($input: expr, $expected: expr) => {
- assert_eq!($input.nfd_chars().collect::<String>(), $expected);
- }
- }
- t!("abc", "abc");
- t!("\u{1e0b}\u{1c4}", "d\u{307}\u{1c4}");
- t!("\u{2026}", "\u{2026}");
- t!("\u{2126}", "\u{3a9}");
- t!("\u{1e0b}\u{323}", "d\u{323}\u{307}");
- t!("\u{1e0d}\u{307}", "d\u{323}\u{307}");
- t!("a\u{301}", "a\u{301}");
- t!("\u{301}a", "\u{301}a");
- t!("\u{d4db}", "\u{1111}\u{1171}\u{11b6}");
- t!("\u{ac1c}", "\u{1100}\u{1162}");
- }
-
- #[test]
- fn test_nfkd_chars() {
- macro_rules! t {
- ($input: expr, $expected: expr) => {
- assert_eq!($input.nfkd_chars().collect::<String>(), $expected);
- }
- }
- t!("abc", "abc");
- t!("\u{1e0b}\u{1c4}", "d\u{307}DZ\u{30c}");
- t!("\u{2026}", "...");
- t!("\u{2126}", "\u{3a9}");
- t!("\u{1e0b}\u{323}", "d\u{323}\u{307}");
- t!("\u{1e0d}\u{307}", "d\u{323}\u{307}");
- t!("a\u{301}", "a\u{301}");
- t!("\u{301}a", "\u{301}a");
- t!("\u{d4db}", "\u{1111}\u{1171}\u{11b6}");
- t!("\u{ac1c}", "\u{1100}\u{1162}");
- }
-
- #[test]
- fn test_nfc_chars() {
- macro_rules! t {
- ($input: expr, $expected: expr) => {
- assert_eq!($input.nfc_chars().collect::<String>(), $expected);
- }
- }
- t!("abc", "abc");
- t!("\u{1e0b}\u{1c4}", "\u{1e0b}\u{1c4}");
- t!("\u{2026}", "\u{2026}");
- t!("\u{2126}", "\u{3a9}");
- t!("\u{1e0b}\u{323}", "\u{1e0d}\u{307}");
- t!("\u{1e0d}\u{307}", "\u{1e0d}\u{307}");
- t!("a\u{301}", "\u{e1}");
- t!("\u{301}a", "\u{301}a");
- t!("\u{d4db}", "\u{d4db}");
- t!("\u{ac1c}", "\u{ac1c}");
- t!("a\u{300}\u{305}\u{315}\u{5ae}b", "\u{e0}\u{5ae}\u{305}\u{315}b");
- }
-
- #[test]
- fn test_nfkc_chars() {
- macro_rules! t {
- ($input: expr, $expected: expr) => {
- assert_eq!($input.nfkc_chars().collect::<String>(), $expected);
- }
- }
- t!("abc", "abc");
- t!("\u{1e0b}\u{1c4}", "\u{1e0b}D\u{17d}");
- t!("\u{2026}", "...");
- t!("\u{2126}", "\u{3a9}");
- t!("\u{1e0b}\u{323}", "\u{1e0d}\u{307}");
- t!("\u{1e0d}\u{307}", "\u{1e0d}\u{307}");
- t!("a\u{301}", "\u{e1}");
- t!("\u{301}a", "\u{301}a");
- t!("\u{d4db}", "\u{d4db}");
- t!("\u{ac1c}", "\u{ac1c}");
- t!("a\u{300}\u{305}\u{315}\u{5ae}b", "\u{e0}\u{5ae}\u{305}\u{315}b");
- }
-
- #[test]
- fn test_lines() {
- let data = "\nMäry häd ä little lämb\n\nLittle lämb\n";
- let lines: Vec<&str> = data.lines().collect();
- assert_eq!(lines, ["", "Märy häd ä little lämb", "", "Little lämb"]);
-
- let data = "\nMäry häd ä little lämb\n\nLittle lämb"; // no trailing \n
- let lines: Vec<&str> = data.lines().collect();
- assert_eq!(lines, ["", "Märy häd ä little lämb", "", "Little lämb"]);
- }
-
- #[test]
- fn test_graphemes() {
- use core::iter::order;
- // official Unicode test data
- // from http://www.unicode.org/Public/UCD/latest/ucd/auxiliary/GraphemeBreakTest.txt
- let test_same: [(_, &[_]); 325] = [
- ("\u{20}\u{20}", &["\u{20}", "\u{20}"]),
- ("\u{20}\u{308}\u{20}", &["\u{20}\u{308}", "\u{20}"]),
- ("\u{20}\u{D}", &["\u{20}", "\u{D}"]),
- ("\u{20}\u{308}\u{D}", &["\u{20}\u{308}", "\u{D}"]),
- ("\u{20}\u{A}", &["\u{20}", "\u{A}"]),
- ("\u{20}\u{308}\u{A}", &["\u{20}\u{308}", "\u{A}"]),
- ("\u{20}\u{1}", &["\u{20}", "\u{1}"]),
- ("\u{20}\u{308}\u{1}", &["\u{20}\u{308}", "\u{1}"]),
- ("\u{20}\u{300}", &["\u{20}\u{300}"]),
- ("\u{20}\u{308}\u{300}", &["\u{20}\u{308}\u{300}"]),
- ("\u{20}\u{1100}", &["\u{20}", "\u{1100}"]),
- ("\u{20}\u{308}\u{1100}", &["\u{20}\u{308}", "\u{1100}"]),
- ("\u{20}\u{1160}", &["\u{20}", "\u{1160}"]),
- ("\u{20}\u{308}\u{1160}", &["\u{20}\u{308}", "\u{1160}"]),
- ("\u{20}\u{11A8}", &["\u{20}", "\u{11A8}"]),
- ("\u{20}\u{308}\u{11A8}", &["\u{20}\u{308}", "\u{11A8}"]),
- ("\u{20}\u{AC00}", &["\u{20}", "\u{AC00}"]),
- ("\u{20}\u{308}\u{AC00}", &["\u{20}\u{308}", "\u{AC00}"]),
- ("\u{20}\u{AC01}", &["\u{20}", "\u{AC01}"]),
- ("\u{20}\u{308}\u{AC01}", &["\u{20}\u{308}", "\u{AC01}"]),
- ("\u{20}\u{1F1E6}", &["\u{20}", "\u{1F1E6}"]),
- ("\u{20}\u{308}\u{1F1E6}", &["\u{20}\u{308}", "\u{1F1E6}"]),
- ("\u{20}\u{378}", &["\u{20}", "\u{378}"]),
- ("\u{20}\u{308}\u{378}", &["\u{20}\u{308}", "\u{378}"]),
- ("\u{D}\u{20}", &["\u{D}", "\u{20}"]),
- ("\u{D}\u{308}\u{20}", &["\u{D}", "\u{308}", "\u{20}"]),
- ("\u{D}\u{D}", &["\u{D}", "\u{D}"]),
- ("\u{D}\u{308}\u{D}", &["\u{D}", "\u{308}", "\u{D}"]),
- ("\u{D}\u{A}", &["\u{D}\u{A}"]),
- ("\u{D}\u{308}\u{A}", &["\u{D}", "\u{308}", "\u{A}"]),
- ("\u{D}\u{1}", &["\u{D}", "\u{1}"]),
- ("\u{D}\u{308}\u{1}", &["\u{D}", "\u{308}", "\u{1}"]),
- ("\u{D}\u{300}", &["\u{D}", "\u{300}"]),
- ("\u{D}\u{308}\u{300}", &["\u{D}", "\u{308}\u{300}"]),
- ("\u{D}\u{903}", &["\u{D}", "\u{903}"]),
- ("\u{D}\u{1100}", &["\u{D}", "\u{1100}"]),
- ("\u{D}\u{308}\u{1100}", &["\u{D}", "\u{308}", "\u{1100}"]),
- ("\u{D}\u{1160}", &["\u{D}", "\u{1160}"]),
- ("\u{D}\u{308}\u{1160}", &["\u{D}", "\u{308}", "\u{1160}"]),
- ("\u{D}\u{11A8}", &["\u{D}", "\u{11A8}"]),
- ("\u{D}\u{308}\u{11A8}", &["\u{D}", "\u{308}", "\u{11A8}"]),
- ("\u{D}\u{AC00}", &["\u{D}", "\u{AC00}"]),
- ("\u{D}\u{308}\u{AC00}", &["\u{D}", "\u{308}", "\u{AC00}"]),
- ("\u{D}\u{AC01}", &["\u{D}", "\u{AC01}"]),
- ("\u{D}\u{308}\u{AC01}", &["\u{D}", "\u{308}", "\u{AC01}"]),
- ("\u{D}\u{1F1E6}", &["\u{D}", "\u{1F1E6}"]),
- ("\u{D}\u{308}\u{1F1E6}", &["\u{D}", "\u{308}", "\u{1F1E6}"]),
- ("\u{D}\u{378}", &["\u{D}", "\u{378}"]),
- ("\u{D}\u{308}\u{378}", &["\u{D}", "\u{308}", "\u{378}"]),
- ("\u{A}\u{20}", &["\u{A}", "\u{20}"]),
- ("\u{A}\u{308}\u{20}", &["\u{A}", "\u{308}", "\u{20}"]),
- ("\u{A}\u{D}", &["\u{A}", "\u{D}"]),
- ("\u{A}\u{308}\u{D}", &["\u{A}", "\u{308}", "\u{D}"]),
- ("\u{A}\u{A}", &["\u{A}", "\u{A}"]),
- ("\u{A}\u{308}\u{A}", &["\u{A}", "\u{308}", "\u{A}"]),
- ("\u{A}\u{1}", &["\u{A}", "\u{1}"]),
- ("\u{A}\u{308}\u{1}", &["\u{A}", "\u{308}", "\u{1}"]),
- ("\u{A}\u{300}", &["\u{A}", "\u{300}"]),
- ("\u{A}\u{308}\u{300}", &["\u{A}", "\u{308}\u{300}"]),
- ("\u{A}\u{903}", &["\u{A}", "\u{903}"]),
- ("\u{A}\u{1100}", &["\u{A}", "\u{1100}"]),
- ("\u{A}\u{308}\u{1100}", &["\u{A}", "\u{308}", "\u{1100}"]),
- ("\u{A}\u{1160}", &["\u{A}", "\u{1160}"]),
- ("\u{A}\u{308}\u{1160}", &["\u{A}", "\u{308}", "\u{1160}"]),
- ("\u{A}\u{11A8}", &["\u{A}", "\u{11A8}"]),
- ("\u{A}\u{308}\u{11A8}", &["\u{A}", "\u{308}", "\u{11A8}"]),
- ("\u{A}\u{AC00}", &["\u{A}", "\u{AC00}"]),
- ("\u{A}\u{308}\u{AC00}", &["\u{A}", "\u{308}", "\u{AC00}"]),
- ("\u{A}\u{AC01}", &["\u{A}", "\u{AC01}"]),
- ("\u{A}\u{308}\u{AC01}", &["\u{A}", "\u{308}", "\u{AC01}"]),
- ("\u{A}\u{1F1E6}", &["\u{A}", "\u{1F1E6}"]),
- ("\u{A}\u{308}\u{1F1E6}", &["\u{A}", "\u{308}", "\u{1F1E6}"]),
- ("\u{A}\u{378}", &["\u{A}", "\u{378}"]),
- ("\u{A}\u{308}\u{378}", &["\u{A}", "\u{308}", "\u{378}"]),
- ("\u{1}\u{20}", &["\u{1}", "\u{20}"]),
- ("\u{1}\u{308}\u{20}", &["\u{1}", "\u{308}", "\u{20}"]),
- ("\u{1}\u{D}", &["\u{1}", "\u{D}"]),
- ("\u{1}\u{308}\u{D}", &["\u{1}", "\u{308}", "\u{D}"]),
- ("\u{1}\u{A}", &["\u{1}", "\u{A}"]),
- ("\u{1}\u{308}\u{A}", &["\u{1}", "\u{308}", "\u{A}"]),
- ("\u{1}\u{1}", &["\u{1}", "\u{1}"]),
- ("\u{1}\u{308}\u{1}", &["\u{1}", "\u{308}", "\u{1}"]),
- ("\u{1}\u{300}", &["\u{1}", "\u{300}"]),
- ("\u{1}\u{308}\u{300}", &["\u{1}", "\u{308}\u{300}"]),
- ("\u{1}\u{903}", &["\u{1}", "\u{903}"]),
- ("\u{1}\u{1100}", &["\u{1}", "\u{1100}"]),
- ("\u{1}\u{308}\u{1100}", &["\u{1}", "\u{308}", "\u{1100}"]),
- ("\u{1}\u{1160}", &["\u{1}", "\u{1160}"]),
- ("\u{1}\u{308}\u{1160}", &["\u{1}", "\u{308}", "\u{1160}"]),
- ("\u{1}\u{11A8}", &["\u{1}", "\u{11A8}"]),
- ("\u{1}\u{308}\u{11A8}", &["\u{1}", "\u{308}", "\u{11A8}"]),
- ("\u{1}\u{AC00}", &["\u{1}", "\u{AC00}"]),
- ("\u{1}\u{308}\u{AC00}", &["\u{1}", "\u{308}", "\u{AC00}"]),
- ("\u{1}\u{AC01}", &["\u{1}", "\u{AC01}"]),
- ("\u{1}\u{308}\u{AC01}", &["\u{1}", "\u{308}", "\u{AC01}"]),
- ("\u{1}\u{1F1E6}", &["\u{1}", "\u{1F1E6}"]),
- ("\u{1}\u{308}\u{1F1E6}", &["\u{1}", "\u{308}", "\u{1F1E6}"]),
- ("\u{1}\u{378}", &["\u{1}", "\u{378}"]),
- ("\u{1}\u{308}\u{378}", &["\u{1}", "\u{308}", "\u{378}"]),
- ("\u{300}\u{20}", &["\u{300}", "\u{20}"]),
- ("\u{300}\u{308}\u{20}", &["\u{300}\u{308}", "\u{20}"]),
- ("\u{300}\u{D}", &["\u{300}", "\u{D}"]),
- ("\u{300}\u{308}\u{D}", &["\u{300}\u{308}", "\u{D}"]),
- ("\u{300}\u{A}", &["\u{300}", "\u{A}"]),
- ("\u{300}\u{308}\u{A}", &["\u{300}\u{308}", "\u{A}"]),
- ("\u{300}\u{1}", &["\u{300}", "\u{1}"]),
- ("\u{300}\u{308}\u{1}", &["\u{300}\u{308}", "\u{1}"]),
- ("\u{300}\u{300}", &["\u{300}\u{300}"]),
- ("\u{300}\u{308}\u{300}", &["\u{300}\u{308}\u{300}"]),
- ("\u{300}\u{1100}", &["\u{300}", "\u{1100}"]),
- ("\u{300}\u{308}\u{1100}", &["\u{300}\u{308}", "\u{1100}"]),
- ("\u{300}\u{1160}", &["\u{300}", "\u{1160}"]),
- ("\u{300}\u{308}\u{1160}", &["\u{300}\u{308}", "\u{1160}"]),
- ("\u{300}\u{11A8}", &["\u{300}", "\u{11A8}"]),
- ("\u{300}\u{308}\u{11A8}", &["\u{300}\u{308}", "\u{11A8}"]),
- ("\u{300}\u{AC00}", &["\u{300}", "\u{AC00}"]),
- ("\u{300}\u{308}\u{AC00}", &["\u{300}\u{308}", "\u{AC00}"]),
- ("\u{300}\u{AC01}", &["\u{300}", "\u{AC01}"]),
- ("\u{300}\u{308}\u{AC01}", &["\u{300}\u{308}", "\u{AC01}"]),
- ("\u{300}\u{1F1E6}", &["\u{300}", "\u{1F1E6}"]),
- ("\u{300}\u{308}\u{1F1E6}", &["\u{300}\u{308}", "\u{1F1E6}"]),
- ("\u{300}\u{378}", &["\u{300}", "\u{378}"]),
- ("\u{300}\u{308}\u{378}", &["\u{300}\u{308}", "\u{378}"]),
- ("\u{903}\u{20}", &["\u{903}", "\u{20}"]),
- ("\u{903}\u{308}\u{20}", &["\u{903}\u{308}", "\u{20}"]),
- ("\u{903}\u{D}", &["\u{903}", "\u{D}"]),
- ("\u{903}\u{308}\u{D}", &["\u{903}\u{308}", "\u{D}"]),
- ("\u{903}\u{A}", &["\u{903}", "\u{A}"]),
- ("\u{903}\u{308}\u{A}", &["\u{903}\u{308}", "\u{A}"]),
- ("\u{903}\u{1}", &["\u{903}", "\u{1}"]),
- ("\u{903}\u{308}\u{1}", &["\u{903}\u{308}", "\u{1}"]),
- ("\u{903}\u{300}", &["\u{903}\u{300}"]),
- ("\u{903}\u{308}\u{300}", &["\u{903}\u{308}\u{300}"]),
- ("\u{903}\u{1100}", &["\u{903}", "\u{1100}"]),
- ("\u{903}\u{308}\u{1100}", &["\u{903}\u{308}", "\u{1100}"]),
- ("\u{903}\u{1160}", &["\u{903}", "\u{1160}"]),
- ("\u{903}\u{308}\u{1160}", &["\u{903}\u{308}", "\u{1160}"]),
- ("\u{903}\u{11A8}", &["\u{903}", "\u{11A8}"]),
- ("\u{903}\u{308}\u{11A8}", &["\u{903}\u{308}", "\u{11A8}"]),
- ("\u{903}\u{AC00}", &["\u{903}", "\u{AC00}"]),
- ("\u{903}\u{308}\u{AC00}", &["\u{903}\u{308}", "\u{AC00}"]),
- ("\u{903}\u{AC01}", &["\u{903}", "\u{AC01}"]),
- ("\u{903}\u{308}\u{AC01}", &["\u{903}\u{308}", "\u{AC01}"]),
- ("\u{903}\u{1F1E6}", &["\u{903}", "\u{1F1E6}"]),
- ("\u{903}\u{308}\u{1F1E6}", &["\u{903}\u{308}", "\u{1F1E6}"]),
- ("\u{903}\u{378}", &["\u{903}", "\u{378}"]),
- ("\u{903}\u{308}\u{378}", &["\u{903}\u{308}", "\u{378}"]),
- ("\u{1100}\u{20}", &["\u{1100}", "\u{20}"]),
- ("\u{1100}\u{308}\u{20}", &["\u{1100}\u{308}", "\u{20}"]),
- ("\u{1100}\u{D}", &["\u{1100}", "\u{D}"]),
- ("\u{1100}\u{308}\u{D}", &["\u{1100}\u{308}", "\u{D}"]),
- ("\u{1100}\u{A}", &["\u{1100}", "\u{A}"]),
- ("\u{1100}\u{308}\u{A}", &["\u{1100}\u{308}", "\u{A}"]),
- ("\u{1100}\u{1}", &["\u{1100}", "\u{1}"]),
- ("\u{1100}\u{308}\u{1}", &["\u{1100}\u{308}", "\u{1}"]),
- ("\u{1100}\u{300}", &["\u{1100}\u{300}"]),
- ("\u{1100}\u{308}\u{300}", &["\u{1100}\u{308}\u{300}"]),
- ("\u{1100}\u{1100}", &["\u{1100}\u{1100}"]),
- ("\u{1100}\u{308}\u{1100}", &["\u{1100}\u{308}", "\u{1100}"]),
- ("\u{1100}\u{1160}", &["\u{1100}\u{1160}"]),
- ("\u{1100}\u{308}\u{1160}", &["\u{1100}\u{308}", "\u{1160}"]),
- ("\u{1100}\u{11A8}", &["\u{1100}", "\u{11A8}"]),
- ("\u{1100}\u{308}\u{11A8}", &["\u{1100}\u{308}", "\u{11A8}"]),
- ("\u{1100}\u{AC00}", &["\u{1100}\u{AC00}"]),
- ("\u{1100}\u{308}\u{AC00}", &["\u{1100}\u{308}", "\u{AC00}"]),
- ("\u{1100}\u{AC01}", &["\u{1100}\u{AC01}"]),
- ("\u{1100}\u{308}\u{AC01}", &["\u{1100}\u{308}", "\u{AC01}"]),
- ("\u{1100}\u{1F1E6}", &["\u{1100}", "\u{1F1E6}"]),
- ("\u{1100}\u{308}\u{1F1E6}", &["\u{1100}\u{308}", "\u{1F1E6}"]),
- ("\u{1100}\u{378}", &["\u{1100}", "\u{378}"]),
- ("\u{1100}\u{308}\u{378}", &["\u{1100}\u{308}", "\u{378}"]),
- ("\u{1160}\u{20}", &["\u{1160}", "\u{20}"]),
- ("\u{1160}\u{308}\u{20}", &["\u{1160}\u{308}", "\u{20}"]),
- ("\u{1160}\u{D}", &["\u{1160}", "\u{D}"]),
- ("\u{1160}\u{308}\u{D}", &["\u{1160}\u{308}", "\u{D}"]),
- ("\u{1160}\u{A}", &["\u{1160}", "\u{A}"]),
- ("\u{1160}\u{308}\u{A}", &["\u{1160}\u{308}", "\u{A}"]),
- ("\u{1160}\u{1}", &["\u{1160}", "\u{1}"]),
- ("\u{1160}\u{308}\u{1}", &["\u{1160}\u{308}", "\u{1}"]),
- ("\u{1160}\u{300}", &["\u{1160}\u{300}"]),
- ("\u{1160}\u{308}\u{300}", &["\u{1160}\u{308}\u{300}"]),
- ("\u{1160}\u{1100}", &["\u{1160}", "\u{1100}"]),
- ("\u{1160}\u{308}\u{1100}", &["\u{1160}\u{308}", "\u{1100}"]),
- ("\u{1160}\u{1160}", &["\u{1160}\u{1160}"]),
- ("\u{1160}\u{308}\u{1160}", &["\u{1160}\u{308}", "\u{1160}"]),
- ("\u{1160}\u{11A8}", &["\u{1160}\u{11A8}"]),
- ("\u{1160}\u{308}\u{11A8}", &["\u{1160}\u{308}", "\u{11A8}"]),
- ("\u{1160}\u{AC00}", &["\u{1160}", "\u{AC00}"]),
- ("\u{1160}\u{308}\u{AC00}", &["\u{1160}\u{308}", "\u{AC00}"]),
- ("\u{1160}\u{AC01}", &["\u{1160}", "\u{AC01}"]),
- ("\u{1160}\u{308}\u{AC01}", &["\u{1160}\u{308}", "\u{AC01}"]),
- ("\u{1160}\u{1F1E6}", &["\u{1160}", "\u{1F1E6}"]),
- ("\u{1160}\u{308}\u{1F1E6}", &["\u{1160}\u{308}", "\u{1F1E6}"]),
- ("\u{1160}\u{378}", &["\u{1160}", "\u{378}"]),
- ("\u{1160}\u{308}\u{378}", &["\u{1160}\u{308}", "\u{378}"]),
- ("\u{11A8}\u{20}", &["\u{11A8}", "\u{20}"]),
- ("\u{11A8}\u{308}\u{20}", &["\u{11A8}\u{308}", "\u{20}"]),
- ("\u{11A8}\u{D}", &["\u{11A8}", "\u{D}"]),
- ("\u{11A8}\u{308}\u{D}", &["\u{11A8}\u{308}", "\u{D}"]),
- ("\u{11A8}\u{A}", &["\u{11A8}", "\u{A}"]),
- ("\u{11A8}\u{308}\u{A}", &["\u{11A8}\u{308}", "\u{A}"]),
- ("\u{11A8}\u{1}", &["\u{11A8}", "\u{1}"]),
- ("\u{11A8}\u{308}\u{1}", &["\u{11A8}\u{308}", "\u{1}"]),
- ("\u{11A8}\u{300}", &["\u{11A8}\u{300}"]),
- ("\u{11A8}\u{308}\u{300}", &["\u{11A8}\u{308}\u{300}"]),
- ("\u{11A8}\u{1100}", &["\u{11A8}", "\u{1100}"]),
- ("\u{11A8}\u{308}\u{1100}", &["\u{11A8}\u{308}", "\u{1100}"]),
- ("\u{11A8}\u{1160}", &["\u{11A8}", "\u{1160}"]),
- ("\u{11A8}\u{308}\u{1160}", &["\u{11A8}\u{308}", "\u{1160}"]),
- ("\u{11A8}\u{11A8}", &["\u{11A8}\u{11A8}"]),
- ("\u{11A8}\u{308}\u{11A8}", &["\u{11A8}\u{308}", "\u{11A8}"]),
- ("\u{11A8}\u{AC00}", &["\u{11A8}", "\u{AC00}"]),
- ("\u{11A8}\u{308}\u{AC00}", &["\u{11A8}\u{308}", "\u{AC00}"]),
- ("\u{11A8}\u{AC01}", &["\u{11A8}", "\u{AC01}"]),
- ("\u{11A8}\u{308}\u{AC01}", &["\u{11A8}\u{308}", "\u{AC01}"]),
- ("\u{11A8}\u{1F1E6}", &["\u{11A8}", "\u{1F1E6}"]),
- ("\u{11A8}\u{308}\u{1F1E6}", &["\u{11A8}\u{308}", "\u{1F1E6}"]),
- ("\u{11A8}\u{378}", &["\u{11A8}", "\u{378}"]),
- ("\u{11A8}\u{308}\u{378}", &["\u{11A8}\u{308}", "\u{378}"]),
- ("\u{AC00}\u{20}", &["\u{AC00}", "\u{20}"]),
- ("\u{AC00}\u{308}\u{20}", &["\u{AC00}\u{308}", "\u{20}"]),
- ("\u{AC00}\u{D}", &["\u{AC00}", "\u{D}"]),
- ("\u{AC00}\u{308}\u{D}", &["\u{AC00}\u{308}", "\u{D}"]),
- ("\u{AC00}\u{A}", &["\u{AC00}", "\u{A}"]),
- ("\u{AC00}\u{308}\u{A}", &["\u{AC00}\u{308}", "\u{A}"]),
- ("\u{AC00}\u{1}", &["\u{AC00}", "\u{1}"]),
- ("\u{AC00}\u{308}\u{1}", &["\u{AC00}\u{308}", "\u{1}"]),
- ("\u{AC00}\u{300}", &["\u{AC00}\u{300}"]),
- ("\u{AC00}\u{308}\u{300}", &["\u{AC00}\u{308}\u{300}"]),
- ("\u{AC00}\u{1100}", &["\u{AC00}", "\u{1100}"]),
- ("\u{AC00}\u{308}\u{1100}", &["\u{AC00}\u{308}", "\u{1100}"]),
- ("\u{AC00}\u{1160}", &["\u{AC00}\u{1160}"]),
- ("\u{AC00}\u{308}\u{1160}", &["\u{AC00}\u{308}", "\u{1160}"]),
- ("\u{AC00}\u{11A8}", &["\u{AC00}\u{11A8}"]),
- ("\u{AC00}\u{308}\u{11A8}", &["\u{AC00}\u{308}", "\u{11A8}"]),
- ("\u{AC00}\u{AC00}", &["\u{AC00}", "\u{AC00}"]),
- ("\u{AC00}\u{308}\u{AC00}", &["\u{AC00}\u{308}", "\u{AC00}"]),
- ("\u{AC00}\u{AC01}", &["\u{AC00}", "\u{AC01}"]),
- ("\u{AC00}\u{308}\u{AC01}", &["\u{AC00}\u{308}", "\u{AC01}"]),
- ("\u{AC00}\u{1F1E6}", &["\u{AC00}", "\u{1F1E6}"]),
- ("\u{AC00}\u{308}\u{1F1E6}", &["\u{AC00}\u{308}", "\u{1F1E6}"]),
- ("\u{AC00}\u{378}", &["\u{AC00}", "\u{378}"]),
- ("\u{AC00}\u{308}\u{378}", &["\u{AC00}\u{308}", "\u{378}"]),
- ("\u{AC01}\u{20}", &["\u{AC01}", "\u{20}"]),
- ("\u{AC01}\u{308}\u{20}", &["\u{AC01}\u{308}", "\u{20}"]),
- ("\u{AC01}\u{D}", &["\u{AC01}", "\u{D}"]),
- ("\u{AC01}\u{308}\u{D}", &["\u{AC01}\u{308}", "\u{D}"]),
- ("\u{AC01}\u{A}", &["\u{AC01}", "\u{A}"]),
- ("\u{AC01}\u{308}\u{A}", &["\u{AC01}\u{308}", "\u{A}"]),
- ("\u{AC01}\u{1}", &["\u{AC01}", "\u{1}"]),
- ("\u{AC01}\u{308}\u{1}", &["\u{AC01}\u{308}", "\u{1}"]),
- ("\u{AC01}\u{300}", &["\u{AC01}\u{300}"]),
- ("\u{AC01}\u{308}\u{300}", &["\u{AC01}\u{308}\u{300}"]),
- ("\u{AC01}\u{1100}", &["\u{AC01}", "\u{1100}"]),
- ("\u{AC01}\u{308}\u{1100}", &["\u{AC01}\u{308}", "\u{1100}"]),
- ("\u{AC01}\u{1160}", &["\u{AC01}", "\u{1160}"]),
- ("\u{AC01}\u{308}\u{1160}", &["\u{AC01}\u{308}", "\u{1160}"]),
- ("\u{AC01}\u{11A8}", &["\u{AC01}\u{11A8}"]),
- ("\u{AC01}\u{308}\u{11A8}", &["\u{AC01}\u{308}", "\u{11A8}"]),
- ("\u{AC01}\u{AC00}", &["\u{AC01}", "\u{AC00}"]),
- ("\u{AC01}\u{308}\u{AC00}", &["\u{AC01}\u{308}", "\u{AC00}"]),
- ("\u{AC01}\u{AC01}", &["\u{AC01}", "\u{AC01}"]),
- ("\u{AC01}\u{308}\u{AC01}", &["\u{AC01}\u{308}", "\u{AC01}"]),
- ("\u{AC01}\u{1F1E6}", &["\u{AC01}", "\u{1F1E6}"]),
- ("\u{AC01}\u{308}\u{1F1E6}", &["\u{AC01}\u{308}", "\u{1F1E6}"]),
- ("\u{AC01}\u{378}", &["\u{AC01}", "\u{378}"]),
- ("\u{AC01}\u{308}\u{378}", &["\u{AC01}\u{308}", "\u{378}"]),
- ("\u{1F1E6}\u{20}", &["\u{1F1E6}", "\u{20}"]),
- ("\u{1F1E6}\u{308}\u{20}", &["\u{1F1E6}\u{308}", "\u{20}"]),
- ("\u{1F1E6}\u{D}", &["\u{1F1E6}", "\u{D}"]),
- ("\u{1F1E6}\u{308}\u{D}", &["\u{1F1E6}\u{308}", "\u{D}"]),
- ("\u{1F1E6}\u{A}", &["\u{1F1E6}", "\u{A}"]),
- ("\u{1F1E6}\u{308}\u{A}", &["\u{1F1E6}\u{308}", "\u{A}"]),
- ("\u{1F1E6}\u{1}", &["\u{1F1E6}", "\u{1}"]),
- ("\u{1F1E6}\u{308}\u{1}", &["\u{1F1E6}\u{308}", "\u{1}"]),
- ("\u{1F1E6}\u{300}", &["\u{1F1E6}\u{300}"]),
- ("\u{1F1E6}\u{308}\u{300}", &["\u{1F1E6}\u{308}\u{300}"]),
- ("\u{1F1E6}\u{1100}", &["\u{1F1E6}", "\u{1100}"]),
- ("\u{1F1E6}\u{308}\u{1100}", &["\u{1F1E6}\u{308}", "\u{1100}"]),
- ("\u{1F1E6}\u{1160}", &["\u{1F1E6}", "\u{1160}"]),
- ("\u{1F1E6}\u{308}\u{1160}", &["\u{1F1E6}\u{308}", "\u{1160}"]),
- ("\u{1F1E6}\u{11A8}", &["\u{1F1E6}", "\u{11A8}"]),
- ("\u{1F1E6}\u{308}\u{11A8}", &["\u{1F1E6}\u{308}", "\u{11A8}"]),
- ("\u{1F1E6}\u{AC00}", &["\u{1F1E6}", "\u{AC00}"]),
- ("\u{1F1E6}\u{308}\u{AC00}", &["\u{1F1E6}\u{308}", "\u{AC00}"]),
- ("\u{1F1E6}\u{AC01}", &["\u{1F1E6}", "\u{AC01}"]),
- ("\u{1F1E6}\u{308}\u{AC01}", &["\u{1F1E6}\u{308}", "\u{AC01}"]),
- ("\u{1F1E6}\u{1F1E6}", &["\u{1F1E6}\u{1F1E6}"]),
- ("\u{1F1E6}\u{308}\u{1F1E6}", &["\u{1F1E6}\u{308}", "\u{1F1E6}"]),
- ("\u{1F1E6}\u{378}", &["\u{1F1E6}", "\u{378}"]),
- ("\u{1F1E6}\u{308}\u{378}", &["\u{1F1E6}\u{308}", "\u{378}"]),
- ("\u{378}\u{20}", &["\u{378}", "\u{20}"]),
- ("\u{378}\u{308}\u{20}", &["\u{378}\u{308}", "\u{20}"]),
- ("\u{378}\u{D}", &["\u{378}", "\u{D}"]),
- ("\u{378}\u{308}\u{D}", &["\u{378}\u{308}", "\u{D}"]),
- ("\u{378}\u{A}", &["\u{378}", "\u{A}"]),
- ("\u{378}\u{308}\u{A}", &["\u{378}\u{308}", "\u{A}"]),
- ("\u{378}\u{1}", &["\u{378}", "\u{1}"]),
- ("\u{378}\u{308}\u{1}", &["\u{378}\u{308}", "\u{1}"]),
- ("\u{378}\u{300}", &["\u{378}\u{300}"]),
- ("\u{378}\u{308}\u{300}", &["\u{378}\u{308}\u{300}"]),
- ("\u{378}\u{1100}", &["\u{378}", "\u{1100}"]),
- ("\u{378}\u{308}\u{1100}", &["\u{378}\u{308}", "\u{1100}"]),
- ("\u{378}\u{1160}", &["\u{378}", "\u{1160}"]),
- ("\u{378}\u{308}\u{1160}", &["\u{378}\u{308}", "\u{1160}"]),
- ("\u{378}\u{11A8}", &["\u{378}", "\u{11A8}"]),
- ("\u{378}\u{308}\u{11A8}", &["\u{378}\u{308}", "\u{11A8}"]),
- ("\u{378}\u{AC00}", &["\u{378}", "\u{AC00}"]),
- ("\u{378}\u{308}\u{AC00}", &["\u{378}\u{308}", "\u{AC00}"]),
- ("\u{378}\u{AC01}", &["\u{378}", "\u{AC01}"]),
- ("\u{378}\u{308}\u{AC01}", &["\u{378}\u{308}", "\u{AC01}"]),
- ("\u{378}\u{1F1E6}", &["\u{378}", "\u{1F1E6}"]),
- ("\u{378}\u{308}\u{1F1E6}", &["\u{378}\u{308}", "\u{1F1E6}"]),
- ("\u{378}\u{378}", &["\u{378}", "\u{378}"]),
- ("\u{378}\u{308}\u{378}", &["\u{378}\u{308}", "\u{378}"]),
- ("\u{61}\u{1F1E6}\u{62}", &["\u{61}", "\u{1F1E6}", "\u{62}"]),
- ("\u{1F1F7}\u{1F1FA}", &["\u{1F1F7}\u{1F1FA}"]),
- ("\u{1F1F7}\u{1F1FA}\u{1F1F8}", &["\u{1F1F7}\u{1F1FA}\u{1F1F8}"]),
- ("\u{1F1F7}\u{1F1FA}\u{1F1F8}\u{1F1EA}",
- &["\u{1F1F7}\u{1F1FA}\u{1F1F8}\u{1F1EA}"]),
- ("\u{1F1F7}\u{1F1FA}\u{200B}\u{1F1F8}\u{1F1EA}",
- &["\u{1F1F7}\u{1F1FA}", "\u{200B}", "\u{1F1F8}\u{1F1EA}"]),
- ("\u{1F1E6}\u{1F1E7}\u{1F1E8}", &["\u{1F1E6}\u{1F1E7}\u{1F1E8}"]),
- ("\u{1F1E6}\u{200D}\u{1F1E7}\u{1F1E8}", &["\u{1F1E6}\u{200D}",
- "\u{1F1E7}\u{1F1E8}"]),
- ("\u{1F1E6}\u{1F1E7}\u{200D}\u{1F1E8}",
- &["\u{1F1E6}\u{1F1E7}\u{200D}", "\u{1F1E8}"]),
- ("\u{20}\u{200D}\u{646}", &["\u{20}\u{200D}", "\u{646}"]),
- ("\u{646}\u{200D}\u{20}", &["\u{646}\u{200D}", "\u{20}"]),
- ];
-
- let test_diff: [(_, &[_], &[_]); 23] = [
- ("\u{20}\u{903}", &["\u{20}\u{903}"], &["\u{20}", "\u{903}"]), ("\u{20}\u{308}\u{903}",
- &["\u{20}\u{308}\u{903}"], &["\u{20}\u{308}", "\u{903}"]), ("\u{D}\u{308}\u{903}",
- &["\u{D}", "\u{308}\u{903}"], &["\u{D}", "\u{308}", "\u{903}"]), ("\u{A}\u{308}\u{903}",
- &["\u{A}", "\u{308}\u{903}"], &["\u{A}", "\u{308}", "\u{903}"]), ("\u{1}\u{308}\u{903}",
- &["\u{1}", "\u{308}\u{903}"], &["\u{1}", "\u{308}", "\u{903}"]), ("\u{300}\u{903}",
- &["\u{300}\u{903}"], &["\u{300}", "\u{903}"]), ("\u{300}\u{308}\u{903}",
- &["\u{300}\u{308}\u{903}"], &["\u{300}\u{308}", "\u{903}"]), ("\u{903}\u{903}",
- &["\u{903}\u{903}"], &["\u{903}", "\u{903}"]), ("\u{903}\u{308}\u{903}",
- &["\u{903}\u{308}\u{903}"], &["\u{903}\u{308}", "\u{903}"]), ("\u{1100}\u{903}",
- &["\u{1100}\u{903}"], &["\u{1100}", "\u{903}"]), ("\u{1100}\u{308}\u{903}",
- &["\u{1100}\u{308}\u{903}"], &["\u{1100}\u{308}", "\u{903}"]), ("\u{1160}\u{903}",
- &["\u{1160}\u{903}"], &["\u{1160}", "\u{903}"]), ("\u{1160}\u{308}\u{903}",
- &["\u{1160}\u{308}\u{903}"], &["\u{1160}\u{308}", "\u{903}"]), ("\u{11A8}\u{903}",
- &["\u{11A8}\u{903}"], &["\u{11A8}", "\u{903}"]), ("\u{11A8}\u{308}\u{903}",
- &["\u{11A8}\u{308}\u{903}"], &["\u{11A8}\u{308}", "\u{903}"]), ("\u{AC00}\u{903}",
- &["\u{AC00}\u{903}"], &["\u{AC00}", "\u{903}"]), ("\u{AC00}\u{308}\u{903}",
- &["\u{AC00}\u{308}\u{903}"], &["\u{AC00}\u{308}", "\u{903}"]), ("\u{AC01}\u{903}",
- &["\u{AC01}\u{903}"], &["\u{AC01}", "\u{903}"]), ("\u{AC01}\u{308}\u{903}",
- &["\u{AC01}\u{308}\u{903}"], &["\u{AC01}\u{308}", "\u{903}"]), ("\u{1F1E6}\u{903}",
- &["\u{1F1E6}\u{903}"], &["\u{1F1E6}", "\u{903}"]), ("\u{1F1E6}\u{308}\u{903}",
- &["\u{1F1E6}\u{308}\u{903}"], &["\u{1F1E6}\u{308}", "\u{903}"]), ("\u{378}\u{903}",
- &["\u{378}\u{903}"], &["\u{378}", "\u{903}"]), ("\u{378}\u{308}\u{903}",
- &["\u{378}\u{308}\u{903}"], &["\u{378}\u{308}", "\u{903}"]),
- ];
-
- for &(s, g) in &test_same[..] {
- // test forward iterator
- assert!(order::equals(s.graphemes(true), g.iter().cloned()));
- assert!(order::equals(s.graphemes(false), g.iter().cloned()));
-
- // test reverse iterator
- assert!(order::equals(s.graphemes(true).rev(), g.iter().rev().cloned()));
- assert!(order::equals(s.graphemes(false).rev(), g.iter().rev().cloned()));
- }
-
- for &(s, gt, gf) in &test_diff {
- // test forward iterator
- assert!(order::equals(s.graphemes(true), gt.iter().cloned()));
- assert!(order::equals(s.graphemes(false), gf.iter().cloned()));
-
- // test reverse iterator
- assert!(order::equals(s.graphemes(true).rev(), gt.iter().rev().cloned()));
- assert!(order::equals(s.graphemes(false).rev(), gf.iter().rev().cloned()));
- }
-
- // test the indices iterators
- let s = "a̐éö̲\r\n";
- let gr_inds = s.grapheme_indices(true).collect::<Vec<(usize, &str)>>();
- let b: &[_] = &[(0, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")];
- assert_eq!(gr_inds, b);
- let gr_inds = s.grapheme_indices(true).rev().collect::<Vec<(usize, &str)>>();
- let b: &[_] = &[(11, "\r\n"), (6, "ö̲"), (3, "é"), (0, "a̐")];
- assert_eq!(gr_inds, b);
- let mut gr_inds_iter = s.grapheme_indices(true);
- {
- let gr_inds = gr_inds_iter.by_ref();
- let e1 = gr_inds.size_hint();
- assert_eq!(e1, (1, Some(13)));
- let c = gr_inds.count();
- assert_eq!(c, 4);
- }
- let e2 = gr_inds_iter.size_hint();
- assert_eq!(e2, (0, Some(0)));
-
- // make sure the reverse iterator does the right thing with "\n" at beginning of string
- let s = "\n\r\n\r";
- let gr = s.graphemes(true).rev().collect::<Vec<&str>>();
- let b: &[_] = &["\r", "\r\n", "\n"];
- assert_eq!(gr, b);
- }
-
- #[test]
- fn test_split_strator() {
- fn t(s: &str, sep: &str, u: &[&str]) {
- let v: Vec<&str> = s.split_str(sep).collect();
- assert_eq!(v, u);
- }
- t("--1233345--", "12345", &["--1233345--"]);
- t("abc::hello::there", "::", &["abc", "hello", "there"]);
- t("::hello::there", "::", &["", "hello", "there"]);
- t("hello::there::", "::", &["hello", "there", ""]);
- t("::hello::there::", "::", &["", "hello", "there", ""]);
- t("ประเทศไทย中华Việt Nam", "中华", &["ประเทศไทย", "Việt Nam"]);
- t("zzXXXzzYYYzz", "zz", &["", "XXX", "YYY", ""]);
- t("zzXXXzYYYz", "XXX", &["zz", "zYYYz"]);
- t(".XXX.YYY.", ".", &["", "XXX", "YYY", ""]);
- t("", ".", &[""]);
- t("zz", "zz", &["",""]);
- t("ok", "z", &["ok"]);
- t("zzz", "zz", &["","z"]);
- t("zzzzz", "zz", &["","","z"]);
- }
-
- #[test]
- fn test_str_default() {
- use core::default::Default;
- fn t<S: Default + Str>() {
- let s: S = Default::default();
- assert_eq!(s.as_slice(), "");
- }
-
- t::<&str>();
- t::<String>();
- }
-
- #[test]
- fn test_str_container() {
- fn sum_len(v: &[&str]) -> usize {
- v.iter().map(|x| x.len()).sum()
- }
-
- let s = String::from_str("01234");
- assert_eq!(5, sum_len(&["012", "", "34"]));
- assert_eq!(5, sum_len(&[&String::from_str("01"),
- &String::from_str("2"),
- &String::from_str("34"),
- &String::from_str("")]));
- assert_eq!(5, sum_len(&[&s]));
- }
-
- #[test]
- fn test_str_from_utf8() {
- let xs = b"hello";
- assert_eq!(from_utf8(xs), Ok("hello"));
-
- let xs = "ศไทย中华Việt Nam".as_bytes();
- assert_eq!(from_utf8(xs), Ok("ศไทย中华Việt Nam"));
-
- let xs = b"hello\xFF";
- assert_eq!(from_utf8(xs), Err(Utf8Error::TooShort));
- }
-}
-
-#[cfg(test)]
-mod bench {
- use super::*;
- use prelude::{SliceExt, IteratorExt, SliceConcatExt};
- use test::Bencher;
- use test::black_box;
-
- #[bench]
- fn char_iterator(b: &mut Bencher) {
- let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
-
- b.iter(|| s.chars().count());
- }
-
- #[bench]
- fn char_iterator_for(b: &mut Bencher) {
- let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
-
- b.iter(|| {
- for ch in s.chars() { black_box(ch); }
- });
- }
-
- #[bench]
- fn char_iterator_ascii(b: &mut Bencher) {
- let s = "Mary had a little lamb, Little lamb
- Mary had a little lamb, Little lamb
- Mary had a little lamb, Little lamb
- Mary had a little lamb, Little lamb
- Mary had a little lamb, Little lamb
- Mary had a little lamb, Little lamb";
-
- b.iter(|| s.chars().count());
- }
-
- #[bench]
- fn char_iterator_rev(b: &mut Bencher) {
- let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
-
- b.iter(|| s.chars().rev().count());
- }
-
- #[bench]
- fn char_iterator_rev_for(b: &mut Bencher) {
- let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
-
- b.iter(|| {
- for ch in s.chars().rev() { black_box(ch); }
- });
- }
-
- #[bench]
- fn char_indicesator(b: &mut Bencher) {
- let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
- let len = s.chars().count();
-
- b.iter(|| assert_eq!(s.char_indices().count(), len));
- }
-
- #[bench]
- fn char_indicesator_rev(b: &mut Bencher) {
- let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
- let len = s.chars().count();
-
- b.iter(|| assert_eq!(s.char_indices().rev().count(), len));
- }
-
- #[bench]
- fn split_unicode_ascii(b: &mut Bencher) {
- let s = "ประเทศไทย中华Việt Namประเทศไทย中华Việt Nam";
-
- b.iter(|| assert_eq!(s.split('V').count(), 3));
- }
-
- #[bench]
- fn split_ascii(b: &mut Bencher) {
- let s = "Mary had a little lamb, Little lamb, little-lamb.";
- let len = s.split(' ').count();
-
- b.iter(|| assert_eq!(s.split(' ').count(), len));
- }
-
- #[bench]
- fn split_extern_fn(b: &mut Bencher) {
- let s = "Mary had a little lamb, Little lamb, little-lamb.";
- let len = s.split(' ').count();
- fn pred(c: char) -> bool { c == ' ' }
-
- b.iter(|| assert_eq!(s.split(pred).count(), len));
- }
-
- #[bench]
- fn split_closure(b: &mut Bencher) {
- let s = "Mary had a little lamb, Little lamb, little-lamb.";
- let len = s.split(' ').count();
-
- b.iter(|| assert_eq!(s.split(|c: char| c == ' ').count(), len));
- }
-
- #[bench]
- fn split_slice(b: &mut Bencher) {
- let s = "Mary had a little lamb, Little lamb, little-lamb.";
- let len = s.split(' ').count();
-
- let c: &[char] = &[' '];
- b.iter(|| assert_eq!(s.split(c).count(), len));
- }
-
- #[bench]
- fn bench_connect(b: &mut Bencher) {
- let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
- let sep = "→";
- let v = vec![s, s, s, s, s, s, s, s, s, s];
- b.iter(|| {
- assert_eq!(v.connect(sep).len(), s.len() * 10 + sep.len() * 9);
- })
- }
-
- #[bench]
- fn bench_contains_short_short(b: &mut Bencher) {
- let haystack = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
- let needle = "sit";
-
- b.iter(|| {
- assert!(haystack.contains(needle));
- })
- }
-
- #[bench]
- fn bench_contains_short_long(b: &mut Bencher) {
- let haystack = "\
-Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse quis lorem sit amet dolor \
-ultricies condimentum. Praesent iaculis purus elit, ac malesuada quam malesuada in. Duis sed orci \
-eros. Suspendisse sit amet magna mollis, mollis nunc luctus, imperdiet mi. Integer fringilla non \
-sem ut lacinia. Fusce varius tortor a risus porttitor hendrerit. Morbi mauris dui, ultricies nec \
-tempus vel, gravida nec quam.
-
-In est dui, tincidunt sed tempus interdum, adipiscing laoreet ante. Etiam tempor, tellus quis \
-sagittis interdum, nulla purus mattis sem, quis auctor erat odio ac tellus. In nec nunc sit amet \
-diam volutpat molestie at sed ipsum. Vestibulum laoreet consequat vulputate. Integer accumsan \
-lorem ac dignissim placerat. Suspendisse convallis faucibus lorem. Aliquam erat volutpat. In vel \
-eleifend felis. Sed suscipit nulla lorem, sed mollis est sollicitudin et. Nam fermentum egestas \
-interdum. Curabitur ut nisi justo.
-
-Sed sollicitudin ipsum tellus, ut condimentum leo eleifend nec. Cras ut velit ante. Phasellus nec \
-mollis odio. Mauris molestie erat in arcu mattis, at aliquet dolor vehicula. Quisque malesuada \
-lectus sit amet nisi pretium, a condimentum ipsum porta. Morbi at dapibus diam. Praesent egestas \
-est sed risus elementum, eu rutrum metus ultrices. Etiam fermentum consectetur magna, id rutrum \
-felis accumsan a. Aliquam ut pellentesque libero. Sed mi nulla, lobortis eu tortor id, suscipit \
-ultricies neque. Morbi iaculis sit amet risus at iaculis. Praesent eget ligula quis turpis \
-feugiat suscipit vel non arcu. Interdum et malesuada fames ac ante ipsum primis in faucibus. \
-Aliquam sit amet placerat lorem.
-
-Cras a lacus vel ante posuere elementum. Nunc est leo, bibendum ut facilisis vel, bibendum at \
-mauris. Nullam adipiscing diam vel odio ornare, luctus adipiscing mi luctus. Nulla facilisi. \
-Mauris adipiscing bibendum neque, quis adipiscing lectus tempus et. Sed feugiat erat et nisl \
-lobortis pharetra. Donec vitae erat enim. Nullam sit amet felis et quam lacinia tincidunt. Aliquam \
-suscipit dapibus urna. Sed volutpat urna in magna pulvinar volutpat. Phasellus nec tellus ac diam \
-cursus accumsan.
-
-Nam lectus enim, dapibus non nisi tempor, consectetur convallis massa. Maecenas eleifend dictum \
-feugiat. Etiam quis mauris vel risus luctus mattis a a nunc. Nullam orci quam, imperdiet id \
-vehicula in, porttitor ut nibh. Duis sagittis adipiscing nisl vitae congue. Donec mollis risus eu \
-leo suscipit, varius porttitor nulla porta. Pellentesque ut sem nec nisi euismod vehicula. Nulla \
-malesuada sollicitudin quam eu fermentum.";
- let needle = "english";
-
- b.iter(|| {
- assert!(!haystack.contains(needle));
- })
- }
-
- #[bench]
- fn bench_contains_bad_naive(b: &mut Bencher) {
- let haystack = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
- let needle = "aaaaaaaab";
-
- b.iter(|| {
- assert!(!haystack.contains(needle));
- })
- }
-
- #[bench]
- fn bench_contains_equal(b: &mut Bencher) {
- let haystack = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
- let needle = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
-
- b.iter(|| {
- assert!(haystack.contains(needle));
- })
- }
-}
Ok(())
}
}
-
-#[cfg(test)]
-mod tests {
- use prelude::*;
- use test::Bencher;
-
- use str::Utf8Error;
- use core::iter::repeat;
- use super::{as_string, CowString};
-
- #[test]
- fn test_as_string() {
- let x = "foo";
- assert_eq!(x, &**as_string(x));
- }
-
- #[test]
- fn test_from_str() {
- let owned: Option<::std::string::String> = "string".parse().ok();
- assert_eq!(owned.as_ref().map(|s| &**s), Some("string"));
- }
-
- #[test]
- fn test_unsized_to_string() {
- let s: &str = "abc";
- let _: String = (*s).to_string();
- }
-
- #[test]
- fn test_from_utf8() {
- let xs = b"hello".to_vec();
- assert_eq!(String::from_utf8(xs).unwrap(),
- String::from_str("hello"));
-
- let xs = "ศไทย中华Việt Nam".as_bytes().to_vec();
- assert_eq!(String::from_utf8(xs).unwrap(),
- String::from_str("ศไทย中华Việt Nam"));
-
- let xs = b"hello\xFF".to_vec();
- let err = String::from_utf8(xs).err().unwrap();
- assert_eq!(err.utf8_error(), Utf8Error::TooShort);
- assert_eq!(err.into_bytes(), b"hello\xff".to_vec());
- }
-
- #[test]
- fn test_from_utf8_lossy() {
- let xs = b"hello";
- let ys: CowString = "hello".into_cow();
- assert_eq!(String::from_utf8_lossy(xs), ys);
-
- let xs = "ศไทย中华Việt Nam".as_bytes();
- let ys: CowString = "ศไทย中华Việt Nam".into_cow();
- assert_eq!(String::from_utf8_lossy(xs), ys);
-
- let xs = b"Hello\xC2 There\xFF Goodbye";
- assert_eq!(String::from_utf8_lossy(xs),
- String::from_str("Hello\u{FFFD} There\u{FFFD} Goodbye").into_cow());
-
- let xs = b"Hello\xC0\x80 There\xE6\x83 Goodbye";
- assert_eq!(String::from_utf8_lossy(xs),
- String::from_str("Hello\u{FFFD}\u{FFFD} There\u{FFFD} Goodbye").into_cow());
-
- let xs = b"\xF5foo\xF5\x80bar";
- assert_eq!(String::from_utf8_lossy(xs),
- String::from_str("\u{FFFD}foo\u{FFFD}\u{FFFD}bar").into_cow());
-
- let xs = b"\xF1foo\xF1\x80bar\xF1\x80\x80baz";
- assert_eq!(String::from_utf8_lossy(xs),
- String::from_str("\u{FFFD}foo\u{FFFD}bar\u{FFFD}baz").into_cow());
-
- let xs = b"\xF4foo\xF4\x80bar\xF4\xBFbaz";
- assert_eq!(String::from_utf8_lossy(xs),
- String::from_str("\u{FFFD}foo\u{FFFD}bar\u{FFFD}\u{FFFD}baz").into_cow());
-
- let xs = b"\xF0\x80\x80\x80foo\xF0\x90\x80\x80bar";
- assert_eq!(String::from_utf8_lossy(xs), String::from_str("\u{FFFD}\u{FFFD}\u{FFFD}\u{FFFD}\
- foo\u{10000}bar").into_cow());
-
- // surrogates
- let xs = b"\xED\xA0\x80foo\xED\xBF\xBFbar";
- assert_eq!(String::from_utf8_lossy(xs), String::from_str("\u{FFFD}\u{FFFD}\u{FFFD}foo\
- \u{FFFD}\u{FFFD}\u{FFFD}bar").into_cow());
- }
-
- #[test]
- fn test_from_utf16() {
- let pairs =
- [(String::from_str("𐍅𐌿𐌻𐍆𐌹𐌻𐌰\n"),
- vec![0xd800, 0xdf45, 0xd800, 0xdf3f,
- 0xd800, 0xdf3b, 0xd800, 0xdf46,
- 0xd800, 0xdf39, 0xd800, 0xdf3b,
- 0xd800, 0xdf30, 0x000a]),
-
- (String::from_str("𐐒𐑉𐐮𐑀𐐲𐑋 𐐏𐐲𐑍\n"),
- vec![0xd801, 0xdc12, 0xd801,
- 0xdc49, 0xd801, 0xdc2e, 0xd801,
- 0xdc40, 0xd801, 0xdc32, 0xd801,
- 0xdc4b, 0x0020, 0xd801, 0xdc0f,
- 0xd801, 0xdc32, 0xd801, 0xdc4d,
- 0x000a]),
-
- (String::from_str("𐌀𐌖𐌋𐌄𐌑𐌉·𐌌𐌄𐌕𐌄𐌋𐌉𐌑\n"),
- vec![0xd800, 0xdf00, 0xd800, 0xdf16,
- 0xd800, 0xdf0b, 0xd800, 0xdf04,
- 0xd800, 0xdf11, 0xd800, 0xdf09,
- 0x00b7, 0xd800, 0xdf0c, 0xd800,
- 0xdf04, 0xd800, 0xdf15, 0xd800,
- 0xdf04, 0xd800, 0xdf0b, 0xd800,
- 0xdf09, 0xd800, 0xdf11, 0x000a ]),
-
- (String::from_str("𐒋𐒘𐒈𐒑𐒛𐒒 𐒕𐒓 𐒈𐒚𐒍 𐒏𐒜𐒒𐒖𐒆 𐒕𐒆\n"),
- vec![0xd801, 0xdc8b, 0xd801, 0xdc98,
- 0xd801, 0xdc88, 0xd801, 0xdc91,
- 0xd801, 0xdc9b, 0xd801, 0xdc92,
- 0x0020, 0xd801, 0xdc95, 0xd801,
- 0xdc93, 0x0020, 0xd801, 0xdc88,
- 0xd801, 0xdc9a, 0xd801, 0xdc8d,
- 0x0020, 0xd801, 0xdc8f, 0xd801,
- 0xdc9c, 0xd801, 0xdc92, 0xd801,
- 0xdc96, 0xd801, 0xdc86, 0x0020,
- 0xd801, 0xdc95, 0xd801, 0xdc86,
- 0x000a ]),
- // Issue #12318, even-numbered non-BMP planes
- (String::from_str("\u{20000}"),
- vec![0xD840, 0xDC00])];
-
- for p in &pairs {
- let (s, u) = (*p).clone();
- let s_as_utf16 = s.utf16_units().collect::<Vec<u16>>();
- let u_as_string = String::from_utf16(&u).unwrap();
-
- assert!(::unicode::str::is_utf16(&u));
- assert_eq!(s_as_utf16, u);
-
- assert_eq!(u_as_string, s);
- assert_eq!(String::from_utf16_lossy(&u), s);
-
- assert_eq!(String::from_utf16(&s_as_utf16).unwrap(), s);
- assert_eq!(u_as_string.utf16_units().collect::<Vec<u16>>(), u);
- }
- }
-
- #[test]
- fn test_utf16_invalid() {
- // completely positive cases tested above.
- // lead + eof
- assert!(String::from_utf16(&[0xD800]).is_err());
- // lead + lead
- assert!(String::from_utf16(&[0xD800, 0xD800]).is_err());
-
- // isolated trail
- assert!(String::from_utf16(&[0x0061, 0xDC00]).is_err());
-
- // general
- assert!(String::from_utf16(&[0xD800, 0xd801, 0xdc8b, 0xD800]).is_err());
- }
-
- #[test]
- fn test_from_utf16_lossy() {
- // completely positive cases tested above.
- // lead + eof
- assert_eq!(String::from_utf16_lossy(&[0xD800]), String::from_str("\u{FFFD}"));
- // lead + lead
- assert_eq!(String::from_utf16_lossy(&[0xD800, 0xD800]),
- String::from_str("\u{FFFD}\u{FFFD}"));
-
- // isolated trail
- assert_eq!(String::from_utf16_lossy(&[0x0061, 0xDC00]), String::from_str("a\u{FFFD}"));
-
- // general
- assert_eq!(String::from_utf16_lossy(&[0xD800, 0xd801, 0xdc8b, 0xD800]),
- String::from_str("\u{FFFD}𐒋\u{FFFD}"));
- }
-
- #[test]
- fn test_push_bytes() {
- let mut s = String::from_str("ABC");
- unsafe {
- let mv = s.as_mut_vec();
- mv.push_all(&[b'D']);
- }
- assert_eq!(s, "ABCD");
- }
-
- #[test]
- fn test_push_str() {
- let mut s = String::new();
- s.push_str("");
- assert_eq!(&s[0..], "");
- s.push_str("abc");
- assert_eq!(&s[0..], "abc");
- s.push_str("ประเทศไทย中华Việt Nam");
- assert_eq!(&s[0..], "abcประเทศไทย中华Việt Nam");
- }
-
- #[test]
- fn test_push() {
- let mut data = String::from_str("ประเทศไทย中");
- data.push('华');
- data.push('b'); // 1 byte
- data.push('¢'); // 2 byte
- data.push('€'); // 3 byte
- data.push('𤭢'); // 4 byte
- assert_eq!(data, "ประเทศไทย中华b¢€𤭢");
- }
-
- #[test]
- fn test_pop() {
- let mut data = String::from_str("ประเทศไทย中华b¢€𤭢");
- assert_eq!(data.pop().unwrap(), '𤭢'); // 4 bytes
- assert_eq!(data.pop().unwrap(), '€'); // 3 bytes
- assert_eq!(data.pop().unwrap(), '¢'); // 2 bytes
- assert_eq!(data.pop().unwrap(), 'b'); // 1 bytes
- assert_eq!(data.pop().unwrap(), '华');
- assert_eq!(data, "ประเทศไทย中");
- }
-
- #[test]
- fn test_str_truncate() {
- let mut s = String::from_str("12345");
- s.truncate(5);
- assert_eq!(s, "12345");
- s.truncate(3);
- assert_eq!(s, "123");
- s.truncate(0);
- assert_eq!(s, "");
-
- let mut s = String::from_str("12345");
- let p = s.as_ptr();
- s.truncate(3);
- s.push_str("6");
- let p_ = s.as_ptr();
- assert_eq!(p_, p);
- }
-
- #[test]
- #[should_panic]
- fn test_str_truncate_invalid_len() {
- let mut s = String::from_str("12345");
- s.truncate(6);
- }
-
- #[test]
- #[should_panic]
- fn test_str_truncate_split_codepoint() {
- let mut s = String::from_str("\u{FC}"); // ü
- s.truncate(1);
- }
-
- #[test]
- fn test_str_clear() {
- let mut s = String::from_str("12345");
- s.clear();
- assert_eq!(s.len(), 0);
- assert_eq!(s, "");
- }
-
- #[test]
- fn test_str_add() {
- let a = String::from_str("12345");
- let b = a + "2";
- let b = b + "2";
- assert_eq!(b.len(), 7);
- assert_eq!(b, "1234522");
- }
-
- #[test]
- fn remove() {
- let mut s = "ศไทย中华Việt Nam; foobar".to_string();;
- assert_eq!(s.remove(0), 'ศ');
- assert_eq!(s.len(), 33);
- assert_eq!(s, "ไทย中华Việt Nam; foobar");
- assert_eq!(s.remove(17), 'ệ');
- assert_eq!(s, "ไทย中华Vit Nam; foobar");
- }
-
- #[test] #[should_panic]
- fn remove_bad() {
- "ศ".to_string().remove(1);
- }
-
- #[test]
- fn insert() {
- let mut s = "foobar".to_string();
- s.insert(0, 'ệ');
- assert_eq!(s, "ệfoobar");
- s.insert(6, 'ย');
- assert_eq!(s, "ệfooยbar");
- }
-
- #[test] #[should_panic] fn insert_bad1() { "".to_string().insert(1, 't'); }
- #[test] #[should_panic] fn insert_bad2() { "ệ".to_string().insert(1, 't'); }
-
- #[test]
- fn test_slicing() {
- let s = "foobar".to_string();
- assert_eq!("foobar", &s[..]);
- assert_eq!("foo", &s[..3]);
- assert_eq!("bar", &s[3..]);
- assert_eq!("oob", &s[1..4]);
- }
-
- #[test]
- fn test_simple_types() {
- assert_eq!(1.to_string(), "1");
- assert_eq!((-1).to_string(), "-1");
- assert_eq!(200.to_string(), "200");
- assert_eq!(2.to_string(), "2");
- assert_eq!(true.to_string(), "true");
- assert_eq!(false.to_string(), "false");
- assert_eq!(("hi".to_string()).to_string(), "hi");
- }
-
- #[test]
- fn test_vectors() {
- let x: Vec<i32> = vec![];
- assert_eq!(format!("{:?}", x), "[]");
- assert_eq!(format!("{:?}", vec![1]), "[1]");
- assert_eq!(format!("{:?}", vec![1, 2, 3]), "[1, 2, 3]");
- assert!(format!("{:?}", vec![vec![], vec![1], vec![1, 1]]) ==
- "[[], [1], [1, 1]]");
- }
-
- #[test]
- fn test_from_iterator() {
- let s = "ศไทย中华Việt Nam".to_string();
- let t = "ศไทย中华";
- let u = "Việt Nam";
-
- let a: String = s.chars().collect();
- assert_eq!(s, a);
-
- let mut b = t.to_string();
- b.extend(u.chars());
- assert_eq!(s, b);
-
- let c: String = vec![t, u].into_iter().collect();
- assert_eq!(s, c);
-
- let mut d = t.to_string();
- d.extend(vec![u].into_iter());
- assert_eq!(s, d);
- }
-
- #[bench]
- fn bench_with_capacity(b: &mut Bencher) {
- b.iter(|| {
- String::with_capacity(100)
- });
- }
-
- #[bench]
- fn bench_push_str(b: &mut Bencher) {
- let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
- b.iter(|| {
- let mut r = String::new();
- r.push_str(s);
- });
- }
-
- const REPETITIONS: u64 = 10_000;
-
- #[bench]
- fn bench_push_str_one_byte(b: &mut Bencher) {
- b.bytes = REPETITIONS;
- b.iter(|| {
- let mut r = String::new();
- for _ in 0..REPETITIONS {
- r.push_str("a")
- }
- });
- }
-
- #[bench]
- fn bench_push_char_one_byte(b: &mut Bencher) {
- b.bytes = REPETITIONS;
- b.iter(|| {
- let mut r = String::new();
- for _ in 0..REPETITIONS {
- r.push('a')
- }
- });
- }
-
- #[bench]
- fn bench_push_char_two_bytes(b: &mut Bencher) {
- b.bytes = REPETITIONS * 2;
- b.iter(|| {
- let mut r = String::new();
- for _ in 0..REPETITIONS {
- r.push('â')
- }
- });
- }
-
- #[bench]
- fn from_utf8_lossy_100_ascii(b: &mut Bencher) {
- let s = b"Hello there, the quick brown fox jumped over the lazy dog! \
- Lorem ipsum dolor sit amet, consectetur. ";
-
- assert_eq!(100, s.len());
- b.iter(|| {
- let _ = String::from_utf8_lossy(s);
- });
- }
-
- #[bench]
- fn from_utf8_lossy_100_multibyte(b: &mut Bencher) {
- let s = "𐌀𐌖𐌋𐌄𐌑𐌉ปรدولة الكويتทศไทย中华𐍅𐌿𐌻𐍆𐌹𐌻𐌰".as_bytes();
- assert_eq!(100, s.len());
- b.iter(|| {
- let _ = String::from_utf8_lossy(s);
- });
- }
-
- #[bench]
- fn from_utf8_lossy_invalid(b: &mut Bencher) {
- let s = b"Hello\xC0\x80 There\xE6\x83 Goodbye";
- b.iter(|| {
- let _ = String::from_utf8_lossy(s);
- });
- }
-
- #[bench]
- fn from_utf8_lossy_100_invalid(b: &mut Bencher) {
- let s = repeat(0xf5).take(100).collect::<Vec<_>>();
- b.iter(|| {
- let _ = String::from_utf8_lossy(&s);
- });
- }
-
- #[bench]
- fn bench_exact_size_shrink_to_fit(b: &mut Bencher) {
- let s = "Hello there, the quick brown fox jumped over the lazy dog! \
- Lorem ipsum dolor sit amet, consectetur. ";
- // ensure our operation produces an exact-size string before we benchmark it
- let mut r = String::with_capacity(s.len());
- r.push_str(s);
- assert_eq!(r.len(), r.capacity());
- b.iter(|| {
- let mut r = String::with_capacity(s.len());
- r.push_str(s);
- r.shrink_to_fit();
- r
- });
- }
-}
}
}
}
-
-#[cfg(test)]
-mod tests {
- use prelude::*;
- use core::mem::size_of;
- use core::iter::repeat;
- use test::Bencher;
- use super::as_vec;
-
- struct DropCounter<'a> {
- count: &'a mut u32
- }
-
- #[unsafe_destructor]
- impl<'a> Drop for DropCounter<'a> {
- fn drop(&mut self) {
- *self.count += 1;
- }
- }
-
- #[test]
- fn test_as_vec() {
- let xs = [1u8, 2u8, 3u8];
- assert_eq!(&**as_vec(&xs), xs);
- }
-
- #[test]
- fn test_as_vec_dtor() {
- let (mut count_x, mut count_y) = (0, 0);
- {
- let xs = &[DropCounter { count: &mut count_x }, DropCounter { count: &mut count_y }];
- assert_eq!(as_vec(xs).len(), 2);
- }
- assert_eq!(count_x, 1);
- assert_eq!(count_y, 1);
- }
-
- #[test]
- fn test_small_vec_struct() {
- assert!(size_of::<Vec<u8>>() == size_of::<usize>() * 3);
- }
-
- #[test]
- fn test_double_drop() {
- struct TwoVec<T> {
- x: Vec<T>,
- y: Vec<T>
- }
-
- let (mut count_x, mut count_y) = (0, 0);
- {
- let mut tv = TwoVec {
- x: Vec::new(),
- y: Vec::new()
- };
- tv.x.push(DropCounter {count: &mut count_x});
- tv.y.push(DropCounter {count: &mut count_y});
-
- // If Vec had a drop flag, here is where it would be zeroed.
- // Instead, it should rely on its internal state to prevent
- // doing anything significant when dropped multiple times.
- drop(tv.x);
-
- // Here tv goes out of scope, tv.y should be dropped, but not tv.x.
- }
-
- assert_eq!(count_x, 1);
- assert_eq!(count_y, 1);
- }
-
- #[test]
- fn test_reserve() {
- let mut v = Vec::new();
- assert_eq!(v.capacity(), 0);
-
- v.reserve(2);
- assert!(v.capacity() >= 2);
-
- for i in 0..16 {
- v.push(i);
- }
-
- assert!(v.capacity() >= 16);
- v.reserve(16);
- assert!(v.capacity() >= 32);
-
- v.push(16);
-
- v.reserve(16);
- assert!(v.capacity() >= 33)
- }
-
- #[test]
- fn test_extend() {
- let mut v = Vec::new();
- let mut w = Vec::new();
-
- v.extend(0..3);
- for i in 0..3 { w.push(i) }
-
- assert_eq!(v, w);
-
- v.extend(3..10);
- for i in 3..10 { w.push(i) }
-
- assert_eq!(v, w);
- }
-
- #[test]
- fn test_slice_from_mut() {
- let mut values = vec![1, 2, 3, 4, 5];
- {
- let slice = &mut values[2 ..];
- assert!(slice == [3, 4, 5]);
- for p in slice {
- *p += 2;
- }
- }
-
- assert!(values == [1, 2, 5, 6, 7]);
- }
-
- #[test]
- fn test_slice_to_mut() {
- let mut values = vec![1, 2, 3, 4, 5];
- {
- let slice = &mut values[.. 2];
- assert!(slice == [1, 2]);
- for p in slice {
- *p += 1;
- }
- }
-
- assert!(values == [2, 3, 3, 4, 5]);
- }
-
- #[test]
- fn test_split_at_mut() {
- let mut values = vec![1, 2, 3, 4, 5];
- {
- let (left, right) = values.split_at_mut(2);
- {
- let left: &[_] = left;
- assert!(&left[..left.len()] == &[1, 2]);
- }
- for p in left {
- *p += 1;
- }
-
- {
- let right: &[_] = right;
- assert!(&right[..right.len()] == &[3, 4, 5]);
- }
- for p in right {
- *p += 2;
- }
- }
-
- assert_eq!(values, [2, 3, 5, 6, 7]);
- }
-
- #[test]
- fn test_clone() {
- let v: Vec<i32> = vec![];
- let w = vec!(1, 2, 3);
-
- assert_eq!(v, v.clone());
-
- let z = w.clone();
- assert_eq!(w, z);
- // they should be disjoint in memory.
- assert!(w.as_ptr() != z.as_ptr())
- }
-
- #[test]
- fn test_clone_from() {
- let mut v = vec!();
- let three: Vec<Box<_>> = vec!(box 1, box 2, box 3);
- let two: Vec<Box<_>> = vec!(box 4, box 5);
- // zero, long
- v.clone_from(&three);
- assert_eq!(v, three);
-
- // equal
- v.clone_from(&three);
- assert_eq!(v, three);
-
- // long, short
- v.clone_from(&two);
- assert_eq!(v, two);
-
- // short, long
- v.clone_from(&three);
- assert_eq!(v, three)
- }
-
- #[test]
- fn test_retain() {
- let mut vec = vec![1, 2, 3, 4];
- vec.retain(|&x| x % 2 == 0);
- assert_eq!(vec, [2, 4]);
- }
-
- #[test]
- fn zero_sized_values() {
- let mut v = Vec::new();
- assert_eq!(v.len(), 0);
- v.push(());
- assert_eq!(v.len(), 1);
- v.push(());
- assert_eq!(v.len(), 2);
- assert_eq!(v.pop(), Some(()));
- assert_eq!(v.pop(), Some(()));
- assert_eq!(v.pop(), None);
-
- assert_eq!(v.iter().count(), 0);
- v.push(());
- assert_eq!(v.iter().count(), 1);
- v.push(());
- assert_eq!(v.iter().count(), 2);
-
- for &() in &v {}
-
- assert_eq!(v.iter_mut().count(), 2);
- v.push(());
- assert_eq!(v.iter_mut().count(), 3);
- v.push(());
- assert_eq!(v.iter_mut().count(), 4);
-
- for &mut () in &mut v {}
- unsafe { v.set_len(0); }
- assert_eq!(v.iter_mut().count(), 0);
- }
-
- #[test]
- fn test_partition() {
- assert_eq!(vec![].into_iter().partition(|x: &i32| *x < 3), (vec![], vec![]));
- assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 4), (vec![1, 2, 3], vec![]));
- assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 2), (vec![1], vec![2, 3]));
- assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 0), (vec![], vec![1, 2, 3]));
- }
-
- #[test]
- fn test_zip_unzip() {
- let z1 = vec![(1, 4), (2, 5), (3, 6)];
-
- let (left, right): (Vec<_>, Vec<_>) = z1.iter().cloned().unzip();
-
- assert_eq!((1, 4), (left[0], right[0]));
- assert_eq!((2, 5), (left[1], right[1]));
- assert_eq!((3, 6), (left[2], right[2]));
- }
-
- #[test]
- fn test_unsafe_ptrs() {
- unsafe {
- // Test on-stack copy-from-buf.
- let a = [1, 2, 3];
- let ptr = a.as_ptr();
- let b = Vec::from_raw_buf(ptr, 3);
- assert_eq!(b, [1, 2, 3]);
-
- // Test on-heap copy-from-buf.
- let c = vec![1, 2, 3, 4, 5];
- let ptr = c.as_ptr();
- let d = Vec::from_raw_buf(ptr, 5);
- assert_eq!(d, [1, 2, 3, 4, 5]);
- }
- }
-
- #[test]
- fn test_vec_truncate_drop() {
- static mut drops: u32 = 0;
- struct Elem(i32);
- impl Drop for Elem {
- fn drop(&mut self) {
- unsafe { drops += 1; }
- }
- }
-
- let mut v = vec![Elem(1), Elem(2), Elem(3), Elem(4), Elem(5)];
- assert_eq!(unsafe { drops }, 0);
- v.truncate(3);
- assert_eq!(unsafe { drops }, 2);
- v.truncate(0);
- assert_eq!(unsafe { drops }, 5);
- }
-
- #[test]
- #[should_panic]
- fn test_vec_truncate_fail() {
- struct BadElem(i32);
- impl Drop for BadElem {
- fn drop(&mut self) {
- let BadElem(ref mut x) = *self;
- if *x == 0xbadbeef {
- panic!("BadElem panic: 0xbadbeef")
- }
- }
- }
-
- let mut v = vec![BadElem(1), BadElem(2), BadElem(0xbadbeef), BadElem(4)];
- v.truncate(0);
- }
-
- #[test]
- fn test_index() {
- let vec = vec![1, 2, 3];
- assert!(vec[1] == 2);
- }
-
- #[test]
- #[should_panic]
- fn test_index_out_of_bounds() {
- let vec = vec![1, 2, 3];
- let _ = vec[3];
- }
-
- #[test]
- #[should_panic]
- fn test_slice_out_of_bounds_1() {
- let x = vec![1, 2, 3, 4, 5];
- &x[-1..];
- }
-
- #[test]
- #[should_panic]
- fn test_slice_out_of_bounds_2() {
- let x = vec![1, 2, 3, 4, 5];
- &x[..6];
- }
-
- #[test]
- #[should_panic]
- fn test_slice_out_of_bounds_3() {
- let x = vec![1, 2, 3, 4, 5];
- &x[-1..4];
- }
-
- #[test]
- #[should_panic]
- fn test_slice_out_of_bounds_4() {
- let x = vec![1, 2, 3, 4, 5];
- &x[1..6];
- }
-
- #[test]
- #[should_panic]
- fn test_slice_out_of_bounds_5() {
- let x = vec![1, 2, 3, 4, 5];
- &x[3..2];
- }
-
- #[test]
- #[should_panic]
- fn test_swap_remove_empty() {
- let mut vec= Vec::<i32>::new();
- vec.swap_remove(0);
- }
-
- #[test]
- fn test_move_iter_unwrap() {
- let mut vec = Vec::with_capacity(7);
- vec.push(1);
- vec.push(2);
- let ptr = vec.as_ptr();
- vec = vec.into_iter().into_inner();
- assert_eq!(vec.as_ptr(), ptr);
- assert_eq!(vec.capacity(), 7);
- assert_eq!(vec.len(), 0);
- }
-
- #[test]
- #[should_panic]
- fn test_map_in_place_incompatible_types_fail() {
- let v = vec![0, 1, 2];
- v.map_in_place(|_| ());
- }
-
- #[test]
- fn test_map_in_place() {
- let v = vec![0, 1, 2];
- assert_eq!(v.map_in_place(|i: u32| i as i32 - 1), [-1, 0, 1]);
- }
-
- #[test]
- fn test_map_in_place_zero_sized() {
- let v = vec![(), ()];
- #[derive(PartialEq, Debug)]
- struct ZeroSized;
- assert_eq!(v.map_in_place(|_| ZeroSized), [ZeroSized, ZeroSized]);
- }
-
- #[test]
- fn test_map_in_place_zero_drop_count() {
- use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
-
- #[derive(Clone, PartialEq, Debug)]
- struct Nothing;
- impl Drop for Nothing { fn drop(&mut self) { } }
-
- #[derive(Clone, PartialEq, Debug)]
- struct ZeroSized;
- impl Drop for ZeroSized {
- fn drop(&mut self) {
- DROP_COUNTER.fetch_add(1, Ordering::Relaxed);
- }
- }
- const NUM_ELEMENTS: usize = 2;
- static DROP_COUNTER: AtomicUsize = ATOMIC_USIZE_INIT;
-
- let v = repeat(Nothing).take(NUM_ELEMENTS).collect::<Vec<_>>();
-
- DROP_COUNTER.store(0, Ordering::Relaxed);
-
- let v = v.map_in_place(|_| ZeroSized);
- assert_eq!(DROP_COUNTER.load(Ordering::Relaxed), 0);
- drop(v);
- assert_eq!(DROP_COUNTER.load(Ordering::Relaxed), NUM_ELEMENTS);
- }
-
- #[test]
- fn test_move_items() {
- let vec = vec![1, 2, 3];
- let mut vec2 = vec![];
- for i in vec {
- vec2.push(i);
- }
- assert_eq!(vec2, [1, 2, 3]);
- }
-
- #[test]
- fn test_move_items_reverse() {
- let vec = vec![1, 2, 3];
- let mut vec2 = vec![];
- for i in vec.into_iter().rev() {
- vec2.push(i);
- }
- assert_eq!(vec2, [3, 2, 1]);
- }
-
- #[test]
- fn test_move_items_zero_sized() {
- let vec = vec![(), (), ()];
- let mut vec2 = vec![];
- for i in vec {
- vec2.push(i);
- }
- assert_eq!(vec2, [(), (), ()]);
- }
-
- #[test]
- fn test_drain_items() {
- let mut vec = vec![1, 2, 3];
- let mut vec2 = vec![];
- for i in vec.drain() {
- vec2.push(i);
- }
- assert_eq!(vec, []);
- assert_eq!(vec2, [ 1, 2, 3 ]);
- }
-
- #[test]
- fn test_drain_items_reverse() {
- let mut vec = vec![1, 2, 3];
- let mut vec2 = vec![];
- for i in vec.drain().rev() {
- vec2.push(i);
- }
- assert_eq!(vec, []);
- assert_eq!(vec2, [3, 2, 1]);
- }
-
- #[test]
- fn test_drain_items_zero_sized() {
- let mut vec = vec![(), (), ()];
- let mut vec2 = vec![];
- for i in vec.drain() {
- vec2.push(i);
- }
- assert_eq!(vec, []);
- assert_eq!(vec2, [(), (), ()]);
- }
-
- #[test]
- fn test_into_boxed_slice() {
- let xs = vec![1, 2, 3];
- let ys = xs.into_boxed_slice();
- assert_eq!(&*ys, [1, 2, 3]);
- }
-
- #[test]
- fn test_append() {
- let mut vec = vec![1, 2, 3];
- let mut vec2 = vec![4, 5, 6];
- vec.append(&mut vec2);
- assert_eq!(vec, [1, 2, 3, 4, 5, 6]);
- assert_eq!(vec2, []);
- }
-
- #[test]
- fn test_split_off() {
- let mut vec = vec![1, 2, 3, 4, 5, 6];
- let vec2 = vec.split_off(4);
- assert_eq!(vec, [1, 2, 3, 4]);
- assert_eq!(vec2, [5, 6]);
- }
-
- #[bench]
- fn bench_new(b: &mut Bencher) {
- b.iter(|| {
- let v: Vec<u32> = Vec::new();
- assert_eq!(v.len(), 0);
- assert_eq!(v.capacity(), 0);
- })
- }
-
- fn do_bench_with_capacity(b: &mut Bencher, src_len: usize) {
- b.bytes = src_len as u64;
-
- b.iter(|| {
- let v: Vec<u32> = Vec::with_capacity(src_len);
- assert_eq!(v.len(), 0);
- assert_eq!(v.capacity(), src_len);
- })
- }
-
- #[bench]
- fn bench_with_capacity_0000(b: &mut Bencher) {
- do_bench_with_capacity(b, 0)
- }
-
- #[bench]
- fn bench_with_capacity_0010(b: &mut Bencher) {
- do_bench_with_capacity(b, 10)
- }
-
- #[bench]
- fn bench_with_capacity_0100(b: &mut Bencher) {
- do_bench_with_capacity(b, 100)
- }
-
- #[bench]
- fn bench_with_capacity_1000(b: &mut Bencher) {
- do_bench_with_capacity(b, 1000)
- }
-
- fn do_bench_from_fn(b: &mut Bencher, src_len: usize) {
- b.bytes = src_len as u64;
-
- b.iter(|| {
- let dst = (0..src_len).collect::<Vec<_>>();
- assert_eq!(dst.len(), src_len);
- assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
- })
- }
-
- #[bench]
- fn bench_from_fn_0000(b: &mut Bencher) {
- do_bench_from_fn(b, 0)
- }
-
- #[bench]
- fn bench_from_fn_0010(b: &mut Bencher) {
- do_bench_from_fn(b, 10)
- }
-
- #[bench]
- fn bench_from_fn_0100(b: &mut Bencher) {
- do_bench_from_fn(b, 100)
- }
-
- #[bench]
- fn bench_from_fn_1000(b: &mut Bencher) {
- do_bench_from_fn(b, 1000)
- }
-
- fn do_bench_from_elem(b: &mut Bencher, src_len: usize) {
- b.bytes = src_len as u64;
-
- b.iter(|| {
- let dst: Vec<usize> = repeat(5).take(src_len).collect();
- assert_eq!(dst.len(), src_len);
- assert!(dst.iter().all(|x| *x == 5));
- })
- }
-
- #[bench]
- fn bench_from_elem_0000(b: &mut Bencher) {
- do_bench_from_elem(b, 0)
- }
-
- #[bench]
- fn bench_from_elem_0010(b: &mut Bencher) {
- do_bench_from_elem(b, 10)
- }
-
- #[bench]
- fn bench_from_elem_0100(b: &mut Bencher) {
- do_bench_from_elem(b, 100)
- }
-
- #[bench]
- fn bench_from_elem_1000(b: &mut Bencher) {
- do_bench_from_elem(b, 1000)
- }
-
- fn do_bench_from_slice(b: &mut Bencher, src_len: usize) {
- let src: Vec<_> = FromIterator::from_iter(0..src_len);
-
- b.bytes = src_len as u64;
-
- b.iter(|| {
- let dst = src.clone()[..].to_vec();
- assert_eq!(dst.len(), src_len);
- assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
- });
- }
-
- #[bench]
- fn bench_from_slice_0000(b: &mut Bencher) {
- do_bench_from_slice(b, 0)
- }
-
- #[bench]
- fn bench_from_slice_0010(b: &mut Bencher) {
- do_bench_from_slice(b, 10)
- }
-
- #[bench]
- fn bench_from_slice_0100(b: &mut Bencher) {
- do_bench_from_slice(b, 100)
- }
-
- #[bench]
- fn bench_from_slice_1000(b: &mut Bencher) {
- do_bench_from_slice(b, 1000)
- }
-
- fn do_bench_from_iter(b: &mut Bencher, src_len: usize) {
- let src: Vec<_> = FromIterator::from_iter(0..src_len);
-
- b.bytes = src_len as u64;
-
- b.iter(|| {
- let dst: Vec<_> = FromIterator::from_iter(src.clone().into_iter());
- assert_eq!(dst.len(), src_len);
- assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
- });
- }
-
- #[bench]
- fn bench_from_iter_0000(b: &mut Bencher) {
- do_bench_from_iter(b, 0)
- }
-
- #[bench]
- fn bench_from_iter_0010(b: &mut Bencher) {
- do_bench_from_iter(b, 10)
- }
-
- #[bench]
- fn bench_from_iter_0100(b: &mut Bencher) {
- do_bench_from_iter(b, 100)
- }
-
- #[bench]
- fn bench_from_iter_1000(b: &mut Bencher) {
- do_bench_from_iter(b, 1000)
- }
-
- fn do_bench_extend(b: &mut Bencher, dst_len: usize, src_len: usize) {
- let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
- let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
-
- b.bytes = src_len as u64;
-
- b.iter(|| {
- let mut dst = dst.clone();
- dst.extend(src.clone().into_iter());
- assert_eq!(dst.len(), dst_len + src_len);
- assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
- });
- }
-
- #[bench]
- fn bench_extend_0000_0000(b: &mut Bencher) {
- do_bench_extend(b, 0, 0)
- }
-
- #[bench]
- fn bench_extend_0000_0010(b: &mut Bencher) {
- do_bench_extend(b, 0, 10)
- }
-
- #[bench]
- fn bench_extend_0000_0100(b: &mut Bencher) {
- do_bench_extend(b, 0, 100)
- }
-
- #[bench]
- fn bench_extend_0000_1000(b: &mut Bencher) {
- do_bench_extend(b, 0, 1000)
- }
-
- #[bench]
- fn bench_extend_0010_0010(b: &mut Bencher) {
- do_bench_extend(b, 10, 10)
- }
-
- #[bench]
- fn bench_extend_0100_0100(b: &mut Bencher) {
- do_bench_extend(b, 100, 100)
- }
-
- #[bench]
- fn bench_extend_1000_1000(b: &mut Bencher) {
- do_bench_extend(b, 1000, 1000)
- }
-
- fn do_bench_push_all(b: &mut Bencher, dst_len: usize, src_len: usize) {
- let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
- let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
-
- b.bytes = src_len as u64;
-
- b.iter(|| {
- let mut dst = dst.clone();
- dst.push_all(&src);
- assert_eq!(dst.len(), dst_len + src_len);
- assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
- });
- }
-
- #[bench]
- fn bench_push_all_0000_0000(b: &mut Bencher) {
- do_bench_push_all(b, 0, 0)
- }
-
- #[bench]
- fn bench_push_all_0000_0010(b: &mut Bencher) {
- do_bench_push_all(b, 0, 10)
- }
-
- #[bench]
- fn bench_push_all_0000_0100(b: &mut Bencher) {
- do_bench_push_all(b, 0, 100)
- }
-
- #[bench]
- fn bench_push_all_0000_1000(b: &mut Bencher) {
- do_bench_push_all(b, 0, 1000)
- }
-
- #[bench]
- fn bench_push_all_0010_0010(b: &mut Bencher) {
- do_bench_push_all(b, 10, 10)
- }
-
- #[bench]
- fn bench_push_all_0100_0100(b: &mut Bencher) {
- do_bench_push_all(b, 100, 100)
- }
-
- #[bench]
- fn bench_push_all_1000_1000(b: &mut Bencher) {
- do_bench_push_all(b, 1000, 1000)
- }
-
- fn do_bench_push_all_move(b: &mut Bencher, dst_len: usize, src_len: usize) {
- let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
- let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
-
- b.bytes = src_len as u64;
-
- b.iter(|| {
- let mut dst = dst.clone();
- dst.extend(src.clone().into_iter());
- assert_eq!(dst.len(), dst_len + src_len);
- assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
- });
- }
-
- #[bench]
- fn bench_push_all_move_0000_0000(b: &mut Bencher) {
- do_bench_push_all_move(b, 0, 0)
- }
-
- #[bench]
- fn bench_push_all_move_0000_0010(b: &mut Bencher) {
- do_bench_push_all_move(b, 0, 10)
- }
-
- #[bench]
- fn bench_push_all_move_0000_0100(b: &mut Bencher) {
- do_bench_push_all_move(b, 0, 100)
- }
-
- #[bench]
- fn bench_push_all_move_0000_1000(b: &mut Bencher) {
- do_bench_push_all_move(b, 0, 1000)
- }
-
- #[bench]
- fn bench_push_all_move_0010_0010(b: &mut Bencher) {
- do_bench_push_all_move(b, 10, 10)
- }
-
- #[bench]
- fn bench_push_all_move_0100_0100(b: &mut Bencher) {
- do_bench_push_all_move(b, 100, 100)
- }
-
- #[bench]
- fn bench_push_all_move_1000_1000(b: &mut Bencher) {
- do_bench_push_all_move(b, 1000, 1000)
- }
-
- fn do_bench_clone(b: &mut Bencher, src_len: usize) {
- let src: Vec<usize> = FromIterator::from_iter(0..src_len);
-
- b.bytes = src_len as u64;
-
- b.iter(|| {
- let dst = src.clone();
- assert_eq!(dst.len(), src_len);
- assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
- });
- }
-
- #[bench]
- fn bench_clone_0000(b: &mut Bencher) {
- do_bench_clone(b, 0)
- }
-
- #[bench]
- fn bench_clone_0010(b: &mut Bencher) {
- do_bench_clone(b, 10)
- }
-
- #[bench]
- fn bench_clone_0100(b: &mut Bencher) {
- do_bench_clone(b, 100)
- }
-
- #[bench]
- fn bench_clone_1000(b: &mut Bencher) {
- do_bench_clone(b, 1000)
- }
-
- fn do_bench_clone_from(b: &mut Bencher, times: usize, dst_len: usize, src_len: usize) {
- let dst: Vec<_> = FromIterator::from_iter(0..src_len);
- let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
-
- b.bytes = (times * src_len) as u64;
-
- b.iter(|| {
- let mut dst = dst.clone();
-
- for _ in 0..times {
- dst.clone_from(&src);
-
- assert_eq!(dst.len(), src_len);
- assert!(dst.iter().enumerate().all(|(i, x)| dst_len + i == *x));
- }
- });
- }
-
- #[bench]
- fn bench_clone_from_01_0000_0000(b: &mut Bencher) {
- do_bench_clone_from(b, 1, 0, 0)
- }
-
- #[bench]
- fn bench_clone_from_01_0000_0010(b: &mut Bencher) {
- do_bench_clone_from(b, 1, 0, 10)
- }
-
- #[bench]
- fn bench_clone_from_01_0000_0100(b: &mut Bencher) {
- do_bench_clone_from(b, 1, 0, 100)
- }
-
- #[bench]
- fn bench_clone_from_01_0000_1000(b: &mut Bencher) {
- do_bench_clone_from(b, 1, 0, 1000)
- }
-
- #[bench]
- fn bench_clone_from_01_0010_0010(b: &mut Bencher) {
- do_bench_clone_from(b, 1, 10, 10)
- }
-
- #[bench]
- fn bench_clone_from_01_0100_0100(b: &mut Bencher) {
- do_bench_clone_from(b, 1, 100, 100)
- }
-
- #[bench]
- fn bench_clone_from_01_1000_1000(b: &mut Bencher) {
- do_bench_clone_from(b, 1, 1000, 1000)
- }
-
- #[bench]
- fn bench_clone_from_01_0010_0100(b: &mut Bencher) {
- do_bench_clone_from(b, 1, 10, 100)
- }
-
- #[bench]
- fn bench_clone_from_01_0100_1000(b: &mut Bencher) {
- do_bench_clone_from(b, 1, 100, 1000)
- }
-
- #[bench]
- fn bench_clone_from_01_0010_0000(b: &mut Bencher) {
- do_bench_clone_from(b, 1, 10, 0)
- }
-
- #[bench]
- fn bench_clone_from_01_0100_0010(b: &mut Bencher) {
- do_bench_clone_from(b, 1, 100, 10)
- }
-
- #[bench]
- fn bench_clone_from_01_1000_0100(b: &mut Bencher) {
- do_bench_clone_from(b, 1, 1000, 100)
- }
-
- #[bench]
- fn bench_clone_from_10_0000_0000(b: &mut Bencher) {
- do_bench_clone_from(b, 10, 0, 0)
- }
-
- #[bench]
- fn bench_clone_from_10_0000_0010(b: &mut Bencher) {
- do_bench_clone_from(b, 10, 0, 10)
- }
-
- #[bench]
- fn bench_clone_from_10_0000_0100(b: &mut Bencher) {
- do_bench_clone_from(b, 10, 0, 100)
- }
-
- #[bench]
- fn bench_clone_from_10_0000_1000(b: &mut Bencher) {
- do_bench_clone_from(b, 10, 0, 1000)
- }
-
- #[bench]
- fn bench_clone_from_10_0010_0010(b: &mut Bencher) {
- do_bench_clone_from(b, 10, 10, 10)
- }
-
- #[bench]
- fn bench_clone_from_10_0100_0100(b: &mut Bencher) {
- do_bench_clone_from(b, 10, 100, 100)
- }
-
- #[bench]
- fn bench_clone_from_10_1000_1000(b: &mut Bencher) {
- do_bench_clone_from(b, 10, 1000, 1000)
- }
-
- #[bench]
- fn bench_clone_from_10_0010_0100(b: &mut Bencher) {
- do_bench_clone_from(b, 10, 10, 100)
- }
-
- #[bench]
- fn bench_clone_from_10_0100_1000(b: &mut Bencher) {
- do_bench_clone_from(b, 10, 100, 1000)
- }
-
- #[bench]
- fn bench_clone_from_10_0010_0000(b: &mut Bencher) {
- do_bench_clone_from(b, 10, 10, 0)
- }
-
- #[bench]
- fn bench_clone_from_10_0100_0010(b: &mut Bencher) {
- do_bench_clone_from(b, 10, 100, 10)
- }
-
- #[bench]
- fn bench_clone_from_10_1000_0100(b: &mut Bencher) {
- do_bench_clone_from(b, 10, 1000, 100)
- }
-}
write!(f, "]")
}
}
-
-#[cfg(test)]
-mod tests {
- use self::Taggy::*;
- use self::Taggypar::*;
- use prelude::*;
- use core::iter;
- use std::fmt::Debug;
- use std::hash::{self, SipHasher};
- use test::Bencher;
- use test;
-
- use super::VecDeque;
-
- #[test]
- #[allow(deprecated)]
- fn test_simple() {
- let mut d = VecDeque::new();
- assert_eq!(d.len(), 0);
- d.push_front(17);
- d.push_front(42);
- d.push_back(137);
- assert_eq!(d.len(), 3);
- d.push_back(137);
- assert_eq!(d.len(), 4);
- assert_eq!(*d.front().unwrap(), 42);
- assert_eq!(*d.back().unwrap(), 137);
- let mut i = d.pop_front();
- assert_eq!(i, Some(42));
- i = d.pop_back();
- assert_eq!(i, Some(137));
- i = d.pop_back();
- assert_eq!(i, Some(137));
- i = d.pop_back();
- assert_eq!(i, Some(17));
- assert_eq!(d.len(), 0);
- d.push_back(3);
- assert_eq!(d.len(), 1);
- d.push_front(2);
- assert_eq!(d.len(), 2);
- d.push_back(4);
- assert_eq!(d.len(), 3);
- d.push_front(1);
- assert_eq!(d.len(), 4);
- debug!("{}", d[0]);
- debug!("{}", d[1]);
- debug!("{}", d[2]);
- debug!("{}", d[3]);
- assert_eq!(d[0], 1);
- assert_eq!(d[1], 2);
- assert_eq!(d[2], 3);
- assert_eq!(d[3], 4);
- }
-
- #[cfg(test)]
- fn test_parameterized<T:Clone + PartialEq + Debug>(a: T, b: T, c: T, d: T) {
- let mut deq = VecDeque::new();
- assert_eq!(deq.len(), 0);
- deq.push_front(a.clone());
- deq.push_front(b.clone());
- deq.push_back(c.clone());
- assert_eq!(deq.len(), 3);
- deq.push_back(d.clone());
- assert_eq!(deq.len(), 4);
- assert_eq!((*deq.front().unwrap()).clone(), b.clone());
- assert_eq!((*deq.back().unwrap()).clone(), d.clone());
- assert_eq!(deq.pop_front().unwrap(), b.clone());
- assert_eq!(deq.pop_back().unwrap(), d.clone());
- assert_eq!(deq.pop_back().unwrap(), c.clone());
- assert_eq!(deq.pop_back().unwrap(), a.clone());
- assert_eq!(deq.len(), 0);
- deq.push_back(c.clone());
- assert_eq!(deq.len(), 1);
- deq.push_front(b.clone());
- assert_eq!(deq.len(), 2);
- deq.push_back(d.clone());
- assert_eq!(deq.len(), 3);
- deq.push_front(a.clone());
- assert_eq!(deq.len(), 4);
- assert_eq!(deq[0].clone(), a.clone());
- assert_eq!(deq[1].clone(), b.clone());
- assert_eq!(deq[2].clone(), c.clone());
- assert_eq!(deq[3].clone(), d.clone());
- }
-
- #[test]
- fn test_push_front_grow() {
- let mut deq = VecDeque::new();
- for i in 0..66 {
- deq.push_front(i);
- }
- assert_eq!(deq.len(), 66);
-
- for i in 0..66 {
- assert_eq!(deq[i], 65 - i);
- }
-
- let mut deq = VecDeque::new();
- for i in 0..66 {
- deq.push_back(i);
- }
-
- for i in 0..66 {
- assert_eq!(deq[i], i);
- }
- }
-
- #[test]
- fn test_index() {
- let mut deq = VecDeque::new();
- for i in 1..4 {
- deq.push_front(i);
- }
- assert_eq!(deq[1], 2);
- }
-
- #[test]
- #[should_panic]
- fn test_index_out_of_bounds() {
- let mut deq = VecDeque::new();
- for i in 1..4 {
- deq.push_front(i);
- }
- deq[3];
- }
-
- #[bench]
- fn bench_new(b: &mut test::Bencher) {
- b.iter(|| {
- let ring: VecDeque<i32> = VecDeque::new();
- test::black_box(ring);
- })
- }
-
- #[bench]
- fn bench_push_back_100(b: &mut test::Bencher) {
- let mut deq = VecDeque::with_capacity(101);
- b.iter(|| {
- for i in 0..100 {
- deq.push_back(i);
- }
- deq.head = 0;
- deq.tail = 0;
- })
- }
-
- #[bench]
- fn bench_push_front_100(b: &mut test::Bencher) {
- let mut deq = VecDeque::with_capacity(101);
- b.iter(|| {
- for i in 0..100 {
- deq.push_front(i);
- }
- deq.head = 0;
- deq.tail = 0;
- })
- }
-
- #[bench]
- fn bench_pop_back_100(b: &mut test::Bencher) {
- let mut deq= VecDeque::<i32>::with_capacity(101);
-
- b.iter(|| {
- deq.head = 100;
- deq.tail = 0;
- while !deq.is_empty() {
- test::black_box(deq.pop_back());
- }
- })
- }
-
- #[bench]
- fn bench_pop_front_100(b: &mut test::Bencher) {
- let mut deq = VecDeque::<i32>::with_capacity(101);
-
- b.iter(|| {
- deq.head = 100;
- deq.tail = 0;
- while !deq.is_empty() {
- test::black_box(deq.pop_front());
- }
- })
- }
-
- #[bench]
- fn bench_grow_1025(b: &mut test::Bencher) {
- b.iter(|| {
- let mut deq = VecDeque::new();
- for i in 0..1025 {
- deq.push_front(i);
- }
- test::black_box(deq);
- })
- }
-
- #[bench]
- fn bench_iter_1000(b: &mut test::Bencher) {
- let ring: VecDeque<_> = (0..1000).collect();
-
- b.iter(|| {
- let mut sum = 0;
- for &i in &ring {
- sum += i;
- }
- test::black_box(sum);
- })
- }
-
- #[bench]
- fn bench_mut_iter_1000(b: &mut test::Bencher) {
- let mut ring: VecDeque<_> = (0..1000).collect();
-
- b.iter(|| {
- let mut sum = 0;
- for i in &mut ring {
- sum += *i;
- }
- test::black_box(sum);
- })
- }
-
- #[derive(Clone, PartialEq, Debug)]
- enum Taggy {
- One(i32),
- Two(i32, i32),
- Three(i32, i32, i32),
- }
-
- #[derive(Clone, PartialEq, Debug)]
- enum Taggypar<T> {
- Onepar(T),
- Twopar(T, T),
- Threepar(T, T, T),
- }
-
- #[derive(Clone, PartialEq, Debug)]
- struct RecCy {
- x: i32,
- y: i32,
- t: Taggy
- }
-
- #[test]
- fn test_param_int() {
- test_parameterized::<i32>(5, 72, 64, 175);
- }
-
- #[test]
- fn test_param_taggy() {
- test_parameterized::<Taggy>(One(1), Two(1, 2), Three(1, 2, 3), Two(17, 42));
- }
-
- #[test]
- fn test_param_taggypar() {
- test_parameterized::<Taggypar<i32>>(Onepar::<i32>(1),
- Twopar::<i32>(1, 2),
- Threepar::<i32>(1, 2, 3),
- Twopar::<i32>(17, 42));
- }
-
- #[test]
- fn test_param_reccy() {
- let reccy1 = RecCy { x: 1, y: 2, t: One(1) };
- let reccy2 = RecCy { x: 345, y: 2, t: Two(1, 2) };
- let reccy3 = RecCy { x: 1, y: 777, t: Three(1, 2, 3) };
- let reccy4 = RecCy { x: 19, y: 252, t: Two(17, 42) };
- test_parameterized::<RecCy>(reccy1, reccy2, reccy3, reccy4);
- }
-
- #[test]
- fn test_with_capacity() {
- let mut d = VecDeque::with_capacity(0);
- d.push_back(1);
- assert_eq!(d.len(), 1);
- let mut d = VecDeque::with_capacity(50);
- d.push_back(1);
- assert_eq!(d.len(), 1);
- }
-
- #[test]
- fn test_with_capacity_non_power_two() {
- let mut d3 = VecDeque::with_capacity(3);
- d3.push_back(1);
-
- // X = None, | = lo
- // [|1, X, X]
- assert_eq!(d3.pop_front(), Some(1));
- // [X, |X, X]
- assert_eq!(d3.front(), None);
-
- // [X, |3, X]
- d3.push_back(3);
- // [X, |3, 6]
- d3.push_back(6);
- // [X, X, |6]
- assert_eq!(d3.pop_front(), Some(3));
-
- // Pushing the lo past half way point to trigger
- // the 'B' scenario for growth
- // [9, X, |6]
- d3.push_back(9);
- // [9, 12, |6]
- d3.push_back(12);
-
- d3.push_back(15);
- // There used to be a bug here about how the
- // VecDeque made growth assumptions about the
- // underlying Vec which didn't hold and lead
- // to corruption.
- // (Vec grows to next power of two)
- //good- [9, 12, 15, X, X, X, X, |6]
- //bug- [15, 12, X, X, X, |6, X, X]
- assert_eq!(d3.pop_front(), Some(6));
-
- // Which leads us to the following state which
- // would be a failure case.
- //bug- [15, 12, X, X, X, X, |X, X]
- assert_eq!(d3.front(), Some(&9));
- }
-
- #[test]
- fn test_reserve_exact() {
- let mut d = VecDeque::new();
- d.push_back(0);
- d.reserve_exact(50);
- assert!(d.capacity() >= 51);
- }
-
- #[test]
- fn test_reserve() {
- let mut d = VecDeque::new();
- d.push_back(0);
- d.reserve(50);
- assert!(d.capacity() >= 51);
- }
-
- #[test]
- fn test_swap() {
- let mut d: VecDeque<_> = (0..5).collect();
- d.pop_front();
- d.swap(0, 3);
- assert_eq!(d.iter().cloned().collect::<Vec<_>>(), [4, 2, 3, 1]);
- }
-
- #[test]
- fn test_iter() {
- let mut d = VecDeque::new();
- assert_eq!(d.iter().next(), None);
- assert_eq!(d.iter().size_hint(), (0, Some(0)));
-
- for i in 0..5 {
- d.push_back(i);
- }
- {
- let b: &[_] = &[&0,&1,&2,&3,&4];
- assert_eq!(d.iter().collect::<Vec<_>>(), b);
- }
-
- for i in 6..9 {
- d.push_front(i);
- }
- {
- let b: &[_] = &[&8,&7,&6,&0,&1,&2,&3,&4];
- assert_eq!(d.iter().collect::<Vec<_>>(), b);
- }
-
- let mut it = d.iter();
- let mut len = d.len();
- loop {
- match it.next() {
- None => break,
- _ => { len -= 1; assert_eq!(it.size_hint(), (len, Some(len))) }
- }
- }
- }
-
- #[test]
- fn test_rev_iter() {
- let mut d = VecDeque::new();
- assert_eq!(d.iter().rev().next(), None);
-
- for i in 0..5 {
- d.push_back(i);
- }
- {
- let b: &[_] = &[&4,&3,&2,&1,&0];
- assert_eq!(d.iter().rev().collect::<Vec<_>>(), b);
- }
-
- for i in 6..9 {
- d.push_front(i);
- }
- let b: &[_] = &[&4,&3,&2,&1,&0,&6,&7,&8];
- assert_eq!(d.iter().rev().collect::<Vec<_>>(), b);
- }
-
- #[test]
- fn test_mut_rev_iter_wrap() {
- let mut d = VecDeque::with_capacity(3);
- assert!(d.iter_mut().rev().next().is_none());
-
- d.push_back(1);
- d.push_back(2);
- d.push_back(3);
- assert_eq!(d.pop_front(), Some(1));
- d.push_back(4);
-
- assert_eq!(d.iter_mut().rev().cloned().collect::<Vec<_>>(),
- vec![4, 3, 2]);
- }
-
- #[test]
- fn test_mut_iter() {
- let mut d = VecDeque::new();
- assert!(d.iter_mut().next().is_none());
-
- for i in 0..3 {
- d.push_front(i);
- }
-
- for (i, elt) in d.iter_mut().enumerate() {
- assert_eq!(*elt, 2 - i);
- *elt = i;
- }
-
- {
- let mut it = d.iter_mut();
- assert_eq!(*it.next().unwrap(), 0);
- assert_eq!(*it.next().unwrap(), 1);
- assert_eq!(*it.next().unwrap(), 2);
- assert!(it.next().is_none());
- }
- }
-
- #[test]
- fn test_mut_rev_iter() {
- let mut d = VecDeque::new();
- assert!(d.iter_mut().rev().next().is_none());
-
- for i in 0..3 {
- d.push_front(i);
- }
-
- for (i, elt) in d.iter_mut().rev().enumerate() {
- assert_eq!(*elt, i);
- *elt = i;
- }
-
- {
- let mut it = d.iter_mut().rev();
- assert_eq!(*it.next().unwrap(), 0);
- assert_eq!(*it.next().unwrap(), 1);
- assert_eq!(*it.next().unwrap(), 2);
- assert!(it.next().is_none());
- }
- }
-
- #[test]
- fn test_into_iter() {
-
- // Empty iter
- {
- let d: VecDeque<i32> = VecDeque::new();
- let mut iter = d.into_iter();
-
- assert_eq!(iter.size_hint(), (0, Some(0)));
- assert_eq!(iter.next(), None);
- assert_eq!(iter.size_hint(), (0, Some(0)));
- }
-
- // simple iter
- {
- let mut d = VecDeque::new();
- for i in 0..5 {
- d.push_back(i);
- }
-
- let b = vec![0,1,2,3,4];
- assert_eq!(d.into_iter().collect::<Vec<_>>(), b);
- }
-
- // wrapped iter
- {
- let mut d = VecDeque::new();
- for i in 0..5 {
- d.push_back(i);
- }
- for i in 6..9 {
- d.push_front(i);
- }
-
- let b = vec![8,7,6,0,1,2,3,4];
- assert_eq!(d.into_iter().collect::<Vec<_>>(), b);
- }
-
- // partially used
- {
- let mut d = VecDeque::new();
- for i in 0..5 {
- d.push_back(i);
- }
- for i in 6..9 {
- d.push_front(i);
- }
-
- let mut it = d.into_iter();
- assert_eq!(it.size_hint(), (8, Some(8)));
- assert_eq!(it.next(), Some(8));
- assert_eq!(it.size_hint(), (7, Some(7)));
- assert_eq!(it.next_back(), Some(4));
- assert_eq!(it.size_hint(), (6, Some(6)));
- assert_eq!(it.next(), Some(7));
- assert_eq!(it.size_hint(), (5, Some(5)));
- }
- }
-
- #[test]
- fn test_drain() {
-
- // Empty iter
- {
- let mut d: VecDeque<i32> = VecDeque::new();
-
- {
- let mut iter = d.drain();
-
- assert_eq!(iter.size_hint(), (0, Some(0)));
- assert_eq!(iter.next(), None);
- assert_eq!(iter.size_hint(), (0, Some(0)));
- }
-
- assert!(d.is_empty());
- }
-
- // simple iter
- {
- let mut d = VecDeque::new();
- for i in 0..5 {
- d.push_back(i);
- }
-
- assert_eq!(d.drain().collect::<Vec<_>>(), [0, 1, 2, 3, 4]);
- assert!(d.is_empty());
- }
-
- // wrapped iter
- {
- let mut d = VecDeque::new();
- for i in 0..5 {
- d.push_back(i);
- }
- for i in 6..9 {
- d.push_front(i);
- }
-
- assert_eq!(d.drain().collect::<Vec<_>>(), [8,7,6,0,1,2,3,4]);
- assert!(d.is_empty());
- }
-
- // partially used
- {
- let mut d: VecDeque<_> = VecDeque::new();
- for i in 0..5 {
- d.push_back(i);
- }
- for i in 6..9 {
- d.push_front(i);
- }
-
- {
- let mut it = d.drain();
- assert_eq!(it.size_hint(), (8, Some(8)));
- assert_eq!(it.next(), Some(8));
- assert_eq!(it.size_hint(), (7, Some(7)));
- assert_eq!(it.next_back(), Some(4));
- assert_eq!(it.size_hint(), (6, Some(6)));
- assert_eq!(it.next(), Some(7));
- assert_eq!(it.size_hint(), (5, Some(5)));
- }
- assert!(d.is_empty());
- }
- }
-
- #[test]
- fn test_from_iter() {
- use core::iter;
- let v = vec!(1,2,3,4,5,6,7);
- let deq: VecDeque<_> = v.iter().cloned().collect();
- let u: Vec<_> = deq.iter().cloned().collect();
- assert_eq!(u, v);
-
- let seq = iter::count(0, 2).take(256);
- let deq: VecDeque<_> = seq.collect();
- for (i, &x) in deq.iter().enumerate() {
- assert_eq!(2*i, x);
- }
- assert_eq!(deq.len(), 256);
- }
-
- #[test]
- fn test_clone() {
- let mut d = VecDeque::new();
- d.push_front(17);
- d.push_front(42);
- d.push_back(137);
- d.push_back(137);
- assert_eq!(d.len(), 4);
- let mut e = d.clone();
- assert_eq!(e.len(), 4);
- while !d.is_empty() {
- assert_eq!(d.pop_back(), e.pop_back());
- }
- assert_eq!(d.len(), 0);
- assert_eq!(e.len(), 0);
- }
-
- #[test]
- fn test_eq() {
- let mut d = VecDeque::new();
- assert!(d == VecDeque::with_capacity(0));
- d.push_front(137);
- d.push_front(17);
- d.push_front(42);
- d.push_back(137);
- let mut e = VecDeque::with_capacity(0);
- e.push_back(42);
- e.push_back(17);
- e.push_back(137);
- e.push_back(137);
- assert!(&e == &d);
- e.pop_back();
- e.push_back(0);
- assert!(e != d);
- e.clear();
- assert!(e == VecDeque::new());
- }
-
- #[test]
- fn test_hash() {
- let mut x = VecDeque::new();
- let mut y = VecDeque::new();
-
- x.push_back(1);
- x.push_back(2);
- x.push_back(3);
-
- y.push_back(0);
- y.push_back(1);
- y.pop_front();
- y.push_back(2);
- y.push_back(3);
-
- assert!(hash::hash::<_, SipHasher>(&x) == hash::hash::<_, SipHasher>(&y));
- }
-
- #[test]
- fn test_ord() {
- let x = VecDeque::new();
- let mut y = VecDeque::new();
- y.push_back(1);
- y.push_back(2);
- y.push_back(3);
- assert!(x < y);
- assert!(y > x);
- assert!(x <= x);
- assert!(x >= x);
- }
-
- #[test]
- fn test_show() {
- let ringbuf: VecDeque<_> = (0..10).collect();
- assert_eq!(format!("{:?}", ringbuf), "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
-
- let ringbuf: VecDeque<_> = vec!["just", "one", "test", "more"].iter()
- .cloned()
- .collect();
- assert_eq!(format!("{:?}", ringbuf), "[\"just\", \"one\", \"test\", \"more\"]");
- }
-
- #[test]
- fn test_drop() {
- static mut drops: i32 = 0;
- struct Elem;
- impl Drop for Elem {
- fn drop(&mut self) {
- unsafe { drops += 1; }
- }
- }
-
- let mut ring = VecDeque::new();
- ring.push_back(Elem);
- ring.push_front(Elem);
- ring.push_back(Elem);
- ring.push_front(Elem);
- drop(ring);
-
- assert_eq!(unsafe {drops}, 4);
- }
-
- #[test]
- fn test_drop_with_pop() {
- static mut drops: i32 = 0;
- struct Elem;
- impl Drop for Elem {
- fn drop(&mut self) {
- unsafe { drops += 1; }
- }
- }
-
- let mut ring = VecDeque::new();
- ring.push_back(Elem);
- ring.push_front(Elem);
- ring.push_back(Elem);
- ring.push_front(Elem);
-
- drop(ring.pop_back());
- drop(ring.pop_front());
- assert_eq!(unsafe {drops}, 2);
-
- drop(ring);
- assert_eq!(unsafe {drops}, 4);
- }
-
- #[test]
- fn test_drop_clear() {
- static mut drops: i32 = 0;
- struct Elem;
- impl Drop for Elem {
- fn drop(&mut self) {
- unsafe { drops += 1; }
- }
- }
-
- let mut ring = VecDeque::new();
- ring.push_back(Elem);
- ring.push_front(Elem);
- ring.push_back(Elem);
- ring.push_front(Elem);
- ring.clear();
- assert_eq!(unsafe {drops}, 4);
-
- drop(ring);
- assert_eq!(unsafe {drops}, 4);
- }
-
- #[test]
- fn test_reserve_grow() {
- // test growth path A
- // [T o o H] -> [T o o H . . . . ]
- let mut ring = VecDeque::with_capacity(4);
- for i in 0..3 {
- ring.push_back(i);
- }
- ring.reserve(7);
- for i in 0..3 {
- assert_eq!(ring.pop_front(), Some(i));
- }
-
- // test growth path B
- // [H T o o] -> [. T o o H . . . ]
- let mut ring = VecDeque::with_capacity(4);
- for i in 0..1 {
- ring.push_back(i);
- assert_eq!(ring.pop_front(), Some(i));
- }
- for i in 0..3 {
- ring.push_back(i);
- }
- ring.reserve(7);
- for i in 0..3 {
- assert_eq!(ring.pop_front(), Some(i));
- }
-
- // test growth path C
- // [o o H T] -> [o o H . . . . T ]
- let mut ring = VecDeque::with_capacity(4);
- for i in 0..3 {
- ring.push_back(i);
- assert_eq!(ring.pop_front(), Some(i));
- }
- for i in 0..3 {
- ring.push_back(i);
- }
- ring.reserve(7);
- for i in 0..3 {
- assert_eq!(ring.pop_front(), Some(i));
- }
- }
-
- #[test]
- fn test_get() {
- let mut ring = VecDeque::new();
- ring.push_back(0);
- assert_eq!(ring.get(0), Some(&0));
- assert_eq!(ring.get(1), None);
-
- ring.push_back(1);
- assert_eq!(ring.get(0), Some(&0));
- assert_eq!(ring.get(1), Some(&1));
- assert_eq!(ring.get(2), None);
-
- ring.push_back(2);
- assert_eq!(ring.get(0), Some(&0));
- assert_eq!(ring.get(1), Some(&1));
- assert_eq!(ring.get(2), Some(&2));
- assert_eq!(ring.get(3), None);
-
- assert_eq!(ring.pop_front(), Some(0));
- assert_eq!(ring.get(0), Some(&1));
- assert_eq!(ring.get(1), Some(&2));
- assert_eq!(ring.get(2), None);
-
- assert_eq!(ring.pop_front(), Some(1));
- assert_eq!(ring.get(0), Some(&2));
- assert_eq!(ring.get(1), None);
-
- assert_eq!(ring.pop_front(), Some(2));
- assert_eq!(ring.get(0), None);
- assert_eq!(ring.get(1), None);
- }
-
- #[test]
- fn test_get_mut() {
- let mut ring = VecDeque::new();
- for i in 0..3 {
- ring.push_back(i);
- }
-
- match ring.get_mut(1) {
- Some(x) => *x = -1,
- None => ()
- };
-
- assert_eq!(ring.get_mut(0), Some(&mut 0));
- assert_eq!(ring.get_mut(1), Some(&mut -1));
- assert_eq!(ring.get_mut(2), Some(&mut 2));
- assert_eq!(ring.get_mut(3), None);
-
- assert_eq!(ring.pop_front(), Some(0));
- assert_eq!(ring.get_mut(0), Some(&mut -1));
- assert_eq!(ring.get_mut(1), Some(&mut 2));
- assert_eq!(ring.get_mut(2), None);
- }
-
- #[test]
- fn test_swap_front_back_remove() {
- fn test(back: bool) {
- // This test checks that every single combination of tail position and length is tested.
- // Capacity 15 should be large enough to cover every case.
- let mut tester = VecDeque::with_capacity(15);
- let usable_cap = tester.capacity();
- let final_len = usable_cap / 2;
-
- for len in 0..final_len {
- let expected = if back {
- (0..len).collect()
- } else {
- (0..len).rev().collect()
- };
- for tail_pos in 0..usable_cap {
- tester.tail = tail_pos;
- tester.head = tail_pos;
- if back {
- for i in 0..len * 2 {
- tester.push_front(i);
- }
- for i in 0..len {
- assert_eq!(tester.swap_back_remove(i), Some(len * 2 - 1 - i));
- }
- } else {
- for i in 0..len * 2 {
- tester.push_back(i);
- }
- for i in 0..len {
- let idx = tester.len() - 1 - i;
- assert_eq!(tester.swap_front_remove(idx), Some(len * 2 - 1 - i));
- }
- }
- assert!(tester.tail < tester.cap);
- assert!(tester.head < tester.cap);
- assert_eq!(tester, expected);
- }
- }
- }
- test(true);
- test(false);
- }
-
- #[test]
- fn test_insert() {
- // This test checks that every single combination of tail position, length, and
- // insertion position is tested. Capacity 15 should be large enough to cover every case.
-
- let mut tester = VecDeque::with_capacity(15);
- // can't guarantee we got 15, so have to get what we got.
- // 15 would be great, but we will definitely get 2^k - 1, for k >= 4, or else
- // this test isn't covering what it wants to
- let cap = tester.capacity();
-
-
- // len is the length *after* insertion
- for len in 1..cap {
- // 0, 1, 2, .., len - 1
- let expected = iter::count(0, 1).take(len).collect();
- for tail_pos in 0..cap {
- for to_insert in 0..len {
- tester.tail = tail_pos;
- tester.head = tail_pos;
- for i in 0..len {
- if i != to_insert {
- tester.push_back(i);
- }
- }
- tester.insert(to_insert, to_insert);
- assert!(tester.tail < tester.cap);
- assert!(tester.head < tester.cap);
- assert_eq!(tester, expected);
- }
- }
- }
- }
-
- #[test]
- fn test_remove() {
- // This test checks that every single combination of tail position, length, and
- // removal position is tested. Capacity 15 should be large enough to cover every case.
-
- let mut tester = VecDeque::with_capacity(15);
- // can't guarantee we got 15, so have to get what we got.
- // 15 would be great, but we will definitely get 2^k - 1, for k >= 4, or else
- // this test isn't covering what it wants to
- let cap = tester.capacity();
-
- // len is the length *after* removal
- for len in 0..cap - 1 {
- // 0, 1, 2, .., len - 1
- let expected = iter::count(0, 1).take(len).collect();
- for tail_pos in 0..cap {
- for to_remove in 0..len + 1 {
- tester.tail = tail_pos;
- tester.head = tail_pos;
- for i in 0..len {
- if i == to_remove {
- tester.push_back(1234);
- }
- tester.push_back(i);
- }
- if to_remove == len {
- tester.push_back(1234);
- }
- tester.remove(to_remove);
- assert!(tester.tail < tester.cap);
- assert!(tester.head < tester.cap);
- assert_eq!(tester, expected);
- }
- }
- }
- }
-
- #[test]
- fn test_shrink_to_fit() {
- // This test checks that every single combination of head and tail position,
- // is tested. Capacity 15 should be large enough to cover every case.
-
- let mut tester = VecDeque::with_capacity(15);
- // can't guarantee we got 15, so have to get what we got.
- // 15 would be great, but we will definitely get 2^k - 1, for k >= 4, or else
- // this test isn't covering what it wants to
- let cap = tester.capacity();
- tester.reserve(63);
- let max_cap = tester.capacity();
-
- for len in 0..cap + 1 {
- // 0, 1, 2, .., len - 1
- let expected = iter::count(0, 1).take(len).collect();
- for tail_pos in 0..max_cap + 1 {
- tester.tail = tail_pos;
- tester.head = tail_pos;
- tester.reserve(63);
- for i in 0..len {
- tester.push_back(i);
- }
- tester.shrink_to_fit();
- assert!(tester.capacity() <= cap);
- assert!(tester.tail < tester.cap);
- assert!(tester.head < tester.cap);
- assert_eq!(tester, expected);
- }
- }
- }
-
- #[test]
- fn test_front() {
- let mut ring = VecDeque::new();
- ring.push_back(10);
- ring.push_back(20);
- assert_eq!(ring.front(), Some(&10));
- ring.pop_front();
- assert_eq!(ring.front(), Some(&20));
- ring.pop_front();
- assert_eq!(ring.front(), None);
- }
-
- #[test]
- fn test_as_slices() {
- let mut ring: VecDeque<i32> = VecDeque::with_capacity(127);
- let cap = ring.capacity() as i32;
- let first = cap/2;
- let last = cap - first;
- for i in 0..first {
- ring.push_back(i);
-
- let (left, right) = ring.as_slices();
- let expected: Vec<_> = (0..i+1).collect();
- assert_eq!(left, expected);
- assert_eq!(right, []);
- }
-
- for j in -last..0 {
- ring.push_front(j);
- let (left, right) = ring.as_slices();
- let expected_left: Vec<_> = (-last..j+1).rev().collect();
- let expected_right: Vec<_> = (0..first).collect();
- assert_eq!(left, expected_left);
- assert_eq!(right, expected_right);
- }
-
- assert_eq!(ring.len() as i32, cap);
- assert_eq!(ring.capacity() as i32, cap);
- }
-
- #[test]
- fn test_as_mut_slices() {
- let mut ring: VecDeque<i32> = VecDeque::with_capacity(127);
- let cap = ring.capacity() as i32;
- let first = cap/2;
- let last = cap - first;
- for i in 0..first {
- ring.push_back(i);
-
- let (left, right) = ring.as_mut_slices();
- let expected: Vec<_> = (0..i+1).collect();
- assert_eq!(left, expected);
- assert_eq!(right, []);
- }
-
- for j in -last..0 {
- ring.push_front(j);
- let (left, right) = ring.as_mut_slices();
- let expected_left: Vec<_> = (-last..j+1).rev().collect();
- let expected_right: Vec<_> = (0..first).collect();
- assert_eq!(left, expected_left);
- assert_eq!(right, expected_right);
- }
-
- assert_eq!(ring.len() as i32, cap);
- assert_eq!(ring.capacity() as i32, cap);
- }
-
- #[test]
- fn test_split_off() {
- // This test checks that every single combination of tail position, length, and
- // split position is tested. Capacity 15 should be large enough to cover every case.
-
- let mut tester = VecDeque::with_capacity(15);
- // can't guarantee we got 15, so have to get what we got.
- // 15 would be great, but we will definitely get 2^k - 1, for k >= 4, or else
- // this test isn't covering what it wants to
- let cap = tester.capacity();
-
- // len is the length *before* splitting
- for len in 0..cap {
- // index to split at
- for at in 0..len + 1 {
- // 0, 1, 2, .., at - 1 (may be empty)
- let expected_self = iter::count(0, 1).take(at).collect();
- // at, at + 1, .., len - 1 (may be empty)
- let expected_other = iter::count(at, 1).take(len - at).collect();
-
- for tail_pos in 0..cap {
- tester.tail = tail_pos;
- tester.head = tail_pos;
- for i in 0..len {
- tester.push_back(i);
- }
- let result = tester.split_off(at);
- assert!(tester.tail < tester.cap);
- assert!(tester.head < tester.cap);
- assert!(result.tail < result.cap);
- assert!(result.head < result.cap);
- assert_eq!(tester, expected_self);
- assert_eq!(result, expected_other);
- }
- }
- }
- }
-
- #[test]
- fn test_append() {
- let mut a: VecDeque<_> = vec![1, 2, 3].into_iter().collect();
- let mut b: VecDeque<_> = vec![4, 5, 6].into_iter().collect();
-
- // normal append
- a.append(&mut b);
- assert_eq!(a.iter().cloned().collect::<Vec<_>>(), [1, 2, 3, 4, 5, 6]);
- assert_eq!(b.iter().cloned().collect::<Vec<_>>(), []);
-
- // append nothing to something
- a.append(&mut b);
- assert_eq!(a.iter().cloned().collect::<Vec<_>>(), [1, 2, 3, 4, 5, 6]);
- assert_eq!(b.iter().cloned().collect::<Vec<_>>(), []);
-
- // append something to nothing
- b.append(&mut a);
- assert_eq!(b.iter().cloned().collect::<Vec<_>>(), [1, 2, 3, 4, 5, 6]);
- assert_eq!(a.iter().cloned().collect::<Vec<_>>(), []);
- }
-}
impl<V> DoubleEndedIterator for IntoIter<V> {
fn next_back(&mut self) -> Option<(usize, V)> { self.iter.next_back() }
}
-
-#[cfg(test)]
-mod test_map {
- use prelude::*;
- use core::hash::{hash, SipHasher};
-
- use super::VecMap;
- use super::Entry::{Occupied, Vacant};
-
- #[test]
- fn test_get_mut() {
- let mut m = VecMap::new();
- assert!(m.insert(1, 12).is_none());
- assert!(m.insert(2, 8).is_none());
- assert!(m.insert(5, 14).is_none());
- let new = 100;
- match m.get_mut(&5) {
- None => panic!(), Some(x) => *x = new
- }
- assert_eq!(m.get(&5), Some(&new));
- }
-
- #[test]
- fn test_len() {
- let mut map = VecMap::new();
- assert_eq!(map.len(), 0);
- assert!(map.is_empty());
- assert!(map.insert(5, 20).is_none());
- assert_eq!(map.len(), 1);
- assert!(!map.is_empty());
- assert!(map.insert(11, 12).is_none());
- assert_eq!(map.len(), 2);
- assert!(!map.is_empty());
- assert!(map.insert(14, 22).is_none());
- assert_eq!(map.len(), 3);
- assert!(!map.is_empty());
- }
-
- #[test]
- fn test_clear() {
- let mut map = VecMap::new();
- assert!(map.insert(5, 20).is_none());
- assert!(map.insert(11, 12).is_none());
- assert!(map.insert(14, 22).is_none());
- map.clear();
- assert!(map.is_empty());
- assert!(map.get(&5).is_none());
- assert!(map.get(&11).is_none());
- assert!(map.get(&14).is_none());
- }
-
- #[test]
- fn test_insert() {
- let mut m = VecMap::new();
- assert_eq!(m.insert(1, 2), None);
- assert_eq!(m.insert(1, 3), Some(2));
- assert_eq!(m.insert(1, 4), Some(3));
- }
-
- #[test]
- fn test_remove() {
- let mut m = VecMap::new();
- m.insert(1, 2);
- assert_eq!(m.remove(&1), Some(2));
- assert_eq!(m.remove(&1), None);
- }
-
- #[test]
- fn test_keys() {
- let mut map = VecMap::new();
- map.insert(1, 'a');
- map.insert(2, 'b');
- map.insert(3, 'c');
- let keys: Vec<_> = map.keys().collect();
- assert_eq!(keys.len(), 3);
- assert!(keys.contains(&1));
- assert!(keys.contains(&2));
- assert!(keys.contains(&3));
- }
-
- #[test]
- fn test_values() {
- let mut map = VecMap::new();
- map.insert(1, 'a');
- map.insert(2, 'b');
- map.insert(3, 'c');
- let values: Vec<_> = map.values().cloned().collect();
- assert_eq!(values.len(), 3);
- assert!(values.contains(&'a'));
- assert!(values.contains(&'b'));
- assert!(values.contains(&'c'));
- }
-
- #[test]
- fn test_iterator() {
- let mut m = VecMap::new();
-
- assert!(m.insert(0, 1).is_none());
- assert!(m.insert(1, 2).is_none());
- assert!(m.insert(3, 5).is_none());
- assert!(m.insert(6, 10).is_none());
- assert!(m.insert(10, 11).is_none());
-
- let mut it = m.iter();
- assert_eq!(it.size_hint(), (0, Some(11)));
- assert_eq!(it.next().unwrap(), (0, &1));
- assert_eq!(it.size_hint(), (0, Some(10)));
- assert_eq!(it.next().unwrap(), (1, &2));
- assert_eq!(it.size_hint(), (0, Some(9)));
- assert_eq!(it.next().unwrap(), (3, &5));
- assert_eq!(it.size_hint(), (0, Some(7)));
- assert_eq!(it.next().unwrap(), (6, &10));
- assert_eq!(it.size_hint(), (0, Some(4)));
- assert_eq!(it.next().unwrap(), (10, &11));
- assert_eq!(it.size_hint(), (0, Some(0)));
- assert!(it.next().is_none());
- }
-
- #[test]
- fn test_iterator_size_hints() {
- let mut m = VecMap::new();
-
- assert!(m.insert(0, 1).is_none());
- assert!(m.insert(1, 2).is_none());
- assert!(m.insert(3, 5).is_none());
- assert!(m.insert(6, 10).is_none());
- assert!(m.insert(10, 11).is_none());
-
- assert_eq!(m.iter().size_hint(), (0, Some(11)));
- assert_eq!(m.iter().rev().size_hint(), (0, Some(11)));
- assert_eq!(m.iter_mut().size_hint(), (0, Some(11)));
- assert_eq!(m.iter_mut().rev().size_hint(), (0, Some(11)));
- }
-
- #[test]
- fn test_mut_iterator() {
- let mut m = VecMap::new();
-
- assert!(m.insert(0, 1).is_none());
- assert!(m.insert(1, 2).is_none());
- assert!(m.insert(3, 5).is_none());
- assert!(m.insert(6, 10).is_none());
- assert!(m.insert(10, 11).is_none());
-
- for (k, v) in &mut m {
- *v += k as isize;
- }
-
- let mut it = m.iter();
- assert_eq!(it.next().unwrap(), (0, &1));
- assert_eq!(it.next().unwrap(), (1, &3));
- assert_eq!(it.next().unwrap(), (3, &8));
- assert_eq!(it.next().unwrap(), (6, &16));
- assert_eq!(it.next().unwrap(), (10, &21));
- assert!(it.next().is_none());
- }
-
- #[test]
- fn test_rev_iterator() {
- let mut m = VecMap::new();
-
- assert!(m.insert(0, 1).is_none());
- assert!(m.insert(1, 2).is_none());
- assert!(m.insert(3, 5).is_none());
- assert!(m.insert(6, 10).is_none());
- assert!(m.insert(10, 11).is_none());
-
- let mut it = m.iter().rev();
- assert_eq!(it.next().unwrap(), (10, &11));
- assert_eq!(it.next().unwrap(), (6, &10));
- assert_eq!(it.next().unwrap(), (3, &5));
- assert_eq!(it.next().unwrap(), (1, &2));
- assert_eq!(it.next().unwrap(), (0, &1));
- assert!(it.next().is_none());
- }
-
- #[test]
- fn test_mut_rev_iterator() {
- let mut m = VecMap::new();
-
- assert!(m.insert(0, 1).is_none());
- assert!(m.insert(1, 2).is_none());
- assert!(m.insert(3, 5).is_none());
- assert!(m.insert(6, 10).is_none());
- assert!(m.insert(10, 11).is_none());
-
- for (k, v) in m.iter_mut().rev() {
- *v += k as isize;
- }
-
- let mut it = m.iter();
- assert_eq!(it.next().unwrap(), (0, &1));
- assert_eq!(it.next().unwrap(), (1, &3));
- assert_eq!(it.next().unwrap(), (3, &8));
- assert_eq!(it.next().unwrap(), (6, &16));
- assert_eq!(it.next().unwrap(), (10, &21));
- assert!(it.next().is_none());
- }
-
- #[test]
- fn test_move_iter() {
- let mut m: VecMap<Box<_>> = VecMap::new();
- m.insert(1, box 2);
- let mut called = false;
- for (k, v) in m {
- assert!(!called);
- called = true;
- assert_eq!(k, 1);
- assert_eq!(v, box 2);
- }
- assert!(called);
- }
-
- #[test]
- fn test_drain_iterator() {
- let mut map = VecMap::new();
- map.insert(1, "a");
- map.insert(3, "c");
- map.insert(2, "b");
-
- let vec: Vec<_> = map.drain().collect();
-
- assert_eq!(vec, [(1, "a"), (2, "b"), (3, "c")]);
- assert_eq!(map.len(), 0);
- }
-
- #[test]
- fn test_append() {
- let mut a = VecMap::new();
- a.insert(1, "a");
- a.insert(2, "b");
- a.insert(3, "c");
-
- let mut b = VecMap::new();
- b.insert(3, "d"); // Overwrite element from a
- b.insert(4, "e");
- b.insert(5, "f");
-
- a.append(&mut b);
-
- assert_eq!(a.len(), 5);
- assert_eq!(b.len(), 0);
- // Capacity shouldn't change for possible reuse
- assert!(b.capacity() >= 4);
-
- assert_eq!(a[1], "a");
- assert_eq!(a[2], "b");
- assert_eq!(a[3], "d");
- assert_eq!(a[4], "e");
- assert_eq!(a[5], "f");
- }
-
- #[test]
- fn test_split_off() {
- // Split within the key range
- let mut a = VecMap::new();
- a.insert(1, "a");
- a.insert(2, "b");
- a.insert(3, "c");
- a.insert(4, "d");
-
- let b = a.split_off(3);
-
- assert_eq!(a.len(), 2);
- assert_eq!(b.len(), 2);
-
- assert_eq!(a[1], "a");
- assert_eq!(a[2], "b");
-
- assert_eq!(b[3], "c");
- assert_eq!(b[4], "d");
-
- // Split at 0
- a.clear();
- a.insert(1, "a");
- a.insert(2, "b");
- a.insert(3, "c");
- a.insert(4, "d");
-
- let b = a.split_off(0);
-
- assert_eq!(a.len(), 0);
- assert_eq!(b.len(), 4);
- assert_eq!(b[1], "a");
- assert_eq!(b[2], "b");
- assert_eq!(b[3], "c");
- assert_eq!(b[4], "d");
-
- // Split behind max_key
- a.clear();
- a.insert(1, "a");
- a.insert(2, "b");
- a.insert(3, "c");
- a.insert(4, "d");
-
- let b = a.split_off(5);
-
- assert_eq!(a.len(), 4);
- assert_eq!(b.len(), 0);
- assert_eq!(a[1], "a");
- assert_eq!(a[2], "b");
- assert_eq!(a[3], "c");
- assert_eq!(a[4], "d");
- }
-
- #[test]
- fn test_show() {
- let mut map = VecMap::new();
- let empty = VecMap::<i32>::new();
-
- map.insert(1, 2);
- map.insert(3, 4);
-
- let map_str = format!("{:?}", map);
- assert!(map_str == "{1: 2, 3: 4}" || map_str == "{3: 4, 1: 2}");
- assert_eq!(format!("{:?}", empty), "{}");
- }
-
- #[test]
- fn test_clone() {
- let mut a = VecMap::new();
-
- a.insert(1, 'x');
- a.insert(4, 'y');
- a.insert(6, 'z');
-
- assert!(a.clone() == a);
- }
-
- #[test]
- fn test_eq() {
- let mut a = VecMap::new();
- let mut b = VecMap::new();
-
- assert!(a == b);
- assert!(a.insert(0, 5).is_none());
- assert!(a != b);
- assert!(b.insert(0, 4).is_none());
- assert!(a != b);
- assert!(a.insert(5, 19).is_none());
- assert!(a != b);
- assert!(!b.insert(0, 5).is_none());
- assert!(a != b);
- assert!(b.insert(5, 19).is_none());
- assert!(a == b);
-
- a = VecMap::new();
- b = VecMap::with_capacity(1);
- assert!(a == b);
- }
-
- #[test]
- fn test_lt() {
- let mut a = VecMap::new();
- let mut b = VecMap::new();
-
- assert!(!(a < b) && !(b < a));
- assert!(b.insert(2, 5).is_none());
- assert!(a < b);
- assert!(a.insert(2, 7).is_none());
- assert!(!(a < b) && b < a);
- assert!(b.insert(1, 0).is_none());
- assert!(b < a);
- assert!(a.insert(0, 6).is_none());
- assert!(a < b);
- assert!(a.insert(6, 2).is_none());
- assert!(a < b && !(b < a));
- }
-
- #[test]
- fn test_ord() {
- let mut a = VecMap::new();
- let mut b = VecMap::new();
-
- assert!(a <= b && a >= b);
- assert!(a.insert(1, 1).is_none());
- assert!(a > b && a >= b);
- assert!(b < a && b <= a);
- assert!(b.insert(2, 2).is_none());
- assert!(b > a && b >= a);
- assert!(a < b && a <= b);
- }
-
- #[test]
- fn test_hash() {
- let mut x = VecMap::new();
- let mut y = VecMap::new();
-
- assert!(hash::<_, SipHasher>(&x) == hash::<_, SipHasher>(&y));
- x.insert(1, 'a');
- x.insert(2, 'b');
- x.insert(3, 'c');
-
- y.insert(3, 'c');
- y.insert(2, 'b');
- y.insert(1, 'a');
-
- assert!(hash::<_, SipHasher>(&x) == hash::<_, SipHasher>(&y));
-
- x.insert(1000, 'd');
- x.remove(&1000);
-
- assert!(hash::<_, SipHasher>(&x) == hash::<_, SipHasher>(&y));
- }
-
- #[test]
- fn test_from_iter() {
- let xs = vec![(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')];
-
- let map: VecMap<_> = xs.iter().cloned().collect();
-
- for &(k, v) in &xs {
- assert_eq!(map.get(&k), Some(&v));
- }
- }
-
- #[test]
- fn test_index() {
- let mut map = VecMap::new();
-
- map.insert(1, 2);
- map.insert(2, 1);
- map.insert(3, 4);
-
- assert_eq!(map[3], 4);
- }
-
- #[test]
- #[should_panic]
- fn test_index_nonexistent() {
- let mut map = VecMap::new();
-
- map.insert(1, 2);
- map.insert(2, 1);
- map.insert(3, 4);
-
- map[4];
- }
-
- #[test]
- fn test_entry(){
- let xs = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)];
-
- let mut map: VecMap<_> = xs.iter().cloned().collect();
-
- // Existing key (insert)
- match map.entry(1) {
- Vacant(_) => unreachable!(),
- Occupied(mut view) => {
- assert_eq!(view.get(), &10);
- assert_eq!(view.insert(100), 10);
- }
- }
- assert_eq!(map.get(&1).unwrap(), &100);
- assert_eq!(map.len(), 6);
-
-
- // Existing key (update)
- match map.entry(2) {
- Vacant(_) => unreachable!(),
- Occupied(mut view) => {
- let v = view.get_mut();
- *v *= 10;
- }
- }
- assert_eq!(map.get(&2).unwrap(), &200);
- assert_eq!(map.len(), 6);
-
- // Existing key (take)
- match map.entry(3) {
- Vacant(_) => unreachable!(),
- Occupied(view) => {
- assert_eq!(view.remove(), 30);
- }
- }
- assert_eq!(map.get(&3), None);
- assert_eq!(map.len(), 5);
-
-
- // Inexistent key (insert)
- match map.entry(10) {
- Occupied(_) => unreachable!(),
- Vacant(view) => {
- assert_eq!(*view.insert(1000), 1000);
- }
- }
- assert_eq!(map.get(&10).unwrap(), &1000);
- assert_eq!(map.len(), 6);
- }
-}
-
-#[cfg(test)]
-mod bench {
- use super::VecMap;
-
- map_insert_rand_bench!{insert_rand_100, 100, VecMap}
- map_insert_rand_bench!{insert_rand_10_000, 10_000, VecMap}
-
- map_insert_seq_bench!{insert_seq_100, 100, VecMap}
- map_insert_seq_bench!{insert_seq_10_000, 10_000, VecMap}
-
- map_find_rand_bench!{find_rand_100, 100, VecMap}
- map_find_rand_bench!{find_rand_10_000, 10_000, VecMap}
-
- map_find_seq_bench!{find_seq_100, 100, VecMap}
- map_find_seq_bench!{find_seq_10_000, 10_000, VecMap}
-}
--- /dev/null
+// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+macro_rules! map_insert_rand_bench {
+ ($name: ident, $n: expr, $map: ident) => (
+ #[bench]
+ pub fn $name(b: &mut ::test::Bencher) {
+ use std::rand;
+ use std::rand::Rng;
+ use test::black_box;
+
+ let n: usize = $n;
+ let mut map = $map::new();
+ // setup
+ let mut rng = rand::weak_rng();
+
+ for _ in 0..n {
+ let i = rng.gen() % n;
+ map.insert(i, i);
+ }
+
+ // measure
+ b.iter(|| {
+ let k = rng.gen() % n;
+ map.insert(k, k);
+ map.remove(&k);
+ });
+ black_box(map);
+ }
+ )
+}
+
+macro_rules! map_insert_seq_bench {
+ ($name: ident, $n: expr, $map: ident) => (
+ #[bench]
+ pub fn $name(b: &mut ::test::Bencher) {
+ use test::black_box;
+
+ let mut map = $map::new();
+ let n: usize = $n;
+ // setup
+ for i in 0..n {
+ map.insert(i * 2, i * 2);
+ }
+
+ // measure
+ let mut i = 1;
+ b.iter(|| {
+ map.insert(i, i);
+ map.remove(&i);
+ i = (i + 2) % n;
+ });
+ black_box(map);
+ }
+ )
+}
+
+macro_rules! map_find_rand_bench {
+ ($name: ident, $n: expr, $map: ident) => (
+ #[bench]
+ pub fn $name(b: &mut ::test::Bencher) {
+ use std::iter::IteratorExt;
+ use std::rand::Rng;
+ use std::rand;
+ use std::vec::Vec;
+ use test::black_box;
+
+ let mut map = $map::new();
+ let n: usize = $n;
+
+ // setup
+ let mut rng = rand::weak_rng();
+ let mut keys: Vec<_> = (0..n).map(|_| rng.gen() % n).collect();
+
+ for &k in &keys {
+ map.insert(k, k);
+ }
+
+ rng.shuffle(&mut keys);
+
+ // measure
+ let mut i = 0;
+ b.iter(|| {
+ let t = map.get(&keys[i]);
+ i = (i + 1) % n;
+ black_box(t);
+ })
+ }
+ )
+}
+
+macro_rules! map_find_seq_bench {
+ ($name: ident, $n: expr, $map: ident) => (
+ #[bench]
+ pub fn $name(b: &mut ::test::Bencher) {
+ use test::black_box;
+
+ let mut map = $map::new();
+ let n: usize = $n;
+
+ // setup
+ for i in 0..n {
+ map.insert(i, i);
+ }
+
+ // measure
+ let mut i = 0;
+ b.iter(|| {
+ let x = map.get(&i);
+ i = (i + 1) % n;
+ black_box(x);
+ })
+ }
+ )
+}
--- /dev/null
+// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::collections::BinaryHeap;
+
+#[test]
+fn test_iterator() {
+ let data = vec![5, 9, 3];
+ let iterout = [9, 5, 3];
+ let heap = BinaryHeap::from_vec(data);
+ let mut i = 0;
+ for el in &heap {
+ assert_eq!(*el, iterout[i]);
+ i += 1;
+ }
+}
+
+#[test]
+fn test_iterator_reverse() {
+ let data = vec![5, 9, 3];
+ let iterout = vec![3, 5, 9];
+ let pq = BinaryHeap::from_vec(data);
+
+ let v: Vec<_> = pq.iter().rev().cloned().collect();
+ assert_eq!(v, iterout);
+}
+
+#[test]
+fn test_move_iter() {
+ let data = vec![5, 9, 3];
+ let iterout = vec![9, 5, 3];
+ let pq = BinaryHeap::from_vec(data);
+
+ let v: Vec<_> = pq.into_iter().collect();
+ assert_eq!(v, iterout);
+}
+
+#[test]
+fn test_move_iter_size_hint() {
+ let data = vec![5, 9];
+ let pq = BinaryHeap::from_vec(data);
+
+ let mut it = pq.into_iter();
+
+ assert_eq!(it.size_hint(), (2, Some(2)));
+ assert_eq!(it.next(), Some(9));
+
+ assert_eq!(it.size_hint(), (1, Some(1)));
+ assert_eq!(it.next(), Some(5));
+
+ assert_eq!(it.size_hint(), (0, Some(0)));
+ assert_eq!(it.next(), None);
+}
+
+#[test]
+fn test_move_iter_reverse() {
+ let data = vec![5, 9, 3];
+ let iterout = vec![3, 5, 9];
+ let pq = BinaryHeap::from_vec(data);
+
+ let v: Vec<_> = pq.into_iter().rev().collect();
+ assert_eq!(v, iterout);
+}
+
+#[test]
+fn test_peek_and_pop() {
+ let data = vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1];
+ let mut sorted = data.clone();
+ sorted.sort();
+ let mut heap = BinaryHeap::from_vec(data);
+ while !heap.is_empty() {
+ assert_eq!(heap.peek().unwrap(), sorted.last().unwrap());
+ assert_eq!(heap.pop().unwrap(), sorted.pop().unwrap());
+ }
+}
+
+#[test]
+fn test_push() {
+ let mut heap = BinaryHeap::from_vec(vec![2, 4, 9]);
+ assert_eq!(heap.len(), 3);
+ assert!(*heap.peek().unwrap() == 9);
+ heap.push(11);
+ assert_eq!(heap.len(), 4);
+ assert!(*heap.peek().unwrap() == 11);
+ heap.push(5);
+ assert_eq!(heap.len(), 5);
+ assert!(*heap.peek().unwrap() == 11);
+ heap.push(27);
+ assert_eq!(heap.len(), 6);
+ assert!(*heap.peek().unwrap() == 27);
+ heap.push(3);
+ assert_eq!(heap.len(), 7);
+ assert!(*heap.peek().unwrap() == 27);
+ heap.push(103);
+ assert_eq!(heap.len(), 8);
+ assert!(*heap.peek().unwrap() == 103);
+}
+
+#[test]
+fn test_push_unique() {
+ let mut heap = BinaryHeap::<Box<_>>::from_vec(vec![box 2, box 4, box 9]);
+ assert_eq!(heap.len(), 3);
+ assert!(*heap.peek().unwrap() == box 9);
+ heap.push(box 11);
+ assert_eq!(heap.len(), 4);
+ assert!(*heap.peek().unwrap() == box 11);
+ heap.push(box 5);
+ assert_eq!(heap.len(), 5);
+ assert!(*heap.peek().unwrap() == box 11);
+ heap.push(box 27);
+ assert_eq!(heap.len(), 6);
+ assert!(*heap.peek().unwrap() == box 27);
+ heap.push(box 3);
+ assert_eq!(heap.len(), 7);
+ assert!(*heap.peek().unwrap() == box 27);
+ heap.push(box 103);
+ assert_eq!(heap.len(), 8);
+ assert!(*heap.peek().unwrap() == box 103);
+}
+
+#[test]
+fn test_push_pop() {
+ let mut heap = BinaryHeap::from_vec(vec![5, 5, 2, 1, 3]);
+ assert_eq!(heap.len(), 5);
+ assert_eq!(heap.push_pop(6), 6);
+ assert_eq!(heap.len(), 5);
+ assert_eq!(heap.push_pop(0), 5);
+ assert_eq!(heap.len(), 5);
+ assert_eq!(heap.push_pop(4), 5);
+ assert_eq!(heap.len(), 5);
+ assert_eq!(heap.push_pop(1), 4);
+ assert_eq!(heap.len(), 5);
+}
+
+#[test]
+fn test_replace() {
+ let mut heap = BinaryHeap::from_vec(vec![5, 5, 2, 1, 3]);
+ assert_eq!(heap.len(), 5);
+ assert_eq!(heap.replace(6).unwrap(), 5);
+ assert_eq!(heap.len(), 5);
+ assert_eq!(heap.replace(0).unwrap(), 6);
+ assert_eq!(heap.len(), 5);
+ assert_eq!(heap.replace(4).unwrap(), 5);
+ assert_eq!(heap.len(), 5);
+ assert_eq!(heap.replace(1).unwrap(), 4);
+ assert_eq!(heap.len(), 5);
+}
+
+fn check_to_vec(mut data: Vec<i32>) {
+ let heap = BinaryHeap::from_vec(data.clone());
+ let mut v = heap.clone().into_vec();
+ v.sort();
+ data.sort();
+
+ assert_eq!(v, data);
+ assert_eq!(heap.into_sorted_vec(), data);
+}
+
+#[test]
+fn test_to_vec() {
+ check_to_vec(vec![]);
+ check_to_vec(vec![5]);
+ check_to_vec(vec![3, 2]);
+ check_to_vec(vec![2, 3]);
+ check_to_vec(vec![5, 1, 2]);
+ check_to_vec(vec![1, 100, 2, 3]);
+ check_to_vec(vec![1, 3, 5, 7, 9, 2, 4, 6, 8, 0]);
+ check_to_vec(vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1]);
+ check_to_vec(vec![9, 11, 9, 9, 9, 9, 11, 2, 3, 4, 11, 9, 0, 0, 0, 0]);
+ check_to_vec(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+ check_to_vec(vec![10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]);
+ check_to_vec(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 1, 2]);
+ check_to_vec(vec![5, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2, 1]);
+}
+
+#[test]
+fn test_empty_pop() {
+ let mut heap = BinaryHeap::<i32>::new();
+ assert!(heap.pop().is_none());
+}
+
+#[test]
+fn test_empty_peek() {
+ let empty = BinaryHeap::<i32>::new();
+ assert!(empty.peek().is_none());
+}
+
+#[test]
+fn test_empty_replace() {
+ let mut heap = BinaryHeap::new();
+ assert!(heap.replace(5).is_none());
+}
+
+#[test]
+fn test_from_iter() {
+ let xs = vec![9, 8, 7, 6, 5, 4, 3, 2, 1];
+
+ let mut q: BinaryHeap<_> = xs.iter().rev().cloned().collect();
+
+ for &x in &xs {
+ assert_eq!(q.pop().unwrap(), x);
+ }
+}
+
+#[test]
+fn test_drain() {
+ let mut q: BinaryHeap<_> = [9, 8, 7, 6, 5, 4, 3, 2, 1].iter().cloned().collect();
+
+ assert_eq!(q.drain().take(5).count(), 5);
+
+ assert!(q.is_empty());
+}
--- /dev/null
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+mod set;
+mod vec;
--- /dev/null
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::cmp::Ordering::{Equal, Greater, Less};
+use std::collections::{BitSet, BitVec};
+use std::iter::range_step;
+
+#[test]
+fn test_bit_set_show() {
+ let mut s = BitSet::new();
+ s.insert(1);
+ s.insert(10);
+ s.insert(50);
+ s.insert(2);
+ assert_eq!("{1, 2, 10, 50}", format!("{:?}", s));
+}
+
+#[test]
+fn test_bit_set_from_usizes() {
+ let usizes = vec![0, 2, 2, 3];
+ let a: BitSet = usizes.into_iter().collect();
+ let mut b = BitSet::new();
+ b.insert(0);
+ b.insert(2);
+ b.insert(3);
+ assert_eq!(a, b);
+}
+
+#[test]
+fn test_bit_set_iterator() {
+ let usizes = vec![0, 2, 2, 3];
+ let bit_vec: BitSet = usizes.into_iter().collect();
+
+ let idxs: Vec<_> = bit_vec.iter().collect();
+ assert_eq!(idxs, [0, 2, 3]);
+
+ let long: BitSet = (0..10000).filter(|&n| n % 2 == 0).collect();
+ let real: Vec<_> = range_step(0, 10000, 2).collect();
+
+ let idxs: Vec<_> = long.iter().collect();
+ assert_eq!(idxs, real);
+}
+
+#[test]
+fn test_bit_set_frombit_vec_init() {
+ let bools = [true, false];
+ let lengths = [10, 64, 100];
+ for &b in &bools {
+ for &l in &lengths {
+ let bitset = BitSet::from_bit_vec(BitVec::from_elem(l, b));
+ assert_eq!(bitset.contains(&1), b);
+ assert_eq!(bitset.contains(&(l-1)), b);
+ assert!(!bitset.contains(&l));
+ }
+ }
+}
+
+#[test]
+fn test_bit_vec_masking() {
+ let b = BitVec::from_elem(140, true);
+ let mut bs = BitSet::from_bit_vec(b);
+ assert!(bs.contains(&139));
+ assert!(!bs.contains(&140));
+ assert!(bs.insert(150));
+ assert!(!bs.contains(&140));
+ assert!(!bs.contains(&149));
+ assert!(bs.contains(&150));
+ assert!(!bs.contains(&151));
+}
+
+#[test]
+fn test_bit_set_basic() {
+ let mut b = BitSet::new();
+ assert!(b.insert(3));
+ assert!(!b.insert(3));
+ assert!(b.contains(&3));
+ assert!(b.insert(4));
+ assert!(!b.insert(4));
+ assert!(b.contains(&3));
+ assert!(b.insert(400));
+ assert!(!b.insert(400));
+ assert!(b.contains(&400));
+ assert_eq!(b.len(), 3);
+}
+
+#[test]
+fn test_bit_set_intersection() {
+ let mut a = BitSet::new();
+ let mut b = BitSet::new();
+
+ assert!(a.insert(11));
+ assert!(a.insert(1));
+ assert!(a.insert(3));
+ assert!(a.insert(77));
+ assert!(a.insert(103));
+ assert!(a.insert(5));
+
+ assert!(b.insert(2));
+ assert!(b.insert(11));
+ assert!(b.insert(77));
+ assert!(b.insert(5));
+ assert!(b.insert(3));
+
+ let expected = [3, 5, 11, 77];
+ let actual: Vec<_> = a.intersection(&b).collect();
+ assert_eq!(actual, expected);
+}
+
+#[test]
+fn test_bit_set_difference() {
+ let mut a = BitSet::new();
+ let mut b = BitSet::new();
+
+ assert!(a.insert(1));
+ assert!(a.insert(3));
+ assert!(a.insert(5));
+ assert!(a.insert(200));
+ assert!(a.insert(500));
+
+ assert!(b.insert(3));
+ assert!(b.insert(200));
+
+ let expected = [1, 5, 500];
+ let actual: Vec<_> = a.difference(&b).collect();
+ assert_eq!(actual, expected);
+}
+
+#[test]
+fn test_bit_set_symmetric_difference() {
+ let mut a = BitSet::new();
+ let mut b = BitSet::new();
+
+ assert!(a.insert(1));
+ assert!(a.insert(3));
+ assert!(a.insert(5));
+ assert!(a.insert(9));
+ assert!(a.insert(11));
+
+ assert!(b.insert(3));
+ assert!(b.insert(9));
+ assert!(b.insert(14));
+ assert!(b.insert(220));
+
+ let expected = [1, 5, 11, 14, 220];
+ let actual: Vec<_> = a.symmetric_difference(&b).collect();
+ assert_eq!(actual, expected);
+}
+
+#[test]
+fn test_bit_set_union() {
+ let mut a = BitSet::new();
+ let mut b = BitSet::new();
+ assert!(a.insert(1));
+ assert!(a.insert(3));
+ assert!(a.insert(5));
+ assert!(a.insert(9));
+ assert!(a.insert(11));
+ assert!(a.insert(160));
+ assert!(a.insert(19));
+ assert!(a.insert(24));
+ assert!(a.insert(200));
+
+ assert!(b.insert(1));
+ assert!(b.insert(5));
+ assert!(b.insert(9));
+ assert!(b.insert(13));
+ assert!(b.insert(19));
+
+ let expected = [1, 3, 5, 9, 11, 13, 19, 24, 160, 200];
+ let actual: Vec<_> = a.union(&b).collect();
+ assert_eq!(actual, expected);
+}
+
+#[test]
+fn test_bit_set_subset() {
+ let mut set1 = BitSet::new();
+ let mut set2 = BitSet::new();
+
+ assert!(set1.is_subset(&set2)); // {} {}
+ set2.insert(100);
+ assert!(set1.is_subset(&set2)); // {} { 1 }
+ set2.insert(200);
+ assert!(set1.is_subset(&set2)); // {} { 1, 2 }
+ set1.insert(200);
+ assert!(set1.is_subset(&set2)); // { 2 } { 1, 2 }
+ set1.insert(300);
+ assert!(!set1.is_subset(&set2)); // { 2, 3 } { 1, 2 }
+ set2.insert(300);
+ assert!(set1.is_subset(&set2)); // { 2, 3 } { 1, 2, 3 }
+ set2.insert(400);
+ assert!(set1.is_subset(&set2)); // { 2, 3 } { 1, 2, 3, 4 }
+ set2.remove(&100);
+ assert!(set1.is_subset(&set2)); // { 2, 3 } { 2, 3, 4 }
+ set2.remove(&300);
+ assert!(!set1.is_subset(&set2)); // { 2, 3 } { 2, 4 }
+ set1.remove(&300);
+ assert!(set1.is_subset(&set2)); // { 2 } { 2, 4 }
+}
+
+#[test]
+fn test_bit_set_is_disjoint() {
+ let a = BitSet::from_bit_vec(BitVec::from_bytes(&[0b10100010]));
+ let b = BitSet::from_bit_vec(BitVec::from_bytes(&[0b01000000]));
+ let c = BitSet::new();
+ let d = BitSet::from_bit_vec(BitVec::from_bytes(&[0b00110000]));
+
+ assert!(!a.is_disjoint(&d));
+ assert!(!d.is_disjoint(&a));
+
+ assert!(a.is_disjoint(&b));
+ assert!(a.is_disjoint(&c));
+ assert!(b.is_disjoint(&a));
+ assert!(b.is_disjoint(&c));
+ assert!(c.is_disjoint(&a));
+ assert!(c.is_disjoint(&b));
+}
+
+#[test]
+fn test_bit_set_union_with() {
+ //a should grow to include larger elements
+ let mut a = BitSet::new();
+ a.insert(0);
+ let mut b = BitSet::new();
+ b.insert(5);
+ let expected = BitSet::from_bit_vec(BitVec::from_bytes(&[0b10000100]));
+ a.union_with(&b);
+ assert_eq!(a, expected);
+
+ // Standard
+ let mut a = BitSet::from_bit_vec(BitVec::from_bytes(&[0b10100010]));
+ let mut b = BitSet::from_bit_vec(BitVec::from_bytes(&[0b01100010]));
+ let c = a.clone();
+ a.union_with(&b);
+ b.union_with(&c);
+ assert_eq!(a.len(), 4);
+ assert_eq!(b.len(), 4);
+}
+
+#[test]
+fn test_bit_set_intersect_with() {
+ // Explicitly 0'ed bits
+ let mut a = BitSet::from_bit_vec(BitVec::from_bytes(&[0b10100010]));
+ let mut b = BitSet::from_bit_vec(BitVec::from_bytes(&[0b00000000]));
+ let c = a.clone();
+ a.intersect_with(&b);
+ b.intersect_with(&c);
+ assert!(a.is_empty());
+ assert!(b.is_empty());
+
+ // Uninitialized bits should behave like 0's
+ let mut a = BitSet::from_bit_vec(BitVec::from_bytes(&[0b10100010]));
+ let mut b = BitSet::new();
+ let c = a.clone();
+ a.intersect_with(&b);
+ b.intersect_with(&c);
+ assert!(a.is_empty());
+ assert!(b.is_empty());
+
+ // Standard
+ let mut a = BitSet::from_bit_vec(BitVec::from_bytes(&[0b10100010]));
+ let mut b = BitSet::from_bit_vec(BitVec::from_bytes(&[0b01100010]));
+ let c = a.clone();
+ a.intersect_with(&b);
+ b.intersect_with(&c);
+ assert_eq!(a.len(), 2);
+ assert_eq!(b.len(), 2);
+}
+
+#[test]
+fn test_bit_set_difference_with() {
+ // Explicitly 0'ed bits
+ let mut a = BitSet::from_bit_vec(BitVec::from_bytes(&[0b00000000]));
+ let b = BitSet::from_bit_vec(BitVec::from_bytes(&[0b10100010]));
+ a.difference_with(&b);
+ assert!(a.is_empty());
+
+ // Uninitialized bits should behave like 0's
+ let mut a = BitSet::new();
+ let b = BitSet::from_bit_vec(BitVec::from_bytes(&[0b11111111]));
+ a.difference_with(&b);
+ assert!(a.is_empty());
+
+ // Standard
+ let mut a = BitSet::from_bit_vec(BitVec::from_bytes(&[0b10100010]));
+ let mut b = BitSet::from_bit_vec(BitVec::from_bytes(&[0b01100010]));
+ let c = a.clone();
+ a.difference_with(&b);
+ b.difference_with(&c);
+ assert_eq!(a.len(), 1);
+ assert_eq!(b.len(), 1);
+}
+
+#[test]
+fn test_bit_set_symmetric_difference_with() {
+ //a should grow to include larger elements
+ let mut a = BitSet::new();
+ a.insert(0);
+ a.insert(1);
+ let mut b = BitSet::new();
+ b.insert(1);
+ b.insert(5);
+ let expected = BitSet::from_bit_vec(BitVec::from_bytes(&[0b10000100]));
+ a.symmetric_difference_with(&b);
+ assert_eq!(a, expected);
+
+ let mut a = BitSet::from_bit_vec(BitVec::from_bytes(&[0b10100010]));
+ let b = BitSet::new();
+ let c = a.clone();
+ a.symmetric_difference_with(&b);
+ assert_eq!(a, c);
+
+ // Standard
+ let mut a = BitSet::from_bit_vec(BitVec::from_bytes(&[0b11100010]));
+ let mut b = BitSet::from_bit_vec(BitVec::from_bytes(&[0b01101010]));
+ let c = a.clone();
+ a.symmetric_difference_with(&b);
+ b.symmetric_difference_with(&c);
+ assert_eq!(a.len(), 2);
+ assert_eq!(b.len(), 2);
+}
+
+#[test]
+fn test_bit_set_eq() {
+ let a = BitSet::from_bit_vec(BitVec::from_bytes(&[0b10100010]));
+ let b = BitSet::from_bit_vec(BitVec::from_bytes(&[0b00000000]));
+ let c = BitSet::new();
+
+ assert!(a == a);
+ assert!(a != b);
+ assert!(a != c);
+ assert!(b == b);
+ assert!(b == c);
+ assert!(c == c);
+}
+
+#[test]
+fn test_bit_set_cmp() {
+ let a = BitSet::from_bit_vec(BitVec::from_bytes(&[0b10100010]));
+ let b = BitSet::from_bit_vec(BitVec::from_bytes(&[0b00000000]));
+ let c = BitSet::new();
+
+ assert_eq!(a.cmp(&b), Greater);
+ assert_eq!(a.cmp(&c), Greater);
+ assert_eq!(b.cmp(&a), Less);
+ assert_eq!(b.cmp(&c), Equal);
+ assert_eq!(c.cmp(&a), Less);
+ assert_eq!(c.cmp(&b), Equal);
+}
+
+#[test]
+fn test_bit_vec_remove() {
+ let mut a = BitSet::new();
+
+ assert!(a.insert(1));
+ assert!(a.remove(&1));
+
+ assert!(a.insert(100));
+ assert!(a.remove(&100));
+
+ assert!(a.insert(1000));
+ assert!(a.remove(&1000));
+ a.shrink_to_fit();
+}
+
+#[test]
+fn test_bit_vec_clone() {
+ let mut a = BitSet::new();
+
+ assert!(a.insert(1));
+ assert!(a.insert(100));
+ assert!(a.insert(1000));
+
+ let mut b = a.clone();
+
+ assert!(a == b);
+
+ assert!(b.remove(&1));
+ assert!(a.contains(&1));
+
+ assert!(a.remove(&1000));
+ assert!(b.contains(&1000));
+}
+
+mod bench {
+ use std::collections::{BitSet, BitVec};
+ use std::rand::{Rng, self};
+ use std::u32;
+
+ use test::{Bencher, black_box};
+
+ const BENCH_BITS : usize = 1 << 14;
+
+ fn rng() -> rand::IsaacRng {
+ let seed: &[_] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
+ rand::SeedableRng::from_seed(seed)
+ }
+
+ #[bench]
+ fn bench_bit_vecset_small(b: &mut Bencher) {
+ let mut r = rng();
+ let mut bit_vec = BitSet::new();
+ b.iter(|| {
+ for _ in 0..100 {
+ bit_vec.insert((r.next_u32() as usize) % u32::BITS as usize);
+ }
+ black_box(&bit_vec);
+ });
+ }
+
+ #[bench]
+ fn bench_bit_vecset_big(b: &mut Bencher) {
+ let mut r = rng();
+ let mut bit_vec = BitSet::new();
+ b.iter(|| {
+ for _ in 0..100 {
+ bit_vec.insert((r.next_u32() as usize) % BENCH_BITS);
+ }
+ black_box(&bit_vec);
+ });
+ }
+
+ #[bench]
+ fn bench_bit_vecset_iter(b: &mut Bencher) {
+ let bit_vec = BitSet::from_bit_vec(BitVec::from_fn(BENCH_BITS,
+ |idx| {idx % 3 == 0}));
+ b.iter(|| {
+ let mut sum = 0;
+ for idx in &bit_vec {
+ sum += idx as usize;
+ }
+ sum
+ })
+ }
+}
--- /dev/null
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::collections::BitVec;
+use std::u32;
+
+#[test]
+fn test_to_str() {
+ let zerolen = BitVec::new();
+ assert_eq!(format!("{:?}", zerolen), "");
+
+ let eightbits = BitVec::from_elem(8, false);
+ assert_eq!(format!("{:?}", eightbits), "00000000")
+}
+
+#[test]
+fn test_0_elements() {
+ let act = BitVec::new();
+ let exp = Vec::new();
+ assert!(act.eq_vec(&exp));
+ assert!(act.none() && act.all());
+}
+
+#[test]
+fn test_1_element() {
+ let mut act = BitVec::from_elem(1, false);
+ assert!(act.eq_vec(&[false]));
+ assert!(act.none() && !act.all());
+ act = BitVec::from_elem(1, true);
+ assert!(act.eq_vec(&[true]));
+ assert!(!act.none() && act.all());
+}
+
+#[test]
+fn test_2_elements() {
+ let mut b = BitVec::from_elem(2, false);
+ b.set(0, true);
+ b.set(1, false);
+ assert_eq!(format!("{:?}", b), "10");
+ assert!(!b.none() && !b.all());
+}
+
+#[test]
+fn test_10_elements() {
+ let mut act;
+ // all 0
+
+ act = BitVec::from_elem(10, false);
+ assert!((act.eq_vec(
+ &[false, false, false, false, false, false, false, false, false, false])));
+ assert!(act.none() && !act.all());
+ // all 1
+
+ act = BitVec::from_elem(10, true);
+ assert!((act.eq_vec(&[true, true, true, true, true, true, true, true, true, true])));
+ assert!(!act.none() && act.all());
+ // mixed
+
+ act = BitVec::from_elem(10, false);
+ act.set(0, true);
+ act.set(1, true);
+ act.set(2, true);
+ act.set(3, true);
+ act.set(4, true);
+ assert!((act.eq_vec(&[true, true, true, true, true, false, false, false, false, false])));
+ assert!(!act.none() && !act.all());
+ // mixed
+
+ act = BitVec::from_elem(10, false);
+ act.set(5, true);
+ act.set(6, true);
+ act.set(7, true);
+ act.set(8, true);
+ act.set(9, true);
+ assert!((act.eq_vec(&[false, false, false, false, false, true, true, true, true, true])));
+ assert!(!act.none() && !act.all());
+ // mixed
+
+ act = BitVec::from_elem(10, false);
+ act.set(0, true);
+ act.set(3, true);
+ act.set(6, true);
+ act.set(9, true);
+ assert!((act.eq_vec(&[true, false, false, true, false, false, true, false, false, true])));
+ assert!(!act.none() && !act.all());
+}
+
+#[test]
+fn test_31_elements() {
+ let mut act;
+ // all 0
+
+ act = BitVec::from_elem(31, false);
+ assert!(act.eq_vec(
+ &[false, false, false, false, false, false, false, false, false, false, false,
+ false, false, false, false, false, false, false, false, false, false, false,
+ false, false, false, false, false, false, false, false, false]));
+ assert!(act.none() && !act.all());
+ // all 1
+
+ act = BitVec::from_elem(31, true);
+ assert!(act.eq_vec(
+ &[true, true, true, true, true, true, true, true, true, true, true, true, true,
+ true, true, true, true, true, true, true, true, true, true, true, true, true,
+ true, true, true, true, true]));
+ assert!(!act.none() && act.all());
+ // mixed
+
+ act = BitVec::from_elem(31, false);
+ act.set(0, true);
+ act.set(1, true);
+ act.set(2, true);
+ act.set(3, true);
+ act.set(4, true);
+ act.set(5, true);
+ act.set(6, true);
+ act.set(7, true);
+ assert!(act.eq_vec(
+ &[true, true, true, true, true, true, true, true, false, false, false, false, false,
+ false, false, false, false, false, false, false, false, false, false, false,
+ false, false, false, false, false, false, false]));
+ assert!(!act.none() && !act.all());
+ // mixed
+
+ act = BitVec::from_elem(31, false);
+ act.set(16, true);
+ act.set(17, true);
+ act.set(18, true);
+ act.set(19, true);
+ act.set(20, true);
+ act.set(21, true);
+ act.set(22, true);
+ act.set(23, true);
+ assert!(act.eq_vec(
+ &[false, false, false, false, false, false, false, false, false, false, false,
+ false, false, false, false, false, true, true, true, true, true, true, true, true,
+ false, false, false, false, false, false, false]));
+ assert!(!act.none() && !act.all());
+ // mixed
+
+ act = BitVec::from_elem(31, false);
+ act.set(24, true);
+ act.set(25, true);
+ act.set(26, true);
+ act.set(27, true);
+ act.set(28, true);
+ act.set(29, true);
+ act.set(30, true);
+ assert!(act.eq_vec(
+ &[false, false, false, false, false, false, false, false, false, false, false,
+ false, false, false, false, false, false, false, false, false, false, false,
+ false, false, true, true, true, true, true, true, true]));
+ assert!(!act.none() && !act.all());
+ // mixed
+
+ act = BitVec::from_elem(31, false);
+ act.set(3, true);
+ act.set(17, true);
+ act.set(30, true);
+ assert!(act.eq_vec(
+ &[false, false, false, true, false, false, false, false, false, false, false, false,
+ false, false, false, false, false, true, false, false, false, false, false, false,
+ false, false, false, false, false, false, true]));
+ assert!(!act.none() && !act.all());
+}
+
+#[test]
+fn test_32_elements() {
+ let mut act;
+ // all 0
+
+ act = BitVec::from_elem(32, false);
+ assert!(act.eq_vec(
+ &[false, false, false, false, false, false, false, false, false, false, false,
+ false, false, false, false, false, false, false, false, false, false, false,
+ false, false, false, false, false, false, false, false, false, false]));
+ assert!(act.none() && !act.all());
+ // all 1
+
+ act = BitVec::from_elem(32, true);
+ assert!(act.eq_vec(
+ &[true, true, true, true, true, true, true, true, true, true, true, true, true,
+ true, true, true, true, true, true, true, true, true, true, true, true, true,
+ true, true, true, true, true, true]));
+ assert!(!act.none() && act.all());
+ // mixed
+
+ act = BitVec::from_elem(32, false);
+ act.set(0, true);
+ act.set(1, true);
+ act.set(2, true);
+ act.set(3, true);
+ act.set(4, true);
+ act.set(5, true);
+ act.set(6, true);
+ act.set(7, true);
+ assert!(act.eq_vec(
+ &[true, true, true, true, true, true, true, true, false, false, false, false, false,
+ false, false, false, false, false, false, false, false, false, false, false,
+ false, false, false, false, false, false, false, false]));
+ assert!(!act.none() && !act.all());
+ // mixed
+
+ act = BitVec::from_elem(32, false);
+ act.set(16, true);
+ act.set(17, true);
+ act.set(18, true);
+ act.set(19, true);
+ act.set(20, true);
+ act.set(21, true);
+ act.set(22, true);
+ act.set(23, true);
+ assert!(act.eq_vec(
+ &[false, false, false, false, false, false, false, false, false, false, false,
+ false, false, false, false, false, true, true, true, true, true, true, true, true,
+ false, false, false, false, false, false, false, false]));
+ assert!(!act.none() && !act.all());
+ // mixed
+
+ act = BitVec::from_elem(32, false);
+ act.set(24, true);
+ act.set(25, true);
+ act.set(26, true);
+ act.set(27, true);
+ act.set(28, true);
+ act.set(29, true);
+ act.set(30, true);
+ act.set(31, true);
+ assert!(act.eq_vec(
+ &[false, false, false, false, false, false, false, false, false, false, false,
+ false, false, false, false, false, false, false, false, false, false, false,
+ false, false, true, true, true, true, true, true, true, true]));
+ assert!(!act.none() && !act.all());
+ // mixed
+
+ act = BitVec::from_elem(32, false);
+ act.set(3, true);
+ act.set(17, true);
+ act.set(30, true);
+ act.set(31, true);
+ assert!(act.eq_vec(
+ &[false, false, false, true, false, false, false, false, false, false, false, false,
+ false, false, false, false, false, true, false, false, false, false, false, false,
+ false, false, false, false, false, false, true, true]));
+ assert!(!act.none() && !act.all());
+}
+
+#[test]
+fn test_33_elements() {
+ let mut act;
+ // all 0
+
+ act = BitVec::from_elem(33, false);
+ assert!(act.eq_vec(
+ &[false, false, false, false, false, false, false, false, false, false, false,
+ false, false, false, false, false, false, false, false, false, false, false,
+ false, false, false, false, false, false, false, false, false, false, false]));
+ assert!(act.none() && !act.all());
+ // all 1
+
+ act = BitVec::from_elem(33, true);
+ assert!(act.eq_vec(
+ &[true, true, true, true, true, true, true, true, true, true, true, true, true,
+ true, true, true, true, true, true, true, true, true, true, true, true, true,
+ true, true, true, true, true, true, true]));
+ assert!(!act.none() && act.all());
+ // mixed
+
+ act = BitVec::from_elem(33, false);
+ act.set(0, true);
+ act.set(1, true);
+ act.set(2, true);
+ act.set(3, true);
+ act.set(4, true);
+ act.set(5, true);
+ act.set(6, true);
+ act.set(7, true);
+ assert!(act.eq_vec(
+ &[true, true, true, true, true, true, true, true, false, false, false, false, false,
+ false, false, false, false, false, false, false, false, false, false, false,
+ false, false, false, false, false, false, false, false, false]));
+ assert!(!act.none() && !act.all());
+ // mixed
+
+ act = BitVec::from_elem(33, false);
+ act.set(16, true);
+ act.set(17, true);
+ act.set(18, true);
+ act.set(19, true);
+ act.set(20, true);
+ act.set(21, true);
+ act.set(22, true);
+ act.set(23, true);
+ assert!(act.eq_vec(
+ &[false, false, false, false, false, false, false, false, false, false, false,
+ false, false, false, false, false, true, true, true, true, true, true, true, true,
+ false, false, false, false, false, false, false, false, false]));
+ assert!(!act.none() && !act.all());
+ // mixed
+
+ act = BitVec::from_elem(33, false);
+ act.set(24, true);
+ act.set(25, true);
+ act.set(26, true);
+ act.set(27, true);
+ act.set(28, true);
+ act.set(29, true);
+ act.set(30, true);
+ act.set(31, true);
+ assert!(act.eq_vec(
+ &[false, false, false, false, false, false, false, false, false, false, false,
+ false, false, false, false, false, false, false, false, false, false, false,
+ false, false, true, true, true, true, true, true, true, true, false]));
+ assert!(!act.none() && !act.all());
+ // mixed
+
+ act = BitVec::from_elem(33, false);
+ act.set(3, true);
+ act.set(17, true);
+ act.set(30, true);
+ act.set(31, true);
+ act.set(32, true);
+ assert!(act.eq_vec(
+ &[false, false, false, true, false, false, false, false, false, false, false, false,
+ false, false, false, false, false, true, false, false, false, false, false, false,
+ false, false, false, false, false, false, true, true, true]));
+ assert!(!act.none() && !act.all());
+}
+
+#[test]
+fn test_equal_differing_sizes() {
+ let v0 = BitVec::from_elem(10, false);
+ let v1 = BitVec::from_elem(11, false);
+ assert!(v0 != v1);
+}
+
+#[test]
+fn test_equal_greatly_differing_sizes() {
+ let v0 = BitVec::from_elem(10, false);
+ let v1 = BitVec::from_elem(110, false);
+ assert!(v0 != v1);
+}
+
+#[test]
+fn test_equal_sneaky_small() {
+ let mut a = BitVec::from_elem(1, false);
+ a.set(0, true);
+
+ let mut b = BitVec::from_elem(1, true);
+ b.set(0, true);
+
+ assert_eq!(a, b);
+}
+
+#[test]
+fn test_equal_sneaky_big() {
+ let mut a = BitVec::from_elem(100, false);
+ for i in 0..100 {
+ a.set(i, true);
+ }
+
+ let mut b = BitVec::from_elem(100, true);
+ for i in 0..100 {
+ b.set(i, true);
+ }
+
+ assert_eq!(a, b);
+}
+
+#[test]
+fn test_from_bytes() {
+ let bit_vec = BitVec::from_bytes(&[0b10110110, 0b00000000, 0b11111111]);
+ let str = concat!("10110110", "00000000", "11111111");
+ assert_eq!(format!("{:?}", bit_vec), str);
+}
+
+#[test]
+fn test_to_bytes() {
+ let mut bv = BitVec::from_elem(3, true);
+ bv.set(1, false);
+ assert_eq!(bv.to_bytes(), [0b10100000]);
+
+ let mut bv = BitVec::from_elem(9, false);
+ bv.set(2, true);
+ bv.set(8, true);
+ assert_eq!(bv.to_bytes(), [0b00100000, 0b10000000]);
+}
+
+#[test]
+fn test_from_bools() {
+ let bools = vec![true, false, true, true];
+ let bit_vec: BitVec = bools.iter().map(|n| *n).collect();
+ assert_eq!(format!("{:?}", bit_vec), "1011");
+}
+
+#[test]
+fn test_to_bools() {
+ let bools = vec![false, false, true, false, false, true, true, false];
+ assert_eq!(BitVec::from_bytes(&[0b00100110]).iter().collect::<Vec<bool>>(), bools);
+}
+
+#[test]
+fn test_bit_vec_iterator() {
+ let bools = vec![true, false, true, true];
+ let bit_vec: BitVec = bools.iter().map(|n| *n).collect();
+
+ assert_eq!(bit_vec.iter().collect::<Vec<bool>>(), bools);
+
+ let long: Vec<_> = (0..10000).map(|i| i % 2 == 0).collect();
+ let bit_vec: BitVec = long.iter().map(|n| *n).collect();
+ assert_eq!(bit_vec.iter().collect::<Vec<bool>>(), long)
+}
+
+#[test]
+fn test_small_difference() {
+ let mut b1 = BitVec::from_elem(3, false);
+ let mut b2 = BitVec::from_elem(3, false);
+ b1.set(0, true);
+ b1.set(1, true);
+ b2.set(1, true);
+ b2.set(2, true);
+ assert!(b1.difference(&b2));
+ assert!(b1[0]);
+ assert!(!b1[1]);
+ assert!(!b1[2]);
+}
+
+#[test]
+fn test_big_difference() {
+ let mut b1 = BitVec::from_elem(100, false);
+ let mut b2 = BitVec::from_elem(100, false);
+ b1.set(0, true);
+ b1.set(40, true);
+ b2.set(40, true);
+ b2.set(80, true);
+ assert!(b1.difference(&b2));
+ assert!(b1[0]);
+ assert!(!b1[40]);
+ assert!(!b1[80]);
+}
+
+#[test]
+fn test_small_clear() {
+ let mut b = BitVec::from_elem(14, true);
+ assert!(!b.none() && b.all());
+ b.clear();
+ assert!(b.none() && !b.all());
+}
+
+#[test]
+fn test_big_clear() {
+ let mut b = BitVec::from_elem(140, true);
+ assert!(!b.none() && b.all());
+ b.clear();
+ assert!(b.none() && !b.all());
+}
+
+#[test]
+fn test_bit_vec_lt() {
+ let mut a = BitVec::from_elem(5, false);
+ let mut b = BitVec::from_elem(5, false);
+
+ assert!(!(a < b) && !(b < a));
+ b.set(2, true);
+ assert!(a < b);
+ a.set(3, true);
+ assert!(a < b);
+ a.set(2, true);
+ assert!(!(a < b) && b < a);
+ b.set(0, true);
+ assert!(a < b);
+}
+
+#[test]
+fn test_ord() {
+ let mut a = BitVec::from_elem(5, false);
+ let mut b = BitVec::from_elem(5, false);
+
+ assert!(a <= b && a >= b);
+ a.set(1, true);
+ assert!(a > b && a >= b);
+ assert!(b < a && b <= a);
+ b.set(1, true);
+ b.set(2, true);
+ assert!(b > a && b >= a);
+ assert!(a < b && a <= b);
+}
+
+
+#[test]
+fn test_small_bit_vec_tests() {
+ let v = BitVec::from_bytes(&[0]);
+ assert!(!v.all());
+ assert!(!v.any());
+ assert!(v.none());
+
+ let v = BitVec::from_bytes(&[0b00010100]);
+ assert!(!v.all());
+ assert!(v.any());
+ assert!(!v.none());
+
+ let v = BitVec::from_bytes(&[0xFF]);
+ assert!(v.all());
+ assert!(v.any());
+ assert!(!v.none());
+}
+
+#[test]
+fn test_big_bit_vec_tests() {
+ let v = BitVec::from_bytes(&[ // 88 bits
+ 0, 0, 0, 0,
+ 0, 0, 0, 0,
+ 0, 0, 0]);
+ assert!(!v.all());
+ assert!(!v.any());
+ assert!(v.none());
+
+ let v = BitVec::from_bytes(&[ // 88 bits
+ 0, 0, 0b00010100, 0,
+ 0, 0, 0, 0b00110100,
+ 0, 0, 0]);
+ assert!(!v.all());
+ assert!(v.any());
+ assert!(!v.none());
+
+ let v = BitVec::from_bytes(&[ // 88 bits
+ 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF]);
+ assert!(v.all());
+ assert!(v.any());
+ assert!(!v.none());
+}
+
+#[test]
+fn test_bit_vec_push_pop() {
+ let mut s = BitVec::from_elem(5 * u32::BITS as usize - 2, false);
+ assert_eq!(s.len(), 5 * u32::BITS as usize - 2);
+ assert_eq!(s[5 * u32::BITS as usize - 3], false);
+ s.push(true);
+ s.push(true);
+ assert_eq!(s[5 * u32::BITS as usize - 2], true);
+ assert_eq!(s[5 * u32::BITS as usize - 1], true);
+ // Here the internal vector will need to be extended
+ s.push(false);
+ assert_eq!(s[5 * u32::BITS as usize], false);
+ s.push(false);
+ assert_eq!(s[5 * u32::BITS as usize + 1], false);
+ assert_eq!(s.len(), 5 * u32::BITS as usize + 2);
+ // Pop it all off
+ assert_eq!(s.pop(), Some(false));
+ assert_eq!(s.pop(), Some(false));
+ assert_eq!(s.pop(), Some(true));
+ assert_eq!(s.pop(), Some(true));
+ assert_eq!(s.len(), 5 * u32::BITS as usize - 2);
+}
+
+#[test]
+fn test_bit_vec_truncate() {
+ let mut s = BitVec::from_elem(5 * u32::BITS as usize, true);
+
+ assert_eq!(s, BitVec::from_elem(5 * u32::BITS as usize, true));
+ assert_eq!(s.len(), 5 * u32::BITS as usize);
+ s.truncate(4 * u32::BITS as usize);
+ assert_eq!(s, BitVec::from_elem(4 * u32::BITS as usize, true));
+ assert_eq!(s.len(), 4 * u32::BITS as usize);
+ // Truncating to a size > s.len() should be a noop
+ s.truncate(5 * u32::BITS as usize);
+ assert_eq!(s, BitVec::from_elem(4 * u32::BITS as usize, true));
+ assert_eq!(s.len(), 4 * u32::BITS as usize);
+ s.truncate(3 * u32::BITS as usize - 10);
+ assert_eq!(s, BitVec::from_elem(3 * u32::BITS as usize - 10, true));
+ assert_eq!(s.len(), 3 * u32::BITS as usize - 10);
+ s.truncate(0);
+ assert_eq!(s, BitVec::from_elem(0, true));
+ assert_eq!(s.len(), 0);
+}
+
+#[test]
+fn test_bit_vec_reserve() {
+ let mut s = BitVec::from_elem(5 * u32::BITS as usize, true);
+ // Check capacity
+ assert!(s.capacity() >= 5 * u32::BITS as usize);
+ s.reserve(2 * u32::BITS as usize);
+ assert!(s.capacity() >= 7 * u32::BITS as usize);
+ s.reserve(7 * u32::BITS as usize);
+ assert!(s.capacity() >= 12 * u32::BITS as usize);
+ s.reserve_exact(7 * u32::BITS as usize);
+ assert!(s.capacity() >= 12 * u32::BITS as usize);
+ s.reserve(7 * u32::BITS as usize + 1);
+ assert!(s.capacity() >= 12 * u32::BITS as usize + 1);
+ // Check that length hasn't changed
+ assert_eq!(s.len(), 5 * u32::BITS as usize);
+ s.push(true);
+ s.push(false);
+ s.push(true);
+ assert_eq!(s[5 * u32::BITS as usize - 1], true);
+ assert_eq!(s[5 * u32::BITS as usize - 0], true);
+ assert_eq!(s[5 * u32::BITS as usize + 1], false);
+ assert_eq!(s[5 * u32::BITS as usize + 2], true);
+}
+
+#[test]
+fn test_bit_vec_grow() {
+ let mut bit_vec = BitVec::from_bytes(&[0b10110110, 0b00000000, 0b10101010]);
+ bit_vec.grow(32, true);
+ assert_eq!(bit_vec, BitVec::from_bytes(&[0b10110110, 0b00000000, 0b10101010,
+ 0xFF, 0xFF, 0xFF, 0xFF]));
+ bit_vec.grow(64, false);
+ assert_eq!(bit_vec, BitVec::from_bytes(&[0b10110110, 0b00000000, 0b10101010,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0, 0, 0, 0, 0, 0, 0, 0]));
+ bit_vec.grow(16, true);
+ assert_eq!(bit_vec, BitVec::from_bytes(&[0b10110110, 0b00000000, 0b10101010,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF]));
+}
+
+#[test]
+fn test_bit_vec_extend() {
+ let mut bit_vec = BitVec::from_bytes(&[0b10110110, 0b00000000, 0b11111111]);
+ let ext = BitVec::from_bytes(&[0b01001001, 0b10010010, 0b10111101]);
+ bit_vec.extend(ext.iter());
+ assert_eq!(bit_vec, BitVec::from_bytes(&[0b10110110, 0b00000000, 0b11111111,
+ 0b01001001, 0b10010010, 0b10111101]));
+}
+
+mod bench {
+ use std::collections::BitVec;
+ use std::u32;
+ use std::rand::{Rng, self};
+
+ use test::{Bencher, black_box};
+
+ const BENCH_BITS : usize = 1 << 14;
+
+ fn rng() -> rand::IsaacRng {
+ let seed: &[_] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
+ rand::SeedableRng::from_seed(seed)
+ }
+
+ #[bench]
+ fn bench_usize_small(b: &mut Bencher) {
+ let mut r = rng();
+ let mut bit_vec = 0 as usize;
+ b.iter(|| {
+ for _ in 0..100 {
+ bit_vec |= 1 << ((r.next_u32() as usize) % u32::BITS as usize);
+ }
+ black_box(&bit_vec);
+ });
+ }
+
+ #[bench]
+ fn bench_bit_set_big_fixed(b: &mut Bencher) {
+ let mut r = rng();
+ let mut bit_vec = BitVec::from_elem(BENCH_BITS, false);
+ b.iter(|| {
+ for _ in 0..100 {
+ bit_vec.set((r.next_u32() as usize) % BENCH_BITS, true);
+ }
+ black_box(&bit_vec);
+ });
+ }
+
+ #[bench]
+ fn bench_bit_set_big_variable(b: &mut Bencher) {
+ let mut r = rng();
+ let mut bit_vec = BitVec::from_elem(BENCH_BITS, false);
+ b.iter(|| {
+ for _ in 0..100 {
+ bit_vec.set((r.next_u32() as usize) % BENCH_BITS, r.gen());
+ }
+ black_box(&bit_vec);
+ });
+ }
+
+ #[bench]
+ fn bench_bit_set_small(b: &mut Bencher) {
+ let mut r = rng();
+ let mut bit_vec = BitVec::from_elem(u32::BITS as usize, false);
+ b.iter(|| {
+ for _ in 0..100 {
+ bit_vec.set((r.next_u32() as usize) % u32::BITS as usize, true);
+ }
+ black_box(&bit_vec);
+ });
+ }
+
+ #[bench]
+ fn bench_bit_vec_big_union(b: &mut Bencher) {
+ let mut b1 = BitVec::from_elem(BENCH_BITS, false);
+ let b2 = BitVec::from_elem(BENCH_BITS, false);
+ b.iter(|| {
+ b1.union(&b2)
+ })
+ }
+
+ #[bench]
+ fn bench_bit_vec_small_iter(b: &mut Bencher) {
+ let bit_vec = BitVec::from_elem(u32::BITS as usize, false);
+ b.iter(|| {
+ let mut sum = 0;
+ for _ in 0..10 {
+ for pres in &bit_vec {
+ sum += pres as usize;
+ }
+ }
+ sum
+ })
+ }
+
+ #[bench]
+ fn bench_bit_vec_big_iter(b: &mut Bencher) {
+ let bit_vec = BitVec::from_elem(BENCH_BITS, false);
+ b.iter(|| {
+ let mut sum = 0;
+ for pres in &bit_vec {
+ sum += pres as usize;
+ }
+ sum
+ })
+ }
+}
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::collections::BTreeMap;
+use std::collections::Bound::{Excluded, Included, Unbounded, self};
+use std::collections::btree_map::Entry::{Occupied, Vacant};
+use std::iter::range_inclusive;
+
+#[test]
+fn test_basic_large() {
+ let mut map = BTreeMap::new();
+ let size = 10000;
+ assert_eq!(map.len(), 0);
+
+ for i in 0..size {
+ assert_eq!(map.insert(i, 10*i), None);
+ assert_eq!(map.len(), i + 1);
+ }
+
+ for i in 0..size {
+ assert_eq!(map.get(&i).unwrap(), &(i*10));
+ }
+
+ for i in size..size*2 {
+ assert_eq!(map.get(&i), None);
+ }
+
+ for i in 0..size {
+ assert_eq!(map.insert(i, 100*i), Some(10*i));
+ assert_eq!(map.len(), size);
+ }
+
+ for i in 0..size {
+ assert_eq!(map.get(&i).unwrap(), &(i*100));
+ }
+
+ for i in 0..size/2 {
+ assert_eq!(map.remove(&(i*2)), Some(i*200));
+ assert_eq!(map.len(), size - i - 1);
+ }
+
+ for i in 0..size/2 {
+ assert_eq!(map.get(&(2*i)), None);
+ assert_eq!(map.get(&(2*i+1)).unwrap(), &(i*200 + 100));
+ }
+
+ for i in 0..size/2 {
+ assert_eq!(map.remove(&(2*i)), None);
+ assert_eq!(map.remove(&(2*i+1)), Some(i*200 + 100));
+ assert_eq!(map.len(), size/2 - i - 1);
+ }
+}
+
+#[test]
+fn test_basic_small() {
+ let mut map = BTreeMap::new();
+ assert_eq!(map.remove(&1), None);
+ assert_eq!(map.get(&1), None);
+ assert_eq!(map.insert(1, 1), None);
+ assert_eq!(map.get(&1), Some(&1));
+ assert_eq!(map.insert(1, 2), Some(1));
+ assert_eq!(map.get(&1), Some(&2));
+ assert_eq!(map.insert(2, 4), None);
+ assert_eq!(map.get(&2), Some(&4));
+ assert_eq!(map.remove(&1), Some(2));
+ assert_eq!(map.remove(&2), Some(4));
+ assert_eq!(map.remove(&1), None);
+}
+
+#[test]
+fn test_iter() {
+ let size = 10000;
+
+ // Forwards
+ let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
+
+ fn test<T>(size: usize, mut iter: T) where T: Iterator<Item=(usize, usize)> {
+ for i in 0..size {
+ assert_eq!(iter.size_hint(), (size - i, Some(size - i)));
+ assert_eq!(iter.next().unwrap(), (i, i));
+ }
+ assert_eq!(iter.size_hint(), (0, Some(0)));
+ assert_eq!(iter.next(), None);
+ }
+ test(size, map.iter().map(|(&k, &v)| (k, v)));
+ test(size, map.iter_mut().map(|(&k, &mut v)| (k, v)));
+ test(size, map.into_iter());
+}
+
+#[test]
+fn test_iter_rev() {
+ let size = 10000;
+
+ // Forwards
+ let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
+
+ fn test<T>(size: usize, mut iter: T) where T: Iterator<Item=(usize, usize)> {
+ for i in 0..size {
+ assert_eq!(iter.size_hint(), (size - i, Some(size - i)));
+ assert_eq!(iter.next().unwrap(), (size - i - 1, size - i - 1));
+ }
+ assert_eq!(iter.size_hint(), (0, Some(0)));
+ assert_eq!(iter.next(), None);
+ }
+ test(size, map.iter().rev().map(|(&k, &v)| (k, v)));
+ test(size, map.iter_mut().rev().map(|(&k, &mut v)| (k, v)));
+ test(size, map.into_iter().rev());
+}
+
+#[test]
+fn test_iter_mixed() {
+ let size = 10000;
+
+ // Forwards
+ let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
+
+ fn test<T>(size: usize, mut iter: T)
+ where T: Iterator<Item=(usize, usize)> + DoubleEndedIterator {
+ for i in 0..size / 4 {
+ assert_eq!(iter.size_hint(), (size - i * 2, Some(size - i * 2)));
+ assert_eq!(iter.next().unwrap(), (i, i));
+ assert_eq!(iter.next_back().unwrap(), (size - i - 1, size - i - 1));
+ }
+ for i in size / 4..size * 3 / 4 {
+ assert_eq!(iter.size_hint(), (size * 3 / 4 - i, Some(size * 3 / 4 - i)));
+ assert_eq!(iter.next().unwrap(), (i, i));
+ }
+ assert_eq!(iter.size_hint(), (0, Some(0)));
+ assert_eq!(iter.next(), None);
+ }
+ test(size, map.iter().map(|(&k, &v)| (k, v)));
+ test(size, map.iter_mut().map(|(&k, &mut v)| (k, v)));
+ test(size, map.into_iter());
+}
+
+#[test]
+fn test_range_small() {
+ let size = 5;
+
+ // Forwards
+ let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
+
+ let mut j = 0;
+ for ((&k, &v), i) in map.range(Included(&2), Unbounded).zip(2..size) {
+ assert_eq!(k, i);
+ assert_eq!(v, i);
+ j += 1;
+ }
+ assert_eq!(j, size - 2);
+}
+
+#[test]
+fn test_range_1000() {
+ let size = 1000;
+ let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
+
+ fn test(map: &BTreeMap<u32, u32>, size: u32, min: Bound<&u32>, max: Bound<&u32>) {
+ let mut kvs = map.range(min, max).map(|(&k, &v)| (k, v));
+ let mut pairs = (0..size).map(|i| (i, i));
+
+ for (kv, pair) in kvs.by_ref().zip(pairs.by_ref()) {
+ assert_eq!(kv, pair);
+ }
+ assert_eq!(kvs.next(), None);
+ assert_eq!(pairs.next(), None);
+ }
+ test(&map, size, Included(&0), Excluded(&size));
+ test(&map, size, Unbounded, Excluded(&size));
+ test(&map, size, Included(&0), Included(&(size - 1)));
+ test(&map, size, Unbounded, Included(&(size - 1)));
+ test(&map, size, Included(&0), Unbounded);
+ test(&map, size, Unbounded, Unbounded);
+}
+
+#[test]
+fn test_range() {
+ let size = 200;
+ let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
+
+ for i in 0..size {
+ for j in i..size {
+ let mut kvs = map.range(Included(&i), Included(&j)).map(|(&k, &v)| (k, v));
+ let mut pairs = range_inclusive(i, j).map(|i| (i, i));
+
+ for (kv, pair) in kvs.by_ref().zip(pairs.by_ref()) {
+ assert_eq!(kv, pair);
+ }
+ assert_eq!(kvs.next(), None);
+ assert_eq!(pairs.next(), None);
+ }
+ }
+}
+
+#[test]
+fn test_entry(){
+ let xs = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)];
+
+ let mut map: BTreeMap<_, _> = xs.iter().cloned().collect();
+
+ // Existing key (insert)
+ match map.entry(1) {
+ Vacant(_) => unreachable!(),
+ Occupied(mut view) => {
+ assert_eq!(view.get(), &10);
+ assert_eq!(view.insert(100), 10);
+ }
+ }
+ assert_eq!(map.get(&1).unwrap(), &100);
+ assert_eq!(map.len(), 6);
+
+
+ // Existing key (update)
+ match map.entry(2) {
+ Vacant(_) => unreachable!(),
+ Occupied(mut view) => {
+ let v = view.get_mut();
+ *v *= 10;
+ }
+ }
+ assert_eq!(map.get(&2).unwrap(), &200);
+ assert_eq!(map.len(), 6);
+
+ // Existing key (take)
+ match map.entry(3) {
+ Vacant(_) => unreachable!(),
+ Occupied(view) => {
+ assert_eq!(view.remove(), 30);
+ }
+ }
+ assert_eq!(map.get(&3), None);
+ assert_eq!(map.len(), 5);
+
+
+ // Inexistent key (insert)
+ match map.entry(10) {
+ Occupied(_) => unreachable!(),
+ Vacant(view) => {
+ assert_eq!(*view.insert(1000), 1000);
+ }
+ }
+ assert_eq!(map.get(&10).unwrap(), &1000);
+ assert_eq!(map.len(), 6);
+}
+
+mod bench {
+ use std::collections::BTreeMap;
+ use std::rand::{Rng, weak_rng};
+
+ use test::{Bencher, black_box};
+
+ map_insert_rand_bench!{insert_rand_100, 100, BTreeMap}
+ map_insert_rand_bench!{insert_rand_10_000, 10_000, BTreeMap}
+
+ map_insert_seq_bench!{insert_seq_100, 100, BTreeMap}
+ map_insert_seq_bench!{insert_seq_10_000, 10_000, BTreeMap}
+
+ map_find_rand_bench!{find_rand_100, 100, BTreeMap}
+ map_find_rand_bench!{find_rand_10_000, 10_000, BTreeMap}
+
+ map_find_seq_bench!{find_seq_100, 100, BTreeMap}
+ map_find_seq_bench!{find_seq_10_000, 10_000, BTreeMap}
+
+ fn bench_iter(b: &mut Bencher, size: i32) {
+ let mut map = BTreeMap::<i32, i32>::new();
+ let mut rng = weak_rng();
+
+ for _ in 0..size {
+ map.insert(rng.gen(), rng.gen());
+ }
+
+ b.iter(|| {
+ for entry in &map {
+ black_box(entry);
+ }
+ });
+ }
+
+ #[bench]
+ pub fn iter_20(b: &mut Bencher) {
+ bench_iter(b, 20);
+ }
+
+ #[bench]
+ pub fn iter_1000(b: &mut Bencher) {
+ bench_iter(b, 1000);
+ }
+
+ #[bench]
+ pub fn iter_100000(b: &mut Bencher) {
+ bench_iter(b, 100000);
+ }
+}
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+mod map;
+mod set;
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::collections::BTreeSet;
+use std::hash::{SipHasher, self};
+
+#[test]
+fn test_clone_eq() {
+ let mut m = BTreeSet::new();
+
+ m.insert(1);
+ m.insert(2);
+
+ assert!(m.clone() == m);
+}
+
+#[test]
+fn test_hash() {
+ let mut x = BTreeSet::new();
+ let mut y = BTreeSet::new();
+
+ x.insert(1);
+ x.insert(2);
+ x.insert(3);
+
+ y.insert(3);
+ y.insert(2);
+ y.insert(1);
+
+ assert!(hash::hash::<_, SipHasher>(&x) == hash::hash::<_, SipHasher>(&y));
+}
+
+struct Counter<'a, 'b> {
+ i: &'a mut usize,
+ expected: &'b [i32],
+}
+
+impl<'a, 'b, 'c> FnMut<(&'c i32,)> for Counter<'a, 'b> {
+ type Output = bool;
+
+ extern "rust-call" fn call_mut(&mut self, (&x,): (&'c i32,)) -> bool {
+ assert_eq!(x, self.expected[*self.i]);
+ *self.i += 1;
+ true
+ }
+}
+
+fn check<F>(a: &[i32], b: &[i32], expected: &[i32], f: F) where
+ // FIXME Replace Counter with `Box<FnMut(_) -> _>`
+ F: FnOnce(&BTreeSet<i32>, &BTreeSet<i32>, Counter) -> bool,
+{
+ let mut set_a = BTreeSet::new();
+ let mut set_b = BTreeSet::new();
+
+ for x in a { assert!(set_a.insert(*x)) }
+ for y in b { assert!(set_b.insert(*y)) }
+
+ let mut i = 0;
+ f(&set_a, &set_b, Counter { i: &mut i, expected: expected });
+ assert_eq!(i, expected.len());
+}
+
+#[test]
+fn test_intersection() {
+ fn check_intersection(a: &[i32], b: &[i32], expected: &[i32]) {
+ check(a, b, expected, |x, y, f| x.intersection(y).all(f))
+ }
+
+ check_intersection(&[], &[], &[]);
+ check_intersection(&[1, 2, 3], &[], &[]);
+ check_intersection(&[], &[1, 2, 3], &[]);
+ check_intersection(&[2], &[1, 2, 3], &[2]);
+ check_intersection(&[1, 2, 3], &[2], &[2]);
+ check_intersection(&[11, 1, 3, 77, 103, 5, -5],
+ &[2, 11, 77, -9, -42, 5, 3],
+ &[3, 5, 11, 77]);
+}
+
+#[test]
+fn test_difference() {
+ fn check_difference(a: &[i32], b: &[i32], expected: &[i32]) {
+ check(a, b, expected, |x, y, f| x.difference(y).all(f))
+ }
+
+ check_difference(&[], &[], &[]);
+ check_difference(&[1, 12], &[], &[1, 12]);
+ check_difference(&[], &[1, 2, 3, 9], &[]);
+ check_difference(&[1, 3, 5, 9, 11],
+ &[3, 9],
+ &[1, 5, 11]);
+ check_difference(&[-5, 11, 22, 33, 40, 42],
+ &[-12, -5, 14, 23, 34, 38, 39, 50],
+ &[11, 22, 33, 40, 42]);
+}
+
+#[test]
+fn test_symmetric_difference() {
+ fn check_symmetric_difference(a: &[i32], b: &[i32], expected: &[i32]) {
+ check(a, b, expected, |x, y, f| x.symmetric_difference(y).all(f))
+ }
+
+ check_symmetric_difference(&[], &[], &[]);
+ check_symmetric_difference(&[1, 2, 3], &[2], &[1, 3]);
+ check_symmetric_difference(&[2], &[1, 2, 3], &[1, 3]);
+ check_symmetric_difference(&[1, 3, 5, 9, 11],
+ &[-2, 3, 9, 14, 22],
+ &[-2, 1, 5, 11, 14, 22]);
+}
+
+#[test]
+fn test_union() {
+ fn check_union(a: &[i32], b: &[i32], expected: &[i32]) {
+ check(a, b, expected, |x, y, f| x.union(y).all(f))
+ }
+
+ check_union(&[], &[], &[]);
+ check_union(&[1, 2, 3], &[2], &[1, 2, 3]);
+ check_union(&[2], &[1, 2, 3], &[1, 2, 3]);
+ check_union(&[1, 3, 5, 9, 11, 16, 19, 24],
+ &[-2, 1, 5, 9, 13, 19],
+ &[-2, 1, 3, 5, 9, 11, 13, 16, 19, 24]);
+}
+
+#[test]
+fn test_zip() {
+ let mut x = BTreeSet::new();
+ x.insert(5);
+ x.insert(12);
+ x.insert(11);
+
+ let mut y = BTreeSet::new();
+ y.insert("foo");
+ y.insert("bar");
+
+ let x = x;
+ let y = y;
+ let mut z = x.iter().zip(y.iter());
+
+ // FIXME: #5801: this needs a type hint to compile...
+ let result: Option<(&usize, & &'static str)> = z.next();
+ assert_eq!(result.unwrap(), (&5, &("bar")));
+
+ let result: Option<(&usize, & &'static str)> = z.next();
+ assert_eq!(result.unwrap(), (&11, &("foo")));
+
+ let result: Option<(&usize, & &'static str)> = z.next();
+ assert!(result.is_none());
+}
+
+#[test]
+fn test_from_iter() {
+ let xs = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+
+ let set: BTreeSet<_> = xs.iter().cloned().collect();
+
+ for x in &xs {
+ assert!(set.contains(x));
+ }
+}
+
+#[test]
+fn test_show() {
+ let mut set = BTreeSet::new();
+ let empty = BTreeSet::<i32>::new();
+
+ set.insert(1);
+ set.insert(2);
+
+ let set_str = format!("{:?}", set);
+
+ assert_eq!(set_str, "{1, 2}");
+ assert_eq!(format!("{:?}", empty), "{}");
+}
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::collections::EnumSet;
+
+#[derive(Copy, PartialEq, Debug)]
+#[repr(usize)]
+enum Foo {
+ A, B, C
+}
+
+impl CLike for Foo {
+ fn to_usize(&self) -> usize {
+ *self as usize
+ }
+
+ fn from_usize(v: usize) -> Foo {
+ unsafe { mem::transmute(v) }
+ }
+}
+
+#[test]
+fn test_new() {
+ let e: EnumSet<Foo> = EnumSet::new();
+ assert!(e.is_empty());
+}
+
+#[test]
+fn test_show() {
+ let mut e = EnumSet::new();
+ assert!(format!("{:?}", e) == "{}");
+ e.insert(A);
+ assert!(format!("{:?}", e) == "{A}");
+ e.insert(C);
+ assert!(format!("{:?}", e) == "{A, C}");
+}
+
+#[test]
+fn test_len() {
+ let mut e = EnumSet::new();
+ assert_eq!(e.len(), 0);
+ e.insert(A);
+ e.insert(B);
+ e.insert(C);
+ assert_eq!(e.len(), 3);
+ e.remove(&A);
+ assert_eq!(e.len(), 2);
+ e.clear();
+ assert_eq!(e.len(), 0);
+}
+
+///////////////////////////////////////////////////////////////////////////
+// intersect
+
+#[test]
+fn test_two_empties_do_not_intersect() {
+ let e1: EnumSet<Foo> = EnumSet::new();
+ let e2: EnumSet<Foo> = EnumSet::new();
+ assert!(e1.is_disjoint(&e2));
+}
+
+#[test]
+fn test_empty_does_not_intersect_with_full() {
+ let e1: EnumSet<Foo> = EnumSet::new();
+
+ let mut e2: EnumSet<Foo> = EnumSet::new();
+ e2.insert(A);
+ e2.insert(B);
+ e2.insert(C);
+
+ assert!(e1.is_disjoint(&e2));
+}
+
+#[test]
+fn test_disjoint_intersects() {
+ let mut e1: EnumSet<Foo> = EnumSet::new();
+ e1.insert(A);
+
+ let mut e2: EnumSet<Foo> = EnumSet::new();
+ e2.insert(B);
+
+ assert!(e1.is_disjoint(&e2));
+}
+
+#[test]
+fn test_overlapping_intersects() {
+ let mut e1: EnumSet<Foo> = EnumSet::new();
+ e1.insert(A);
+
+ let mut e2: EnumSet<Foo> = EnumSet::new();
+ e2.insert(A);
+ e2.insert(B);
+
+ assert!(!e1.is_disjoint(&e2));
+}
+
+///////////////////////////////////////////////////////////////////////////
+// contains and contains_elem
+
+#[test]
+fn test_superset() {
+ let mut e1: EnumSet<Foo> = EnumSet::new();
+ e1.insert(A);
+
+ let mut e2: EnumSet<Foo> = EnumSet::new();
+ e2.insert(A);
+ e2.insert(B);
+
+ let mut e3: EnumSet<Foo> = EnumSet::new();
+ e3.insert(C);
+
+ assert!(e1.is_subset(&e2));
+ assert!(e2.is_superset(&e1));
+ assert!(!e3.is_superset(&e2));
+ assert!(!e2.is_superset(&e3))
+}
+
+#[test]
+fn test_contains() {
+ let mut e1: EnumSet<Foo> = EnumSet::new();
+ e1.insert(A);
+ assert!(e1.contains(&A));
+ assert!(!e1.contains(&B));
+ assert!(!e1.contains(&C));
+
+ e1.insert(A);
+ e1.insert(B);
+ assert!(e1.contains(&A));
+ assert!(e1.contains(&B));
+ assert!(!e1.contains(&C));
+}
+
+///////////////////////////////////////////////////////////////////////////
+// iter
+
+#[test]
+fn test_iterator() {
+ let mut e1: EnumSet<Foo> = EnumSet::new();
+
+ let elems: ::vec::Vec<Foo> = e1.iter().collect();
+ assert!(elems.is_empty());
+
+ e1.insert(A);
+ let elems: ::vec::Vec<_> = e1.iter().collect();
+ assert_eq!([A], elems);
+
+ e1.insert(C);
+ let elems: ::vec::Vec<_> = e1.iter().collect();
+ assert_eq!([A,C], elems);
+
+ e1.insert(C);
+ let elems: ::vec::Vec<_> = e1.iter().collect();
+ assert_eq!([A,C], elems);
+
+ e1.insert(B);
+ let elems: ::vec::Vec<_> = e1.iter().collect();
+ assert_eq!([A,B,C], elems);
+}
+
+///////////////////////////////////////////////////////////////////////////
+// operators
+
+#[test]
+fn test_operators() {
+ let mut e1: EnumSet<Foo> = EnumSet::new();
+ e1.insert(A);
+ e1.insert(C);
+
+ let mut e2: EnumSet<Foo> = EnumSet::new();
+ e2.insert(B);
+ e2.insert(C);
+
+ let e_union = e1 | e2;
+ let elems: ::vec::Vec<_> = e_union.iter().collect();
+ assert_eq!([A,B,C], elems);
+
+ let e_intersection = e1 & e2;
+ let elems: ::vec::Vec<_> = e_intersection.iter().collect();
+ assert_eq!([C], elems);
+
+ // Another way to express intersection
+ let e_intersection = e1 - (e1 - e2);
+ let elems: ::vec::Vec<_> = e_intersection.iter().collect();
+ assert_eq!([C], elems);
+
+ let e_subtract = e1 - e2;
+ let elems: ::vec::Vec<_> = e_subtract.iter().collect();
+ assert_eq!([A], elems);
+
+ // Bitwise XOR of two sets, aka symmetric difference
+ let e_symmetric_diff = e1 ^ e2;
+ let elems: ::vec::Vec<_> = e_symmetric_diff.iter().collect();
+ assert_eq!([A,B], elems);
+
+ // Another way to express symmetric difference
+ let e_symmetric_diff = (e1 - e2) | (e2 - e1);
+ let elems: ::vec::Vec<_> = e_symmetric_diff.iter().collect();
+ assert_eq!([A,B], elems);
+
+ // Yet another way to express symmetric difference
+ let e_symmetric_diff = (e1 | e2) - (e1 & e2);
+ let elems: ::vec::Vec<_> = e_symmetric_diff.iter().collect();
+ assert_eq!([A,B], elems);
+}
+
+#[test]
+#[should_panic]
+fn test_overflow() {
+ #[allow(dead_code)]
+ #[derive(Copy)]
+ #[repr(usize)]
+ enum Bar {
+ V00, V01, V02, V03, V04, V05, V06, V07, V08, V09,
+ V10, V11, V12, V13, V14, V15, V16, V17, V18, V19,
+ V20, V21, V22, V23, V24, V25, V26, V27, V28, V29,
+ V30, V31, V32, V33, V34, V35, V36, V37, V38, V39,
+ V40, V41, V42, V43, V44, V45, V46, V47, V48, V49,
+ V50, V51, V52, V53, V54, V55, V56, V57, V58, V59,
+ V60, V61, V62, V63, V64, V65, V66, V67, V68, V69,
+ }
+
+ impl CLike for Bar {
+ fn to_usize(&self) -> usize {
+ *self as usize
+ }
+
+ fn from_usize(v: usize) -> Bar {
+ unsafe { mem::transmute(v) }
+ }
+ }
+ let mut set = EnumSet::new();
+ set.insert(Bar::V64);
+}
--- /dev/null
+// Copyright 2013-2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::fmt;
+
+#[test]
+fn test_format() {
+ let s = fmt::format(format_args!("Hello, {}!", "world"));
+ assert_eq!(s.as_slice(), "Hello, world!");
+}
--- /dev/null
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![allow(deprecated)]
+#![feature(box_syntax)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(hash)]
+#![feature(rand)]
+#![feature(rustc_private)]
+#![feature(str_words)]
+#![feature(test)]
+#![feature(unboxed_closures)]
+#![feature(unicode)]
+#![feature(unsafe_destructor)]
+
+#[macro_use] extern crate log;
+
+extern crate collections;
+extern crate test;
+extern crate unicode;
+
+#[cfg(test)] #[macro_use] mod bench;
+
+mod binary_heap;
+mod bit;
+mod btree;
+// FIXME(japaric) privacy
+//mod enum_set;
+mod fmt;
+mod linked_list;
+mod slice;
+mod str;
+mod string;
+mod vec_deque;
+mod vec_map;
+mod vec;
--- /dev/null
+// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::collections::LinkedList;
+use std::hash::{SipHasher, self};
+
+use test;
+
+// FIXME(japaric) privacy
+/*
+pub fn check_links<T>(list: &LinkedList<T>) {
+ let mut len = 0;
+ let mut last_ptr: Option<&Node<T>> = None;
+ let mut node_ptr: &Node<T>;
+ match list.list_head {
+ None => { assert_eq!(0, list.length); return }
+ Some(ref node) => node_ptr = &**node,
+ }
+ loop {
+ match (last_ptr, node_ptr.prev.resolve_immut()) {
+ (None , None ) => {}
+ (None , _ ) => panic!("prev link for list_head"),
+ (Some(p), Some(pptr)) => {
+ assert_eq!(p as *const Node<T>, pptr as *const Node<T>);
+ }
+ _ => panic!("prev link is none, not good"),
+ }
+ match node_ptr.next {
+ Some(ref next) => {
+ last_ptr = Some(node_ptr);
+ node_ptr = &**next;
+ len += 1;
+ }
+ None => {
+ len += 1;
+ break;
+ }
+ }
+ }
+ assert_eq!(len, list.length);
+}
+*/
+
+#[test]
+fn test_basic() {
+ let mut m = LinkedList::<Box<_>>::new();
+ assert_eq!(m.pop_front(), None);
+ assert_eq!(m.pop_back(), None);
+ assert_eq!(m.pop_front(), None);
+ m.push_front(box 1);
+ assert_eq!(m.pop_front(), Some(box 1));
+ m.push_back(box 2);
+ m.push_back(box 3);
+ assert_eq!(m.len(), 2);
+ assert_eq!(m.pop_front(), Some(box 2));
+ assert_eq!(m.pop_front(), Some(box 3));
+ assert_eq!(m.len(), 0);
+ assert_eq!(m.pop_front(), None);
+ m.push_back(box 1);
+ m.push_back(box 3);
+ m.push_back(box 5);
+ m.push_back(box 7);
+ assert_eq!(m.pop_front(), Some(box 1));
+
+ let mut n = LinkedList::new();
+ n.push_front(2);
+ n.push_front(3);
+ {
+ assert_eq!(n.front().unwrap(), &3);
+ let x = n.front_mut().unwrap();
+ assert_eq!(*x, 3);
+ *x = 0;
+ }
+ {
+ assert_eq!(n.back().unwrap(), &2);
+ let y = n.back_mut().unwrap();
+ assert_eq!(*y, 2);
+ *y = 1;
+ }
+ assert_eq!(n.pop_front(), Some(0));
+ assert_eq!(n.pop_front(), Some(1));
+}
+
+#[cfg(test)]
+fn generate_test() -> LinkedList<i32> {
+ list_from(&[0,1,2,3,4,5,6])
+}
+
+#[cfg(test)]
+fn list_from<T: Clone>(v: &[T]) -> LinkedList<T> {
+ v.iter().cloned().collect()
+}
+
+// FIXME(japaric) privacy
+/*
+#[test]
+fn test_append() {
+ // Empty to empty
+ {
+ let mut m = LinkedList::<i32>::new();
+ let mut n = LinkedList::new();
+ m.append(&mut n);
+ check_links(&m);
+ assert_eq!(m.len(), 0);
+ assert_eq!(n.len(), 0);
+ }
+ // Non-empty to empty
+ {
+ let mut m = LinkedList::new();
+ let mut n = LinkedList::new();
+ n.push_back(2);
+ m.append(&mut n);
+ check_links(&m);
+ assert_eq!(m.len(), 1);
+ assert_eq!(m.pop_back(), Some(2));
+ assert_eq!(n.len(), 0);
+ check_links(&m);
+ }
+ // Empty to non-empty
+ {
+ let mut m = LinkedList::new();
+ let mut n = LinkedList::new();
+ m.push_back(2);
+ m.append(&mut n);
+ check_links(&m);
+ assert_eq!(m.len(), 1);
+ assert_eq!(m.pop_back(), Some(2));
+ check_links(&m);
+ }
+
+ // Non-empty to non-empty
+ let v = vec![1,2,3,4,5];
+ let u = vec![9,8,1,2,3,4,5];
+ let mut m = list_from(&v);
+ let mut n = list_from(&u);
+ m.append(&mut n);
+ check_links(&m);
+ let mut sum = v;
+ sum.push_all(&u);
+ assert_eq!(sum.len(), m.len());
+ for elt in sum {
+ assert_eq!(m.pop_front(), Some(elt))
+ }
+ assert_eq!(n.len(), 0);
+ // let's make sure it's working properly, since we
+ // did some direct changes to private members
+ n.push_back(3);
+ assert_eq!(n.len(), 1);
+ assert_eq!(n.pop_front(), Some(3));
+ check_links(&n);
+}
+*/
+
+#[test]
+fn test_split_off() {
+ // singleton
+ {
+ let mut m = LinkedList::new();
+ m.push_back(1);
+
+ let p = m.split_off(0);
+ assert_eq!(m.len(), 0);
+ assert_eq!(p.len(), 1);
+ assert_eq!(p.back(), Some(&1));
+ assert_eq!(p.front(), Some(&1));
+ }
+
+ // not singleton, forwards
+ {
+ let u = vec![1,2,3,4,5];
+ let mut m = list_from(&u);
+ let mut n = m.split_off(2);
+ assert_eq!(m.len(), 2);
+ assert_eq!(n.len(), 3);
+ for elt in 1..3 {
+ assert_eq!(m.pop_front(), Some(elt));
+ }
+ for elt in 3..6 {
+ assert_eq!(n.pop_front(), Some(elt));
+ }
+ }
+ // not singleton, backwards
+ {
+ let u = vec![1,2,3,4,5];
+ let mut m = list_from(&u);
+ let mut n = m.split_off(4);
+ assert_eq!(m.len(), 4);
+ assert_eq!(n.len(), 1);
+ for elt in 1..5 {
+ assert_eq!(m.pop_front(), Some(elt));
+ }
+ for elt in 5..6 {
+ assert_eq!(n.pop_front(), Some(elt));
+ }
+ }
+
+ // no-op on the last index
+ {
+ let mut m = LinkedList::new();
+ m.push_back(1);
+
+ let p = m.split_off(1);
+ assert_eq!(m.len(), 1);
+ assert_eq!(p.len(), 0);
+ assert_eq!(m.back(), Some(&1));
+ assert_eq!(m.front(), Some(&1));
+ }
+
+}
+
+#[test]
+fn test_iterator() {
+ let m = generate_test();
+ for (i, elt) in m.iter().enumerate() {
+ assert_eq!(i as i32, *elt);
+ }
+ let mut n = LinkedList::new();
+ assert_eq!(n.iter().next(), None);
+ n.push_front(4);
+ let mut it = n.iter();
+ assert_eq!(it.size_hint(), (1, Some(1)));
+ assert_eq!(it.next().unwrap(), &4);
+ assert_eq!(it.size_hint(), (0, Some(0)));
+ assert_eq!(it.next(), None);
+}
+
+#[test]
+fn test_iterator_clone() {
+ let mut n = LinkedList::new();
+ n.push_back(2);
+ n.push_back(3);
+ n.push_back(4);
+ let mut it = n.iter();
+ it.next();
+ let mut jt = it.clone();
+ assert_eq!(it.next(), jt.next());
+ assert_eq!(it.next_back(), jt.next_back());
+ assert_eq!(it.next(), jt.next());
+}
+
+#[test]
+fn test_iterator_double_end() {
+ let mut n = LinkedList::new();
+ assert_eq!(n.iter().next(), None);
+ n.push_front(4);
+ n.push_front(5);
+ n.push_front(6);
+ let mut it = n.iter();
+ assert_eq!(it.size_hint(), (3, Some(3)));
+ assert_eq!(it.next().unwrap(), &6);
+ assert_eq!(it.size_hint(), (2, Some(2)));
+ assert_eq!(it.next_back().unwrap(), &4);
+ assert_eq!(it.size_hint(), (1, Some(1)));
+ assert_eq!(it.next_back().unwrap(), &5);
+ assert_eq!(it.next_back(), None);
+ assert_eq!(it.next(), None);
+}
+
+#[test]
+fn test_rev_iter() {
+ let m = generate_test();
+ for (i, elt) in m.iter().rev().enumerate() {
+ assert_eq!((6 - i) as i32, *elt);
+ }
+ let mut n = LinkedList::new();
+ assert_eq!(n.iter().rev().next(), None);
+ n.push_front(4);
+ let mut it = n.iter().rev();
+ assert_eq!(it.size_hint(), (1, Some(1)));
+ assert_eq!(it.next().unwrap(), &4);
+ assert_eq!(it.size_hint(), (0, Some(0)));
+ assert_eq!(it.next(), None);
+}
+
+#[test]
+fn test_mut_iter() {
+ let mut m = generate_test();
+ let mut len = m.len();
+ for (i, elt) in m.iter_mut().enumerate() {
+ assert_eq!(i as i32, *elt);
+ len -= 1;
+ }
+ assert_eq!(len, 0);
+ let mut n = LinkedList::new();
+ assert!(n.iter_mut().next().is_none());
+ n.push_front(4);
+ n.push_back(5);
+ let mut it = n.iter_mut();
+ assert_eq!(it.size_hint(), (2, Some(2)));
+ assert!(it.next().is_some());
+ assert!(it.next().is_some());
+ assert_eq!(it.size_hint(), (0, Some(0)));
+ assert!(it.next().is_none());
+}
+
+#[test]
+fn test_iterator_mut_double_end() {
+ let mut n = LinkedList::new();
+ assert!(n.iter_mut().next_back().is_none());
+ n.push_front(4);
+ n.push_front(5);
+ n.push_front(6);
+ let mut it = n.iter_mut();
+ assert_eq!(it.size_hint(), (3, Some(3)));
+ assert_eq!(*it.next().unwrap(), 6);
+ assert_eq!(it.size_hint(), (2, Some(2)));
+ assert_eq!(*it.next_back().unwrap(), 4);
+ assert_eq!(it.size_hint(), (1, Some(1)));
+ assert_eq!(*it.next_back().unwrap(), 5);
+ assert!(it.next_back().is_none());
+ assert!(it.next().is_none());
+}
+
+// FIXME(japaric) privacy
+/*
+#[test]
+fn test_insert_prev() {
+ let mut m = list_from(&[0,2,4,6,8]);
+ let len = m.len();
+ {
+ let mut it = m.iter_mut();
+ it.insert_next(-2);
+ loop {
+ match it.next() {
+ None => break,
+ Some(elt) => {
+ it.insert_next(*elt + 1);
+ match it.peek_next() {
+ Some(x) => assert_eq!(*x, *elt + 2),
+ None => assert_eq!(8, *elt),
+ }
+ }
+ }
+ }
+ it.insert_next(0);
+ it.insert_next(1);
+ }
+ check_links(&m);
+ assert_eq!(m.len(), 3 + len * 2);
+ assert_eq!(m.into_iter().collect::<Vec<_>>(), [-2,0,1,2,3,4,5,6,7,8,9,0,1]);
+}
+*/
+
+#[test]
+fn test_mut_rev_iter() {
+ let mut m = generate_test();
+ for (i, elt) in m.iter_mut().rev().enumerate() {
+ assert_eq!((6 - i) as i32, *elt);
+ }
+ let mut n = LinkedList::new();
+ assert!(n.iter_mut().rev().next().is_none());
+ n.push_front(4);
+ let mut it = n.iter_mut().rev();
+ assert!(it.next().is_some());
+ assert!(it.next().is_none());
+}
+
+// FIXME(japaric) privacy
+/*
+#[test]
+fn test_send() {
+ let n = list_from(&[1,2,3]);
+ thread::spawn(move || {
+ check_links(&n);
+ let a: &[_] = &[&1,&2,&3];
+ assert_eq!(a, n.iter().collect::<Vec<_>>());
+ }).join().ok().unwrap();
+}
+*/
+
+#[test]
+fn test_eq() {
+ let mut n = list_from(&[]);
+ let mut m = list_from(&[]);
+ assert!(n == m);
+ n.push_front(1);
+ assert!(n != m);
+ m.push_back(1);
+ assert!(n == m);
+
+ let n = list_from(&[2,3,4]);
+ let m = list_from(&[1,2,3]);
+ assert!(n != m);
+}
+
+#[test]
+fn test_hash() {
+ let mut x = LinkedList::new();
+ let mut y = LinkedList::new();
+
+ assert!(hash::hash::<_, SipHasher>(&x) == hash::hash::<_, SipHasher>(&y));
+
+ x.push_back(1);
+ x.push_back(2);
+ x.push_back(3);
+
+ y.push_front(3);
+ y.push_front(2);
+ y.push_front(1);
+
+ assert!(hash::hash::<_, SipHasher>(&x) == hash::hash::<_, SipHasher>(&y));
+}
+
+#[test]
+fn test_ord() {
+ let n = list_from(&[]);
+ let m = list_from(&[1,2,3]);
+ assert!(n < m);
+ assert!(m > n);
+ assert!(n <= n);
+ assert!(n >= n);
+}
+
+#[test]
+fn test_ord_nan() {
+ let nan = 0.0f64/0.0;
+ let n = list_from(&[nan]);
+ let m = list_from(&[nan]);
+ assert!(!(n < m));
+ assert!(!(n > m));
+ assert!(!(n <= m));
+ assert!(!(n >= m));
+
+ let n = list_from(&[nan]);
+ let one = list_from(&[1.0f64]);
+ assert!(!(n < one));
+ assert!(!(n > one));
+ assert!(!(n <= one));
+ assert!(!(n >= one));
+
+ let u = list_from(&[1.0f64,2.0,nan]);
+ let v = list_from(&[1.0f64,2.0,3.0]);
+ assert!(!(u < v));
+ assert!(!(u > v));
+ assert!(!(u <= v));
+ assert!(!(u >= v));
+
+ let s = list_from(&[1.0f64,2.0,4.0,2.0]);
+ let t = list_from(&[1.0f64,2.0,3.0,2.0]);
+ assert!(!(s < t));
+ assert!(s > one);
+ assert!(!(s <= one));
+ assert!(s >= one);
+}
+
+// FIXME(japaric) privacy
+/*
+#[test]
+fn test_fuzz() {
+ for _ in 0..25 {
+ fuzz_test(3);
+ fuzz_test(16);
+ fuzz_test(189);
+ }
+}
+*/
+
+#[test]
+fn test_show() {
+ let list: LinkedList<_> = (0..10).collect();
+ assert_eq!(format!("{:?}", list), "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
+
+ let list: LinkedList<_> = vec!["just", "one", "test", "more"].iter().cloned().collect();
+ assert_eq!(format!("{:?}", list), "[\"just\", \"one\", \"test\", \"more\"]");
+}
+
+// FIXME(japaric) privacy
+/*
+#[cfg(test)]
+fn fuzz_test(sz: i32) {
+ let mut m: LinkedList<_> = LinkedList::new();
+ let mut v = vec![];
+ for i in 0..sz {
+ check_links(&m);
+ let r: u8 = rand::random();
+ match r % 6 {
+ 0 => {
+ m.pop_back();
+ v.pop();
+ }
+ 1 => {
+ if !v.is_empty() {
+ m.pop_front();
+ v.remove(0);
+ }
+ }
+ 2 | 4 => {
+ m.push_front(-i);
+ v.insert(0, -i);
+ }
+ 3 | 5 | _ => {
+ m.push_back(i);
+ v.push(i);
+ }
+ }
+ }
+
+ check_links(&m);
+
+ let mut i = 0;
+ for (a, &b) in m.into_iter().zip(v.iter()) {
+ i += 1;
+ assert_eq!(a, b);
+ }
+ assert_eq!(i, v.len());
+}
+*/
+
+#[bench]
+fn bench_collect_into(b: &mut test::Bencher) {
+ let v = &[0; 64];
+ b.iter(|| {
+ let _: LinkedList<_> = v.iter().cloned().collect();
+ })
+}
+
+#[bench]
+fn bench_push_front(b: &mut test::Bencher) {
+ let mut m: LinkedList<_> = LinkedList::new();
+ b.iter(|| {
+ m.push_front(0);
+ })
+}
+
+#[bench]
+fn bench_push_back(b: &mut test::Bencher) {
+ let mut m: LinkedList<_> = LinkedList::new();
+ b.iter(|| {
+ m.push_back(0);
+ })
+}
+
+#[bench]
+fn bench_push_back_pop_back(b: &mut test::Bencher) {
+ let mut m: LinkedList<_> = LinkedList::new();
+ b.iter(|| {
+ m.push_back(0);
+ m.pop_back();
+ })
+}
+
+#[bench]
+fn bench_push_front_pop_front(b: &mut test::Bencher) {
+ let mut m: LinkedList<_> = LinkedList::new();
+ b.iter(|| {
+ m.push_front(0);
+ m.pop_front();
+ })
+}
+
+#[bench]
+fn bench_iter(b: &mut test::Bencher) {
+ let v = &[0; 128];
+ let m: LinkedList<_> = v.iter().cloned().collect();
+ b.iter(|| {
+ assert!(m.iter().count() == 128);
+ })
+}
+#[bench]
+fn bench_iter_mut(b: &mut test::Bencher) {
+ let v = &[0; 128];
+ let mut m: LinkedList<_> = v.iter().cloned().collect();
+ b.iter(|| {
+ assert!(m.iter_mut().count() == 128);
+ })
+}
+#[bench]
+fn bench_iter_rev(b: &mut test::Bencher) {
+ let v = &[0; 128];
+ let m: LinkedList<_> = v.iter().cloned().collect();
+ b.iter(|| {
+ assert!(m.iter().rev().count() == 128);
+ })
+}
+#[bench]
+fn bench_iter_mut_rev(b: &mut test::Bencher) {
+ let v = &[0; 128];
+ let mut m: LinkedList<_> = v.iter().cloned().collect();
+ b.iter(|| {
+ assert!(m.iter_mut().rev().count() == 128);
+ })
+}
--- /dev/null
+// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::cmp::Ordering::{Equal, Greater, Less};
+use std::default::Default;
+use std::iter::RandomAccessIterator;
+use std::mem;
+use std::rand::{Rng, thread_rng};
+use std::rc::Rc;
+use std::slice::ElementSwaps;
+
+fn square(n: usize) -> usize { n * n }
+
+fn is_odd(n: &usize) -> bool { *n % 2 == 1 }
+
+#[test]
+fn test_from_fn() {
+ // Test on-stack from_fn.
+ let mut v: Vec<_> = (0..3).map(square).collect();
+ {
+ let v = v;
+ assert_eq!(v.len(), 3);
+ assert_eq!(v[0], 0);
+ assert_eq!(v[1], 1);
+ assert_eq!(v[2], 4);
+ }
+
+ // Test on-heap from_fn.
+ v = (0..5).map(square).collect();
+ {
+ let v = v;
+ assert_eq!(v.len(), 5);
+ assert_eq!(v[0], 0);
+ assert_eq!(v[1], 1);
+ assert_eq!(v[2], 4);
+ assert_eq!(v[3], 9);
+ assert_eq!(v[4], 16);
+ }
+}
+
+#[test]
+fn test_from_elem() {
+ // Test on-stack from_elem.
+ let mut v = vec![10, 10];
+ {
+ let v = v;
+ assert_eq!(v.len(), 2);
+ assert_eq!(v[0], 10);
+ assert_eq!(v[1], 10);
+ }
+
+ // Test on-heap from_elem.
+ v = vec![20; 6];
+ {
+ let v = v.as_slice();
+ assert_eq!(v[0], 20);
+ assert_eq!(v[1], 20);
+ assert_eq!(v[2], 20);
+ assert_eq!(v[3], 20);
+ assert_eq!(v[4], 20);
+ assert_eq!(v[5], 20);
+ }
+}
+
+#[test]
+fn test_is_empty() {
+ let xs: [i32; 0] = [];
+ assert!(xs.is_empty());
+ assert!(![0].is_empty());
+}
+
+#[test]
+fn test_len_divzero() {
+ type Z = [i8; 0];
+ let v0 : &[Z] = &[];
+ let v1 : &[Z] = &[[]];
+ let v2 : &[Z] = &[[], []];
+ assert_eq!(mem::size_of::<Z>(), 0);
+ assert_eq!(v0.len(), 0);
+ assert_eq!(v1.len(), 1);
+ assert_eq!(v2.len(), 2);
+}
+
+#[test]
+fn test_get() {
+ let mut a = vec![11];
+ assert_eq!(a.get(1), None);
+ a = vec![11, 12];
+ assert_eq!(a.get(1).unwrap(), &12);
+ a = vec![11, 12, 13];
+ assert_eq!(a.get(1).unwrap(), &12);
+}
+
+#[test]
+fn test_first() {
+ let mut a = vec![];
+ assert_eq!(a.first(), None);
+ a = vec![11];
+ assert_eq!(a.first().unwrap(), &11);
+ a = vec![11, 12];
+ assert_eq!(a.first().unwrap(), &11);
+}
+
+#[test]
+fn test_first_mut() {
+ let mut a = vec![];
+ assert_eq!(a.first_mut(), None);
+ a = vec![11];
+ assert_eq!(*a.first_mut().unwrap(), 11);
+ a = vec![11, 12];
+ assert_eq!(*a.first_mut().unwrap(), 11);
+}
+
+#[test]
+fn test_tail() {
+ let mut a = vec![11];
+ let b: &[i32] = &[];
+ assert_eq!(a.tail(), b);
+ a = vec![11, 12];
+ let b: &[i32] = &[12];
+ assert_eq!(a.tail(), b);
+}
+
+#[test]
+fn test_tail_mut() {
+ let mut a = vec![11];
+ let b: &mut [i32] = &mut [];
+ assert!(a.tail_mut() == b);
+ a = vec![11, 12];
+ let b: &mut [_] = &mut [12];
+ assert!(a.tail_mut() == b);
+}
+
+#[test]
+#[should_panic]
+fn test_tail_empty() {
+ let a = Vec::<i32>::new();
+ a.tail();
+}
+
+#[test]
+#[should_panic]
+fn test_tail_mut_empty() {
+ let mut a = Vec::<i32>::new();
+ a.tail_mut();
+}
+
+#[test]
+fn test_init() {
+ let mut a = vec![11];
+ let b: &[i32] = &[];
+ assert_eq!(a.init(), b);
+ a = vec![11, 12];
+ let b: &[_] = &[11];
+ assert_eq!(a.init(), b);
+}
+
+#[test]
+fn test_init_mut() {
+ let mut a = vec![11];
+ let b: &mut [i32] = &mut [];
+ assert!(a.init_mut() == b);
+ a = vec![11, 12];
+ let b: &mut [_] = &mut [11];
+ assert!(a.init_mut() == b);
+}
+
+#[test]
+#[should_panic]
+fn test_init_empty() {
+ let a = Vec::<i32>::new();
+ a.init();
+}
+
+#[test]
+#[should_panic]
+fn test_init_mut_empty() {
+ let mut a = Vec::<i32>::new();
+ a.init_mut();
+}
+
+#[test]
+fn test_last() {
+ let mut a = vec![];
+ assert_eq!(a.last(), None);
+ a = vec![11];
+ assert_eq!(a.last().unwrap(), &11);
+ a = vec![11, 12];
+ assert_eq!(a.last().unwrap(), &12);
+}
+
+#[test]
+fn test_last_mut() {
+ let mut a = vec![];
+ assert_eq!(a.last_mut(), None);
+ a = vec![11];
+ assert_eq!(*a.last_mut().unwrap(), 11);
+ a = vec![11, 12];
+ assert_eq!(*a.last_mut().unwrap(), 12);
+}
+
+#[test]
+fn test_slice() {
+ // Test fixed length vector.
+ let vec_fixed = [1, 2, 3, 4];
+ let v_a = vec_fixed[1..vec_fixed.len()].to_vec();
+ assert_eq!(v_a.len(), 3);
+
+ assert_eq!(v_a[0], 2);
+ assert_eq!(v_a[1], 3);
+ assert_eq!(v_a[2], 4);
+
+ // Test on stack.
+ let vec_stack: &[_] = &[1, 2, 3];
+ let v_b = vec_stack[1..3].to_vec();
+ assert_eq!(v_b.len(), 2);
+
+ assert_eq!(v_b[0], 2);
+ assert_eq!(v_b[1], 3);
+
+ // Test `Box<[T]>`
+ let vec_unique = vec![1, 2, 3, 4, 5, 6];
+ let v_d = vec_unique[1..6].to_vec();
+ assert_eq!(v_d.len(), 5);
+
+ assert_eq!(v_d[0], 2);
+ assert_eq!(v_d[1], 3);
+ assert_eq!(v_d[2], 4);
+ assert_eq!(v_d[3], 5);
+ assert_eq!(v_d[4], 6);
+}
+
+#[test]
+fn test_slice_from() {
+ let vec: &[_] = &[1, 2, 3, 4];
+ assert_eq!(&vec[..], vec);
+ let b: &[_] = &[3, 4];
+ assert_eq!(&vec[2..], b);
+ let b: &[_] = &[];
+ assert_eq!(&vec[4..], b);
+}
+
+#[test]
+fn test_slice_to() {
+ let vec: &[_] = &[1, 2, 3, 4];
+ assert_eq!(&vec[..4], vec);
+ let b: &[_] = &[1, 2];
+ assert_eq!(&vec[..2], b);
+ let b: &[_] = &[];
+ assert_eq!(&vec[..0], b);
+}
+
+
+#[test]
+fn test_pop() {
+ let mut v = vec![5];
+ let e = v.pop();
+ assert_eq!(v.len(), 0);
+ assert_eq!(e, Some(5));
+ let f = v.pop();
+ assert_eq!(f, None);
+ let g = v.pop();
+ assert_eq!(g, None);
+}
+
+#[test]
+fn test_swap_remove() {
+ let mut v = vec![1, 2, 3, 4, 5];
+ let mut e = v.swap_remove(0);
+ assert_eq!(e, 1);
+ assert_eq!(v, [5, 2, 3, 4]);
+ e = v.swap_remove(3);
+ assert_eq!(e, 4);
+ assert_eq!(v, [5, 2, 3]);
+}
+
+#[test]
+#[should_panic]
+fn test_swap_remove_fail() {
+ let mut v = vec![1];
+ let _ = v.swap_remove(0);
+ let _ = v.swap_remove(0);
+}
+
+#[test]
+fn test_swap_remove_noncopyable() {
+ // Tests that we don't accidentally run destructors twice.
+ let mut v: Vec<Box<_>> = Vec::new();
+ v.push(box 0u8);
+ v.push(box 0u8);
+ v.push(box 0u8);
+ let mut _e = v.swap_remove(0);
+ assert_eq!(v.len(), 2);
+ _e = v.swap_remove(1);
+ assert_eq!(v.len(), 1);
+ _e = v.swap_remove(0);
+ assert_eq!(v.len(), 0);
+}
+
+#[test]
+fn test_push() {
+ // Test on-stack push().
+ let mut v = vec![];
+ v.push(1);
+ assert_eq!(v.len(), 1);
+ assert_eq!(v[0], 1);
+
+ // Test on-heap push().
+ v.push(2);
+ assert_eq!(v.len(), 2);
+ assert_eq!(v[0], 1);
+ assert_eq!(v[1], 2);
+}
+
+#[test]
+fn test_truncate() {
+ let mut v: Vec<Box<_>> = vec![box 6,box 5,box 4];
+ v.truncate(1);
+ let v = v;
+ assert_eq!(v.len(), 1);
+ assert_eq!(*(v[0]), 6);
+ // If the unsafe block didn't drop things properly, we blow up here.
+}
+
+#[test]
+fn test_clear() {
+ let mut v: Vec<Box<_>> = vec![box 6,box 5,box 4];
+ v.clear();
+ assert_eq!(v.len(), 0);
+ // If the unsafe block didn't drop things properly, we blow up here.
+}
+
+#[test]
+fn test_dedup() {
+ fn case(a: Vec<i32>, b: Vec<i32>) {
+ let mut v = a;
+ v.dedup();
+ assert_eq!(v, b);
+ }
+ case(vec![], vec![]);
+ case(vec![1], vec![1]);
+ case(vec![1,1], vec![1]);
+ case(vec![1,2,3], vec![1,2,3]);
+ case(vec![1,1,2,3], vec![1,2,3]);
+ case(vec![1,2,2,3], vec![1,2,3]);
+ case(vec![1,2,3,3], vec![1,2,3]);
+ case(vec![1,1,2,2,2,3,3], vec![1,2,3]);
+}
+
+#[test]
+fn test_dedup_unique() {
+ let mut v0: Vec<Box<_>> = vec![box 1, box 1, box 2, box 3];
+ v0.dedup();
+ let mut v1: Vec<Box<_>> = vec![box 1, box 2, box 2, box 3];
+ v1.dedup();
+ let mut v2: Vec<Box<_>> = vec![box 1, box 2, box 3, box 3];
+ v2.dedup();
+ /*
+ * If the boxed pointers were leaked or otherwise misused, valgrind
+ * and/or rt should raise errors.
+ */
+}
+
+#[test]
+fn test_dedup_shared() {
+ let mut v0: Vec<Box<_>> = vec![box 1, box 1, box 2, box 3];
+ v0.dedup();
+ let mut v1: Vec<Box<_>> = vec![box 1, box 2, box 2, box 3];
+ v1.dedup();
+ let mut v2: Vec<Box<_>> = vec![box 1, box 2, box 3, box 3];
+ v2.dedup();
+ /*
+ * If the pointers were leaked or otherwise misused, valgrind and/or
+ * rt should raise errors.
+ */
+}
+
+#[test]
+fn test_retain() {
+ let mut v = vec![1, 2, 3, 4, 5];
+ v.retain(is_odd);
+ assert_eq!(v, [1, 3, 5]);
+}
+
+#[test]
+fn test_element_swaps() {
+ let mut v = [1, 2, 3];
+ for (i, (a, b)) in ElementSwaps::new(v.len()).enumerate() {
+ v.swap(a, b);
+ match i {
+ 0 => assert!(v == [1, 3, 2]),
+ 1 => assert!(v == [3, 1, 2]),
+ 2 => assert!(v == [3, 2, 1]),
+ 3 => assert!(v == [2, 3, 1]),
+ 4 => assert!(v == [2, 1, 3]),
+ 5 => assert!(v == [1, 2, 3]),
+ _ => panic!(),
+ }
+ }
+}
+
+// FIXME(japaric) privacy
+/*
+#[test]
+fn test_permutations() {
+ {
+ let v: [i32; 0] = [];
+ let mut it = v.permutations();
+ let (min_size, max_opt) = it.size_hint();
+ assert_eq!(min_size, 1);
+ assert_eq!(max_opt.unwrap(), 1);
+ assert_eq!(it.next(), Some(v.to_vec()));
+ assert_eq!(it.next(), None);
+ }
+ {
+ let v = ["Hello".to_string()];
+ let mut it = v.permutations();
+ let (min_size, max_opt) = it.size_hint();
+ assert_eq!(min_size, 1);
+ assert_eq!(max_opt.unwrap(), 1);
+ assert_eq!(it.next(), Some(v.to_vec()));
+ assert_eq!(it.next(), None);
+ }
+ {
+ let v = [1, 2, 3];
+ let mut it = v.permutations();
+ let (min_size, max_opt) = it.size_hint();
+ assert_eq!(min_size, 3*2);
+ assert_eq!(max_opt.unwrap(), 3*2);
+ assert_eq!(it.next(), Some(vec![1,2,3]));
+ assert_eq!(it.next(), Some(vec![1,3,2]));
+ assert_eq!(it.next(), Some(vec![3,1,2]));
+ let (min_size, max_opt) = it.size_hint();
+ assert_eq!(min_size, 3);
+ assert_eq!(max_opt.unwrap(), 3);
+ assert_eq!(it.next(), Some(vec![3,2,1]));
+ assert_eq!(it.next(), Some(vec![2,3,1]));
+ assert_eq!(it.next(), Some(vec![2,1,3]));
+ assert_eq!(it.next(), None);
+ }
+ {
+ // check that we have N! permutations
+ let v = ['A', 'B', 'C', 'D', 'E', 'F'];
+ let mut amt = 0;
+ let mut it = v.permutations();
+ let (min_size, max_opt) = it.size_hint();
+ for _perm in it.by_ref() {
+ amt += 1;
+ }
+ assert_eq!(amt, it.swaps.swaps_made);
+ assert_eq!(amt, min_size);
+ assert_eq!(amt, 2 * 3 * 4 * 5 * 6);
+ assert_eq!(amt, max_opt.unwrap());
+ }
+}
+*/
+
+#[test]
+fn test_lexicographic_permutations() {
+ let v : &mut[_] = &mut[1, 2, 3, 4, 5];
+ assert!(v.prev_permutation() == false);
+ assert!(v.next_permutation());
+ let b: &mut[_] = &mut[1, 2, 3, 5, 4];
+ assert!(v == b);
+ assert!(v.prev_permutation());
+ let b: &mut[_] = &mut[1, 2, 3, 4, 5];
+ assert!(v == b);
+ assert!(v.next_permutation());
+ assert!(v.next_permutation());
+ let b: &mut[_] = &mut[1, 2, 4, 3, 5];
+ assert!(v == b);
+ assert!(v.next_permutation());
+ let b: &mut[_] = &mut[1, 2, 4, 5, 3];
+ assert!(v == b);
+
+ let v : &mut[_] = &mut[1, 0, 0, 0];
+ assert!(v.next_permutation() == false);
+ assert!(v.prev_permutation());
+ let b: &mut[_] = &mut[0, 1, 0, 0];
+ assert!(v == b);
+ assert!(v.prev_permutation());
+ let b: &mut[_] = &mut[0, 0, 1, 0];
+ assert!(v == b);
+ assert!(v.prev_permutation());
+ let b: &mut[_] = &mut[0, 0, 0, 1];
+ assert!(v == b);
+ assert!(v.prev_permutation() == false);
+}
+
+#[test]
+fn test_lexicographic_permutations_empty_and_short() {
+ let empty : &mut[i32] = &mut[];
+ assert!(empty.next_permutation() == false);
+ let b: &mut[i32] = &mut[];
+ assert!(empty == b);
+ assert!(empty.prev_permutation() == false);
+ assert!(empty == b);
+
+ let one_elem : &mut[_] = &mut[4];
+ assert!(one_elem.prev_permutation() == false);
+ let b: &mut[_] = &mut[4];
+ assert!(one_elem == b);
+ assert!(one_elem.next_permutation() == false);
+ assert!(one_elem == b);
+
+ let two_elem : &mut[_] = &mut[1, 2];
+ assert!(two_elem.prev_permutation() == false);
+ let b : &mut[_] = &mut[1, 2];
+ let c : &mut[_] = &mut[2, 1];
+ assert!(two_elem == b);
+ assert!(two_elem.next_permutation());
+ assert!(two_elem == c);
+ assert!(two_elem.next_permutation() == false);
+ assert!(two_elem == c);
+ assert!(two_elem.prev_permutation());
+ assert!(two_elem == b);
+ assert!(two_elem.prev_permutation() == false);
+ assert!(two_elem == b);
+}
+
+#[test]
+fn test_position_elem() {
+ assert!([].position_elem(&1).is_none());
+
+ let v1 = vec![1, 2, 3, 3, 2, 5];
+ assert_eq!(v1.position_elem(&1), Some(0));
+ assert_eq!(v1.position_elem(&2), Some(1));
+ assert_eq!(v1.position_elem(&5), Some(5));
+ assert!(v1.position_elem(&4).is_none());
+}
+
+#[test]
+fn test_binary_search() {
+ assert_eq!([1,2,3,4,5].binary_search(&5).ok(), Some(4));
+ assert_eq!([1,2,3,4,5].binary_search(&4).ok(), Some(3));
+ assert_eq!([1,2,3,4,5].binary_search(&3).ok(), Some(2));
+ assert_eq!([1,2,3,4,5].binary_search(&2).ok(), Some(1));
+ assert_eq!([1,2,3,4,5].binary_search(&1).ok(), Some(0));
+
+ assert_eq!([2,4,6,8,10].binary_search(&1).ok(), None);
+ assert_eq!([2,4,6,8,10].binary_search(&5).ok(), None);
+ assert_eq!([2,4,6,8,10].binary_search(&4).ok(), Some(1));
+ assert_eq!([2,4,6,8,10].binary_search(&10).ok(), Some(4));
+
+ assert_eq!([2,4,6,8].binary_search(&1).ok(), None);
+ assert_eq!([2,4,6,8].binary_search(&5).ok(), None);
+ assert_eq!([2,4,6,8].binary_search(&4).ok(), Some(1));
+ assert_eq!([2,4,6,8].binary_search(&8).ok(), Some(3));
+
+ assert_eq!([2,4,6].binary_search(&1).ok(), None);
+ assert_eq!([2,4,6].binary_search(&5).ok(), None);
+ assert_eq!([2,4,6].binary_search(&4).ok(), Some(1));
+ assert_eq!([2,4,6].binary_search(&6).ok(), Some(2));
+
+ assert_eq!([2,4].binary_search(&1).ok(), None);
+ assert_eq!([2,4].binary_search(&5).ok(), None);
+ assert_eq!([2,4].binary_search(&2).ok(), Some(0));
+ assert_eq!([2,4].binary_search(&4).ok(), Some(1));
+
+ assert_eq!([2].binary_search(&1).ok(), None);
+ assert_eq!([2].binary_search(&5).ok(), None);
+ assert_eq!([2].binary_search(&2).ok(), Some(0));
+
+ assert_eq!([].binary_search(&1).ok(), None);
+ assert_eq!([].binary_search(&5).ok(), None);
+
+ assert!([1,1,1,1,1].binary_search(&1).ok() != None);
+ assert!([1,1,1,1,2].binary_search(&1).ok() != None);
+ assert!([1,1,1,2,2].binary_search(&1).ok() != None);
+ assert!([1,1,2,2,2].binary_search(&1).ok() != None);
+ assert_eq!([1,2,2,2,2].binary_search(&1).ok(), Some(0));
+
+ assert_eq!([1,2,3,4,5].binary_search(&6).ok(), None);
+ assert_eq!([1,2,3,4,5].binary_search(&0).ok(), None);
+}
+
+#[test]
+fn test_reverse() {
+ let mut v = vec![10, 20];
+ assert_eq!(v[0], 10);
+ assert_eq!(v[1], 20);
+ v.reverse();
+ assert_eq!(v[0], 20);
+ assert_eq!(v[1], 10);
+
+ let mut v3 = Vec::<i32>::new();
+ v3.reverse();
+ assert!(v3.is_empty());
+}
+
+#[test]
+fn test_sort() {
+ for len in 4..25 {
+ for _ in 0..100 {
+ let mut v: Vec<_> = thread_rng().gen_iter::<i32>().take(len).collect();
+ let mut v1 = v.clone();
+
+ v.sort();
+ assert!(v.windows(2).all(|w| w[0] <= w[1]));
+
+ v1.sort_by(|a, b| a.cmp(b));
+ assert!(v1.windows(2).all(|w| w[0] <= w[1]));
+
+ v1.sort_by(|a, b| b.cmp(a));
+ assert!(v1.windows(2).all(|w| w[0] >= w[1]));
+ }
+ }
+
+ // shouldn't panic
+ let mut v: [i32; 0] = [];
+ v.sort();
+
+ let mut v = [0xDEADBEEFu64];
+ v.sort();
+ assert!(v == [0xDEADBEEF]);
+}
+
+#[test]
+fn test_sort_stability() {
+ for len in 4..25 {
+ for _ in 0..10 {
+ let mut counts = [0; 10];
+
+ // create a vector like [(6, 1), (5, 1), (6, 2), ...],
+ // where the first item of each tuple is random, but
+ // the second item represents which occurrence of that
+ // number this element is, i.e. the second elements
+ // will occur in sorted order.
+ let mut v: Vec<_> = (0..len).map(|_| {
+ let n = thread_rng().gen::<usize>() % 10;
+ counts[n] += 1;
+ (n, counts[n])
+ }).collect();
+
+ // only sort on the first element, so an unstable sort
+ // may mix up the counts.
+ v.sort_by(|&(a,_), &(b,_)| a.cmp(&b));
+
+ // this comparison includes the count (the second item
+ // of the tuple), so elements with equal first items
+ // will need to be ordered with increasing
+ // counts... i.e. exactly asserting that this sort is
+ // stable.
+ assert!(v.windows(2).all(|w| w[0] <= w[1]));
+ }
+ }
+}
+
+#[test]
+fn test_concat() {
+ let v: [Vec<i32>; 0] = [];
+ let c = v.concat();
+ assert_eq!(c, []);
+ let d = [vec![1], vec![2, 3]].concat();
+ assert_eq!(d, [1, 2, 3]);
+
+ let v: &[&[_]] = &[&[1], &[2, 3]];
+ assert_eq!(v.connect(&0), [1, 0, 2, 3]);
+ let v: &[&[_]] = &[&[1], &[2], &[3]];
+ assert_eq!(v.connect(&0), [1, 0, 2, 0, 3]);
+}
+
+#[test]
+fn test_connect() {
+ let v: [Vec<i32>; 0] = [];
+ assert_eq!(v.connect(&0), []);
+ assert_eq!([vec![1], vec![2, 3]].connect(&0), [1, 0, 2, 3]);
+ assert_eq!([vec![1], vec![2], vec![3]].connect(&0), [1, 0, 2, 0, 3]);
+
+ let v: [&[_]; 2] = [&[1], &[2, 3]];
+ assert_eq!(v.connect(&0), [1, 0, 2, 3]);
+ let v: [&[_]; 3] = [&[1], &[2], &[3]];
+ assert_eq!(v.connect(&0), [1, 0, 2, 0, 3]);
+}
+
+#[test]
+fn test_insert() {
+ let mut a = vec![1, 2, 4];
+ a.insert(2, 3);
+ assert_eq!(a, [1, 2, 3, 4]);
+
+ let mut a = vec![1, 2, 3];
+ a.insert(0, 0);
+ assert_eq!(a, [0, 1, 2, 3]);
+
+ let mut a = vec![1, 2, 3];
+ a.insert(3, 4);
+ assert_eq!(a, [1, 2, 3, 4]);
+
+ let mut a = vec![];
+ a.insert(0, 1);
+ assert_eq!(a, [1]);
+}
+
+#[test]
+#[should_panic]
+fn test_insert_oob() {
+ let mut a = vec![1, 2, 3];
+ a.insert(4, 5);
+}
+
+#[test]
+fn test_remove() {
+ let mut a = vec![1, 2, 3, 4];
+
+ assert_eq!(a.remove(2), 3);
+ assert_eq!(a, [1, 2, 4]);
+
+ assert_eq!(a.remove(2), 4);
+ assert_eq!(a, [1, 2]);
+
+ assert_eq!(a.remove(0), 1);
+ assert_eq!(a, [2]);
+
+ assert_eq!(a.remove(0), 2);
+ assert_eq!(a, []);
+}
+
+#[test]
+#[should_panic]
+fn test_remove_fail() {
+ let mut a = vec![1];
+ let _ = a.remove(0);
+ let _ = a.remove(0);
+}
+
+#[test]
+fn test_capacity() {
+ let mut v = vec![0];
+ v.reserve_exact(10);
+ assert!(v.capacity() >= 11);
+}
+
+#[test]
+fn test_slice_2() {
+ let v = vec![1, 2, 3, 4, 5];
+ let v = v.slice(1, 3);
+ assert_eq!(v.len(), 2);
+ assert_eq!(v[0], 2);
+ assert_eq!(v[1], 3);
+}
+
+#[test]
+#[should_panic]
+fn test_permute_fail() {
+ let v: [(Box<_>, Rc<_>); 4] =
+ [(box 0, Rc::new(0)), (box 0, Rc::new(0)),
+ (box 0, Rc::new(0)), (box 0, Rc::new(0))];
+ let mut i = 0;
+ for _ in v.permutations() {
+ if i == 2 {
+ panic!()
+ }
+ i += 1;
+ }
+}
+
+#[test]
+fn test_total_ord() {
+ let c = &[1, 2, 3];
+ [1, 2, 3, 4][..].cmp(c) == Greater;
+ let c = &[1, 2, 3, 4];
+ [1, 2, 3][..].cmp(c) == Less;
+ let c = &[1, 2, 3, 6];
+ [1, 2, 3, 4][..].cmp(c) == Equal;
+ let c = &[1, 2, 3, 4, 5, 6];
+ [1, 2, 3, 4, 5, 5, 5, 5][..].cmp(c) == Less;
+ let c = &[1, 2, 3, 4];
+ [2, 2][..].cmp(c) == Greater;
+}
+
+#[test]
+fn test_iterator() {
+ let xs = [1, 2, 5, 10, 11];
+ let mut it = xs.iter();
+ assert_eq!(it.size_hint(), (5, Some(5)));
+ assert_eq!(it.next().unwrap(), &1);
+ assert_eq!(it.size_hint(), (4, Some(4)));
+ assert_eq!(it.next().unwrap(), &2);
+ assert_eq!(it.size_hint(), (3, Some(3)));
+ assert_eq!(it.next().unwrap(), &5);
+ assert_eq!(it.size_hint(), (2, Some(2)));
+ assert_eq!(it.next().unwrap(), &10);
+ assert_eq!(it.size_hint(), (1, Some(1)));
+ assert_eq!(it.next().unwrap(), &11);
+ assert_eq!(it.size_hint(), (0, Some(0)));
+ assert!(it.next().is_none());
+}
+
+#[test]
+fn test_random_access_iterator() {
+ let xs = [1, 2, 5, 10, 11];
+ let mut it = xs.iter();
+
+ assert_eq!(it.indexable(), 5);
+ assert_eq!(it.idx(0).unwrap(), &1);
+ assert_eq!(it.idx(2).unwrap(), &5);
+ assert_eq!(it.idx(4).unwrap(), &11);
+ assert!(it.idx(5).is_none());
+
+ assert_eq!(it.next().unwrap(), &1);
+ assert_eq!(it.indexable(), 4);
+ assert_eq!(it.idx(0).unwrap(), &2);
+ assert_eq!(it.idx(3).unwrap(), &11);
+ assert!(it.idx(4).is_none());
+
+ assert_eq!(it.next().unwrap(), &2);
+ assert_eq!(it.indexable(), 3);
+ assert_eq!(it.idx(1).unwrap(), &10);
+ assert!(it.idx(3).is_none());
+
+ assert_eq!(it.next().unwrap(), &5);
+ assert_eq!(it.indexable(), 2);
+ assert_eq!(it.idx(1).unwrap(), &11);
+
+ assert_eq!(it.next().unwrap(), &10);
+ assert_eq!(it.indexable(), 1);
+ assert_eq!(it.idx(0).unwrap(), &11);
+ assert!(it.idx(1).is_none());
+
+ assert_eq!(it.next().unwrap(), &11);
+ assert_eq!(it.indexable(), 0);
+ assert!(it.idx(0).is_none());
+
+ assert!(it.next().is_none());
+}
+
+#[test]
+fn test_iter_size_hints() {
+ let mut xs = [1, 2, 5, 10, 11];
+ assert_eq!(xs.iter().size_hint(), (5, Some(5)));
+ assert_eq!(xs.iter_mut().size_hint(), (5, Some(5)));
+}
+
+#[test]
+fn test_iter_clone() {
+ let xs = [1, 2, 5];
+ let mut it = xs.iter();
+ it.next();
+ let mut jt = it.clone();
+ assert_eq!(it.next(), jt.next());
+ assert_eq!(it.next(), jt.next());
+ assert_eq!(it.next(), jt.next());
+}
+
+#[test]
+fn test_mut_iterator() {
+ let mut xs = [1, 2, 3, 4, 5];
+ for x in &mut xs {
+ *x += 1;
+ }
+ assert!(xs == [2, 3, 4, 5, 6])
+}
+
+#[test]
+fn test_rev_iterator() {
+
+ let xs = [1, 2, 5, 10, 11];
+ let ys = [11, 10, 5, 2, 1];
+ let mut i = 0;
+ for &x in xs.iter().rev() {
+ assert_eq!(x, ys[i]);
+ i += 1;
+ }
+ assert_eq!(i, 5);
+}
+
+#[test]
+fn test_mut_rev_iterator() {
+ let mut xs = [1, 2, 3, 4, 5];
+ for (i,x) in xs.iter_mut().rev().enumerate() {
+ *x += i;
+ }
+ assert!(xs == [5, 5, 5, 5, 5])
+}
+
+#[test]
+fn test_move_iterator() {
+ let xs = vec![1,2,3,4,5];
+ assert_eq!(xs.into_iter().fold(0, |a: usize, b: usize| 10*a + b), 12345);
+}
+
+#[test]
+fn test_move_rev_iterator() {
+ let xs = vec![1,2,3,4,5];
+ assert_eq!(xs.into_iter().rev().fold(0, |a: usize, b: usize| 10*a + b), 54321);
+}
+
+#[test]
+fn test_splitator() {
+ let xs = &[1,2,3,4,5];
+
+ let splits: &[&[_]] = &[&[1], &[3], &[5]];
+ assert_eq!(xs.split(|x| *x % 2 == 0).collect::<Vec<_>>(),
+ splits);
+ let splits: &[&[_]] = &[&[], &[2,3,4,5]];
+ assert_eq!(xs.split(|x| *x == 1).collect::<Vec<_>>(),
+ splits);
+ let splits: &[&[_]] = &[&[1,2,3,4], &[]];
+ assert_eq!(xs.split(|x| *x == 5).collect::<Vec<_>>(),
+ splits);
+ let splits: &[&[_]] = &[&[1,2,3,4,5]];
+ assert_eq!(xs.split(|x| *x == 10).collect::<Vec<_>>(),
+ splits);
+ let splits: &[&[_]] = &[&[], &[], &[], &[], &[], &[]];
+ assert_eq!(xs.split(|_| true).collect::<Vec<&[i32]>>(),
+ splits);
+
+ let xs: &[i32] = &[];
+ let splits: &[&[i32]] = &[&[]];
+ assert_eq!(xs.split(|x| *x == 5).collect::<Vec<&[i32]>>(), splits);
+}
+
+#[test]
+fn test_splitnator() {
+ let xs = &[1,2,3,4,5];
+
+ let splits: &[&[_]] = &[&[1,2,3,4,5]];
+ assert_eq!(xs.splitn(0, |x| *x % 2 == 0).collect::<Vec<_>>(),
+ splits);
+ let splits: &[&[_]] = &[&[1], &[3,4,5]];
+ assert_eq!(xs.splitn(1, |x| *x % 2 == 0).collect::<Vec<_>>(),
+ splits);
+ let splits: &[&[_]] = &[&[], &[], &[], &[4,5]];
+ assert_eq!(xs.splitn(3, |_| true).collect::<Vec<_>>(),
+ splits);
+
+ let xs: &[i32] = &[];
+ let splits: &[&[i32]] = &[&[]];
+ assert_eq!(xs.splitn(1, |x| *x == 5).collect::<Vec<_>>(), splits);
+}
+
+#[test]
+fn test_splitnator_mut() {
+ let xs = &mut [1,2,3,4,5];
+
+ let splits: &[&mut[_]] = &[&mut [1,2,3,4,5]];
+ assert_eq!(xs.splitn_mut(0, |x| *x % 2 == 0).collect::<Vec<_>>(),
+ splits);
+ let splits: &[&mut[_]] = &[&mut [1], &mut [3,4,5]];
+ assert_eq!(xs.splitn_mut(1, |x| *x % 2 == 0).collect::<Vec<_>>(),
+ splits);
+ let splits: &[&mut[_]] = &[&mut [], &mut [], &mut [], &mut [4,5]];
+ assert_eq!(xs.splitn_mut(3, |_| true).collect::<Vec<_>>(),
+ splits);
+
+ let xs: &mut [i32] = &mut [];
+ let splits: &[&mut[i32]] = &[&mut []];
+ assert_eq!(xs.splitn_mut(1, |x| *x == 5).collect::<Vec<_>>(),
+ splits);
+}
+
+#[test]
+fn test_rsplitator() {
+ let xs = &[1,2,3,4,5];
+
+ let splits: &[&[_]] = &[&[5], &[3], &[1]];
+ assert_eq!(xs.split(|x| *x % 2 == 0).rev().collect::<Vec<_>>(),
+ splits);
+ let splits: &[&[_]] = &[&[2,3,4,5], &[]];
+ assert_eq!(xs.split(|x| *x == 1).rev().collect::<Vec<_>>(),
+ splits);
+ let splits: &[&[_]] = &[&[], &[1,2,3,4]];
+ assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<_>>(),
+ splits);
+ let splits: &[&[_]] = &[&[1,2,3,4,5]];
+ assert_eq!(xs.split(|x| *x == 10).rev().collect::<Vec<_>>(),
+ splits);
+
+ let xs: &[i32] = &[];
+ let splits: &[&[i32]] = &[&[]];
+ assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<&[i32]>>(), splits);
+}
+
+#[test]
+fn test_rsplitnator() {
+ let xs = &[1,2,3,4,5];
+
+ let splits: &[&[_]] = &[&[1,2,3,4,5]];
+ assert_eq!(xs.rsplitn(0, |x| *x % 2 == 0).collect::<Vec<_>>(),
+ splits);
+ let splits: &[&[_]] = &[&[5], &[1,2,3]];
+ assert_eq!(xs.rsplitn(1, |x| *x % 2 == 0).collect::<Vec<_>>(),
+ splits);
+ let splits: &[&[_]] = &[&[], &[], &[], &[1,2]];
+ assert_eq!(xs.rsplitn(3, |_| true).collect::<Vec<_>>(),
+ splits);
+
+ let xs: &[i32] = &[];
+ let splits: &[&[i32]] = &[&[]];
+ assert_eq!(xs.rsplitn(1, |x| *x == 5).collect::<Vec<&[i32]>>(), splits);
+}
+
+#[test]
+fn test_windowsator() {
+ let v = &[1,2,3,4];
+
+ let wins: &[&[_]] = &[&[1,2], &[2,3], &[3,4]];
+ assert_eq!(v.windows(2).collect::<Vec<_>>(), wins);
+
+ let wins: &[&[_]] = &[&[1,2,3], &[2,3,4]];
+ assert_eq!(v.windows(3).collect::<Vec<_>>(), wins);
+ assert!(v.windows(6).next().is_none());
+
+ let wins: &[&[_]] = &[&[3,4], &[2,3], &[1,2]];
+ assert_eq!(v.windows(2).rev().collect::<Vec<&[_]>>(), wins);
+ let mut it = v.windows(2);
+ assert_eq!(it.indexable(), 3);
+ let win: &[_] = &[1,2];
+ assert_eq!(it.idx(0).unwrap(), win);
+ let win: &[_] = &[2,3];
+ assert_eq!(it.idx(1).unwrap(), win);
+ let win: &[_] = &[3,4];
+ assert_eq!(it.idx(2).unwrap(), win);
+ assert_eq!(it.idx(3), None);
+}
+
+#[test]
+#[should_panic]
+fn test_windowsator_0() {
+ let v = &[1,2,3,4];
+ let _it = v.windows(0);
+}
+
+#[test]
+fn test_chunksator() {
+ let v = &[1,2,3,4,5];
+
+ assert_eq!(v.chunks(2).len(), 3);
+
+ let chunks: &[&[_]] = &[&[1,2], &[3,4], &[5]];
+ assert_eq!(v.chunks(2).collect::<Vec<_>>(), chunks);
+ let chunks: &[&[_]] = &[&[1,2,3], &[4,5]];
+ assert_eq!(v.chunks(3).collect::<Vec<_>>(), chunks);
+ let chunks: &[&[_]] = &[&[1,2,3,4,5]];
+ assert_eq!(v.chunks(6).collect::<Vec<_>>(), chunks);
+
+ let chunks: &[&[_]] = &[&[5], &[3,4], &[1,2]];
+ assert_eq!(v.chunks(2).rev().collect::<Vec<_>>(), chunks);
+ let mut it = v.chunks(2);
+ assert_eq!(it.indexable(), 3);
+
+ let chunk: &[_] = &[1,2];
+ assert_eq!(it.idx(0).unwrap(), chunk);
+ let chunk: &[_] = &[3,4];
+ assert_eq!(it.idx(1).unwrap(), chunk);
+ let chunk: &[_] = &[5];
+ assert_eq!(it.idx(2).unwrap(), chunk);
+ assert_eq!(it.idx(3), None);
+}
+
+#[test]
+#[should_panic]
+fn test_chunksator_0() {
+ let v = &[1,2,3,4];
+ let _it = v.chunks(0);
+}
+
+#[test]
+fn test_move_from() {
+ let mut a = [1,2,3,4,5];
+ let b = vec![6,7,8];
+ assert_eq!(a.move_from(b, 0, 3), 3);
+ assert!(a == [6,7,8,4,5]);
+ let mut a = [7,2,8,1];
+ let b = vec![3,1,4,1,5,9];
+ assert_eq!(a.move_from(b, 0, 6), 4);
+ assert!(a == [3,1,4,1]);
+ let mut a = [1,2,3,4];
+ let b = vec![5,6,7,8,9,0];
+ assert_eq!(a.move_from(b, 2, 3), 1);
+ assert!(a == [7,2,3,4]);
+ let mut a = [1,2,3,4,5];
+ let b = vec![5,6,7,8,9,0];
+ assert_eq!(a[2..4].move_from(b,1,6), 2);
+ assert!(a == [1,2,6,7,5]);
+}
+
+#[test]
+fn test_reverse_part() {
+ let mut values = [1,2,3,4,5];
+ values[1..4].reverse();
+ assert!(values == [1,4,3,2,5]);
+}
+
+#[test]
+fn test_show() {
+ macro_rules! test_show_vec {
+ ($x:expr, $x_str:expr) => ({
+ let (x, x_str) = ($x, $x_str);
+ assert_eq!(format!("{:?}", x), x_str);
+ assert_eq!(format!("{:?}", x), x_str);
+ })
+ }
+ let empty = Vec::<i32>::new();
+ test_show_vec!(empty, "[]");
+ test_show_vec!(vec![1], "[1]");
+ test_show_vec!(vec![1, 2, 3], "[1, 2, 3]");
+ test_show_vec!(vec![vec![], vec![1], vec![1, 1]],
+ "[[], [1], [1, 1]]");
+
+ let empty_mut: &mut [i32] = &mut[];
+ test_show_vec!(empty_mut, "[]");
+ let v = &mut[1];
+ test_show_vec!(v, "[1]");
+ let v = &mut[1, 2, 3];
+ test_show_vec!(v, "[1, 2, 3]");
+ let v: &mut[&mut[_]] = &mut[&mut[], &mut[1], &mut[1, 1]];
+ test_show_vec!(v, "[[], [1], [1, 1]]");
+}
+
+#[test]
+fn test_vec_default() {
+ macro_rules! t {
+ ($ty:ty) => {{
+ let v: $ty = Default::default();
+ assert!(v.is_empty());
+ }}
+ }
+
+ t!(&[i32]);
+ t!(Vec<i32>);
+}
+
+#[test]
+fn test_bytes_set_memory() {
+ use std::slice::bytes::MutableByteVector;
+
+ let mut values = [1,2,3,4,5];
+ values[0..5].set_memory(0xAB);
+ assert!(values == [0xAB, 0xAB, 0xAB, 0xAB, 0xAB]);
+ values[2..4].set_memory(0xFF);
+ assert!(values == [0xAB, 0xAB, 0xFF, 0xFF, 0xAB]);
+}
+
+#[test]
+#[should_panic]
+fn test_overflow_does_not_cause_segfault() {
+ let mut v = vec![];
+ v.reserve_exact(-1);
+ v.push(1);
+ v.push(2);
+}
+
+#[test]
+#[should_panic]
+fn test_overflow_does_not_cause_segfault_managed() {
+ let mut v = vec![Rc::new(1)];
+ v.reserve_exact(-1);
+ v.push(Rc::new(2));
+}
+
+#[test]
+fn test_mut_split_at() {
+ let mut values = [1u8,2,3,4,5];
+ {
+ let (left, right) = values.split_at_mut(2);
+ {
+ let left: &[_] = left;
+ assert!(left[..left.len()] == [1, 2]);
+ }
+ for p in left {
+ *p += 1;
+ }
+
+ {
+ let right: &[_] = right;
+ assert!(right[..right.len()] == [3, 4, 5]);
+ }
+ for p in right {
+ *p += 2;
+ }
+ }
+
+ assert!(values == [2, 3, 5, 6, 7]);
+}
+
+#[derive(Clone, PartialEq)]
+struct Foo;
+
+#[test]
+fn test_iter_zero_sized() {
+ let mut v = vec![Foo, Foo, Foo];
+ assert_eq!(v.len(), 3);
+ let mut cnt = 0;
+
+ for f in &v {
+ assert!(*f == Foo);
+ cnt += 1;
+ }
+ assert_eq!(cnt, 3);
+
+ for f in &v[1..3] {
+ assert!(*f == Foo);
+ cnt += 1;
+ }
+ assert_eq!(cnt, 5);
+
+ for f in &mut v {
+ assert!(*f == Foo);
+ cnt += 1;
+ }
+ assert_eq!(cnt, 8);
+
+ for f in v {
+ assert!(f == Foo);
+ cnt += 1;
+ }
+ assert_eq!(cnt, 11);
+
+ let xs: [Foo; 3] = [Foo, Foo, Foo];
+ cnt = 0;
+ for f in &xs {
+ assert!(*f == Foo);
+ cnt += 1;
+ }
+ assert!(cnt == 3);
+}
+
+#[test]
+fn test_shrink_to_fit() {
+ let mut xs = vec![0, 1, 2, 3];
+ for i in 4..100 {
+ xs.push(i)
+ }
+ assert_eq!(xs.capacity(), 128);
+ xs.shrink_to_fit();
+ assert_eq!(xs.capacity(), 100);
+ assert_eq!(xs, (0..100).collect::<Vec<_>>());
+}
+
+#[test]
+fn test_starts_with() {
+ assert!(b"foobar".starts_with(b"foo"));
+ assert!(!b"foobar".starts_with(b"oob"));
+ assert!(!b"foobar".starts_with(b"bar"));
+ assert!(!b"foo".starts_with(b"foobar"));
+ assert!(!b"bar".starts_with(b"foobar"));
+ assert!(b"foobar".starts_with(b"foobar"));
+ let empty: &[u8] = &[];
+ assert!(empty.starts_with(empty));
+ assert!(!empty.starts_with(b"foo"));
+ assert!(b"foobar".starts_with(empty));
+}
+
+#[test]
+fn test_ends_with() {
+ assert!(b"foobar".ends_with(b"bar"));
+ assert!(!b"foobar".ends_with(b"oba"));
+ assert!(!b"foobar".ends_with(b"foo"));
+ assert!(!b"foo".ends_with(b"foobar"));
+ assert!(!b"bar".ends_with(b"foobar"));
+ assert!(b"foobar".ends_with(b"foobar"));
+ let empty: &[u8] = &[];
+ assert!(empty.ends_with(empty));
+ assert!(!empty.ends_with(b"foo"));
+ assert!(b"foobar".ends_with(empty));
+}
+
+#[test]
+fn test_mut_splitator() {
+ let mut xs = [0,1,0,2,3,0,0,4,5,0];
+ assert_eq!(xs.split_mut(|x| *x == 0).count(), 6);
+ for slice in xs.split_mut(|x| *x == 0) {
+ slice.reverse();
+ }
+ assert!(xs == [0,1,0,3,2,0,0,5,4,0]);
+
+ let mut xs = [0,1,0,2,3,0,0,4,5,0,6,7];
+ for slice in xs.split_mut(|x| *x == 0).take(5) {
+ slice.reverse();
+ }
+ assert!(xs == [0,1,0,3,2,0,0,5,4,0,6,7]);
+}
+
+#[test]
+fn test_mut_splitator_rev() {
+ let mut xs = [1,2,0,3,4,0,0,5,6,0];
+ for slice in xs.split_mut(|x| *x == 0).rev().take(4) {
+ slice.reverse();
+ }
+ assert!(xs == [1,2,0,4,3,0,0,6,5,0]);
+}
+
+#[test]
+fn test_get_mut() {
+ let mut v = [0,1,2];
+ assert_eq!(v.get_mut(3), None);
+ v.get_mut(1).map(|e| *e = 7);
+ assert_eq!(v[1], 7);
+ let mut x = 2;
+ assert_eq!(v.get_mut(2), Some(&mut x));
+}
+
+#[test]
+fn test_mut_chunks() {
+ let mut v = [0, 1, 2, 3, 4, 5, 6];
+ assert_eq!(v.chunks_mut(2).len(), 4);
+ for (i, chunk) in v.chunks_mut(3).enumerate() {
+ for x in chunk {
+ *x = i as u8;
+ }
+ }
+ let result = [0, 0, 0, 1, 1, 1, 2];
+ assert!(v == result);
+}
+
+#[test]
+fn test_mut_chunks_rev() {
+ let mut v = [0, 1, 2, 3, 4, 5, 6];
+ for (i, chunk) in v.chunks_mut(3).rev().enumerate() {
+ for x in chunk {
+ *x = i as u8;
+ }
+ }
+ let result = [2, 2, 2, 1, 1, 1, 0];
+ assert!(v == result);
+}
+
+#[test]
+#[should_panic]
+fn test_mut_chunks_0() {
+ let mut v = [1, 2, 3, 4];
+ let _it = v.chunks_mut(0);
+}
+
+#[test]
+fn test_mut_last() {
+ let mut x = [1, 2, 3, 4, 5];
+ let h = x.last_mut();
+ assert_eq!(*h.unwrap(), 5);
+
+ let y: &mut [i32] = &mut [];
+ assert!(y.last_mut().is_none());
+}
+
+#[test]
+fn test_to_vec() {
+ let xs: Box<_> = box [1, 2, 3];
+ let ys = xs.to_vec();
+ assert_eq!(ys, [1, 2, 3]);
+}
+
+mod bench {
+ use std::iter::repeat;
+ use std::{mem, ptr};
+ use std::rand::{Rng, weak_rng};
+
+ use test::{Bencher, black_box};
+
+ #[bench]
+ fn iterator(b: &mut Bencher) {
+ // peculiar numbers to stop LLVM from optimising the summation
+ // out.
+ let v: Vec<_> = (0..100).map(|i| i ^ (i << 1) ^ (i >> 1)).collect();
+
+ b.iter(|| {
+ let mut sum = 0;
+ for x in &v {
+ sum += *x;
+ }
+ // sum == 11806, to stop dead code elimination.
+ if sum == 0 {panic!()}
+ })
+ }
+
+ #[bench]
+ fn mut_iterator(b: &mut Bencher) {
+ let mut v: Vec<_> = repeat(0).take(100).collect();
+
+ b.iter(|| {
+ let mut i = 0;
+ for x in &mut v {
+ *x = i;
+ i += 1;
+ }
+ })
+ }
+
+ #[bench]
+ fn concat(b: &mut Bencher) {
+ let xss: Vec<Vec<i32>> =
+ (0..100).map(|i| (0..i).collect()).collect();
+ b.iter(|| {
+ xss.concat();
+ });
+ }
+
+ #[bench]
+ fn connect(b: &mut Bencher) {
+ let xss: Vec<Vec<i32>> =
+ (0..100).map(|i| (0..i).collect()).collect();
+ b.iter(|| {
+ xss.connect(&0)
+ });
+ }
+
+ #[bench]
+ fn push(b: &mut Bencher) {
+ let mut vec = Vec::<i32>::new();
+ b.iter(|| {
+ vec.push(0);
+ black_box(&vec);
+ });
+ }
+
+ #[bench]
+ fn starts_with_same_vector(b: &mut Bencher) {
+ let vec: Vec<_> = (0..100).collect();
+ b.iter(|| {
+ vec.starts_with(&vec)
+ })
+ }
+
+ #[bench]
+ fn starts_with_single_element(b: &mut Bencher) {
+ let vec: Vec<_> = vec![0];
+ b.iter(|| {
+ vec.starts_with(&vec)
+ })
+ }
+
+ #[bench]
+ fn starts_with_diff_one_element_at_end(b: &mut Bencher) {
+ let vec: Vec<_> = (0..100).collect();
+ let mut match_vec: Vec<_> = (0..99).collect();
+ match_vec.push(0);
+ b.iter(|| {
+ vec.starts_with(&match_vec)
+ })
+ }
+
+ #[bench]
+ fn ends_with_same_vector(b: &mut Bencher) {
+ let vec: Vec<_> = (0..100).collect();
+ b.iter(|| {
+ vec.ends_with(&vec)
+ })
+ }
+
+ #[bench]
+ fn ends_with_single_element(b: &mut Bencher) {
+ let vec: Vec<_> = vec![0];
+ b.iter(|| {
+ vec.ends_with(&vec)
+ })
+ }
+
+ #[bench]
+ fn ends_with_diff_one_element_at_beginning(b: &mut Bencher) {
+ let vec: Vec<_> = (0..100).collect();
+ let mut match_vec: Vec<_> = (0..100).collect();
+ match_vec[0] = 200;
+ b.iter(|| {
+ vec.starts_with(&match_vec)
+ })
+ }
+
+ #[bench]
+ fn contains_last_element(b: &mut Bencher) {
+ let vec: Vec<_> = (0..100).collect();
+ b.iter(|| {
+ vec.contains(&99)
+ })
+ }
+
+ #[bench]
+ fn zero_1kb_from_elem(b: &mut Bencher) {
+ b.iter(|| {
+ repeat(0u8).take(1024).collect::<Vec<_>>()
+ });
+ }
+
+ #[bench]
+ fn zero_1kb_set_memory(b: &mut Bencher) {
+ b.iter(|| {
+ let mut v = Vec::<u8>::with_capacity(1024);
+ unsafe {
+ let vp = v.as_mut_ptr();
+ ptr::set_memory(vp, 0, 1024);
+ v.set_len(1024);
+ }
+ v
+ });
+ }
+
+ #[bench]
+ fn zero_1kb_loop_set(b: &mut Bencher) {
+ b.iter(|| {
+ let mut v = Vec::<u8>::with_capacity(1024);
+ unsafe {
+ v.set_len(1024);
+ }
+ for i in 0..1024 {
+ v[i] = 0;
+ }
+ });
+ }
+
+ #[bench]
+ fn zero_1kb_mut_iter(b: &mut Bencher) {
+ b.iter(|| {
+ let mut v = Vec::<u8>::with_capacity(1024);
+ unsafe {
+ v.set_len(1024);
+ }
+ for x in &mut v {
+ *x = 0;
+ }
+ v
+ });
+ }
+
+ #[bench]
+ fn random_inserts(b: &mut Bencher) {
+ let mut rng = weak_rng();
+ b.iter(|| {
+ let mut v: Vec<_> = repeat((0, 0)).take(30).collect();
+ for _ in 0..100 {
+ let l = v.len();
+ v.insert(rng.gen::<usize>() % (l + 1),
+ (1, 1));
+ }
+ })
+ }
+ #[bench]
+ fn random_removes(b: &mut Bencher) {
+ let mut rng = weak_rng();
+ b.iter(|| {
+ let mut v: Vec<_> = repeat((0, 0)).take(130).collect();
+ for _ in 0..100 {
+ let l = v.len();
+ v.remove(rng.gen::<usize>() % l);
+ }
+ })
+ }
+
+ #[bench]
+ fn sort_random_small(b: &mut Bencher) {
+ let mut rng = weak_rng();
+ b.iter(|| {
+ let mut v: Vec<_> = rng.gen_iter::<u64>().take(5).collect();
+ v.sort();
+ });
+ b.bytes = 5 * mem::size_of::<u64>() as u64;
+ }
+
+ #[bench]
+ fn sort_random_medium(b: &mut Bencher) {
+ let mut rng = weak_rng();
+ b.iter(|| {
+ let mut v: Vec<_> = rng.gen_iter::<u64>().take(100).collect();
+ v.sort();
+ });
+ b.bytes = 100 * mem::size_of::<u64>() as u64;
+ }
+
+ #[bench]
+ fn sort_random_large(b: &mut Bencher) {
+ let mut rng = weak_rng();
+ b.iter(|| {
+ let mut v: Vec<_> = rng.gen_iter::<u64>().take(10000).collect();
+ v.sort();
+ });
+ b.bytes = 10000 * mem::size_of::<u64>() as u64;
+ }
+
+ #[bench]
+ fn sort_sorted(b: &mut Bencher) {
+ let mut v: Vec<_> = (0..10000).collect();
+ b.iter(|| {
+ v.sort();
+ });
+ b.bytes = (v.len() * mem::size_of_val(&v[0])) as u64;
+ }
+
+ type BigSortable = (u64, u64, u64, u64);
+
+ #[bench]
+ fn sort_big_random_small(b: &mut Bencher) {
+ let mut rng = weak_rng();
+ b.iter(|| {
+ let mut v = rng.gen_iter::<BigSortable>().take(5)
+ .collect::<Vec<BigSortable>>();
+ v.sort();
+ });
+ b.bytes = 5 * mem::size_of::<BigSortable>() as u64;
+ }
+
+ #[bench]
+ fn sort_big_random_medium(b: &mut Bencher) {
+ let mut rng = weak_rng();
+ b.iter(|| {
+ let mut v = rng.gen_iter::<BigSortable>().take(100)
+ .collect::<Vec<BigSortable>>();
+ v.sort();
+ });
+ b.bytes = 100 * mem::size_of::<BigSortable>() as u64;
+ }
+
+ #[bench]
+ fn sort_big_random_large(b: &mut Bencher) {
+ let mut rng = weak_rng();
+ b.iter(|| {
+ let mut v = rng.gen_iter::<BigSortable>().take(10000)
+ .collect::<Vec<BigSortable>>();
+ v.sort();
+ });
+ b.bytes = 10000 * mem::size_of::<BigSortable>() as u64;
+ }
+
+ #[bench]
+ fn sort_big_sorted(b: &mut Bencher) {
+ let mut v: Vec<BigSortable> = (0..10000).map(|i| (i, i, i, i)).collect();
+ b.iter(|| {
+ v.sort();
+ });
+ b.bytes = (v.len() * mem::size_of_val(&v[0])) as u64;
+ }
+}
--- /dev/null
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::cmp::Ordering::{Equal, Greater, Less};
+use std::iter::AdditiveIterator;
+use std::str::{Utf8Error, from_utf8};
+
+#[test]
+fn test_le() {
+ assert!("" <= "");
+ assert!("" <= "foo");
+ assert!("foo" <= "foo");
+ assert!("foo" != "bar");
+}
+
+#[test]
+fn test_len() {
+ assert_eq!("".len(), 0);
+ assert_eq!("hello world".len(), 11);
+ assert_eq!("\x63".len(), 1);
+ assert_eq!("\u{a2}".len(), 2);
+ assert_eq!("\u{3c0}".len(), 2);
+ assert_eq!("\u{2620}".len(), 3);
+ assert_eq!("\u{1d11e}".len(), 4);
+
+ assert_eq!("".chars().count(), 0);
+ assert_eq!("hello world".chars().count(), 11);
+ assert_eq!("\x63".chars().count(), 1);
+ assert_eq!("\u{a2}".chars().count(), 1);
+ assert_eq!("\u{3c0}".chars().count(), 1);
+ assert_eq!("\u{2620}".chars().count(), 1);
+ assert_eq!("\u{1d11e}".chars().count(), 1);
+ assert_eq!("ประเทศไทย中华Việt Nam".chars().count(), 19);
+
+ assert_eq!("ｈｅｌｌｏ".width(false), 10);
+ assert_eq!("ｈｅｌｌｏ".width(true), 10);
+ assert_eq!("\0\0\0\0\0".width(false), 0);
+ assert_eq!("\0\0\0\0\0".width(true), 0);
+ assert_eq!("".width(false), 0);
+ assert_eq!("".width(true), 0);
+ assert_eq!("\u{2081}\u{2082}\u{2083}\u{2084}".width(false), 4);
+ assert_eq!("\u{2081}\u{2082}\u{2083}\u{2084}".width(true), 8);
+}
+
+#[test]
+fn test_find() {
+ assert_eq!("hello".find('l'), Some(2));
+ assert_eq!("hello".find(|c:char| c == 'o'), Some(4));
+ assert!("hello".find('x').is_none());
+ assert!("hello".find(|c:char| c == 'x').is_none());
+ assert_eq!("ประเทศไทย中华Việt Nam".find('华'), Some(30));
+ assert_eq!("ประเทศไทย中华Việt Nam".find(|c: char| c == '华'), Some(30));
+}
+
+#[test]
+fn test_rfind() {
+ assert_eq!("hello".rfind('l'), Some(3));
+ assert_eq!("hello".rfind(|c:char| c == 'o'), Some(4));
+ assert!("hello".rfind('x').is_none());
+ assert!("hello".rfind(|c:char| c == 'x').is_none());
+ assert_eq!("ประเทศไทย中华Việt Nam".rfind('华'), Some(30));
+ assert_eq!("ประเทศไทย中华Việt Nam".rfind(|c: char| c == '华'), Some(30));
+}
+
+#[test]
+fn test_collect() {
+ let empty = String::from_str("");
+ let s: String = empty.chars().collect();
+ assert_eq!(empty, s);
+ let data = String::from_str("ประเทศไทย中");
+ let s: String = data.chars().collect();
+ assert_eq!(data, s);
+}
+
+#[test]
+fn test_into_bytes() {
+ let data = String::from_str("asdf");
+ let buf = data.into_bytes();
+ assert_eq!(b"asdf", buf);
+}
+
+#[test]
+fn test_find_str() {
+ // byte positions
+ assert_eq!("".find_str(""), Some(0));
+ assert!("banana".find_str("apple pie").is_none());
+
+ let data = "abcabc";
+ assert_eq!(data[0..6].find_str("ab"), Some(0));
+ assert_eq!(data[2..6].find_str("ab"), Some(3 - 2));
+ assert!(data[2..4].find_str("ab").is_none());
+
+ let string = "ประเทศไทย中华Việt Nam";
+ let mut data = String::from_str(string);
+ data.push_str(string);
+ assert!(data.find_str("ไท华").is_none());
+ assert_eq!(data[0..43].find_str(""), Some(0));
+ assert_eq!(data[6..43].find_str(""), Some(6 - 6));
+
+ assert_eq!(data[0..43].find_str("ประ"), Some( 0));
+ assert_eq!(data[0..43].find_str("ทศไ"), Some(12));
+ assert_eq!(data[0..43].find_str("ย中"), Some(24));
+ assert_eq!(data[0..43].find_str("iệt"), Some(34));
+ assert_eq!(data[0..43].find_str("Nam"), Some(40));
+
+ assert_eq!(data[43..86].find_str("ประ"), Some(43 - 43));
+ assert_eq!(data[43..86].find_str("ทศไ"), Some(55 - 43));
+ assert_eq!(data[43..86].find_str("ย中"), Some(67 - 43));
+ assert_eq!(data[43..86].find_str("iệt"), Some(77 - 43));
+ assert_eq!(data[43..86].find_str("Nam"), Some(83 - 43));
+}
+
+#[test]
+fn test_slice_chars() {
+ fn t(a: &str, b: &str, start: usize) {
+ assert_eq!(a.slice_chars(start, start + b.chars().count()), b);
+ }
+ t("", "", 0);
+ t("hello", "llo", 2);
+ t("hello", "el", 1);
+ t("αβλ", "β", 1);
+ t("αβλ", "", 3);
+ assert_eq!("ะเทศไท", "ประเทศไทย中华Việt Nam".slice_chars(2, 8));
+}
+
+fn s(x: &str) -> String { x.to_string() }
+
+macro_rules! test_concat {
+ ($expected: expr, $string: expr) => {
+ {
+ let s: String = $string.concat();
+ assert_eq!($expected, s);
+ }
+ }
+}
+
+#[test]
+fn test_concat_for_different_types() {
+ test_concat!("ab", vec![s("a"), s("b")]);
+ test_concat!("ab", vec!["a", "b"]);
+ test_concat!("ab", vec!["a", "b"]);
+ test_concat!("ab", vec![s("a"), s("b")]);
+}
+
+#[test]
+fn test_concat_for_different_lengths() {
+ let empty: &[&str] = &[];
+ test_concat!("", empty);
+ test_concat!("a", ["a"]);
+ test_concat!("ab", ["a", "b"]);
+ test_concat!("abc", ["", "a", "bc"]);
+}
+
+macro_rules! test_connect {
+ ($expected: expr, $string: expr, $delim: expr) => {
+ {
+ let s = $string.connect($delim);
+ assert_eq!($expected, s);
+ }
+ }
+}
+
+#[test]
+fn test_connect_for_different_types() {
+ test_connect!("a-b", ["a", "b"], "-");
+ let hyphen = "-".to_string();
+ test_connect!("a-b", [s("a"), s("b")], &*hyphen);
+ test_connect!("a-b", vec!["a", "b"], &*hyphen);
+ test_connect!("a-b", &*vec!["a", "b"], "-");
+ test_connect!("a-b", vec![s("a"), s("b")], "-");
+}
+
+#[test]
+fn test_connect_for_different_lengths() {
+ let empty: &[&str] = &[];
+ test_connect!("", empty, "-");
+ test_connect!("a", ["a"], "-");
+ test_connect!("a-b", ["a", "b"], "-");
+ test_connect!("-a-bc", ["", "a", "bc"], "-");
+}
+
+#[test]
+fn test_unsafe_slice() {
+ assert_eq!("ab", unsafe {"abc".slice_unchecked(0, 2)});
+ assert_eq!("bc", unsafe {"abc".slice_unchecked(1, 3)});
+ assert_eq!("", unsafe {"abc".slice_unchecked(1, 1)});
+ fn a_million_letter_a() -> String {
+ let mut i = 0;
+ let mut rs = String::new();
+ while i < 100000 {
+ rs.push_str("aaaaaaaaaa");
+ i += 1;
+ }
+ rs
+ }
+ fn half_a_million_letter_a() -> String {
+ let mut i = 0;
+ let mut rs = String::new();
+ while i < 100000 {
+ rs.push_str("aaaaa");
+ i += 1;
+ }
+ rs
+ }
+ let letters = a_million_letter_a();
+ assert!(half_a_million_letter_a() ==
+ unsafe {String::from_str(letters.slice_unchecked(
+ 0,
+ 500000))});
+}
+
+#[test]
+fn test_starts_with() {
+ assert!(("".starts_with("")));
+ assert!(("abc".starts_with("")));
+ assert!(("abc".starts_with("a")));
+ assert!((!"a".starts_with("abc")));
+ assert!((!"".starts_with("abc")));
+ assert!((!"ödd".starts_with("-")));
+ assert!(("ödd".starts_with("öd")));
+}
+
+#[test]
+fn test_ends_with() {
+ assert!(("".ends_with("")));
+ assert!(("abc".ends_with("")));
+ assert!(("abc".ends_with("c")));
+ assert!((!"a".ends_with("abc")));
+ assert!((!"".ends_with("abc")));
+ assert!((!"ddö".ends_with("-")));
+ assert!(("ddö".ends_with("dö")));
+}
+
+#[test]
+fn test_is_empty() {
+ assert!("".is_empty());
+ assert!(!"a".is_empty());
+}
+
+#[test]
+fn test_replace() {
+ let a = "a";
+ assert_eq!("".replace(a, "b"), String::from_str(""));
+ assert_eq!("a".replace(a, "b"), String::from_str("b"));
+ assert_eq!("ab".replace(a, "b"), String::from_str("bb"));
+ let test = "test";
+ assert!(" test test ".replace(test, "toast") ==
+ String::from_str(" toast toast "));
+ assert_eq!(" test test ".replace(test, ""), String::from_str(" "));
+}
+
+#[test]
+fn test_replace_2a() {
+ let data = "ประเทศไทย中华";
+ let repl = "دولة الكويت";
+
+ let a = "ประเ";
+ let a2 = "دولة الكويتทศไทย中华";
+ assert_eq!(data.replace(a, repl), a2);
+}
+
+#[test]
+fn test_replace_2b() {
+ let data = "ประเทศไทย中华";
+ let repl = "دولة الكويت";
+
+ let b = "ะเ";
+ let b2 = "ปรدولة الكويتทศไทย中华";
+ assert_eq!(data.replace(b, repl), b2);
+}
+
+#[test]
+fn test_replace_2c() {
+ let data = "ประเทศไทย中华";
+ let repl = "دولة الكويت";
+
+ let c = "中华";
+ let c2 = "ประเทศไทยدولة الكويت";
+ assert_eq!(data.replace(c, repl), c2);
+}
+
+#[test]
+fn test_replace_2d() {
+ let data = "ประเทศไทย中华";
+ let repl = "دولة الكويت";
+
+ let d = "ไท华";
+ assert_eq!(data.replace(d, repl), data);
+}
+
+#[test]
+fn test_slice() {
+ assert_eq!("ab", "abc".slice(0, 2));
+ assert_eq!("bc", "abc".slice(1, 3));
+ assert_eq!("", "abc".slice(1, 1));
+ assert_eq!("\u{65e5}", "\u{65e5}\u{672c}".slice(0, 3));
+
+ let data = "ประเทศไทย中华";
+ assert_eq!("ป", data.slice(0, 3));
+ assert_eq!("ร", data.slice(3, 6));
+ assert_eq!("", data.slice(3, 3));
+ assert_eq!("华", data.slice(30, 33));
+
+ fn a_million_letter_x() -> String {
+ let mut i = 0;
+ let mut rs = String::new();
+ while i < 100000 {
+ rs.push_str("华华华华华华华华华华");
+ i += 1;
+ }
+ rs
+ }
+ fn half_a_million_letter_x() -> String {
+ let mut i = 0;
+ let mut rs = String::new();
+ while i < 100000 {
+ rs.push_str("华华华华华");
+ i += 1;
+ }
+ rs
+ }
+ let letters = a_million_letter_x();
+ assert!(half_a_million_letter_x() ==
+ String::from_str(letters.slice(0, 3 * 500000)));
+}
+
+#[test]
+fn test_slice_2() {
+ let ss = "中华Việt Nam";
+
+ assert_eq!("华", ss.slice(3, 6));
+ assert_eq!("Việt Nam", ss.slice(6, 16));
+
+ assert_eq!("ab", "abc".slice(0, 2));
+ assert_eq!("bc", "abc".slice(1, 3));
+ assert_eq!("", "abc".slice(1, 1));
+
+ assert_eq!("中", ss.slice(0, 3));
+ assert_eq!("华V", ss.slice(3, 7));
+ assert_eq!("", ss.slice(3, 3));
+ /*0: 中
+ 3: 华
+ 6: V
+ 7: i
+ 8: ệ
+ 11: t
+ 12:
+ 13: N
+ 14: a
+ 15: m */
+}
+
+#[test]
+#[should_panic]
+fn test_slice_fail() {
+ "中华Việt Nam".slice(0, 2);
+}
+
+#[test]
+fn test_slice_from() {
+ assert_eq!("abcd".slice_from(0), "abcd");
+ assert_eq!("abcd".slice_from(2), "cd");
+ assert_eq!("abcd".slice_from(4), "");
+}
+#[test]
+fn test_slice_to() {
+ assert_eq!("abcd".slice_to(0), "");
+ assert_eq!("abcd".slice_to(2), "ab");
+ assert_eq!("abcd".slice_to(4), "abcd");
+}
+
+#[test]
+fn test_trim_left_matches() {
+ let v: &[char] = &[];
+ assert_eq!(" *** foo *** ".trim_left_matches(v), " *** foo *** ");
+ let chars: &[char] = &['*', ' '];
+ assert_eq!(" *** foo *** ".trim_left_matches(chars), "foo *** ");
+ assert_eq!(" *** *** ".trim_left_matches(chars), "");
+ assert_eq!("foo *** ".trim_left_matches(chars), "foo *** ");
+
+ assert_eq!("11foo1bar11".trim_left_matches('1'), "foo1bar11");
+ let chars: &[char] = &['1', '2'];
+ assert_eq!("12foo1bar12".trim_left_matches(chars), "foo1bar12");
+ assert_eq!("123foo1bar123".trim_left_matches(|c: char| c.is_numeric()), "foo1bar123");
+}
+
+#[test]
+fn test_trim_right_matches() {
+ let v: &[char] = &[];
+ assert_eq!(" *** foo *** ".trim_right_matches(v), " *** foo *** ");
+ let chars: &[char] = &['*', ' '];
+ assert_eq!(" *** foo *** ".trim_right_matches(chars), " *** foo");
+ assert_eq!(" *** *** ".trim_right_matches(chars), "");
+ assert_eq!(" *** foo".trim_right_matches(chars), " *** foo");
+
+ assert_eq!("11foo1bar11".trim_right_matches('1'), "11foo1bar");
+ let chars: &[char] = &['1', '2'];
+ assert_eq!("12foo1bar12".trim_right_matches(chars), "12foo1bar");
+ assert_eq!("123foo1bar123".trim_right_matches(|c: char| c.is_numeric()), "123foo1bar");
+}
+
+#[test]
+fn test_trim_matches() {
+ let v: &[char] = &[];
+ assert_eq!(" *** foo *** ".trim_matches(v), " *** foo *** ");
+ let chars: &[char] = &['*', ' '];
+ assert_eq!(" *** foo *** ".trim_matches(chars), "foo");
+ assert_eq!(" *** *** ".trim_matches(chars), "");
+ assert_eq!("foo".trim_matches(chars), "foo");
+
+ assert_eq!("11foo1bar11".trim_matches('1'), "foo1bar");
+ let chars: &[char] = &['1', '2'];
+ assert_eq!("12foo1bar12".trim_matches(chars), "foo1bar");
+ assert_eq!("123foo1bar123".trim_matches(|c: char| c.is_numeric()), "foo1bar");
+}
+
+#[test]
+fn test_trim_left() {
+ assert_eq!("".trim_left(), "");
+ assert_eq!("a".trim_left(), "a");
+ assert_eq!(" ".trim_left(), "");
+ assert_eq!(" blah".trim_left(), "blah");
+ assert_eq!(" \u{3000} wut".trim_left(), "wut");
+ assert_eq!("hey ".trim_left(), "hey ");
+}
+
+#[test]
+fn test_trim_right() {
+ assert_eq!("".trim_right(), "");
+ assert_eq!("a".trim_right(), "a");
+ assert_eq!(" ".trim_right(), "");
+ assert_eq!("blah ".trim_right(), "blah");
+ assert_eq!("wut \u{3000} ".trim_right(), "wut");
+ assert_eq!(" hey".trim_right(), " hey");
+}
+
+#[test]
+fn test_trim() {
+ assert_eq!("".trim(), "");
+ assert_eq!("a".trim(), "a");
+ assert_eq!(" ".trim(), "");
+ assert_eq!(" blah ".trim(), "blah");
+ assert_eq!("\nwut \u{3000} ".trim(), "wut");
+ assert_eq!(" hey dude ".trim(), "hey dude");
+}
+
+#[test]
+fn test_is_whitespace() {
+ assert!("".chars().all(|c| c.is_whitespace()));
+ assert!(" ".chars().all(|c| c.is_whitespace()));
+ assert!("\u{2009}".chars().all(|c| c.is_whitespace())); // Thin space
+ assert!(" \n\t ".chars().all(|c| c.is_whitespace()));
+ assert!(!" _ ".chars().all(|c| c.is_whitespace()));
+}
+
+#[test]
+fn test_slice_shift_char() {
+ let data = "ประเทศไทย中";
+ assert_eq!(data.slice_shift_char(), Some(('ป', "ระเทศไทย中")));
+}
+
+#[test]
+fn test_slice_shift_char_2() {
+ let empty = "";
+ assert_eq!(empty.slice_shift_char(), None);
+}
+
+#[test]
+fn test_is_utf8() {
+ // deny overlong encodings
+ assert!(from_utf8(&[0xc0, 0x80]).is_err());
+ assert!(from_utf8(&[0xc0, 0xae]).is_err());
+ assert!(from_utf8(&[0xe0, 0x80, 0x80]).is_err());
+ assert!(from_utf8(&[0xe0, 0x80, 0xaf]).is_err());
+ assert!(from_utf8(&[0xe0, 0x81, 0x81]).is_err());
+ assert!(from_utf8(&[0xf0, 0x82, 0x82, 0xac]).is_err());
+ assert!(from_utf8(&[0xf4, 0x90, 0x80, 0x80]).is_err());
+
+ // deny surrogates
+ assert!(from_utf8(&[0xED, 0xA0, 0x80]).is_err());
+ assert!(from_utf8(&[0xED, 0xBF, 0xBF]).is_err());
+
+ assert!(from_utf8(&[0xC2, 0x80]).is_ok());
+ assert!(from_utf8(&[0xDF, 0xBF]).is_ok());
+ assert!(from_utf8(&[0xE0, 0xA0, 0x80]).is_ok());
+ assert!(from_utf8(&[0xED, 0x9F, 0xBF]).is_ok());
+ assert!(from_utf8(&[0xEE, 0x80, 0x80]).is_ok());
+ assert!(from_utf8(&[0xEF, 0xBF, 0xBF]).is_ok());
+ assert!(from_utf8(&[0xF0, 0x90, 0x80, 0x80]).is_ok());
+ assert!(from_utf8(&[0xF4, 0x8F, 0xBF, 0xBF]).is_ok());
+}
+
+#[test]
+fn test_is_utf16() {
+ use unicode::str::is_utf16;
+
+ macro_rules! pos {
+ ($($e:expr),*) => { { $(assert!(is_utf16($e));)* } }
+ }
+
+ // non-surrogates
+ pos!(&[0x0000],
+ &[0x0001, 0x0002],
+ &[0xD7FF],
+ &[0xE000]);
+
+ // surrogate pairs (randomly generated with Python 3's
+ // .encode('utf-16be'))
+ pos!(&[0xdb54, 0xdf16, 0xd880, 0xdee0, 0xdb6a, 0xdd45],
+ &[0xd91f, 0xdeb1, 0xdb31, 0xdd84, 0xd8e2, 0xde14],
+ &[0xdb9f, 0xdc26, 0xdb6f, 0xde58, 0xd850, 0xdfae]);
+
+ // mixtures (also random)
+ pos!(&[0xd921, 0xdcc2, 0x002d, 0x004d, 0xdb32, 0xdf65],
+ &[0xdb45, 0xdd2d, 0x006a, 0xdacd, 0xddfe, 0x0006],
+ &[0x0067, 0xd8ff, 0xddb7, 0x000f, 0xd900, 0xdc80]);
+
+ // negative tests
+ macro_rules! neg {
+ ($($e:expr),*) => { { $(assert!(!is_utf16($e));)* } }
+ }
+
+ neg!(
+ // surrogate + regular unit
+ &[0xdb45, 0x0000],
+ // surrogate + lead surrogate
+ &[0xd900, 0xd900],
+ // unterminated surrogate
+ &[0xd8ff],
+ // trail surrogate without a lead
+ &[0xddb7]);
+
+ // random byte sequences that Python 3's .decode('utf-16be')
+ // failed on
+ neg!(&[0x5b3d, 0x0141, 0xde9e, 0x8fdc, 0xc6e7],
+ &[0xdf5a, 0x82a5, 0x62b9, 0xb447, 0x92f3],
+ &[0xda4e, 0x42bc, 0x4462, 0xee98, 0xc2ca],
+ &[0xbe00, 0xb04a, 0x6ecb, 0xdd89, 0xe278],
+ &[0x0465, 0xab56, 0xdbb6, 0xa893, 0x665e],
+ &[0x6b7f, 0x0a19, 0x40f4, 0xa657, 0xdcc5],
+ &[0x9b50, 0xda5e, 0x24ec, 0x03ad, 0x6dee],
+ &[0x8d17, 0xcaa7, 0xf4ae, 0xdf6e, 0xbed7],
+ &[0xdaee, 0x2584, 0x7d30, 0xa626, 0x121a],
+ &[0xd956, 0x4b43, 0x7570, 0xccd6, 0x4f4a],
+ &[0x9dcf, 0x1b49, 0x4ba5, 0xfce9, 0xdffe],
+ &[0x6572, 0xce53, 0xb05a, 0xf6af, 0xdacf],
+ &[0x1b90, 0x728c, 0x9906, 0xdb68, 0xf46e],
+ &[0x1606, 0xbeca, 0xbe76, 0x860f, 0xdfa5],
+ &[0x8b4f, 0xde7a, 0xd220, 0x9fac, 0x2b6f],
+ &[0xb8fe, 0xebbe, 0xda32, 0x1a5f, 0x8b8b],
+ &[0x934b, 0x8956, 0xc434, 0x1881, 0xddf7],
+ &[0x5a95, 0x13fc, 0xf116, 0xd89b, 0x93f9],
+ &[0xd640, 0x71f1, 0xdd7d, 0x77eb, 0x1cd8],
+ &[0x348b, 0xaef0, 0xdb2c, 0xebf1, 0x1282],
+ &[0x50d7, 0xd824, 0x5010, 0xb369, 0x22ea]);
+}
+
+#[test]
+fn test_as_bytes() {
+ // no null
+ let v = [
+ 224, 184, 168, 224, 185, 132, 224, 184, 151, 224, 184, 162, 228,
+ 184, 173, 229, 141, 142, 86, 105, 225, 187, 135, 116, 32, 78, 97,
+ 109
+ ];
+ let b: &[u8] = &[];
+ assert_eq!("".as_bytes(), b);
+ assert_eq!("abc".as_bytes(), b"abc");
+ assert_eq!("ศไทย中华Việt Nam".as_bytes(), v);
+}
+
+#[test]
+#[should_panic]
+fn test_as_bytes_fail() {
+ // Don't double free. (I'm not sure if this exercises the
+ // original problem code path anymore.)
+ let s = String::from_str("");
+ let _bytes = s.as_bytes();
+ panic!();
+}
+
+#[test]
+fn test_as_ptr() {
+ let buf = "hello".as_ptr();
+ unsafe {
+ assert_eq!(*buf.offset(0), b'h');
+ assert_eq!(*buf.offset(1), b'e');
+ assert_eq!(*buf.offset(2), b'l');
+ assert_eq!(*buf.offset(3), b'l');
+ assert_eq!(*buf.offset(4), b'o');
+ }
+}
+
+#[test]
+fn test_subslice_offset() {
+ let a = "kernelsprite";
+ let b = &a[7..a.len()];
+ let c = &a[0..a.len() - 6];
+ assert_eq!(a.subslice_offset(b), 7);
+ assert_eq!(a.subslice_offset(c), 0);
+
+ let string = "a\nb\nc";
+ let lines: Vec<&str> = string.lines().collect();
+ assert_eq!(string.subslice_offset(lines[0]), 0);
+ assert_eq!(string.subslice_offset(lines[1]), 2);
+ assert_eq!(string.subslice_offset(lines[2]), 4);
+}
+
+#[test]
+#[should_panic]
+fn test_subslice_offset_2() {
+ let a = "alchemiter";
+ let b = "cruxtruder";
+ a.subslice_offset(b);
+}
+
+#[test]
+fn vec_str_conversions() {
+ let s1: String = String::from_str("All mimsy were the borogoves");
+
+ let v: Vec<u8> = s1.as_bytes().to_vec();
+ let s2: String = String::from_str(from_utf8(&v).unwrap());
+ let mut i = 0;
+ let n1 = s1.len();
+ let n2 = v.len();
+ assert_eq!(n1, n2);
+ while i < n1 {
+ let a: u8 = s1.as_bytes()[i];
+ let b: u8 = s2.as_bytes()[i];
+ debug!("{}", a);
+ debug!("{}", b);
+ assert_eq!(a, b);
+ i += 1;
+ }
+}
+
+#[test]
+fn test_contains() {
+ assert!("abcde".contains("bcd"));
+ assert!("abcde".contains("abcd"));
+ assert!("abcde".contains("bcde"));
+ assert!("abcde".contains(""));
+ assert!("".contains(""));
+ assert!(!"abcde".contains("def"));
+ assert!(!"".contains("a"));
+
+ let data = "ประเทศไทย中华Việt Nam";
+ assert!(data.contains("ประเ"));
+ assert!(data.contains("ะเ"));
+ assert!(data.contains("中华"));
+ assert!(!data.contains("ไท华"));
+}
+
+#[test]
+fn test_contains_char() {
+ assert!("abc".contains_char('b'));
+ assert!("a".contains_char('a'));
+ assert!(!"abc".contains_char('d'));
+ assert!(!"".contains_char('a'));
+}
+
+#[test]
+fn test_char_at() {
+ let s = "ศไทย中华Việt Nam";
+ let v = vec!['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
+ let mut pos = 0;
+ for ch in &v {
+ assert!(s.char_at(pos) == *ch);
+ pos += ch.to_string().len();
+ }
+}
+
+#[test]
+fn test_char_at_reverse() {
+ let s = "ศไทย中华Việt Nam";
+ let v = vec!['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
+ let mut pos = s.len();
+ for ch in v.iter().rev() {
+ assert!(s.char_at_reverse(pos) == *ch);
+ pos -= ch.to_string().len();
+ }
+}
+
+#[test]
+fn test_escape_unicode() {
+ assert_eq!("abc".escape_unicode(),
+ String::from_str("\\u{61}\\u{62}\\u{63}"));
+ assert_eq!("a c".escape_unicode(),
+ String::from_str("\\u{61}\\u{20}\\u{63}"));
+ assert_eq!("\r\n\t".escape_unicode(),
+ String::from_str("\\u{d}\\u{a}\\u{9}"));
+ assert_eq!("'\"\\".escape_unicode(),
+ String::from_str("\\u{27}\\u{22}\\u{5c}"));
+ assert_eq!("\x00\x01\u{fe}\u{ff}".escape_unicode(),
+ String::from_str("\\u{0}\\u{1}\\u{fe}\\u{ff}"));
+ assert_eq!("\u{100}\u{ffff}".escape_unicode(),
+ String::from_str("\\u{100}\\u{ffff}"));
+ assert_eq!("\u{10000}\u{10ffff}".escape_unicode(),
+ String::from_str("\\u{10000}\\u{10ffff}"));
+ assert_eq!("ab\u{fb00}".escape_unicode(),
+ String::from_str("\\u{61}\\u{62}\\u{fb00}"));
+ assert_eq!("\u{1d4ea}\r".escape_unicode(),
+ String::from_str("\\u{1d4ea}\\u{d}"));
+}
+
+#[test]
+fn test_escape_default() {
+ assert_eq!("abc".escape_default(), String::from_str("abc"));
+ assert_eq!("a c".escape_default(), String::from_str("a c"));
+ assert_eq!("\r\n\t".escape_default(), String::from_str("\\r\\n\\t"));
+ assert_eq!("'\"\\".escape_default(), String::from_str("\\'\\\"\\\\"));
+ assert_eq!("\u{100}\u{ffff}".escape_default(),
+ String::from_str("\\u{100}\\u{ffff}"));
+ assert_eq!("\u{10000}\u{10ffff}".escape_default(),
+ String::from_str("\\u{10000}\\u{10ffff}"));
+ assert_eq!("ab\u{fb00}".escape_default(),
+ String::from_str("ab\\u{fb00}"));
+ assert_eq!("\u{1d4ea}\r".escape_default(),
+ String::from_str("\\u{1d4ea}\\r"));
+}
+
+#[test]
+fn test_total_ord() {
+ "1234".cmp("123") == Greater;
+ "123".cmp("1234") == Less;
+ "1234".cmp("1234") == Equal;
+ "12345555".cmp("123456") == Less;
+ "22".cmp("1234") == Greater;
+}
+
+#[test]
+fn test_char_range_at() {
+ let data = "b¢€𤭢𤭢€¢b";
+ assert_eq!('b', data.char_range_at(0).ch);
+ assert_eq!('¢', data.char_range_at(1).ch);
+ assert_eq!('€', data.char_range_at(3).ch);
+ assert_eq!('𤭢', data.char_range_at(6).ch);
+ assert_eq!('𤭢', data.char_range_at(10).ch);
+ assert_eq!('€', data.char_range_at(14).ch);
+ assert_eq!('¢', data.char_range_at(17).ch);
+ assert_eq!('b', data.char_range_at(19).ch);
+}
+
+#[test]
+fn test_char_range_at_reverse_underflow() {
+ assert_eq!("abc".char_range_at_reverse(0).next, 0);
+}
+
+#[test]
+fn test_iterator() {
+ let s = "ศไทย中华Việt Nam";
+ let v = ['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
+
+ let mut pos = 0;
+ let it = s.chars();
+
+ for c in it {
+ assert_eq!(c, v[pos]);
+ pos += 1;
+ }
+ assert_eq!(pos, v.len());
+}
+
+#[test]
+fn test_rev_iterator() {
+ let s = "ศไทย中华Việt Nam";
+ let v = ['m', 'a', 'N', ' ', 't', 'ệ','i','V','华','中','ย','ท','ไ','ศ'];
+
+ let mut pos = 0;
+ let it = s.chars().rev();
+
+ for c in it {
+ assert_eq!(c, v[pos]);
+ pos += 1;
+ }
+ assert_eq!(pos, v.len());
+}
+
+#[test]
+fn test_chars_decoding() {
+ let mut bytes = [0; 4];
+ for c in (0..0x110000).filter_map(::std::char::from_u32) {
+ let len = c.encode_utf8(&mut bytes).unwrap_or(0);
+ let s = ::std::str::from_utf8(&bytes[..len]).unwrap();
+ if Some(c) != s.chars().next() {
+ panic!("character {:x}={} does not decode correctly", c as u32, c);
+ }
+ }
+}
+
+#[test]
+fn test_chars_rev_decoding() {
+ let mut bytes = [0; 4];
+ for c in (0..0x110000).filter_map(::std::char::from_u32) {
+ let len = c.encode_utf8(&mut bytes).unwrap_or(0);
+ let s = ::std::str::from_utf8(&bytes[..len]).unwrap();
+ if Some(c) != s.chars().rev().next() {
+ panic!("character {:x}={} does not decode correctly", c as u32, c);
+ }
+ }
+}
+
+#[test]
+fn test_iterator_clone() {
+ let s = "ศไทย中华Việt Nam";
+ let mut it = s.chars();
+ it.next();
+ assert!(it.clone().zip(it).all(|(x,y)| x == y));
+}
+
+#[test]
+fn test_bytesator() {
+ let s = "ศไทย中华Việt Nam";
+ let v = [
+ 224, 184, 168, 224, 185, 132, 224, 184, 151, 224, 184, 162, 228,
+ 184, 173, 229, 141, 142, 86, 105, 225, 187, 135, 116, 32, 78, 97,
+ 109
+ ];
+ let mut pos = 0;
+
+ for b in s.bytes() {
+ assert_eq!(b, v[pos]);
+ pos += 1;
+ }
+}
+
+#[test]
+fn test_bytes_revator() {
+ let s = "ศไทย中华Việt Nam";
+ let v = [
+ 224, 184, 168, 224, 185, 132, 224, 184, 151, 224, 184, 162, 228,
+ 184, 173, 229, 141, 142, 86, 105, 225, 187, 135, 116, 32, 78, 97,
+ 109
+ ];
+ let mut pos = v.len();
+
+ for b in s.bytes().rev() {
+ pos -= 1;
+ assert_eq!(b, v[pos]);
+ }
+}
+
+#[test]
+fn test_char_indicesator() {
+ let s = "ศไทย中华Việt Nam";
+ let p = [0, 3, 6, 9, 12, 15, 18, 19, 20, 23, 24, 25, 26, 27];
+ let v = ['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
+
+ let mut pos = 0;
+ let it = s.char_indices();
+
+ for c in it {
+ assert_eq!(c, (p[pos], v[pos]));
+ pos += 1;
+ }
+ assert_eq!(pos, v.len());
+ assert_eq!(pos, p.len());
+}
+
+#[test]
+fn test_char_indices_revator() {
+ let s = "ศไทย中华Việt Nam";
+ let p = [27, 26, 25, 24, 23, 20, 19, 18, 15, 12, 9, 6, 3, 0];
+ let v = ['m', 'a', 'N', ' ', 't', 'ệ','i','V','华','中','ย','ท','ไ','ศ'];
+
+ let mut pos = 0;
+ let it = s.char_indices().rev();
+
+ for c in it {
+ assert_eq!(c, (p[pos], v[pos]));
+ pos += 1;
+ }
+ assert_eq!(pos, v.len());
+ assert_eq!(pos, p.len());
+}
+
+#[test]
+fn test_splitn_char_iterator() {
+ let data = "\nMäry häd ä little lämb\nLittle lämb\n";
+
+ let split: Vec<&str> = data.splitn(3, ' ').collect();
+ assert_eq!(split, ["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]);
+
+ let split: Vec<&str> = data.splitn(3, |c: char| c == ' ').collect();
+ assert_eq!(split, ["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]);
+
+ // Unicode
+ let split: Vec<&str> = data.splitn(3, 'ä').collect();
+ assert_eq!(split, ["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]);
+
+ let split: Vec<&str> = data.splitn(3, |c: char| c == 'ä').collect();
+ assert_eq!(split, ["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]);
+}
+
+#[test]
+fn test_split_char_iterator_no_trailing() {
+ let data = "\nMäry häd ä little lämb\nLittle lämb\n";
+
+ let split: Vec<&str> = data.split('\n').collect();
+ assert_eq!(split, ["", "Märy häd ä little lämb", "Little lämb", ""]);
+
+ let split: Vec<&str> = data.split_terminator('\n').collect();
+ assert_eq!(split, ["", "Märy häd ä little lämb", "Little lämb"]);
+}
+
+#[test]
+fn test_words() {
+ let data = "\n \tMäry häd\tä little lämb\nLittle lämb\n";
+ let words: Vec<&str> = data.words().collect();
+ assert_eq!(words, ["Märy", "häd", "ä", "little", "lämb", "Little", "lämb"])
+}
+
+#[test]
+fn test_nfd_chars() {
+ macro_rules! t {
+ ($input: expr, $expected: expr) => {
+ assert_eq!($input.nfd_chars().collect::<String>(), $expected);
+ }
+ }
+ t!("abc", "abc");
+ t!("\u{1e0b}\u{1c4}", "d\u{307}\u{1c4}");
+ t!("\u{2026}", "\u{2026}");
+ t!("\u{2126}", "\u{3a9}");
+ t!("\u{1e0b}\u{323}", "d\u{323}\u{307}");
+ t!("\u{1e0d}\u{307}", "d\u{323}\u{307}");
+ t!("a\u{301}", "a\u{301}");
+ t!("\u{301}a", "\u{301}a");
+ t!("\u{d4db}", "\u{1111}\u{1171}\u{11b6}");
+ t!("\u{ac1c}", "\u{1100}\u{1162}");
+}
+
+#[test]
+fn test_nfkd_chars() {
+ macro_rules! t {
+ ($input: expr, $expected: expr) => {
+ assert_eq!($input.nfkd_chars().collect::<String>(), $expected);
+ }
+ }
+ t!("abc", "abc");
+ t!("\u{1e0b}\u{1c4}", "d\u{307}DZ\u{30c}");
+ t!("\u{2026}", "...");
+ t!("\u{2126}", "\u{3a9}");
+ t!("\u{1e0b}\u{323}", "d\u{323}\u{307}");
+ t!("\u{1e0d}\u{307}", "d\u{323}\u{307}");
+ t!("a\u{301}", "a\u{301}");
+ t!("\u{301}a", "\u{301}a");
+ t!("\u{d4db}", "\u{1111}\u{1171}\u{11b6}");
+ t!("\u{ac1c}", "\u{1100}\u{1162}");
+}
+
+#[test]
+fn test_nfc_chars() {
+ macro_rules! t {
+ ($input: expr, $expected: expr) => {
+ assert_eq!($input.nfc_chars().collect::<String>(), $expected);
+ }
+ }
+ t!("abc", "abc");
+ t!("\u{1e0b}\u{1c4}", "\u{1e0b}\u{1c4}");
+ t!("\u{2026}", "\u{2026}");
+ t!("\u{2126}", "\u{3a9}");
+ t!("\u{1e0b}\u{323}", "\u{1e0d}\u{307}");
+ t!("\u{1e0d}\u{307}", "\u{1e0d}\u{307}");
+ t!("a\u{301}", "\u{e1}");
+ t!("\u{301}a", "\u{301}a");
+ t!("\u{d4db}", "\u{d4db}");
+ t!("\u{ac1c}", "\u{ac1c}");
+ t!("a\u{300}\u{305}\u{315}\u{5ae}b", "\u{e0}\u{5ae}\u{305}\u{315}b");
+}
+
+#[test]
+fn test_nfkc_chars() {
+ macro_rules! t {
+ ($input: expr, $expected: expr) => {
+ assert_eq!($input.nfkc_chars().collect::<String>(), $expected);
+ }
+ }
+ t!("abc", "abc");
+ t!("\u{1e0b}\u{1c4}", "\u{1e0b}D\u{17d}");
+ t!("\u{2026}", "...");
+ t!("\u{2126}", "\u{3a9}");
+ t!("\u{1e0b}\u{323}", "\u{1e0d}\u{307}");
+ t!("\u{1e0d}\u{307}", "\u{1e0d}\u{307}");
+ t!("a\u{301}", "\u{e1}");
+ t!("\u{301}a", "\u{301}a");
+ t!("\u{d4db}", "\u{d4db}");
+ t!("\u{ac1c}", "\u{ac1c}");
+ t!("a\u{300}\u{305}\u{315}\u{5ae}b", "\u{e0}\u{5ae}\u{305}\u{315}b");
+}
+
+#[test]
+fn test_lines() {
+ let data = "\nMäry häd ä little lämb\n\nLittle lämb\n";
+ let lines: Vec<&str> = data.lines().collect();
+ assert_eq!(lines, ["", "Märy häd ä little lämb", "", "Little lämb"]);
+
+ let data = "\nMäry häd ä little lämb\n\nLittle lämb"; // no trailing \n
+ let lines: Vec<&str> = data.lines().collect();
+ assert_eq!(lines, ["", "Märy häd ä little lämb", "", "Little lämb"]);
+}
+
+#[test]
+fn test_graphemes() {
+ use std::iter::order;
+
+ // official Unicode test data
+ // from http://www.unicode.org/Public/UCD/latest/ucd/auxiliary/GraphemeBreakTest.txt
+ let test_same: [(_, &[_]); 325] = [
+ ("\u{20}\u{20}", &["\u{20}", "\u{20}"]),
+ ("\u{20}\u{308}\u{20}", &["\u{20}\u{308}", "\u{20}"]),
+ ("\u{20}\u{D}", &["\u{20}", "\u{D}"]),
+ ("\u{20}\u{308}\u{D}", &["\u{20}\u{308}", "\u{D}"]),
+ ("\u{20}\u{A}", &["\u{20}", "\u{A}"]),
+ ("\u{20}\u{308}\u{A}", &["\u{20}\u{308}", "\u{A}"]),
+ ("\u{20}\u{1}", &["\u{20}", "\u{1}"]),
+ ("\u{20}\u{308}\u{1}", &["\u{20}\u{308}", "\u{1}"]),
+ ("\u{20}\u{300}", &["\u{20}\u{300}"]),
+ ("\u{20}\u{308}\u{300}", &["\u{20}\u{308}\u{300}"]),
+ ("\u{20}\u{1100}", &["\u{20}", "\u{1100}"]),
+ ("\u{20}\u{308}\u{1100}", &["\u{20}\u{308}", "\u{1100}"]),
+ ("\u{20}\u{1160}", &["\u{20}", "\u{1160}"]),
+ ("\u{20}\u{308}\u{1160}", &["\u{20}\u{308}", "\u{1160}"]),
+ ("\u{20}\u{11A8}", &["\u{20}", "\u{11A8}"]),
+ ("\u{20}\u{308}\u{11A8}", &["\u{20}\u{308}", "\u{11A8}"]),
+ ("\u{20}\u{AC00}", &["\u{20}", "\u{AC00}"]),
+ ("\u{20}\u{308}\u{AC00}", &["\u{20}\u{308}", "\u{AC00}"]),
+ ("\u{20}\u{AC01}", &["\u{20}", "\u{AC01}"]),
+ ("\u{20}\u{308}\u{AC01}", &["\u{20}\u{308}", "\u{AC01}"]),
+ ("\u{20}\u{1F1E6}", &["\u{20}", "\u{1F1E6}"]),
+ ("\u{20}\u{308}\u{1F1E6}", &["\u{20}\u{308}", "\u{1F1E6}"]),
+ ("\u{20}\u{378}", &["\u{20}", "\u{378}"]),
+ ("\u{20}\u{308}\u{378}", &["\u{20}\u{308}", "\u{378}"]),
+ ("\u{D}\u{20}", &["\u{D}", "\u{20}"]),
+ ("\u{D}\u{308}\u{20}", &["\u{D}", "\u{308}", "\u{20}"]),
+ ("\u{D}\u{D}", &["\u{D}", "\u{D}"]),
+ ("\u{D}\u{308}\u{D}", &["\u{D}", "\u{308}", "\u{D}"]),
+ ("\u{D}\u{A}", &["\u{D}\u{A}"]),
+ ("\u{D}\u{308}\u{A}", &["\u{D}", "\u{308}", "\u{A}"]),
+ ("\u{D}\u{1}", &["\u{D}", "\u{1}"]),
+ ("\u{D}\u{308}\u{1}", &["\u{D}", "\u{308}", "\u{1}"]),
+ ("\u{D}\u{300}", &["\u{D}", "\u{300}"]),
+ ("\u{D}\u{308}\u{300}", &["\u{D}", "\u{308}\u{300}"]),
+ ("\u{D}\u{903}", &["\u{D}", "\u{903}"]),
+ ("\u{D}\u{1100}", &["\u{D}", "\u{1100}"]),
+ ("\u{D}\u{308}\u{1100}", &["\u{D}", "\u{308}", "\u{1100}"]),
+ ("\u{D}\u{1160}", &["\u{D}", "\u{1160}"]),
+ ("\u{D}\u{308}\u{1160}", &["\u{D}", "\u{308}", "\u{1160}"]),
+ ("\u{D}\u{11A8}", &["\u{D}", "\u{11A8}"]),
+ ("\u{D}\u{308}\u{11A8}", &["\u{D}", "\u{308}", "\u{11A8}"]),
+ ("\u{D}\u{AC00}", &["\u{D}", "\u{AC00}"]),
+ ("\u{D}\u{308}\u{AC00}", &["\u{D}", "\u{308}", "\u{AC00}"]),
+ ("\u{D}\u{AC01}", &["\u{D}", "\u{AC01}"]),
+ ("\u{D}\u{308}\u{AC01}", &["\u{D}", "\u{308}", "\u{AC01}"]),
+ ("\u{D}\u{1F1E6}", &["\u{D}", "\u{1F1E6}"]),
+ ("\u{D}\u{308}\u{1F1E6}", &["\u{D}", "\u{308}", "\u{1F1E6}"]),
+ ("\u{D}\u{378}", &["\u{D}", "\u{378}"]),
+ ("\u{D}\u{308}\u{378}", &["\u{D}", "\u{308}", "\u{378}"]),
+ ("\u{A}\u{20}", &["\u{A}", "\u{20}"]),
+ ("\u{A}\u{308}\u{20}", &["\u{A}", "\u{308}", "\u{20}"]),
+ ("\u{A}\u{D}", &["\u{A}", "\u{D}"]),
+ ("\u{A}\u{308}\u{D}", &["\u{A}", "\u{308}", "\u{D}"]),
+ ("\u{A}\u{A}", &["\u{A}", "\u{A}"]),
+ ("\u{A}\u{308}\u{A}", &["\u{A}", "\u{308}", "\u{A}"]),
+ ("\u{A}\u{1}", &["\u{A}", "\u{1}"]),
+ ("\u{A}\u{308}\u{1}", &["\u{A}", "\u{308}", "\u{1}"]),
+ ("\u{A}\u{300}", &["\u{A}", "\u{300}"]),
+ ("\u{A}\u{308}\u{300}", &["\u{A}", "\u{308}\u{300}"]),
+ ("\u{A}\u{903}", &["\u{A}", "\u{903}"]),
+ ("\u{A}\u{1100}", &["\u{A}", "\u{1100}"]),
+ ("\u{A}\u{308}\u{1100}", &["\u{A}", "\u{308}", "\u{1100}"]),
+ ("\u{A}\u{1160}", &["\u{A}", "\u{1160}"]),
+ ("\u{A}\u{308}\u{1160}", &["\u{A}", "\u{308}", "\u{1160}"]),
+ ("\u{A}\u{11A8}", &["\u{A}", "\u{11A8}"]),
+ ("\u{A}\u{308}\u{11A8}", &["\u{A}", "\u{308}", "\u{11A8}"]),
+ ("\u{A}\u{AC00}", &["\u{A}", "\u{AC00}"]),
+ ("\u{A}\u{308}\u{AC00}", &["\u{A}", "\u{308}", "\u{AC00}"]),
+ ("\u{A}\u{AC01}", &["\u{A}", "\u{AC01}"]),
+ ("\u{A}\u{308}\u{AC01}", &["\u{A}", "\u{308}", "\u{AC01}"]),
+ ("\u{A}\u{1F1E6}", &["\u{A}", "\u{1F1E6}"]),
+ ("\u{A}\u{308}\u{1F1E6}", &["\u{A}", "\u{308}", "\u{1F1E6}"]),
+ ("\u{A}\u{378}", &["\u{A}", "\u{378}"]),
+ ("\u{A}\u{308}\u{378}", &["\u{A}", "\u{308}", "\u{378}"]),
+ ("\u{1}\u{20}", &["\u{1}", "\u{20}"]),
+ ("\u{1}\u{308}\u{20}", &["\u{1}", "\u{308}", "\u{20}"]),
+ ("\u{1}\u{D}", &["\u{1}", "\u{D}"]),
+ ("\u{1}\u{308}\u{D}", &["\u{1}", "\u{308}", "\u{D}"]),
+ ("\u{1}\u{A}", &["\u{1}", "\u{A}"]),
+ ("\u{1}\u{308}\u{A}", &["\u{1}", "\u{308}", "\u{A}"]),
+ ("\u{1}\u{1}", &["\u{1}", "\u{1}"]),
+ ("\u{1}\u{308}\u{1}", &["\u{1}", "\u{308}", "\u{1}"]),
+ ("\u{1}\u{300}", &["\u{1}", "\u{300}"]),
+ ("\u{1}\u{308}\u{300}", &["\u{1}", "\u{308}\u{300}"]),
+ ("\u{1}\u{903}", &["\u{1}", "\u{903}"]),
+ ("\u{1}\u{1100}", &["\u{1}", "\u{1100}"]),
+ ("\u{1}\u{308}\u{1100}", &["\u{1}", "\u{308}", "\u{1100}"]),
+ ("\u{1}\u{1160}", &["\u{1}", "\u{1160}"]),
+ ("\u{1}\u{308}\u{1160}", &["\u{1}", "\u{308}", "\u{1160}"]),
+ ("\u{1}\u{11A8}", &["\u{1}", "\u{11A8}"]),
+ ("\u{1}\u{308}\u{11A8}", &["\u{1}", "\u{308}", "\u{11A8}"]),
+ ("\u{1}\u{AC00}", &["\u{1}", "\u{AC00}"]),
+ ("\u{1}\u{308}\u{AC00}", &["\u{1}", "\u{308}", "\u{AC00}"]),
+ ("\u{1}\u{AC01}", &["\u{1}", "\u{AC01}"]),
+ ("\u{1}\u{308}\u{AC01}", &["\u{1}", "\u{308}", "\u{AC01}"]),
+ ("\u{1}\u{1F1E6}", &["\u{1}", "\u{1F1E6}"]),
+ ("\u{1}\u{308}\u{1F1E6}", &["\u{1}", "\u{308}", "\u{1F1E6}"]),
+ ("\u{1}\u{378}", &["\u{1}", "\u{378}"]),
+ ("\u{1}\u{308}\u{378}", &["\u{1}", "\u{308}", "\u{378}"]),
+ ("\u{300}\u{20}", &["\u{300}", "\u{20}"]),
+ ("\u{300}\u{308}\u{20}", &["\u{300}\u{308}", "\u{20}"]),
+ ("\u{300}\u{D}", &["\u{300}", "\u{D}"]),
+ ("\u{300}\u{308}\u{D}", &["\u{300}\u{308}", "\u{D}"]),
+ ("\u{300}\u{A}", &["\u{300}", "\u{A}"]),
+ ("\u{300}\u{308}\u{A}", &["\u{300}\u{308}", "\u{A}"]),
+ ("\u{300}\u{1}", &["\u{300}", "\u{1}"]),
+ ("\u{300}\u{308}\u{1}", &["\u{300}\u{308}", "\u{1}"]),
+ ("\u{300}\u{300}", &["\u{300}\u{300}"]),
+ ("\u{300}\u{308}\u{300}", &["\u{300}\u{308}\u{300}"]),
+ ("\u{300}\u{1100}", &["\u{300}", "\u{1100}"]),
+ ("\u{300}\u{308}\u{1100}", &["\u{300}\u{308}", "\u{1100}"]),
+ ("\u{300}\u{1160}", &["\u{300}", "\u{1160}"]),
+ ("\u{300}\u{308}\u{1160}", &["\u{300}\u{308}", "\u{1160}"]),
+ ("\u{300}\u{11A8}", &["\u{300}", "\u{11A8}"]),
+ ("\u{300}\u{308}\u{11A8}", &["\u{300}\u{308}", "\u{11A8}"]),
+ ("\u{300}\u{AC00}", &["\u{300}", "\u{AC00}"]),
+ ("\u{300}\u{308}\u{AC00}", &["\u{300}\u{308}", "\u{AC00}"]),
+ ("\u{300}\u{AC01}", &["\u{300}", "\u{AC01}"]),
+ ("\u{300}\u{308}\u{AC01}", &["\u{300}\u{308}", "\u{AC01}"]),
+ ("\u{300}\u{1F1E6}", &["\u{300}", "\u{1F1E6}"]),
+ ("\u{300}\u{308}\u{1F1E6}", &["\u{300}\u{308}", "\u{1F1E6}"]),
+ ("\u{300}\u{378}", &["\u{300}", "\u{378}"]),
+ ("\u{300}\u{308}\u{378}", &["\u{300}\u{308}", "\u{378}"]),
+ ("\u{903}\u{20}", &["\u{903}", "\u{20}"]),
+ ("\u{903}\u{308}\u{20}", &["\u{903}\u{308}", "\u{20}"]),
+ ("\u{903}\u{D}", &["\u{903}", "\u{D}"]),
+ ("\u{903}\u{308}\u{D}", &["\u{903}\u{308}", "\u{D}"]),
+ ("\u{903}\u{A}", &["\u{903}", "\u{A}"]),
+ ("\u{903}\u{308}\u{A}", &["\u{903}\u{308}", "\u{A}"]),
+ ("\u{903}\u{1}", &["\u{903}", "\u{1}"]),
+ ("\u{903}\u{308}\u{1}", &["\u{903}\u{308}", "\u{1}"]),
+ ("\u{903}\u{300}", &["\u{903}\u{300}"]),
+ ("\u{903}\u{308}\u{300}", &["\u{903}\u{308}\u{300}"]),
+ ("\u{903}\u{1100}", &["\u{903}", "\u{1100}"]),
+ ("\u{903}\u{308}\u{1100}", &["\u{903}\u{308}", "\u{1100}"]),
+ ("\u{903}\u{1160}", &["\u{903}", "\u{1160}"]),
+ ("\u{903}\u{308}\u{1160}", &["\u{903}\u{308}", "\u{1160}"]),
+ ("\u{903}\u{11A8}", &["\u{903}", "\u{11A8}"]),
+ ("\u{903}\u{308}\u{11A8}", &["\u{903}\u{308}", "\u{11A8}"]),
+ ("\u{903}\u{AC00}", &["\u{903}", "\u{AC00}"]),
+ ("\u{903}\u{308}\u{AC00}", &["\u{903}\u{308}", "\u{AC00}"]),
+ ("\u{903}\u{AC01}", &["\u{903}", "\u{AC01}"]),
+ ("\u{903}\u{308}\u{AC01}", &["\u{903}\u{308}", "\u{AC01}"]),
+ ("\u{903}\u{1F1E6}", &["\u{903}", "\u{1F1E6}"]),
+ ("\u{903}\u{308}\u{1F1E6}", &["\u{903}\u{308}", "\u{1F1E6}"]),
+ ("\u{903}\u{378}", &["\u{903}", "\u{378}"]),
+ ("\u{903}\u{308}\u{378}", &["\u{903}\u{308}", "\u{378}"]),
+ ("\u{1100}\u{20}", &["\u{1100}", "\u{20}"]),
+ ("\u{1100}\u{308}\u{20}", &["\u{1100}\u{308}", "\u{20}"]),
+ ("\u{1100}\u{D}", &["\u{1100}", "\u{D}"]),
+ ("\u{1100}\u{308}\u{D}", &["\u{1100}\u{308}", "\u{D}"]),
+ ("\u{1100}\u{A}", &["\u{1100}", "\u{A}"]),
+ ("\u{1100}\u{308}\u{A}", &["\u{1100}\u{308}", "\u{A}"]),
+ ("\u{1100}\u{1}", &["\u{1100}", "\u{1}"]),
+ ("\u{1100}\u{308}\u{1}", &["\u{1100}\u{308}", "\u{1}"]),
+ ("\u{1100}\u{300}", &["\u{1100}\u{300}"]),
+ ("\u{1100}\u{308}\u{300}", &["\u{1100}\u{308}\u{300}"]),
+ ("\u{1100}\u{1100}", &["\u{1100}\u{1100}"]),
+ ("\u{1100}\u{308}\u{1100}", &["\u{1100}\u{308}", "\u{1100}"]),
+ ("\u{1100}\u{1160}", &["\u{1100}\u{1160}"]),
+ ("\u{1100}\u{308}\u{1160}", &["\u{1100}\u{308}", "\u{1160}"]),
+ ("\u{1100}\u{11A8}", &["\u{1100}", "\u{11A8}"]),
+ ("\u{1100}\u{308}\u{11A8}", &["\u{1100}\u{308}", "\u{11A8}"]),
+ ("\u{1100}\u{AC00}", &["\u{1100}\u{AC00}"]),
+ ("\u{1100}\u{308}\u{AC00}", &["\u{1100}\u{308}", "\u{AC00}"]),
+ ("\u{1100}\u{AC01}", &["\u{1100}\u{AC01}"]),
+ ("\u{1100}\u{308}\u{AC01}", &["\u{1100}\u{308}", "\u{AC01}"]),
+ ("\u{1100}\u{1F1E6}", &["\u{1100}", "\u{1F1E6}"]),
+ ("\u{1100}\u{308}\u{1F1E6}", &["\u{1100}\u{308}", "\u{1F1E6}"]),
+ ("\u{1100}\u{378}", &["\u{1100}", "\u{378}"]),
+ ("\u{1100}\u{308}\u{378}", &["\u{1100}\u{308}", "\u{378}"]),
+ ("\u{1160}\u{20}", &["\u{1160}", "\u{20}"]),
+ ("\u{1160}\u{308}\u{20}", &["\u{1160}\u{308}", "\u{20}"]),
+ ("\u{1160}\u{D}", &["\u{1160}", "\u{D}"]),
+ ("\u{1160}\u{308}\u{D}", &["\u{1160}\u{308}", "\u{D}"]),
+ ("\u{1160}\u{A}", &["\u{1160}", "\u{A}"]),
+ ("\u{1160}\u{308}\u{A}", &["\u{1160}\u{308}", "\u{A}"]),
+ ("\u{1160}\u{1}", &["\u{1160}", "\u{1}"]),
+ ("\u{1160}\u{308}\u{1}", &["\u{1160}\u{308}", "\u{1}"]),
+ ("\u{1160}\u{300}", &["\u{1160}\u{300}"]),
+ ("\u{1160}\u{308}\u{300}", &["\u{1160}\u{308}\u{300}"]),
+ ("\u{1160}\u{1100}", &["\u{1160}", "\u{1100}"]),
+ ("\u{1160}\u{308}\u{1100}", &["\u{1160}\u{308}", "\u{1100}"]),
+ ("\u{1160}\u{1160}", &["\u{1160}\u{1160}"]),
+ ("\u{1160}\u{308}\u{1160}", &["\u{1160}\u{308}", "\u{1160}"]),
+ ("\u{1160}\u{11A8}", &["\u{1160}\u{11A8}"]),
+ ("\u{1160}\u{308}\u{11A8}", &["\u{1160}\u{308}", "\u{11A8}"]),
+ ("\u{1160}\u{AC00}", &["\u{1160}", "\u{AC00}"]),
+ ("\u{1160}\u{308}\u{AC00}", &["\u{1160}\u{308}", "\u{AC00}"]),
+ ("\u{1160}\u{AC01}", &["\u{1160}", "\u{AC01}"]),
+ ("\u{1160}\u{308}\u{AC01}", &["\u{1160}\u{308}", "\u{AC01}"]),
+ ("\u{1160}\u{1F1E6}", &["\u{1160}", "\u{1F1E6}"]),
+ ("\u{1160}\u{308}\u{1F1E6}", &["\u{1160}\u{308}", "\u{1F1E6}"]),
+ ("\u{1160}\u{378}", &["\u{1160}", "\u{378}"]),
+ ("\u{1160}\u{308}\u{378}", &["\u{1160}\u{308}", "\u{378}"]),
+ ("\u{11A8}\u{20}", &["\u{11A8}", "\u{20}"]),
+ ("\u{11A8}\u{308}\u{20}", &["\u{11A8}\u{308}", "\u{20}"]),
+ ("\u{11A8}\u{D}", &["\u{11A8}", "\u{D}"]),
+ ("\u{11A8}\u{308}\u{D}", &["\u{11A8}\u{308}", "\u{D}"]),
+ ("\u{11A8}\u{A}", &["\u{11A8}", "\u{A}"]),
+ ("\u{11A8}\u{308}\u{A}", &["\u{11A8}\u{308}", "\u{A}"]),
+ ("\u{11A8}\u{1}", &["\u{11A8}", "\u{1}"]),
+ ("\u{11A8}\u{308}\u{1}", &["\u{11A8}\u{308}", "\u{1}"]),
+ ("\u{11A8}\u{300}", &["\u{11A8}\u{300}"]),
+ ("\u{11A8}\u{308}\u{300}", &["\u{11A8}\u{308}\u{300}"]),
+ ("\u{11A8}\u{1100}", &["\u{11A8}", "\u{1100}"]),
+ ("\u{11A8}\u{308}\u{1100}", &["\u{11A8}\u{308}", "\u{1100}"]),
+ ("\u{11A8}\u{1160}", &["\u{11A8}", "\u{1160}"]),
+ ("\u{11A8}\u{308}\u{1160}", &["\u{11A8}\u{308}", "\u{1160}"]),
+ ("\u{11A8}\u{11A8}", &["\u{11A8}\u{11A8}"]),
+ ("\u{11A8}\u{308}\u{11A8}", &["\u{11A8}\u{308}", "\u{11A8}"]),
+ ("\u{11A8}\u{AC00}", &["\u{11A8}", "\u{AC00}"]),
+ ("\u{11A8}\u{308}\u{AC00}", &["\u{11A8}\u{308}", "\u{AC00}"]),
+ ("\u{11A8}\u{AC01}", &["\u{11A8}", "\u{AC01}"]),
+ ("\u{11A8}\u{308}\u{AC01}", &["\u{11A8}\u{308}", "\u{AC01}"]),
+ ("\u{11A8}\u{1F1E6}", &["\u{11A8}", "\u{1F1E6}"]),
+ ("\u{11A8}\u{308}\u{1F1E6}", &["\u{11A8}\u{308}", "\u{1F1E6}"]),
+ ("\u{11A8}\u{378}", &["\u{11A8}", "\u{378}"]),
+ ("\u{11A8}\u{308}\u{378}", &["\u{11A8}\u{308}", "\u{378}"]),
+ ("\u{AC00}\u{20}", &["\u{AC00}", "\u{20}"]),
+ ("\u{AC00}\u{308}\u{20}", &["\u{AC00}\u{308}", "\u{20}"]),
+ ("\u{AC00}\u{D}", &["\u{AC00}", "\u{D}"]),
+ ("\u{AC00}\u{308}\u{D}", &["\u{AC00}\u{308}", "\u{D}"]),
+ ("\u{AC00}\u{A}", &["\u{AC00}", "\u{A}"]),
+ ("\u{AC00}\u{308}\u{A}", &["\u{AC00}\u{308}", "\u{A}"]),
+ ("\u{AC00}\u{1}", &["\u{AC00}", "\u{1}"]),
+ ("\u{AC00}\u{308}\u{1}", &["\u{AC00}\u{308}", "\u{1}"]),
+ ("\u{AC00}\u{300}", &["\u{AC00}\u{300}"]),
+ ("\u{AC00}\u{308}\u{300}", &["\u{AC00}\u{308}\u{300}"]),
+ ("\u{AC00}\u{1100}", &["\u{AC00}", "\u{1100}"]),
+ ("\u{AC00}\u{308}\u{1100}", &["\u{AC00}\u{308}", "\u{1100}"]),
+ ("\u{AC00}\u{1160}", &["\u{AC00}\u{1160}"]),
+ ("\u{AC00}\u{308}\u{1160}", &["\u{AC00}\u{308}", "\u{1160}"]),
+ ("\u{AC00}\u{11A8}", &["\u{AC00}\u{11A8}"]),
+ ("\u{AC00}\u{308}\u{11A8}", &["\u{AC00}\u{308}", "\u{11A8}"]),
+ ("\u{AC00}\u{AC00}", &["\u{AC00}", "\u{AC00}"]),
+ ("\u{AC00}\u{308}\u{AC00}", &["\u{AC00}\u{308}", "\u{AC00}"]),
+ ("\u{AC00}\u{AC01}", &["\u{AC00}", "\u{AC01}"]),
+ ("\u{AC00}\u{308}\u{AC01}", &["\u{AC00}\u{308}", "\u{AC01}"]),
+ ("\u{AC00}\u{1F1E6}", &["\u{AC00}", "\u{1F1E6}"]),
+ ("\u{AC00}\u{308}\u{1F1E6}", &["\u{AC00}\u{308}", "\u{1F1E6}"]),
+ ("\u{AC00}\u{378}", &["\u{AC00}", "\u{378}"]),
+ ("\u{AC00}\u{308}\u{378}", &["\u{AC00}\u{308}", "\u{378}"]),
+ ("\u{AC01}\u{20}", &["\u{AC01}", "\u{20}"]),
+ ("\u{AC01}\u{308}\u{20}", &["\u{AC01}\u{308}", "\u{20}"]),
+ ("\u{AC01}\u{D}", &["\u{AC01}", "\u{D}"]),
+ ("\u{AC01}\u{308}\u{D}", &["\u{AC01}\u{308}", "\u{D}"]),
+ ("\u{AC01}\u{A}", &["\u{AC01}", "\u{A}"]),
+ ("\u{AC01}\u{308}\u{A}", &["\u{AC01}\u{308}", "\u{A}"]),
+ ("\u{AC01}\u{1}", &["\u{AC01}", "\u{1}"]),
+ ("\u{AC01}\u{308}\u{1}", &["\u{AC01}\u{308}", "\u{1}"]),
+ ("\u{AC01}\u{300}", &["\u{AC01}\u{300}"]),
+ ("\u{AC01}\u{308}\u{300}", &["\u{AC01}\u{308}\u{300}"]),
+ ("\u{AC01}\u{1100}", &["\u{AC01}", "\u{1100}"]),
+ ("\u{AC01}\u{308}\u{1100}", &["\u{AC01}\u{308}", "\u{1100}"]),
+ ("\u{AC01}\u{1160}", &["\u{AC01}", "\u{1160}"]),
+ ("\u{AC01}\u{308}\u{1160}", &["\u{AC01}\u{308}", "\u{1160}"]),
+ ("\u{AC01}\u{11A8}", &["\u{AC01}\u{11A8}"]),
+ ("\u{AC01}\u{308}\u{11A8}", &["\u{AC01}\u{308}", "\u{11A8}"]),
+ ("\u{AC01}\u{AC00}", &["\u{AC01}", "\u{AC00}"]),
+ ("\u{AC01}\u{308}\u{AC00}", &["\u{AC01}\u{308}", "\u{AC00}"]),
+ ("\u{AC01}\u{AC01}", &["\u{AC01}", "\u{AC01}"]),
+ ("\u{AC01}\u{308}\u{AC01}", &["\u{AC01}\u{308}", "\u{AC01}"]),
+ ("\u{AC01}\u{1F1E6}", &["\u{AC01}", "\u{1F1E6}"]),
+ ("\u{AC01}\u{308}\u{1F1E6}", &["\u{AC01}\u{308}", "\u{1F1E6}"]),
+ ("\u{AC01}\u{378}", &["\u{AC01}", "\u{378}"]),
+ ("\u{AC01}\u{308}\u{378}", &["\u{AC01}\u{308}", "\u{378}"]),
+ ("\u{1F1E6}\u{20}", &["\u{1F1E6}", "\u{20}"]),
+ ("\u{1F1E6}\u{308}\u{20}", &["\u{1F1E6}\u{308}", "\u{20}"]),
+ ("\u{1F1E6}\u{D}", &["\u{1F1E6}", "\u{D}"]),
+ ("\u{1F1E6}\u{308}\u{D}", &["\u{1F1E6}\u{308}", "\u{D}"]),
+ ("\u{1F1E6}\u{A}", &["\u{1F1E6}", "\u{A}"]),
+ ("\u{1F1E6}\u{308}\u{A}", &["\u{1F1E6}\u{308}", "\u{A}"]),
+ ("\u{1F1E6}\u{1}", &["\u{1F1E6}", "\u{1}"]),
+ ("\u{1F1E6}\u{308}\u{1}", &["\u{1F1E6}\u{308}", "\u{1}"]),
+ ("\u{1F1E6}\u{300}", &["\u{1F1E6}\u{300}"]),
+ ("\u{1F1E6}\u{308}\u{300}", &["\u{1F1E6}\u{308}\u{300}"]),
+ ("\u{1F1E6}\u{1100}", &["\u{1F1E6}", "\u{1100}"]),
+ ("\u{1F1E6}\u{308}\u{1100}", &["\u{1F1E6}\u{308}", "\u{1100}"]),
+ ("\u{1F1E6}\u{1160}", &["\u{1F1E6}", "\u{1160}"]),
+ ("\u{1F1E6}\u{308}\u{1160}", &["\u{1F1E6}\u{308}", "\u{1160}"]),
+ ("\u{1F1E6}\u{11A8}", &["\u{1F1E6}", "\u{11A8}"]),
+ ("\u{1F1E6}\u{308}\u{11A8}", &["\u{1F1E6}\u{308}", "\u{11A8}"]),
+ ("\u{1F1E6}\u{AC00}", &["\u{1F1E6}", "\u{AC00}"]),
+ ("\u{1F1E6}\u{308}\u{AC00}", &["\u{1F1E6}\u{308}", "\u{AC00}"]),
+ ("\u{1F1E6}\u{AC01}", &["\u{1F1E6}", "\u{AC01}"]),
+ ("\u{1F1E6}\u{308}\u{AC01}", &["\u{1F1E6}\u{308}", "\u{AC01}"]),
+ ("\u{1F1E6}\u{1F1E6}", &["\u{1F1E6}\u{1F1E6}"]),
+ ("\u{1F1E6}\u{308}\u{1F1E6}", &["\u{1F1E6}\u{308}", "\u{1F1E6}"]),
+ ("\u{1F1E6}\u{378}", &["\u{1F1E6}", "\u{378}"]),
+ ("\u{1F1E6}\u{308}\u{378}", &["\u{1F1E6}\u{308}", "\u{378}"]),
+ ("\u{378}\u{20}", &["\u{378}", "\u{20}"]),
+ ("\u{378}\u{308}\u{20}", &["\u{378}\u{308}", "\u{20}"]),
+ ("\u{378}\u{D}", &["\u{378}", "\u{D}"]),
+ ("\u{378}\u{308}\u{D}", &["\u{378}\u{308}", "\u{D}"]),
+ ("\u{378}\u{A}", &["\u{378}", "\u{A}"]),
+ ("\u{378}\u{308}\u{A}", &["\u{378}\u{308}", "\u{A}"]),
+ ("\u{378}\u{1}", &["\u{378}", "\u{1}"]),
+ ("\u{378}\u{308}\u{1}", &["\u{378}\u{308}", "\u{1}"]),
+ ("\u{378}\u{300}", &["\u{378}\u{300}"]),
+ ("\u{378}\u{308}\u{300}", &["\u{378}\u{308}\u{300}"]),
+ ("\u{378}\u{1100}", &["\u{378}", "\u{1100}"]),
+ ("\u{378}\u{308}\u{1100}", &["\u{378}\u{308}", "\u{1100}"]),
+ ("\u{378}\u{1160}", &["\u{378}", "\u{1160}"]),
+ ("\u{378}\u{308}\u{1160}", &["\u{378}\u{308}", "\u{1160}"]),
+ ("\u{378}\u{11A8}", &["\u{378}", "\u{11A8}"]),
+ ("\u{378}\u{308}\u{11A8}", &["\u{378}\u{308}", "\u{11A8}"]),
+ ("\u{378}\u{AC00}", &["\u{378}", "\u{AC00}"]),
+ ("\u{378}\u{308}\u{AC00}", &["\u{378}\u{308}", "\u{AC00}"]),
+ ("\u{378}\u{AC01}", &["\u{378}", "\u{AC01}"]),
+ ("\u{378}\u{308}\u{AC01}", &["\u{378}\u{308}", "\u{AC01}"]),
+ ("\u{378}\u{1F1E6}", &["\u{378}", "\u{1F1E6}"]),
+ ("\u{378}\u{308}\u{1F1E6}", &["\u{378}\u{308}", "\u{1F1E6}"]),
+ ("\u{378}\u{378}", &["\u{378}", "\u{378}"]),
+ ("\u{378}\u{308}\u{378}", &["\u{378}\u{308}", "\u{378}"]),
+ ("\u{61}\u{1F1E6}\u{62}", &["\u{61}", "\u{1F1E6}", "\u{62}"]),
+ ("\u{1F1F7}\u{1F1FA}", &["\u{1F1F7}\u{1F1FA}"]),
+ ("\u{1F1F7}\u{1F1FA}\u{1F1F8}", &["\u{1F1F7}\u{1F1FA}\u{1F1F8}"]),
+ ("\u{1F1F7}\u{1F1FA}\u{1F1F8}\u{1F1EA}",
+ &["\u{1F1F7}\u{1F1FA}\u{1F1F8}\u{1F1EA}"]),
+ ("\u{1F1F7}\u{1F1FA}\u{200B}\u{1F1F8}\u{1F1EA}",
+ &["\u{1F1F7}\u{1F1FA}", "\u{200B}", "\u{1F1F8}\u{1F1EA}"]),
+ ("\u{1F1E6}\u{1F1E7}\u{1F1E8}", &["\u{1F1E6}\u{1F1E7}\u{1F1E8}"]),
+ ("\u{1F1E6}\u{200D}\u{1F1E7}\u{1F1E8}", &["\u{1F1E6}\u{200D}",
+ "\u{1F1E7}\u{1F1E8}"]),
+ ("\u{1F1E6}\u{1F1E7}\u{200D}\u{1F1E8}",
+ &["\u{1F1E6}\u{1F1E7}\u{200D}", "\u{1F1E8}"]),
+ ("\u{20}\u{200D}\u{646}", &["\u{20}\u{200D}", "\u{646}"]),
+ ("\u{646}\u{200D}\u{20}", &["\u{646}\u{200D}", "\u{20}"]),
+ ];
+
+ let test_diff: [(_, &[_], &[_]); 23] = [
+ ("\u{20}\u{903}", &["\u{20}\u{903}"], &["\u{20}", "\u{903}"]), ("\u{20}\u{308}\u{903}",
+ &["\u{20}\u{308}\u{903}"], &["\u{20}\u{308}", "\u{903}"]), ("\u{D}\u{308}\u{903}",
+ &["\u{D}", "\u{308}\u{903}"], &["\u{D}", "\u{308}", "\u{903}"]), ("\u{A}\u{308}\u{903}",
+ &["\u{A}", "\u{308}\u{903}"], &["\u{A}", "\u{308}", "\u{903}"]), ("\u{1}\u{308}\u{903}",
+ &["\u{1}", "\u{308}\u{903}"], &["\u{1}", "\u{308}", "\u{903}"]), ("\u{300}\u{903}",
+ &["\u{300}\u{903}"], &["\u{300}", "\u{903}"]), ("\u{300}\u{308}\u{903}",
+ &["\u{300}\u{308}\u{903}"], &["\u{300}\u{308}", "\u{903}"]), ("\u{903}\u{903}",
+ &["\u{903}\u{903}"], &["\u{903}", "\u{903}"]), ("\u{903}\u{308}\u{903}",
+ &["\u{903}\u{308}\u{903}"], &["\u{903}\u{308}", "\u{903}"]), ("\u{1100}\u{903}",
+ &["\u{1100}\u{903}"], &["\u{1100}", "\u{903}"]), ("\u{1100}\u{308}\u{903}",
+ &["\u{1100}\u{308}\u{903}"], &["\u{1100}\u{308}", "\u{903}"]), ("\u{1160}\u{903}",
+ &["\u{1160}\u{903}"], &["\u{1160}", "\u{903}"]), ("\u{1160}\u{308}\u{903}",
+ &["\u{1160}\u{308}\u{903}"], &["\u{1160}\u{308}", "\u{903}"]), ("\u{11A8}\u{903}",
+ &["\u{11A8}\u{903}"], &["\u{11A8}", "\u{903}"]), ("\u{11A8}\u{308}\u{903}",
+ &["\u{11A8}\u{308}\u{903}"], &["\u{11A8}\u{308}", "\u{903}"]), ("\u{AC00}\u{903}",
+ &["\u{AC00}\u{903}"], &["\u{AC00}", "\u{903}"]), ("\u{AC00}\u{308}\u{903}",
+ &["\u{AC00}\u{308}\u{903}"], &["\u{AC00}\u{308}", "\u{903}"]), ("\u{AC01}\u{903}",
+ &["\u{AC01}\u{903}"], &["\u{AC01}", "\u{903}"]), ("\u{AC01}\u{308}\u{903}",
+ &["\u{AC01}\u{308}\u{903}"], &["\u{AC01}\u{308}", "\u{903}"]), ("\u{1F1E6}\u{903}",
+ &["\u{1F1E6}\u{903}"], &["\u{1F1E6}", "\u{903}"]), ("\u{1F1E6}\u{308}\u{903}",
+ &["\u{1F1E6}\u{308}\u{903}"], &["\u{1F1E6}\u{308}", "\u{903}"]), ("\u{378}\u{903}",
+ &["\u{378}\u{903}"], &["\u{378}", "\u{903}"]), ("\u{378}\u{308}\u{903}",
+ &["\u{378}\u{308}\u{903}"], &["\u{378}\u{308}", "\u{903}"]),
+ ];
+
+ for &(s, g) in &test_same[..] {
+ // test forward iterator
+ assert!(order::equals(s.graphemes(true), g.iter().cloned()));
+ assert!(order::equals(s.graphemes(false), g.iter().cloned()));
+
+ // test reverse iterator
+ assert!(order::equals(s.graphemes(true).rev(), g.iter().rev().cloned()));
+ assert!(order::equals(s.graphemes(false).rev(), g.iter().rev().cloned()));
+ }
+
+ for &(s, gt, gf) in &test_diff {
+ // test forward iterator
+ assert!(order::equals(s.graphemes(true), gt.iter().cloned()));
+ assert!(order::equals(s.graphemes(false), gf.iter().cloned()));
+
+ // test reverse iterator
+ assert!(order::equals(s.graphemes(true).rev(), gt.iter().rev().cloned()));
+ assert!(order::equals(s.graphemes(false).rev(), gf.iter().rev().cloned()));
+ }
+
+ // test the indices iterators
+ let s = "a̐éö̲\r\n";
+ let gr_inds = s.grapheme_indices(true).collect::<Vec<(usize, &str)>>();
+ let b: &[_] = &[(0, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")];
+ assert_eq!(gr_inds, b);
+ let gr_inds = s.grapheme_indices(true).rev().collect::<Vec<(usize, &str)>>();
+ let b: &[_] = &[(11, "\r\n"), (6, "ö̲"), (3, "é"), (0, "a̐")];
+ assert_eq!(gr_inds, b);
+ let mut gr_inds_iter = s.grapheme_indices(true);
+ {
+ let gr_inds = gr_inds_iter.by_ref();
+ let e1 = gr_inds.size_hint();
+ assert_eq!(e1, (1, Some(13)));
+ let c = gr_inds.count();
+ assert_eq!(c, 4);
+ }
+ let e2 = gr_inds_iter.size_hint();
+ assert_eq!(e2, (0, Some(0)));
+
+ // make sure the reverse iterator does the right thing with "\n" at beginning of string
+ let s = "\n\r\n\r";
+ let gr = s.graphemes(true).rev().collect::<Vec<&str>>();
+ let b: &[_] = &["\r", "\r\n", "\n"];
+ assert_eq!(gr, b);
+}
+
+#[test]
+fn test_split_strator() {
+ fn t(s: &str, sep: &str, u: &[&str]) {
+ let v: Vec<&str> = s.split_str(sep).collect();
+ assert_eq!(v, u);
+ }
+ t("--1233345--", "12345", &["--1233345--"]);
+ t("abc::hello::there", "::", &["abc", "hello", "there"]);
+ t("::hello::there", "::", &["", "hello", "there"]);
+ t("hello::there::", "::", &["hello", "there", ""]);
+ t("::hello::there::", "::", &["", "hello", "there", ""]);
+ t("ประเทศไทย中华Việt Nam", "中华", &["ประเทศไทย", "Việt Nam"]);
+ t("zzXXXzzYYYzz", "zz", &["", "XXX", "YYY", ""]);
+ t("zzXXXzYYYz", "XXX", &["zz", "zYYYz"]);
+ t(".XXX.YYY.", ".", &["", "XXX", "YYY", ""]);
+ t("", ".", &[""]);
+ t("zz", "zz", &["",""]);
+ t("ok", "z", &["ok"]);
+ t("zzz", "zz", &["","z"]);
+ t("zzzzz", "zz", &["","","z"]);
+}
+
+#[test]
+fn test_str_default() {
+ use std::default::Default;
+
+ fn t<S: Default + Str>() {
+ let s: S = Default::default();
+ assert_eq!(s.as_slice(), "");
+ }
+
+ t::<&str>();
+ t::<String>();
+}
+
+#[test]
+fn test_str_container() {
+ fn sum_len(v: &[&str]) -> usize {
+ v.iter().map(|x| x.len()).sum()
+ }
+
+ let s = String::from_str("01234");
+ assert_eq!(5, sum_len(&["012", "", "34"]));
+ assert_eq!(5, sum_len(&[&String::from_str("01"),
+ &String::from_str("2"),
+ &String::from_str("34"),
+ &String::from_str("")]));
+ assert_eq!(5, sum_len(&[&s]));
+}
+
+#[test]
+fn test_str_from_utf8() {
+ let xs = b"hello";
+ assert_eq!(from_utf8(xs), Ok("hello"));
+
+ let xs = "ศไทย中华Việt Nam".as_bytes();
+ assert_eq!(from_utf8(xs), Ok("ศไทย中华Việt Nam"));
+
+ let xs = b"hello\xFF";
+ assert_eq!(from_utf8(xs), Err(Utf8Error::TooShort));
+}
+
+mod bench {
+ use test::{Bencher, black_box};
+
+ #[bench]
+ fn char_iterator(b: &mut Bencher) {
+ let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
+
+ b.iter(|| s.chars().count());
+ }
+
+ #[bench]
+ fn char_iterator_for(b: &mut Bencher) {
+ let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
+
+ b.iter(|| {
+ for ch in s.chars() { black_box(ch); }
+ });
+ }
+
+ #[bench]
+ fn char_iterator_ascii(b: &mut Bencher) {
+ let s = "Mary had a little lamb, Little lamb
+ Mary had a little lamb, Little lamb
+ Mary had a little lamb, Little lamb
+ Mary had a little lamb, Little lamb
+ Mary had a little lamb, Little lamb
+ Mary had a little lamb, Little lamb";
+
+ b.iter(|| s.chars().count());
+ }
+
+ #[bench]
+ fn char_iterator_rev(b: &mut Bencher) {
+ let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
+
+ b.iter(|| s.chars().rev().count());
+ }
+
+ #[bench]
+ fn char_iterator_rev_for(b: &mut Bencher) {
+ let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
+
+ b.iter(|| {
+ for ch in s.chars().rev() { black_box(ch); }
+ });
+ }
+
+ #[bench]
+ fn char_indicesator(b: &mut Bencher) {
+ let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
+ let len = s.chars().count();
+
+ b.iter(|| assert_eq!(s.char_indices().count(), len));
+ }
+
+ #[bench]
+ fn char_indicesator_rev(b: &mut Bencher) {
+ let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
+ let len = s.chars().count();
+
+ b.iter(|| assert_eq!(s.char_indices().rev().count(), len));
+ }
+
+ #[bench]
+ fn split_unicode_ascii(b: &mut Bencher) {
+ let s = "ประเทศไทย中华Việt Namประเทศไทย中华Việt Nam";
+
+ b.iter(|| assert_eq!(s.split('V').count(), 3));
+ }
+
+ #[bench]
+ fn split_ascii(b: &mut Bencher) {
+ let s = "Mary had a little lamb, Little lamb, little-lamb.";
+ let len = s.split(' ').count();
+
+ b.iter(|| assert_eq!(s.split(' ').count(), len));
+ }
+
+ #[bench]
+ fn split_extern_fn(b: &mut Bencher) {
+ let s = "Mary had a little lamb, Little lamb, little-lamb.";
+ let len = s.split(' ').count();
+ fn pred(c: char) -> bool { c == ' ' }
+
+ b.iter(|| assert_eq!(s.split(pred).count(), len));
+ }
+
+ #[bench]
+ fn split_closure(b: &mut Bencher) {
+ let s = "Mary had a little lamb, Little lamb, little-lamb.";
+ let len = s.split(' ').count();
+
+ b.iter(|| assert_eq!(s.split(|c: char| c == ' ').count(), len));
+ }
+
+ #[bench]
+ fn split_slice(b: &mut Bencher) {
+ let s = "Mary had a little lamb, Little lamb, little-lamb.";
+ let len = s.split(' ').count();
+
+ let c: &[char] = &[' '];
+ b.iter(|| assert_eq!(s.split(c).count(), len));
+ }
+
+ #[bench]
+ fn bench_connect(b: &mut Bencher) {
+ let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
+ let sep = "→";
+ let v = vec![s, s, s, s, s, s, s, s, s, s];
+ b.iter(|| {
+ assert_eq!(v.connect(sep).len(), s.len() * 10 + sep.len() * 9);
+ })
+ }
+
+ #[bench]
+ fn bench_contains_short_short(b: &mut Bencher) {
+ let haystack = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
+ let needle = "sit";
+
+ b.iter(|| {
+ assert!(haystack.contains(needle));
+ })
+ }
+
+ #[bench]
+ fn bench_contains_short_long(b: &mut Bencher) {
+ let haystack = "\
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse quis lorem sit amet dolor \
+ultricies condimentum. Praesent iaculis purus elit, ac malesuada quam malesuada in. Duis sed orci \
+eros. Suspendisse sit amet magna mollis, mollis nunc luctus, imperdiet mi. Integer fringilla non \
+sem ut lacinia. Fusce varius tortor a risus porttitor hendrerit. Morbi mauris dui, ultricies nec \
+tempus vel, gravida nec quam.
+
+In est dui, tincidunt sed tempus interdum, adipiscing laoreet ante. Etiam tempor, tellus quis \
+sagittis interdum, nulla purus mattis sem, quis auctor erat odio ac tellus. In nec nunc sit amet \
+diam volutpat molestie at sed ipsum. Vestibulum laoreet consequat vulputate. Integer accumsan \
+lorem ac dignissim placerat. Suspendisse convallis faucibus lorem. Aliquam erat volutpat. In vel \
+eleifend felis. Sed suscipit nulla lorem, sed mollis est sollicitudin et. Nam fermentum egestas \
+interdum. Curabitur ut nisi justo.
+
+Sed sollicitudin ipsum tellus, ut condimentum leo eleifend nec. Cras ut velit ante. Phasellus nec \
+mollis odio. Mauris molestie erat in arcu mattis, at aliquet dolor vehicula. Quisque malesuada \
+lectus sit amet nisi pretium, a condimentum ipsum porta. Morbi at dapibus diam. Praesent egestas \
+est sed risus elementum, eu rutrum metus ultrices. Etiam fermentum consectetur magna, id rutrum \
+felis accumsan a. Aliquam ut pellentesque libero. Sed mi nulla, lobortis eu tortor id, suscipit \
+ultricies neque. Morbi iaculis sit amet risus at iaculis. Praesent eget ligula quis turpis \
+feugiat suscipit vel non arcu. Interdum et malesuada fames ac ante ipsum primis in faucibus. \
+Aliquam sit amet placerat lorem.
+
+Cras a lacus vel ante posuere elementum. Nunc est leo, bibendum ut facilisis vel, bibendum at \
+mauris. Nullam adipiscing diam vel odio ornare, luctus adipiscing mi luctus. Nulla facilisi. \
+Mauris adipiscing bibendum neque, quis adipiscing lectus tempus et. Sed feugiat erat et nisl \
+lobortis pharetra. Donec vitae erat enim. Nullam sit amet felis et quam lacinia tincidunt. Aliquam \
+suscipit dapibus urna. Sed volutpat urna in magna pulvinar volutpat. Phasellus nec tellus ac diam \
+cursus accumsan.
+
+Nam lectus enim, dapibus non nisi tempor, consectetur convallis massa. Maecenas eleifend dictum \
+feugiat. Etiam quis mauris vel risus luctus mattis a a nunc. Nullam orci quam, imperdiet id \
+vehicula in, porttitor ut nibh. Duis sagittis adipiscing nisl vitae congue. Donec mollis risus eu \
+leo suscipit, varius porttitor nulla porta. Pellentesque ut sem nec nisi euismod vehicula. Nulla \
+malesuada sollicitudin quam eu fermentum.";
+ let needle = "english";
+
+ b.iter(|| {
+ assert!(!haystack.contains(needle));
+ })
+ }
+
+ #[bench]
+ fn bench_contains_bad_naive(b: &mut Bencher) {
+ let haystack = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+ let needle = "aaaaaaaab";
+
+ b.iter(|| {
+ assert!(!haystack.contains(needle));
+ })
+ }
+
+ #[bench]
+ fn bench_contains_equal(b: &mut Bencher) {
+ let haystack = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
+ let needle = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
+
+ b.iter(|| {
+ assert!(haystack.contains(needle));
+ })
+ }
+}
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::borrow::IntoCow;
+use std::iter::repeat;
+use std::str::Utf8Error;
+use std::string::{CowString, as_string};
+
+use test::Bencher;
+
+#[test]
+fn test_as_string() {
+ let x = "foo";
+ assert_eq!(x, &**as_string(x));
+}
+
+#[test]
+fn test_from_str() {
+ let owned: Option<::std::string::String> = "string".parse().ok();
+ assert_eq!(owned.as_ref().map(|s| &**s), Some("string"));
+}
+
+#[test]
+fn test_unsized_to_string() {
+ let s: &str = "abc";
+ let _: String = (*s).to_string();
+}
+
+#[test]
+fn test_from_utf8() {
+ let xs = b"hello".to_vec();
+ assert_eq!(String::from_utf8(xs).unwrap(),
+ String::from_str("hello"));
+
+ let xs = "ศไทย中华Việt Nam".as_bytes().to_vec();
+ assert_eq!(String::from_utf8(xs).unwrap(),
+ String::from_str("ศไทย中华Việt Nam"));
+
+ let xs = b"hello\xFF".to_vec();
+ let err = String::from_utf8(xs).err().unwrap();
+ assert_eq!(err.utf8_error(), Utf8Error::TooShort);
+ assert_eq!(err.into_bytes(), b"hello\xff".to_vec());
+}
+
+#[test]
+fn test_from_utf8_lossy() {
+ let xs = b"hello";
+ let ys: CowString = "hello".into_cow();
+ assert_eq!(String::from_utf8_lossy(xs), ys);
+
+ let xs = "ศไทย中华Việt Nam".as_bytes();
+ let ys: CowString = "ศไทย中华Việt Nam".into_cow();
+ assert_eq!(String::from_utf8_lossy(xs), ys);
+
+ let xs = b"Hello\xC2 There\xFF Goodbye";
+ assert_eq!(String::from_utf8_lossy(xs),
+ String::from_str("Hello\u{FFFD} There\u{FFFD} Goodbye").into_cow());
+
+ let xs = b"Hello\xC0\x80 There\xE6\x83 Goodbye";
+ assert_eq!(String::from_utf8_lossy(xs),
+ String::from_str("Hello\u{FFFD}\u{FFFD} There\u{FFFD} Goodbye").into_cow());
+
+ let xs = b"\xF5foo\xF5\x80bar";
+ assert_eq!(String::from_utf8_lossy(xs),
+ String::from_str("\u{FFFD}foo\u{FFFD}\u{FFFD}bar").into_cow());
+
+ let xs = b"\xF1foo\xF1\x80bar\xF1\x80\x80baz";
+ assert_eq!(String::from_utf8_lossy(xs),
+ String::from_str("\u{FFFD}foo\u{FFFD}bar\u{FFFD}baz").into_cow());
+
+ let xs = b"\xF4foo\xF4\x80bar\xF4\xBFbaz";
+ assert_eq!(String::from_utf8_lossy(xs),
+ String::from_str("\u{FFFD}foo\u{FFFD}bar\u{FFFD}\u{FFFD}baz").into_cow());
+
+ let xs = b"\xF0\x80\x80\x80foo\xF0\x90\x80\x80bar";
+ assert_eq!(String::from_utf8_lossy(xs), String::from_str("\u{FFFD}\u{FFFD}\u{FFFD}\u{FFFD}\
+ foo\u{10000}bar").into_cow());
+
+ // surrogates
+ let xs = b"\xED\xA0\x80foo\xED\xBF\xBFbar";
+ assert_eq!(String::from_utf8_lossy(xs), String::from_str("\u{FFFD}\u{FFFD}\u{FFFD}foo\
+ \u{FFFD}\u{FFFD}\u{FFFD}bar").into_cow());
+}
+
+#[test]
+fn test_from_utf16() {
+ let pairs =
+ [(String::from_str("𐍅𐌿𐌻𐍆𐌹𐌻𐌰\n"),
+ vec![0xd800, 0xdf45, 0xd800, 0xdf3f,
+ 0xd800, 0xdf3b, 0xd800, 0xdf46,
+ 0xd800, 0xdf39, 0xd800, 0xdf3b,
+ 0xd800, 0xdf30, 0x000a]),
+
+ (String::from_str("𐐒𐑉𐐮𐑀𐐲𐑋 𐐏𐐲𐑍\n"),
+ vec![0xd801, 0xdc12, 0xd801,
+ 0xdc49, 0xd801, 0xdc2e, 0xd801,
+ 0xdc40, 0xd801, 0xdc32, 0xd801,
+ 0xdc4b, 0x0020, 0xd801, 0xdc0f,
+ 0xd801, 0xdc32, 0xd801, 0xdc4d,
+ 0x000a]),
+
+ (String::from_str("𐌀𐌖𐌋𐌄𐌑𐌉·𐌌𐌄𐌕𐌄𐌋𐌉𐌑\n"),
+ vec![0xd800, 0xdf00, 0xd800, 0xdf16,
+ 0xd800, 0xdf0b, 0xd800, 0xdf04,
+ 0xd800, 0xdf11, 0xd800, 0xdf09,
+ 0x00b7, 0xd800, 0xdf0c, 0xd800,
+ 0xdf04, 0xd800, 0xdf15, 0xd800,
+ 0xdf04, 0xd800, 0xdf0b, 0xd800,
+ 0xdf09, 0xd800, 0xdf11, 0x000a ]),
+
+ (String::from_str("𐒋𐒘𐒈𐒑𐒛𐒒 𐒕𐒓 𐒈𐒚𐒍 𐒏𐒜𐒒𐒖𐒆 𐒕𐒆\n"),
+ vec![0xd801, 0xdc8b, 0xd801, 0xdc98,
+ 0xd801, 0xdc88, 0xd801, 0xdc91,
+ 0xd801, 0xdc9b, 0xd801, 0xdc92,
+ 0x0020, 0xd801, 0xdc95, 0xd801,
+ 0xdc93, 0x0020, 0xd801, 0xdc88,
+ 0xd801, 0xdc9a, 0xd801, 0xdc8d,
+ 0x0020, 0xd801, 0xdc8f, 0xd801,
+ 0xdc9c, 0xd801, 0xdc92, 0xd801,
+ 0xdc96, 0xd801, 0xdc86, 0x0020,
+ 0xd801, 0xdc95, 0xd801, 0xdc86,
+ 0x000a ]),
+ // Issue #12318, even-numbered non-BMP planes
+ (String::from_str("\u{20000}"),
+ vec![0xD840, 0xDC00])];
+
+ for p in &pairs {
+ let (s, u) = (*p).clone();
+ let s_as_utf16 = s.utf16_units().collect::<Vec<u16>>();
+ let u_as_string = String::from_utf16(&u).unwrap();
+
+ assert!(::unicode::str::is_utf16(&u));
+ assert_eq!(s_as_utf16, u);
+
+ assert_eq!(u_as_string, s);
+ assert_eq!(String::from_utf16_lossy(&u), s);
+
+ assert_eq!(String::from_utf16(&s_as_utf16).unwrap(), s);
+ assert_eq!(u_as_string.utf16_units().collect::<Vec<u16>>(), u);
+ }
+}
+
+#[test]
+fn test_utf16_invalid() {
+ // completely positive cases tested above.
+ // lead + eof
+ assert!(String::from_utf16(&[0xD800]).is_err());
+ // lead + lead
+ assert!(String::from_utf16(&[0xD800, 0xD800]).is_err());
+
+ // isolated trail
+ assert!(String::from_utf16(&[0x0061, 0xDC00]).is_err());
+
+ // general
+ assert!(String::from_utf16(&[0xD800, 0xd801, 0xdc8b, 0xD800]).is_err());
+}
+
+#[test]
+fn test_from_utf16_lossy() {
+ // completely positive cases tested above.
+ // lead + eof
+ assert_eq!(String::from_utf16_lossy(&[0xD800]), String::from_str("\u{FFFD}"));
+ // lead + lead
+ assert_eq!(String::from_utf16_lossy(&[0xD800, 0xD800]),
+ String::from_str("\u{FFFD}\u{FFFD}"));
+
+ // isolated trail
+ assert_eq!(String::from_utf16_lossy(&[0x0061, 0xDC00]), String::from_str("a\u{FFFD}"));
+
+ // general
+ assert_eq!(String::from_utf16_lossy(&[0xD800, 0xd801, 0xdc8b, 0xD800]),
+ String::from_str("\u{FFFD}𐒋\u{FFFD}"));
+}
+
+#[test]
+fn test_push_bytes() {
+ let mut s = String::from_str("ABC");
+ unsafe {
+ let mv = s.as_mut_vec();
+ mv.push_all(&[b'D']);
+ }
+ assert_eq!(s, "ABCD");
+}
+
+#[test]
+fn test_push_str() {
+ let mut s = String::new();
+ s.push_str("");
+ assert_eq!(&s[0..], "");
+ s.push_str("abc");
+ assert_eq!(&s[0..], "abc");
+ s.push_str("ประเทศไทย中华Việt Nam");
+ assert_eq!(&s[0..], "abcประเทศไทย中华Việt Nam");
+}
+
+#[test]
+fn test_push() {
+ let mut data = String::from_str("ประเทศไทย中");
+ data.push('华');
+ data.push('b'); // 1 byte
+ data.push('¢'); // 2 byte
+ data.push('€'); // 3 byte
+ data.push('𤭢'); // 4 byte
+ assert_eq!(data, "ประเทศไทย中华b¢€𤭢");
+}
+
+#[test]
+fn test_pop() {
+ let mut data = String::from_str("ประเทศไทย中华b¢€𤭢");
+ assert_eq!(data.pop().unwrap(), '𤭢'); // 4 bytes
+ assert_eq!(data.pop().unwrap(), '€'); // 3 bytes
+ assert_eq!(data.pop().unwrap(), '¢'); // 2 bytes
+ assert_eq!(data.pop().unwrap(), 'b'); // 1 bytes
+ assert_eq!(data.pop().unwrap(), '华');
+ assert_eq!(data, "ประเทศไทย中");
+}
+
+#[test]
+fn test_str_truncate() {
+ let mut s = String::from_str("12345");
+ s.truncate(5);
+ assert_eq!(s, "12345");
+ s.truncate(3);
+ assert_eq!(s, "123");
+ s.truncate(0);
+ assert_eq!(s, "");
+
+ let mut s = String::from_str("12345");
+ let p = s.as_ptr();
+ s.truncate(3);
+ s.push_str("6");
+ let p_ = s.as_ptr();
+ assert_eq!(p_, p);
+}
+
+#[test]
+#[should_panic]
+fn test_str_truncate_invalid_len() {
+ let mut s = String::from_str("12345");
+ s.truncate(6);
+}
+
+#[test]
+#[should_panic]
+fn test_str_truncate_split_codepoint() {
+ let mut s = String::from_str("\u{FC}"); // ü
+ s.truncate(1);
+}
+
+#[test]
+fn test_str_clear() {
+ let mut s = String::from_str("12345");
+ s.clear();
+ assert_eq!(s.len(), 0);
+ assert_eq!(s, "");
+}
+
+#[test]
+fn test_str_add() {
+ let a = String::from_str("12345");
+ let b = a + "2";
+ let b = b + "2";
+ assert_eq!(b.len(), 7);
+ assert_eq!(b, "1234522");
+}
+
+#[test]
+fn remove() {
+ let mut s = "ศไทย中华Việt Nam; foobar".to_string();;
+ assert_eq!(s.remove(0), 'ศ');
+ assert_eq!(s.len(), 33);
+ assert_eq!(s, "ไทย中华Việt Nam; foobar");
+ assert_eq!(s.remove(17), 'ệ');
+ assert_eq!(s, "ไทย中华Vit Nam; foobar");
+}
+
+#[test] #[should_panic]
+fn remove_bad() {
+ "ศ".to_string().remove(1);
+}
+
+#[test]
+fn insert() {
+ let mut s = "foobar".to_string();
+ s.insert(0, 'ệ');
+ assert_eq!(s, "ệfoobar");
+ s.insert(6, 'ย');
+ assert_eq!(s, "ệfooยbar");
+}
+
+#[test] #[should_panic] fn insert_bad1() { "".to_string().insert(1, 't'); }
+#[test] #[should_panic] fn insert_bad2() { "ệ".to_string().insert(1, 't'); }
+
+#[test]
+fn test_slicing() {
+ let s = "foobar".to_string();
+ assert_eq!("foobar", &s[..]);
+ assert_eq!("foo", &s[..3]);
+ assert_eq!("bar", &s[3..]);
+ assert_eq!("oob", &s[1..4]);
+}
+
+#[test]
+fn test_simple_types() {
+ assert_eq!(1.to_string(), "1");
+ assert_eq!((-1).to_string(), "-1");
+ assert_eq!(200.to_string(), "200");
+ assert_eq!(2.to_string(), "2");
+ assert_eq!(true.to_string(), "true");
+ assert_eq!(false.to_string(), "false");
+ assert_eq!(("hi".to_string()).to_string(), "hi");
+}
+
+#[test]
+fn test_vectors() {
+ let x: Vec<i32> = vec![];
+ assert_eq!(format!("{:?}", x), "[]");
+ assert_eq!(format!("{:?}", vec![1]), "[1]");
+ assert_eq!(format!("{:?}", vec![1, 2, 3]), "[1, 2, 3]");
+ assert!(format!("{:?}", vec![vec![], vec![1], vec![1, 1]]) ==
+ "[[], [1], [1, 1]]");
+}
+
+#[test]
+fn test_from_iterator() {
+ let s = "ศไทย中华Việt Nam".to_string();
+ let t = "ศไทย中华";
+ let u = "Việt Nam";
+
+ let a: String = s.chars().collect();
+ assert_eq!(s, a);
+
+ let mut b = t.to_string();
+ b.extend(u.chars());
+ assert_eq!(s, b);
+
+ let c: String = vec![t, u].into_iter().collect();
+ assert_eq!(s, c);
+
+ let mut d = t.to_string();
+ d.extend(vec![u].into_iter());
+ assert_eq!(s, d);
+}
+
+#[bench]
+fn bench_with_capacity(b: &mut Bencher) {
+ b.iter(|| {
+ String::with_capacity(100)
+ });
+}
+
+#[bench]
+fn bench_push_str(b: &mut Bencher) {
+ let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
+ b.iter(|| {
+ let mut r = String::new();
+ r.push_str(s);
+ });
+}
+
+const REPETITIONS: u64 = 10_000;
+
+#[bench]
+fn bench_push_str_one_byte(b: &mut Bencher) {
+ b.bytes = REPETITIONS;
+ b.iter(|| {
+ let mut r = String::new();
+ for _ in 0..REPETITIONS {
+ r.push_str("a")
+ }
+ });
+}
+
+#[bench]
+fn bench_push_char_one_byte(b: &mut Bencher) {
+ b.bytes = REPETITIONS;
+ b.iter(|| {
+ let mut r = String::new();
+ for _ in 0..REPETITIONS {
+ r.push('a')
+ }
+ });
+}
+
+#[bench]
+fn bench_push_char_two_bytes(b: &mut Bencher) {
+ b.bytes = REPETITIONS * 2;
+ b.iter(|| {
+ let mut r = String::new();
+ for _ in 0..REPETITIONS {
+ r.push('â')
+ }
+ });
+}
+
+#[bench]
+fn from_utf8_lossy_100_ascii(b: &mut Bencher) {
+ let s = b"Hello there, the quick brown fox jumped over the lazy dog! \
+ Lorem ipsum dolor sit amet, consectetur. ";
+
+ assert_eq!(100, s.len());
+ b.iter(|| {
+ let _ = String::from_utf8_lossy(s);
+ });
+}
+
+#[bench]
+fn from_utf8_lossy_100_multibyte(b: &mut Bencher) {
+ let s = "𐌀𐌖𐌋𐌄𐌑𐌉ปรدولة الكويتทศไทย中华𐍅𐌿𐌻𐍆𐌹𐌻𐌰".as_bytes();
+ assert_eq!(100, s.len());
+ b.iter(|| {
+ let _ = String::from_utf8_lossy(s);
+ });
+}
+
+#[bench]
+fn from_utf8_lossy_invalid(b: &mut Bencher) {
+ let s = b"Hello\xC0\x80 There\xE6\x83 Goodbye";
+ b.iter(|| {
+ let _ = String::from_utf8_lossy(s);
+ });
+}
+
+#[bench]
+fn from_utf8_lossy_100_invalid(b: &mut Bencher) {
+ let s = repeat(0xf5).take(100).collect::<Vec<_>>();
+ b.iter(|| {
+ let _ = String::from_utf8_lossy(&s);
+ });
+}
+
+#[bench]
+fn bench_exact_size_shrink_to_fit(b: &mut Bencher) {
+ let s = "Hello there, the quick brown fox jumped over the lazy dog! \
+ Lorem ipsum dolor sit amet, consectetur. ";
+ // ensure our operation produces an exact-size string before we benchmark it
+ let mut r = String::with_capacity(s.len());
+ r.push_str(s);
+ assert_eq!(r.len(), r.capacity());
+ b.iter(|| {
+ let mut r = String::with_capacity(s.len());
+ r.push_str(s);
+ r.shrink_to_fit();
+ r
+ });
+}
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::iter::{FromIterator, repeat};
+use std::mem::size_of;
+use std::vec::as_vec;
+
+use test::Bencher;
+
+struct DropCounter<'a> {
+ count: &'a mut u32
+}
+
+#[unsafe_destructor]
+impl<'a> Drop for DropCounter<'a> {
+ fn drop(&mut self) {
+ *self.count += 1;
+ }
+}
+
+#[test]
+fn test_as_vec() {
+ let xs = [1u8, 2u8, 3u8];
+ assert_eq!(&**as_vec(&xs), xs);
+}
+
+#[test]
+fn test_as_vec_dtor() {
+ let (mut count_x, mut count_y) = (0, 0);
+ {
+ let xs = &[DropCounter { count: &mut count_x }, DropCounter { count: &mut count_y }];
+ assert_eq!(as_vec(xs).len(), 2);
+ }
+ assert_eq!(count_x, 1);
+ assert_eq!(count_y, 1);
+}
+
+#[test]
+fn test_small_vec_struct() {
+ assert!(size_of::<Vec<u8>>() == size_of::<usize>() * 3);
+}
+
+#[test]
+fn test_double_drop() {
+ struct TwoVec<T> {
+ x: Vec<T>,
+ y: Vec<T>
+ }
+
+ let (mut count_x, mut count_y) = (0, 0);
+ {
+ let mut tv = TwoVec {
+ x: Vec::new(),
+ y: Vec::new()
+ };
+ tv.x.push(DropCounter {count: &mut count_x});
+ tv.y.push(DropCounter {count: &mut count_y});
+
+ // If Vec had a drop flag, here is where it would be zeroed.
+ // Instead, it should rely on its internal state to prevent
+ // doing anything significant when dropped multiple times.
+ drop(tv.x);
+
+ // Here tv goes out of scope, tv.y should be dropped, but not tv.x.
+ }
+
+ assert_eq!(count_x, 1);
+ assert_eq!(count_y, 1);
+}
+
+#[test]
+fn test_reserve() {
+ let mut v = Vec::new();
+ assert_eq!(v.capacity(), 0);
+
+ v.reserve(2);
+ assert!(v.capacity() >= 2);
+
+ for i in 0..16 {
+ v.push(i);
+ }
+
+ assert!(v.capacity() >= 16);
+ v.reserve(16);
+ assert!(v.capacity() >= 32);
+
+ v.push(16);
+
+ v.reserve(16);
+ assert!(v.capacity() >= 33)
+}
+
+#[test]
+fn test_extend() {
+ let mut v = Vec::new();
+ let mut w = Vec::new();
+
+ v.extend(0..3);
+ for i in 0..3 { w.push(i) }
+
+ assert_eq!(v, w);
+
+ v.extend(3..10);
+ for i in 3..10 { w.push(i) }
+
+ assert_eq!(v, w);
+}
+
+#[test]
+fn test_slice_from_mut() {
+ let mut values = vec![1, 2, 3, 4, 5];
+ {
+ let slice = &mut values[2 ..];
+ assert!(slice == [3, 4, 5]);
+ for p in slice {
+ *p += 2;
+ }
+ }
+
+ assert!(values == [1, 2, 5, 6, 7]);
+}
+
+#[test]
+fn test_slice_to_mut() {
+ let mut values = vec![1, 2, 3, 4, 5];
+ {
+ let slice = &mut values[.. 2];
+ assert!(slice == [1, 2]);
+ for p in slice {
+ *p += 1;
+ }
+ }
+
+ assert!(values == [2, 3, 3, 4, 5]);
+}
+
+#[test]
+fn test_split_at_mut() {
+ let mut values = vec![1, 2, 3, 4, 5];
+ {
+ let (left, right) = values.split_at_mut(2);
+ {
+ let left: &[_] = left;
+ assert!(&left[..left.len()] == &[1, 2]);
+ }
+ for p in left {
+ *p += 1;
+ }
+
+ {
+ let right: &[_] = right;
+ assert!(&right[..right.len()] == &[3, 4, 5]);
+ }
+ for p in right {
+ *p += 2;
+ }
+ }
+
+ assert_eq!(values, [2, 3, 5, 6, 7]);
+}
+
+#[test]
+fn test_clone() {
+ let v: Vec<i32> = vec![];
+ let w = vec!(1, 2, 3);
+
+ assert_eq!(v, v.clone());
+
+ let z = w.clone();
+ assert_eq!(w, z);
+ // they should be disjoint in memory.
+ assert!(w.as_ptr() != z.as_ptr())
+}
+
+#[test]
+fn test_clone_from() {
+ let mut v = vec!();
+ let three: Vec<Box<_>> = vec!(box 1, box 2, box 3);
+ let two: Vec<Box<_>> = vec!(box 4, box 5);
+ // zero, long
+ v.clone_from(&three);
+ assert_eq!(v, three);
+
+ // equal
+ v.clone_from(&three);
+ assert_eq!(v, three);
+
+ // long, short
+ v.clone_from(&two);
+ assert_eq!(v, two);
+
+ // short, long
+ v.clone_from(&three);
+ assert_eq!(v, three)
+}
+
+#[test]
+fn test_retain() {
+ let mut vec = vec![1, 2, 3, 4];
+ vec.retain(|&x| x % 2 == 0);
+ assert_eq!(vec, [2, 4]);
+}
+
+#[test]
+fn zero_sized_values() {
+ let mut v = Vec::new();
+ assert_eq!(v.len(), 0);
+ v.push(());
+ assert_eq!(v.len(), 1);
+ v.push(());
+ assert_eq!(v.len(), 2);
+ assert_eq!(v.pop(), Some(()));
+ assert_eq!(v.pop(), Some(()));
+ assert_eq!(v.pop(), None);
+
+ assert_eq!(v.iter().count(), 0);
+ v.push(());
+ assert_eq!(v.iter().count(), 1);
+ v.push(());
+ assert_eq!(v.iter().count(), 2);
+
+ for &() in &v {}
+
+ assert_eq!(v.iter_mut().count(), 2);
+ v.push(());
+ assert_eq!(v.iter_mut().count(), 3);
+ v.push(());
+ assert_eq!(v.iter_mut().count(), 4);
+
+ for &mut () in &mut v {}
+ unsafe { v.set_len(0); }
+ assert_eq!(v.iter_mut().count(), 0);
+}
+
+#[test]
+fn test_partition() {
+ assert_eq!(vec![].into_iter().partition(|x: &i32| *x < 3), (vec![], vec![]));
+ assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 4), (vec![1, 2, 3], vec![]));
+ assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 2), (vec![1], vec![2, 3]));
+ assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 0), (vec![], vec![1, 2, 3]));
+}
+
+#[test]
+fn test_zip_unzip() {
+ let z1 = vec![(1, 4), (2, 5), (3, 6)];
+
+ let (left, right): (Vec<_>, Vec<_>) = z1.iter().cloned().unzip();
+
+ assert_eq!((1, 4), (left[0], right[0]));
+ assert_eq!((2, 5), (left[1], right[1]));
+ assert_eq!((3, 6), (left[2], right[2]));
+}
+
+#[test]
+fn test_unsafe_ptrs() {
+ unsafe {
+ // Test on-stack copy-from-buf.
+ let a = [1, 2, 3];
+ let ptr = a.as_ptr();
+ let b = Vec::from_raw_buf(ptr, 3);
+ assert_eq!(b, [1, 2, 3]);
+
+ // Test on-heap copy-from-buf.
+ let c = vec![1, 2, 3, 4, 5];
+ let ptr = c.as_ptr();
+ let d = Vec::from_raw_buf(ptr, 5);
+ assert_eq!(d, [1, 2, 3, 4, 5]);
+ }
+}
+
+#[test]
+fn test_vec_truncate_drop() {
+ static mut drops: u32 = 0;
+ struct Elem(i32);
+ impl Drop for Elem {
+ fn drop(&mut self) {
+ unsafe { drops += 1; }
+ }
+ }
+
+ let mut v = vec![Elem(1), Elem(2), Elem(3), Elem(4), Elem(5)];
+ assert_eq!(unsafe { drops }, 0);
+ v.truncate(3);
+ assert_eq!(unsafe { drops }, 2);
+ v.truncate(0);
+ assert_eq!(unsafe { drops }, 5);
+}
+
+#[test]
+#[should_panic]
+fn test_vec_truncate_fail() {
+ struct BadElem(i32);
+ impl Drop for BadElem {
+ fn drop(&mut self) {
+ let BadElem(ref mut x) = *self;
+ if *x == 0xbadbeef {
+ panic!("BadElem panic: 0xbadbeef")
+ }
+ }
+ }
+
+ let mut v = vec![BadElem(1), BadElem(2), BadElem(0xbadbeef), BadElem(4)];
+ v.truncate(0);
+}
+
+#[test]
+fn test_index() {
+ let vec = vec![1, 2, 3];
+ assert!(vec[1] == 2);
+}
+
+#[test]
+#[should_panic]
+fn test_index_out_of_bounds() {
+ let vec = vec![1, 2, 3];
+ let _ = vec[3];
+}
+
+#[test]
+#[should_panic]
+fn test_slice_out_of_bounds_1() {
+ let x = vec![1, 2, 3, 4, 5];
+ &x[-1..];
+}
+
+#[test]
+#[should_panic]
+fn test_slice_out_of_bounds_2() {
+ let x = vec![1, 2, 3, 4, 5];
+ &x[..6];
+}
+
+#[test]
+#[should_panic]
+fn test_slice_out_of_bounds_3() {
+ let x = vec![1, 2, 3, 4, 5];
+ &x[-1..4];
+}
+
+#[test]
+#[should_panic]
+fn test_slice_out_of_bounds_4() {
+ let x = vec![1, 2, 3, 4, 5];
+ &x[1..6];
+}
+
+#[test]
+#[should_panic]
+fn test_slice_out_of_bounds_5() {
+ let x = vec![1, 2, 3, 4, 5];
+ &x[3..2];
+}
+
+#[test]
+#[should_panic]
+fn test_swap_remove_empty() {
+ let mut vec= Vec::<i32>::new();
+ vec.swap_remove(0);
+}
+
+#[test]
+fn test_move_iter_unwrap() {
+ let mut vec = Vec::with_capacity(7);
+ vec.push(1);
+ vec.push(2);
+ let ptr = vec.as_ptr();
+ vec = vec.into_iter().into_inner();
+ assert_eq!(vec.as_ptr(), ptr);
+ assert_eq!(vec.capacity(), 7);
+ assert_eq!(vec.len(), 0);
+}
+
+#[test]
+#[should_panic]
+fn test_map_in_place_incompatible_types_fail() {
+ let v = vec![0, 1, 2];
+ v.map_in_place(|_| ());
+}
+
+#[test]
+fn test_map_in_place() {
+ let v = vec![0, 1, 2];
+ assert_eq!(v.map_in_place(|i: u32| i as i32 - 1), [-1, 0, 1]);
+}
+
+#[test]
+fn test_map_in_place_zero_sized() {
+ let v = vec![(), ()];
+ #[derive(PartialEq, Debug)]
+ struct ZeroSized;
+ assert_eq!(v.map_in_place(|_| ZeroSized), [ZeroSized, ZeroSized]);
+}
+
+#[test]
+fn test_map_in_place_zero_drop_count() {
+ use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
+
+ #[derive(Clone, PartialEq, Debug)]
+ struct Nothing;
+ impl Drop for Nothing { fn drop(&mut self) { } }
+
+ #[derive(Clone, PartialEq, Debug)]
+ struct ZeroSized;
+ impl Drop for ZeroSized {
+ fn drop(&mut self) {
+ DROP_COUNTER.fetch_add(1, Ordering::Relaxed);
+ }
+ }
+ const NUM_ELEMENTS: usize = 2;
+ static DROP_COUNTER: AtomicUsize = ATOMIC_USIZE_INIT;
+
+ let v = repeat(Nothing).take(NUM_ELEMENTS).collect::<Vec<_>>();
+
+ DROP_COUNTER.store(0, Ordering::Relaxed);
+
+ let v = v.map_in_place(|_| ZeroSized);
+ assert_eq!(DROP_COUNTER.load(Ordering::Relaxed), 0);
+ drop(v);
+ assert_eq!(DROP_COUNTER.load(Ordering::Relaxed), NUM_ELEMENTS);
+}
+
+#[test]
+fn test_move_items() {
+ let vec = vec![1, 2, 3];
+ let mut vec2 = vec![];
+ for i in vec {
+ vec2.push(i);
+ }
+ assert_eq!(vec2, [1, 2, 3]);
+}
+
+#[test]
+fn test_move_items_reverse() {
+ let vec = vec![1, 2, 3];
+ let mut vec2 = vec![];
+ for i in vec.into_iter().rev() {
+ vec2.push(i);
+ }
+ assert_eq!(vec2, [3, 2, 1]);
+}
+
+#[test]
+fn test_move_items_zero_sized() {
+ let vec = vec![(), (), ()];
+ let mut vec2 = vec![];
+ for i in vec {
+ vec2.push(i);
+ }
+ assert_eq!(vec2, [(), (), ()]);
+}
+
+#[test]
+fn test_drain_items() {
+ let mut vec = vec![1, 2, 3];
+ let mut vec2 = vec![];
+ for i in vec.drain() {
+ vec2.push(i);
+ }
+ assert_eq!(vec, []);
+ assert_eq!(vec2, [ 1, 2, 3 ]);
+}
+
+#[test]
+fn test_drain_items_reverse() {
+ let mut vec = vec![1, 2, 3];
+ let mut vec2 = vec![];
+ for i in vec.drain().rev() {
+ vec2.push(i);
+ }
+ assert_eq!(vec, []);
+ assert_eq!(vec2, [3, 2, 1]);
+}
+
+#[test]
+fn test_drain_items_zero_sized() {
+ let mut vec = vec![(), (), ()];
+ let mut vec2 = vec![];
+ for i in vec.drain() {
+ vec2.push(i);
+ }
+ assert_eq!(vec, []);
+ assert_eq!(vec2, [(), (), ()]);
+}
+
+#[test]
+fn test_into_boxed_slice() {
+ let xs = vec![1, 2, 3];
+ let ys = xs.into_boxed_slice();
+ assert_eq!(&*ys, [1, 2, 3]);
+}
+
+#[test]
+fn test_append() {
+ let mut vec = vec![1, 2, 3];
+ let mut vec2 = vec![4, 5, 6];
+ vec.append(&mut vec2);
+ assert_eq!(vec, [1, 2, 3, 4, 5, 6]);
+ assert_eq!(vec2, []);
+}
+
+#[test]
+fn test_split_off() {
+ let mut vec = vec![1, 2, 3, 4, 5, 6];
+ let vec2 = vec.split_off(4);
+ assert_eq!(vec, [1, 2, 3, 4]);
+ assert_eq!(vec2, [5, 6]);
+}
+
+#[bench]
+fn bench_new(b: &mut Bencher) {
+ b.iter(|| {
+ let v: Vec<u32> = Vec::new();
+ assert_eq!(v.len(), 0);
+ assert_eq!(v.capacity(), 0);
+ })
+}
+
+fn do_bench_with_capacity(b: &mut Bencher, src_len: usize) {
+ b.bytes = src_len as u64;
+
+ b.iter(|| {
+ let v: Vec<u32> = Vec::with_capacity(src_len);
+ assert_eq!(v.len(), 0);
+ assert_eq!(v.capacity(), src_len);
+ })
+}
+
+#[bench]
+fn bench_with_capacity_0000(b: &mut Bencher) {
+ do_bench_with_capacity(b, 0)
+}
+
+#[bench]
+fn bench_with_capacity_0010(b: &mut Bencher) {
+ do_bench_with_capacity(b, 10)
+}
+
+#[bench]
+fn bench_with_capacity_0100(b: &mut Bencher) {
+ do_bench_with_capacity(b, 100)
+}
+
+#[bench]
+fn bench_with_capacity_1000(b: &mut Bencher) {
+ do_bench_with_capacity(b, 1000)
+}
+
+fn do_bench_from_fn(b: &mut Bencher, src_len: usize) {
+ b.bytes = src_len as u64;
+
+ b.iter(|| {
+ let dst = (0..src_len).collect::<Vec<_>>();
+ assert_eq!(dst.len(), src_len);
+ assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
+ })
+}
+
+#[bench]
+fn bench_from_fn_0000(b: &mut Bencher) {
+ do_bench_from_fn(b, 0)
+}
+
+#[bench]
+fn bench_from_fn_0010(b: &mut Bencher) {
+ do_bench_from_fn(b, 10)
+}
+
+#[bench]
+fn bench_from_fn_0100(b: &mut Bencher) {
+ do_bench_from_fn(b, 100)
+}
+
+#[bench]
+fn bench_from_fn_1000(b: &mut Bencher) {
+ do_bench_from_fn(b, 1000)
+}
+
+fn do_bench_from_elem(b: &mut Bencher, src_len: usize) {
+ b.bytes = src_len as u64;
+
+ b.iter(|| {
+ let dst: Vec<usize> = repeat(5).take(src_len).collect();
+ assert_eq!(dst.len(), src_len);
+ assert!(dst.iter().all(|x| *x == 5));
+ })
+}
+
+#[bench]
+fn bench_from_elem_0000(b: &mut Bencher) {
+ do_bench_from_elem(b, 0)
+}
+
+#[bench]
+fn bench_from_elem_0010(b: &mut Bencher) {
+ do_bench_from_elem(b, 10)
+}
+
+#[bench]
+fn bench_from_elem_0100(b: &mut Bencher) {
+ do_bench_from_elem(b, 100)
+}
+
+#[bench]
+fn bench_from_elem_1000(b: &mut Bencher) {
+ do_bench_from_elem(b, 1000)
+}
+
+fn do_bench_from_slice(b: &mut Bencher, src_len: usize) {
+ let src: Vec<_> = FromIterator::from_iter(0..src_len);
+
+ b.bytes = src_len as u64;
+
+ b.iter(|| {
+ let dst = src.clone()[..].to_vec();
+ assert_eq!(dst.len(), src_len);
+ assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
+ });
+}
+
+#[bench]
+fn bench_from_slice_0000(b: &mut Bencher) {
+ do_bench_from_slice(b, 0)
+}
+
+#[bench]
+fn bench_from_slice_0010(b: &mut Bencher) {
+ do_bench_from_slice(b, 10)
+}
+
+#[bench]
+fn bench_from_slice_0100(b: &mut Bencher) {
+ do_bench_from_slice(b, 100)
+}
+
+#[bench]
+fn bench_from_slice_1000(b: &mut Bencher) {
+ do_bench_from_slice(b, 1000)
+}
+
+fn do_bench_from_iter(b: &mut Bencher, src_len: usize) {
+ let src: Vec<_> = FromIterator::from_iter(0..src_len);
+
+ b.bytes = src_len as u64;
+
+ b.iter(|| {
+ let dst: Vec<_> = FromIterator::from_iter(src.clone().into_iter());
+ assert_eq!(dst.len(), src_len);
+ assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
+ });
+}
+
+#[bench]
+fn bench_from_iter_0000(b: &mut Bencher) {
+ do_bench_from_iter(b, 0)
+}
+
+#[bench]
+fn bench_from_iter_0010(b: &mut Bencher) {
+ do_bench_from_iter(b, 10)
+}
+
+#[bench]
+fn bench_from_iter_0100(b: &mut Bencher) {
+ do_bench_from_iter(b, 100)
+}
+
+#[bench]
+fn bench_from_iter_1000(b: &mut Bencher) {
+ do_bench_from_iter(b, 1000)
+}
+
+fn do_bench_extend(b: &mut Bencher, dst_len: usize, src_len: usize) {
+ let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
+ let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
+
+ b.bytes = src_len as u64;
+
+ b.iter(|| {
+ let mut dst = dst.clone();
+ dst.extend(src.clone().into_iter());
+ assert_eq!(dst.len(), dst_len + src_len);
+ assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
+ });
+}
+
+#[bench]
+fn bench_extend_0000_0000(b: &mut Bencher) {
+ do_bench_extend(b, 0, 0)
+}
+
+#[bench]
+fn bench_extend_0000_0010(b: &mut Bencher) {
+ do_bench_extend(b, 0, 10)
+}
+
+#[bench]
+fn bench_extend_0000_0100(b: &mut Bencher) {
+ do_bench_extend(b, 0, 100)
+}
+
+#[bench]
+fn bench_extend_0000_1000(b: &mut Bencher) {
+ do_bench_extend(b, 0, 1000)
+}
+
+#[bench]
+fn bench_extend_0010_0010(b: &mut Bencher) {
+ do_bench_extend(b, 10, 10)
+}
+
+#[bench]
+fn bench_extend_0100_0100(b: &mut Bencher) {
+ do_bench_extend(b, 100, 100)
+}
+
+#[bench]
+fn bench_extend_1000_1000(b: &mut Bencher) {
+ do_bench_extend(b, 1000, 1000)
+}
+
+fn do_bench_push_all(b: &mut Bencher, dst_len: usize, src_len: usize) {
+ let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
+ let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
+
+ b.bytes = src_len as u64;
+
+ b.iter(|| {
+ let mut dst = dst.clone();
+ dst.push_all(&src);
+ assert_eq!(dst.len(), dst_len + src_len);
+ assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
+ });
+}
+
+#[bench]
+fn bench_push_all_0000_0000(b: &mut Bencher) {
+ do_bench_push_all(b, 0, 0)
+}
+
+#[bench]
+fn bench_push_all_0000_0010(b: &mut Bencher) {
+ do_bench_push_all(b, 0, 10)
+}
+
+#[bench]
+fn bench_push_all_0000_0100(b: &mut Bencher) {
+ do_bench_push_all(b, 0, 100)
+}
+
+#[bench]
+fn bench_push_all_0000_1000(b: &mut Bencher) {
+ do_bench_push_all(b, 0, 1000)
+}
+
+#[bench]
+fn bench_push_all_0010_0010(b: &mut Bencher) {
+ do_bench_push_all(b, 10, 10)
+}
+
+#[bench]
+fn bench_push_all_0100_0100(b: &mut Bencher) {
+ do_bench_push_all(b, 100, 100)
+}
+
+#[bench]
+fn bench_push_all_1000_1000(b: &mut Bencher) {
+ do_bench_push_all(b, 1000, 1000)
+}
+
+fn do_bench_push_all_move(b: &mut Bencher, dst_len: usize, src_len: usize) {
+ let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
+ let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
+
+ b.bytes = src_len as u64;
+
+ b.iter(|| {
+ let mut dst = dst.clone();
+ dst.extend(src.clone().into_iter());
+ assert_eq!(dst.len(), dst_len + src_len);
+ assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
+ });
+}
+
+#[bench]
+fn bench_push_all_move_0000_0000(b: &mut Bencher) {
+ do_bench_push_all_move(b, 0, 0)
+}
+
+#[bench]
+fn bench_push_all_move_0000_0010(b: &mut Bencher) {
+ do_bench_push_all_move(b, 0, 10)
+}
+
+#[bench]
+fn bench_push_all_move_0000_0100(b: &mut Bencher) {
+ do_bench_push_all_move(b, 0, 100)
+}
+
+#[bench]
+fn bench_push_all_move_0000_1000(b: &mut Bencher) {
+ do_bench_push_all_move(b, 0, 1000)
+}
+
+#[bench]
+fn bench_push_all_move_0010_0010(b: &mut Bencher) {
+ do_bench_push_all_move(b, 10, 10)
+}
+
+#[bench]
+fn bench_push_all_move_0100_0100(b: &mut Bencher) {
+ do_bench_push_all_move(b, 100, 100)
+}
+
+#[bench]
+fn bench_push_all_move_1000_1000(b: &mut Bencher) {
+ do_bench_push_all_move(b, 1000, 1000)
+}
+
+fn do_bench_clone(b: &mut Bencher, src_len: usize) {
+ let src: Vec<usize> = FromIterator::from_iter(0..src_len);
+
+ b.bytes = src_len as u64;
+
+ b.iter(|| {
+ let dst = src.clone();
+ assert_eq!(dst.len(), src_len);
+ assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
+ });
+}
+
+#[bench]
+fn bench_clone_0000(b: &mut Bencher) {
+ do_bench_clone(b, 0)
+}
+
+#[bench]
+fn bench_clone_0010(b: &mut Bencher) {
+ do_bench_clone(b, 10)
+}
+
+#[bench]
+fn bench_clone_0100(b: &mut Bencher) {
+ do_bench_clone(b, 100)
+}
+
+#[bench]
+fn bench_clone_1000(b: &mut Bencher) {
+ do_bench_clone(b, 1000)
+}
+
+fn do_bench_clone_from(b: &mut Bencher, times: usize, dst_len: usize, src_len: usize) {
+ let dst: Vec<_> = FromIterator::from_iter(0..src_len);
+ let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
+
+ b.bytes = (times * src_len) as u64;
+
+ b.iter(|| {
+ let mut dst = dst.clone();
+
+ for _ in 0..times {
+ dst.clone_from(&src);
+
+ assert_eq!(dst.len(), src_len);
+ assert!(dst.iter().enumerate().all(|(i, x)| dst_len + i == *x));
+ }
+ });
+}
+
+#[bench]
+fn bench_clone_from_01_0000_0000(b: &mut Bencher) {
+ do_bench_clone_from(b, 1, 0, 0)
+}
+
+#[bench]
+fn bench_clone_from_01_0000_0010(b: &mut Bencher) {
+ do_bench_clone_from(b, 1, 0, 10)
+}
+
+#[bench]
+fn bench_clone_from_01_0000_0100(b: &mut Bencher) {
+ do_bench_clone_from(b, 1, 0, 100)
+}
+
+#[bench]
+fn bench_clone_from_01_0000_1000(b: &mut Bencher) {
+ do_bench_clone_from(b, 1, 0, 1000)
+}
+
+#[bench]
+fn bench_clone_from_01_0010_0010(b: &mut Bencher) {
+ do_bench_clone_from(b, 1, 10, 10)
+}
+
+#[bench]
+fn bench_clone_from_01_0100_0100(b: &mut Bencher) {
+ do_bench_clone_from(b, 1, 100, 100)
+}
+
+#[bench]
+fn bench_clone_from_01_1000_1000(b: &mut Bencher) {
+ do_bench_clone_from(b, 1, 1000, 1000)
+}
+
+#[bench]
+fn bench_clone_from_01_0010_0100(b: &mut Bencher) {
+ do_bench_clone_from(b, 1, 10, 100)
+}
+
+#[bench]
+fn bench_clone_from_01_0100_1000(b: &mut Bencher) {
+ do_bench_clone_from(b, 1, 100, 1000)
+}
+
+#[bench]
+fn bench_clone_from_01_0010_0000(b: &mut Bencher) {
+ do_bench_clone_from(b, 1, 10, 0)
+}
+
+#[bench]
+fn bench_clone_from_01_0100_0010(b: &mut Bencher) {
+ do_bench_clone_from(b, 1, 100, 10)
+}
+
+#[bench]
+fn bench_clone_from_01_1000_0100(b: &mut Bencher) {
+ do_bench_clone_from(b, 1, 1000, 100)
+}
+
+#[bench]
+fn bench_clone_from_10_0000_0000(b: &mut Bencher) {
+ do_bench_clone_from(b, 10, 0, 0)
+}
+
+#[bench]
+fn bench_clone_from_10_0000_0010(b: &mut Bencher) {
+ do_bench_clone_from(b, 10, 0, 10)
+}
+
+#[bench]
+fn bench_clone_from_10_0000_0100(b: &mut Bencher) {
+ do_bench_clone_from(b, 10, 0, 100)
+}
+
+#[bench]
+fn bench_clone_from_10_0000_1000(b: &mut Bencher) {
+ do_bench_clone_from(b, 10, 0, 1000)
+}
+
+#[bench]
+fn bench_clone_from_10_0010_0010(b: &mut Bencher) {
+ do_bench_clone_from(b, 10, 10, 10)
+}
+
+#[bench]
+fn bench_clone_from_10_0100_0100(b: &mut Bencher) {
+ do_bench_clone_from(b, 10, 100, 100)
+}
+
+#[bench]
+fn bench_clone_from_10_1000_1000(b: &mut Bencher) {
+ do_bench_clone_from(b, 10, 1000, 1000)
+}
+
+#[bench]
+fn bench_clone_from_10_0010_0100(b: &mut Bencher) {
+ do_bench_clone_from(b, 10, 10, 100)
+}
+
+#[bench]
+fn bench_clone_from_10_0100_1000(b: &mut Bencher) {
+ do_bench_clone_from(b, 10, 100, 1000)
+}
+
+#[bench]
+fn bench_clone_from_10_0010_0000(b: &mut Bencher) {
+ do_bench_clone_from(b, 10, 10, 0)
+}
+
+#[bench]
+fn bench_clone_from_10_0100_0010(b: &mut Bencher) {
+ do_bench_clone_from(b, 10, 100, 10)
+}
+
+#[bench]
+fn bench_clone_from_10_1000_0100(b: &mut Bencher) {
+ do_bench_clone_from(b, 10, 1000, 100)
+}
--- /dev/null
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::collections::VecDeque;
+use std::fmt::Debug;
+use std::hash::{SipHasher, self};
+
+use test;
+
+use self::Taggy::*;
+use self::Taggypar::*;
+
+#[test]
+#[allow(deprecated)]
+fn test_simple() {
+ let mut d = VecDeque::new();
+ assert_eq!(d.len(), 0);
+ d.push_front(17);
+ d.push_front(42);
+ d.push_back(137);
+ assert_eq!(d.len(), 3);
+ d.push_back(137);
+ assert_eq!(d.len(), 4);
+ assert_eq!(*d.front().unwrap(), 42);
+ assert_eq!(*d.back().unwrap(), 137);
+ let mut i = d.pop_front();
+ assert_eq!(i, Some(42));
+ i = d.pop_back();
+ assert_eq!(i, Some(137));
+ i = d.pop_back();
+ assert_eq!(i, Some(137));
+ i = d.pop_back();
+ assert_eq!(i, Some(17));
+ assert_eq!(d.len(), 0);
+ d.push_back(3);
+ assert_eq!(d.len(), 1);
+ d.push_front(2);
+ assert_eq!(d.len(), 2);
+ d.push_back(4);
+ assert_eq!(d.len(), 3);
+ d.push_front(1);
+ assert_eq!(d.len(), 4);
+ debug!("{}", d[0]);
+ debug!("{}", d[1]);
+ debug!("{}", d[2]);
+ debug!("{}", d[3]);
+ assert_eq!(d[0], 1);
+ assert_eq!(d[1], 2);
+ assert_eq!(d[2], 3);
+ assert_eq!(d[3], 4);
+}
+
+#[cfg(test)]
+fn test_parameterized<T:Clone + PartialEq + Debug>(a: T, b: T, c: T, d: T) {
+ let mut deq = VecDeque::new();
+ assert_eq!(deq.len(), 0);
+ deq.push_front(a.clone());
+ deq.push_front(b.clone());
+ deq.push_back(c.clone());
+ assert_eq!(deq.len(), 3);
+ deq.push_back(d.clone());
+ assert_eq!(deq.len(), 4);
+ assert_eq!((*deq.front().unwrap()).clone(), b.clone());
+ assert_eq!((*deq.back().unwrap()).clone(), d.clone());
+ assert_eq!(deq.pop_front().unwrap(), b.clone());
+ assert_eq!(deq.pop_back().unwrap(), d.clone());
+ assert_eq!(deq.pop_back().unwrap(), c.clone());
+ assert_eq!(deq.pop_back().unwrap(), a.clone());
+ assert_eq!(deq.len(), 0);
+ deq.push_back(c.clone());
+ assert_eq!(deq.len(), 1);
+ deq.push_front(b.clone());
+ assert_eq!(deq.len(), 2);
+ deq.push_back(d.clone());
+ assert_eq!(deq.len(), 3);
+ deq.push_front(a.clone());
+ assert_eq!(deq.len(), 4);
+ assert_eq!(deq[0].clone(), a.clone());
+ assert_eq!(deq[1].clone(), b.clone());
+ assert_eq!(deq[2].clone(), c.clone());
+ assert_eq!(deq[3].clone(), d.clone());
+}
+
+#[test]
+fn test_push_front_grow() {
+ let mut deq = VecDeque::new();
+ for i in 0..66 {
+ deq.push_front(i);
+ }
+ assert_eq!(deq.len(), 66);
+
+ for i in 0..66 {
+ assert_eq!(deq[i], 65 - i);
+ }
+
+ let mut deq = VecDeque::new();
+ for i in 0..66 {
+ deq.push_back(i);
+ }
+
+ for i in 0..66 {
+ assert_eq!(deq[i], i);
+ }
+}
+
+#[test]
+fn test_index() {
+ let mut deq = VecDeque::new();
+ for i in 1..4 {
+ deq.push_front(i);
+ }
+ assert_eq!(deq[1], 2);
+}
+
+#[test]
+#[should_panic]
+fn test_index_out_of_bounds() {
+ let mut deq = VecDeque::new();
+ for i in 1..4 {
+ deq.push_front(i);
+ }
+ deq[3];
+}
+
+#[bench]
+fn bench_new(b: &mut test::Bencher) {
+ b.iter(|| {
+ let ring: VecDeque<i32> = VecDeque::new();
+ test::black_box(ring);
+ })
+}
+
+// FIXME(japaric) privacy
+/*
+#[bench]
+fn bench_push_back_100(b: &mut test::Bencher) {
+ let mut deq = VecDeque::with_capacity(101);
+ b.iter(|| {
+ for i in 0..100 {
+ deq.push_back(i);
+ }
+ deq.head = 0;
+ deq.tail = 0;
+ })
+}
+*/
+
+// FIXME(japaric) privacy
+/*
+#[bench]
+fn bench_push_front_100(b: &mut test::Bencher) {
+ let mut deq = VecDeque::with_capacity(101);
+ b.iter(|| {
+ for i in 0..100 {
+ deq.push_front(i);
+ }
+ deq.head = 0;
+ deq.tail = 0;
+ })
+}
+*/
+
+// FIXME(japaric) privacy
+/*
+#[bench]
+fn bench_pop_back_100(b: &mut test::Bencher) {
+ let mut deq= VecDeque::<i32>::with_capacity(101);
+
+ b.iter(|| {
+ deq.head = 100;
+ deq.tail = 0;
+ while !deq.is_empty() {
+ test::black_box(deq.pop_back());
+ }
+ })
+}
+*/
+
+// FIXME(japaric) privacy
+/*
+#[bench]
+fn bench_pop_front_100(b: &mut test::Bencher) {
+ let mut deq = VecDeque::<i32>::with_capacity(101);
+
+ b.iter(|| {
+ deq.head = 100;
+ deq.tail = 0;
+ while !deq.is_empty() {
+ test::black_box(deq.pop_front());
+ }
+ })
+}
+*/
+
+#[bench]
+fn bench_grow_1025(b: &mut test::Bencher) {
+ b.iter(|| {
+ let mut deq = VecDeque::new();
+ for i in 0..1025 {
+ deq.push_front(i);
+ }
+ test::black_box(deq);
+ })
+}
+
+#[bench]
+fn bench_iter_1000(b: &mut test::Bencher) {
+ let ring: VecDeque<_> = (0..1000).collect();
+
+ b.iter(|| {
+ let mut sum = 0;
+ for &i in &ring {
+ sum += i;
+ }
+ test::black_box(sum);
+ })
+}
+
+#[bench]
+fn bench_mut_iter_1000(b: &mut test::Bencher) {
+ let mut ring: VecDeque<_> = (0..1000).collect();
+
+ b.iter(|| {
+ let mut sum = 0;
+ for i in &mut ring {
+ sum += *i;
+ }
+ test::black_box(sum);
+ })
+}
+
+#[derive(Clone, PartialEq, Debug)]
+enum Taggy {
+ One(i32),
+ Two(i32, i32),
+ Three(i32, i32, i32),
+}
+
+#[derive(Clone, PartialEq, Debug)]
+enum Taggypar<T> {
+ Onepar(T),
+ Twopar(T, T),
+ Threepar(T, T, T),
+}
+
+#[derive(Clone, PartialEq, Debug)]
+struct RecCy {
+ x: i32,
+ y: i32,
+ t: Taggy
+}
+
+#[test]
+fn test_param_int() {
+ test_parameterized::<i32>(5, 72, 64, 175);
+}
+
+#[test]
+fn test_param_taggy() {
+ test_parameterized::<Taggy>(One(1), Two(1, 2), Three(1, 2, 3), Two(17, 42));
+}
+
+#[test]
+fn test_param_taggypar() {
+ test_parameterized::<Taggypar<i32>>(Onepar::<i32>(1),
+ Twopar::<i32>(1, 2),
+ Threepar::<i32>(1, 2, 3),
+ Twopar::<i32>(17, 42));
+}
+
+#[test]
+fn test_param_reccy() {
+ let reccy1 = RecCy { x: 1, y: 2, t: One(1) };
+ let reccy2 = RecCy { x: 345, y: 2, t: Two(1, 2) };
+ let reccy3 = RecCy { x: 1, y: 777, t: Three(1, 2, 3) };
+ let reccy4 = RecCy { x: 19, y: 252, t: Two(17, 42) };
+ test_parameterized::<RecCy>(reccy1, reccy2, reccy3, reccy4);
+}
+
+#[test]
+fn test_with_capacity() {
+ let mut d = VecDeque::with_capacity(0);
+ d.push_back(1);
+ assert_eq!(d.len(), 1);
+ let mut d = VecDeque::with_capacity(50);
+ d.push_back(1);
+ assert_eq!(d.len(), 1);
+}
+
+#[test]
+fn test_with_capacity_non_power_two() {
+ let mut d3 = VecDeque::with_capacity(3);
+ d3.push_back(1);
+
+ // X = None, | = lo
+ // [|1, X, X]
+ assert_eq!(d3.pop_front(), Some(1));
+ // [X, |X, X]
+ assert_eq!(d3.front(), None);
+
+ // [X, |3, X]
+ d3.push_back(3);
+ // [X, |3, 6]
+ d3.push_back(6);
+ // [X, X, |6]
+ assert_eq!(d3.pop_front(), Some(3));
+
+ // Pushing the lo past half way point to trigger
+ // the 'B' scenario for growth
+ // [9, X, |6]
+ d3.push_back(9);
+ // [9, 12, |6]
+ d3.push_back(12);
+
+ d3.push_back(15);
+ // There used to be a bug here about how the
+ // VecDeque made growth assumptions about the
+ // underlying Vec which didn't hold and lead
+ // to corruption.
+ // (Vec grows to next power of two)
+ //good- [9, 12, 15, X, X, X, X, |6]
+ //bug- [15, 12, X, X, X, |6, X, X]
+ assert_eq!(d3.pop_front(), Some(6));
+
+ // Which leads us to the following state which
+ // would be a failure case.
+ //bug- [15, 12, X, X, X, X, |X, X]
+ assert_eq!(d3.front(), Some(&9));
+}
+
+#[test]
+fn test_reserve_exact() {
+ let mut d = VecDeque::new();
+ d.push_back(0);
+ d.reserve_exact(50);
+ assert!(d.capacity() >= 51);
+}
+
+#[test]
+fn test_reserve() {
+ let mut d = VecDeque::new();
+ d.push_back(0);
+ d.reserve(50);
+ assert!(d.capacity() >= 51);
+}
+
+#[test]
+fn test_swap() {
+ let mut d: VecDeque<_> = (0..5).collect();
+ d.pop_front();
+ d.swap(0, 3);
+ assert_eq!(d.iter().cloned().collect::<Vec<_>>(), [4, 2, 3, 1]);
+}
+
+#[test]
+fn test_iter() {
+ let mut d = VecDeque::new();
+ assert_eq!(d.iter().next(), None);
+ assert_eq!(d.iter().size_hint(), (0, Some(0)));
+
+ for i in 0..5 {
+ d.push_back(i);
+ }
+ {
+ let b: &[_] = &[&0,&1,&2,&3,&4];
+ assert_eq!(d.iter().collect::<Vec<_>>(), b);
+ }
+
+ for i in 6..9 {
+ d.push_front(i);
+ }
+ {
+ let b: &[_] = &[&8,&7,&6,&0,&1,&2,&3,&4];
+ assert_eq!(d.iter().collect::<Vec<_>>(), b);
+ }
+
+ let mut it = d.iter();
+ let mut len = d.len();
+ loop {
+ match it.next() {
+ None => break,
+ _ => { len -= 1; assert_eq!(it.size_hint(), (len, Some(len))) }
+ }
+ }
+}
+
+#[test]
+fn test_rev_iter() {
+ let mut d = VecDeque::new();
+ assert_eq!(d.iter().rev().next(), None);
+
+ for i in 0..5 {
+ d.push_back(i);
+ }
+ {
+ let b: &[_] = &[&4,&3,&2,&1,&0];
+ assert_eq!(d.iter().rev().collect::<Vec<_>>(), b);
+ }
+
+ for i in 6..9 {
+ d.push_front(i);
+ }
+ let b: &[_] = &[&4,&3,&2,&1,&0,&6,&7,&8];
+ assert_eq!(d.iter().rev().collect::<Vec<_>>(), b);
+}
+
+#[test]
+fn test_mut_rev_iter_wrap() {
+ let mut d = VecDeque::with_capacity(3);
+ assert!(d.iter_mut().rev().next().is_none());
+
+ d.push_back(1);
+ d.push_back(2);
+ d.push_back(3);
+ assert_eq!(d.pop_front(), Some(1));
+ d.push_back(4);
+
+ assert_eq!(d.iter_mut().rev().cloned().collect::<Vec<_>>(),
+ vec![4, 3, 2]);
+}
+
+#[test]
+fn test_mut_iter() {
+ let mut d = VecDeque::new();
+ assert!(d.iter_mut().next().is_none());
+
+ for i in 0..3 {
+ d.push_front(i);
+ }
+
+ for (i, elt) in d.iter_mut().enumerate() {
+ assert_eq!(*elt, 2 - i);
+ *elt = i;
+ }
+
+ {
+ let mut it = d.iter_mut();
+ assert_eq!(*it.next().unwrap(), 0);
+ assert_eq!(*it.next().unwrap(), 1);
+ assert_eq!(*it.next().unwrap(), 2);
+ assert!(it.next().is_none());
+ }
+}
+
+#[test]
+fn test_mut_rev_iter() {
+ let mut d = VecDeque::new();
+ assert!(d.iter_mut().rev().next().is_none());
+
+ for i in 0..3 {
+ d.push_front(i);
+ }
+
+ for (i, elt) in d.iter_mut().rev().enumerate() {
+ assert_eq!(*elt, i);
+ *elt = i;
+ }
+
+ {
+ let mut it = d.iter_mut().rev();
+ assert_eq!(*it.next().unwrap(), 0);
+ assert_eq!(*it.next().unwrap(), 1);
+ assert_eq!(*it.next().unwrap(), 2);
+ assert!(it.next().is_none());
+ }
+}
+
+#[test]
+fn test_into_iter() {
+
+ // Empty iter
+ {
+ let d: VecDeque<i32> = VecDeque::new();
+ let mut iter = d.into_iter();
+
+ assert_eq!(iter.size_hint(), (0, Some(0)));
+ assert_eq!(iter.next(), None);
+ assert_eq!(iter.size_hint(), (0, Some(0)));
+ }
+
+ // simple iter
+ {
+ let mut d = VecDeque::new();
+ for i in 0..5 {
+ d.push_back(i);
+ }
+
+ let b = vec![0,1,2,3,4];
+ assert_eq!(d.into_iter().collect::<Vec<_>>(), b);
+ }
+
+ // wrapped iter
+ {
+ let mut d = VecDeque::new();
+ for i in 0..5 {
+ d.push_back(i);
+ }
+ for i in 6..9 {
+ d.push_front(i);
+ }
+
+ let b = vec![8,7,6,0,1,2,3,4];
+ assert_eq!(d.into_iter().collect::<Vec<_>>(), b);
+ }
+
+ // partially used
+ {
+ let mut d = VecDeque::new();
+ for i in 0..5 {
+ d.push_back(i);
+ }
+ for i in 6..9 {
+ d.push_front(i);
+ }
+
+ let mut it = d.into_iter();
+ assert_eq!(it.size_hint(), (8, Some(8)));
+ assert_eq!(it.next(), Some(8));
+ assert_eq!(it.size_hint(), (7, Some(7)));
+ assert_eq!(it.next_back(), Some(4));
+ assert_eq!(it.size_hint(), (6, Some(6)));
+ assert_eq!(it.next(), Some(7));
+ assert_eq!(it.size_hint(), (5, Some(5)));
+ }
+}
+
+#[test]
+fn test_drain() {
+
+ // Empty iter
+ {
+ let mut d: VecDeque<i32> = VecDeque::new();
+
+ {
+ let mut iter = d.drain();
+
+ assert_eq!(iter.size_hint(), (0, Some(0)));
+ assert_eq!(iter.next(), None);
+ assert_eq!(iter.size_hint(), (0, Some(0)));
+ }
+
+ assert!(d.is_empty());
+ }
+
+ // simple iter
+ {
+ let mut d = VecDeque::new();
+ for i in 0..5 {
+ d.push_back(i);
+ }
+
+ assert_eq!(d.drain().collect::<Vec<_>>(), [0, 1, 2, 3, 4]);
+ assert!(d.is_empty());
+ }
+
+ // wrapped iter
+ {
+ let mut d = VecDeque::new();
+ for i in 0..5 {
+ d.push_back(i);
+ }
+ for i in 6..9 {
+ d.push_front(i);
+ }
+
+ assert_eq!(d.drain().collect::<Vec<_>>(), [8,7,6,0,1,2,3,4]);
+ assert!(d.is_empty());
+ }
+
+ // partially used
+ {
+ let mut d: VecDeque<_> = VecDeque::new();
+ for i in 0..5 {
+ d.push_back(i);
+ }
+ for i in 6..9 {
+ d.push_front(i);
+ }
+
+ {
+ let mut it = d.drain();
+ assert_eq!(it.size_hint(), (8, Some(8)));
+ assert_eq!(it.next(), Some(8));
+ assert_eq!(it.size_hint(), (7, Some(7)));
+ assert_eq!(it.next_back(), Some(4));
+ assert_eq!(it.size_hint(), (6, Some(6)));
+ assert_eq!(it.next(), Some(7));
+ assert_eq!(it.size_hint(), (5, Some(5)));
+ }
+ assert!(d.is_empty());
+ }
+}
+
+#[test]
+fn test_from_iter() {
+ use std::iter;
+
+ let v = vec!(1,2,3,4,5,6,7);
+ let deq: VecDeque<_> = v.iter().cloned().collect();
+ let u: Vec<_> = deq.iter().cloned().collect();
+ assert_eq!(u, v);
+
+ let seq = iter::count(0, 2).take(256);
+ let deq: VecDeque<_> = seq.collect();
+ for (i, &x) in deq.iter().enumerate() {
+ assert_eq!(2*i, x);
+ }
+ assert_eq!(deq.len(), 256);
+}
+
+#[test]
+fn test_clone() {
+ let mut d = VecDeque::new();
+ d.push_front(17);
+ d.push_front(42);
+ d.push_back(137);
+ d.push_back(137);
+ assert_eq!(d.len(), 4);
+ let mut e = d.clone();
+ assert_eq!(e.len(), 4);
+ while !d.is_empty() {
+ assert_eq!(d.pop_back(), e.pop_back());
+ }
+ assert_eq!(d.len(), 0);
+ assert_eq!(e.len(), 0);
+}
+
+#[test]
+fn test_eq() {
+ let mut d = VecDeque::new();
+ assert!(d == VecDeque::with_capacity(0));
+ d.push_front(137);
+ d.push_front(17);
+ d.push_front(42);
+ d.push_back(137);
+ let mut e = VecDeque::with_capacity(0);
+ e.push_back(42);
+ e.push_back(17);
+ e.push_back(137);
+ e.push_back(137);
+ assert!(&e == &d);
+ e.pop_back();
+ e.push_back(0);
+ assert!(e != d);
+ e.clear();
+ assert!(e == VecDeque::new());
+}
+
+#[test]
+fn test_hash() {
+ let mut x = VecDeque::new();
+ let mut y = VecDeque::new();
+
+ x.push_back(1);
+ x.push_back(2);
+ x.push_back(3);
+
+ y.push_back(0);
+ y.push_back(1);
+ y.pop_front();
+ y.push_back(2);
+ y.push_back(3);
+
+ assert!(hash::hash::<_, SipHasher>(&x) == hash::hash::<_, SipHasher>(&y));
+}
+
+#[test]
+fn test_ord() {
+ let x = VecDeque::new();
+ let mut y = VecDeque::new();
+ y.push_back(1);
+ y.push_back(2);
+ y.push_back(3);
+ assert!(x < y);
+ assert!(y > x);
+ assert!(x <= x);
+ assert!(x >= x);
+}
+
+#[test]
+fn test_show() {
+ let ringbuf: VecDeque<_> = (0..10).collect();
+ assert_eq!(format!("{:?}", ringbuf), "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
+
+ let ringbuf: VecDeque<_> = vec!["just", "one", "test", "more"].iter()
+ .cloned()
+ .collect();
+ assert_eq!(format!("{:?}", ringbuf), "[\"just\", \"one\", \"test\", \"more\"]");
+}
+
+#[test]
+fn test_drop() {
+ static mut drops: i32 = 0;
+ struct Elem;
+ impl Drop for Elem {
+ fn drop(&mut self) {
+ unsafe { drops += 1; }
+ }
+ }
+
+ let mut ring = VecDeque::new();
+ ring.push_back(Elem);
+ ring.push_front(Elem);
+ ring.push_back(Elem);
+ ring.push_front(Elem);
+ drop(ring);
+
+ assert_eq!(unsafe {drops}, 4);
+}
+
+#[test]
+fn test_drop_with_pop() {
+ static mut drops: i32 = 0;
+ struct Elem;
+ impl Drop for Elem {
+ fn drop(&mut self) {
+ unsafe { drops += 1; }
+ }
+ }
+
+ let mut ring = VecDeque::new();
+ ring.push_back(Elem);
+ ring.push_front(Elem);
+ ring.push_back(Elem);
+ ring.push_front(Elem);
+
+ drop(ring.pop_back());
+ drop(ring.pop_front());
+ assert_eq!(unsafe {drops}, 2);
+
+ drop(ring);
+ assert_eq!(unsafe {drops}, 4);
+}
+
+#[test]
+fn test_drop_clear() {
+ static mut drops: i32 = 0;
+ struct Elem;
+ impl Drop for Elem {
+ fn drop(&mut self) {
+ unsafe { drops += 1; }
+ }
+ }
+
+ let mut ring = VecDeque::new();
+ ring.push_back(Elem);
+ ring.push_front(Elem);
+ ring.push_back(Elem);
+ ring.push_front(Elem);
+ ring.clear();
+ assert_eq!(unsafe {drops}, 4);
+
+ drop(ring);
+ assert_eq!(unsafe {drops}, 4);
+}
+
+#[test]
+fn test_reserve_grow() {
+ // test growth path A
+ // [T o o H] -> [T o o H . . . . ]
+ let mut ring = VecDeque::with_capacity(4);
+ for i in 0..3 {
+ ring.push_back(i);
+ }
+ ring.reserve(7);
+ for i in 0..3 {
+ assert_eq!(ring.pop_front(), Some(i));
+ }
+
+ // test growth path B
+ // [H T o o] -> [. T o o H . . . ]
+ let mut ring = VecDeque::with_capacity(4);
+ for i in 0..1 {
+ ring.push_back(i);
+ assert_eq!(ring.pop_front(), Some(i));
+ }
+ for i in 0..3 {
+ ring.push_back(i);
+ }
+ ring.reserve(7);
+ for i in 0..3 {
+ assert_eq!(ring.pop_front(), Some(i));
+ }
+
+ // test growth path C
+ // [o o H T] -> [o o H . . . . T ]
+ let mut ring = VecDeque::with_capacity(4);
+ for i in 0..3 {
+ ring.push_back(i);
+ assert_eq!(ring.pop_front(), Some(i));
+ }
+ for i in 0..3 {
+ ring.push_back(i);
+ }
+ ring.reserve(7);
+ for i in 0..3 {
+ assert_eq!(ring.pop_front(), Some(i));
+ }
+}
+
+#[test]
+fn test_get() {
+ let mut ring = VecDeque::new();
+ ring.push_back(0);
+ assert_eq!(ring.get(0), Some(&0));
+ assert_eq!(ring.get(1), None);
+
+ ring.push_back(1);
+ assert_eq!(ring.get(0), Some(&0));
+ assert_eq!(ring.get(1), Some(&1));
+ assert_eq!(ring.get(2), None);
+
+ ring.push_back(2);
+ assert_eq!(ring.get(0), Some(&0));
+ assert_eq!(ring.get(1), Some(&1));
+ assert_eq!(ring.get(2), Some(&2));
+ assert_eq!(ring.get(3), None);
+
+ assert_eq!(ring.pop_front(), Some(0));
+ assert_eq!(ring.get(0), Some(&1));
+ assert_eq!(ring.get(1), Some(&2));
+ assert_eq!(ring.get(2), None);
+
+ assert_eq!(ring.pop_front(), Some(1));
+ assert_eq!(ring.get(0), Some(&2));
+ assert_eq!(ring.get(1), None);
+
+ assert_eq!(ring.pop_front(), Some(2));
+ assert_eq!(ring.get(0), None);
+ assert_eq!(ring.get(1), None);
+}
+
+#[test]
+fn test_get_mut() {
+ let mut ring = VecDeque::new();
+ for i in 0..3 {
+ ring.push_back(i);
+ }
+
+ match ring.get_mut(1) {
+ Some(x) => *x = -1,
+ None => ()
+ };
+
+ assert_eq!(ring.get_mut(0), Some(&mut 0));
+ assert_eq!(ring.get_mut(1), Some(&mut -1));
+ assert_eq!(ring.get_mut(2), Some(&mut 2));
+ assert_eq!(ring.get_mut(3), None);
+
+ assert_eq!(ring.pop_front(), Some(0));
+ assert_eq!(ring.get_mut(0), Some(&mut -1));
+ assert_eq!(ring.get_mut(1), Some(&mut 2));
+ assert_eq!(ring.get_mut(2), None);
+}
+
+// FIXME(japaric) privacy
+/*
+#[test]
+fn test_swap_front_back_remove() {
+ fn test(back: bool) {
+ // This test checks that every single combination of tail position and length is tested.
+ // Capacity 15 should be large enough to cover every case.
+ let mut tester = VecDeque::with_capacity(15);
+ let usable_cap = tester.capacity();
+ let final_len = usable_cap / 2;
+
+ for len in 0..final_len {
+ let expected = if back {
+ (0..len).collect()
+ } else {
+ (0..len).rev().collect()
+ };
+ for tail_pos in 0..usable_cap {
+ tester.tail = tail_pos;
+ tester.head = tail_pos;
+ if back {
+ for i in 0..len * 2 {
+ tester.push_front(i);
+ }
+ for i in 0..len {
+ assert_eq!(tester.swap_back_remove(i), Some(len * 2 - 1 - i));
+ }
+ } else {
+ for i in 0..len * 2 {
+ tester.push_back(i);
+ }
+ for i in 0..len {
+ let idx = tester.len() - 1 - i;
+ assert_eq!(tester.swap_front_remove(idx), Some(len * 2 - 1 - i));
+ }
+ }
+ assert!(tester.tail < tester.cap);
+ assert!(tester.head < tester.cap);
+ assert_eq!(tester, expected);
+ }
+ }
+ }
+ test(true);
+ test(false);
+}
+*/
+
+// FIXME(japaric) privacy
+/*
+#[test]
+fn test_insert() {
+ // This test checks that every single combination of tail position, length, and
+ // insertion position is tested. Capacity 15 should be large enough to cover every case.
+
+ let mut tester = VecDeque::with_capacity(15);
+ // can't guarantee we got 15, so have to get what we got.
+ // 15 would be great, but we will definitely get 2^k - 1, for k >= 4, or else
+ // this test isn't covering what it wants to
+ let cap = tester.capacity();
+
+
+ // len is the length *after* insertion
+ for len in 1..cap {
+ // 0, 1, 2, .., len - 1
+ let expected = iter::count(0, 1).take(len).collect();
+ for tail_pos in 0..cap {
+ for to_insert in 0..len {
+ tester.tail = tail_pos;
+ tester.head = tail_pos;
+ for i in 0..len {
+ if i != to_insert {
+ tester.push_back(i);
+ }
+ }
+ tester.insert(to_insert, to_insert);
+ assert!(tester.tail < tester.cap);
+ assert!(tester.head < tester.cap);
+ assert_eq!(tester, expected);
+ }
+ }
+ }
+}
+*/
+
+// FIXME(japaric) privacy
+/*
+#[test]
+fn test_remove() {
+ // This test checks that every single combination of tail position, length, and
+ // removal position is tested. Capacity 15 should be large enough to cover every case.
+
+ let mut tester = VecDeque::with_capacity(15);
+ // can't guarantee we got 15, so have to get what we got.
+ // 15 would be great, but we will definitely get 2^k - 1, for k >= 4, or else
+ // this test isn't covering what it wants to
+ let cap = tester.capacity();
+
+ // len is the length *after* removal
+ for len in 0..cap - 1 {
+ // 0, 1, 2, .., len - 1
+ let expected = iter::count(0, 1).take(len).collect();
+ for tail_pos in 0..cap {
+ for to_remove in 0..len + 1 {
+ tester.tail = tail_pos;
+ tester.head = tail_pos;
+ for i in 0..len {
+ if i == to_remove {
+ tester.push_back(1234);
+ }
+ tester.push_back(i);
+ }
+ if to_remove == len {
+ tester.push_back(1234);
+ }
+ tester.remove(to_remove);
+ assert!(tester.tail < tester.cap);
+ assert!(tester.head < tester.cap);
+ assert_eq!(tester, expected);
+ }
+ }
+ }
+}
+*/
+
+// FIXME(japaric) privacy
+/*
+#[test]
+fn test_shrink_to_fit() {
+ // This test checks that every single combination of head and tail position,
+ // is tested. Capacity 15 should be large enough to cover every case.
+
+ let mut tester = VecDeque::with_capacity(15);
+ // can't guarantee we got 15, so have to get what we got.
+ // 15 would be great, but we will definitely get 2^k - 1, for k >= 4, or else
+ // this test isn't covering what it wants to
+ let cap = tester.capacity();
+ tester.reserve(63);
+ let max_cap = tester.capacity();
+
+ for len in 0..cap + 1 {
+ // 0, 1, 2, .., len - 1
+ let expected = iter::count(0, 1).take(len).collect();
+ for tail_pos in 0..max_cap + 1 {
+ tester.tail = tail_pos;
+ tester.head = tail_pos;
+ tester.reserve(63);
+ for i in 0..len {
+ tester.push_back(i);
+ }
+ tester.shrink_to_fit();
+ assert!(tester.capacity() <= cap);
+ assert!(tester.tail < tester.cap);
+ assert!(tester.head < tester.cap);
+ assert_eq!(tester, expected);
+ }
+ }
+}
+*/
+
+#[test]
+fn test_front() {
+ let mut ring = VecDeque::new();
+ ring.push_back(10);
+ ring.push_back(20);
+ assert_eq!(ring.front(), Some(&10));
+ ring.pop_front();
+ assert_eq!(ring.front(), Some(&20));
+ ring.pop_front();
+ assert_eq!(ring.front(), None);
+}
+
+#[test]
+fn test_as_slices() {
+ let mut ring: VecDeque<i32> = VecDeque::with_capacity(127);
+ let cap = ring.capacity() as i32;
+ let first = cap/2;
+ let last = cap - first;
+ for i in 0..first {
+ ring.push_back(i);
+
+ let (left, right) = ring.as_slices();
+ let expected: Vec<_> = (0..i+1).collect();
+ assert_eq!(left, expected);
+ assert_eq!(right, []);
+ }
+
+ for j in -last..0 {
+ ring.push_front(j);
+ let (left, right) = ring.as_slices();
+ let expected_left: Vec<_> = (-last..j+1).rev().collect();
+ let expected_right: Vec<_> = (0..first).collect();
+ assert_eq!(left, expected_left);
+ assert_eq!(right, expected_right);
+ }
+
+ assert_eq!(ring.len() as i32, cap);
+ assert_eq!(ring.capacity() as i32, cap);
+}
+
+#[test]
+fn test_as_mut_slices() {
+ let mut ring: VecDeque<i32> = VecDeque::with_capacity(127);
+ let cap = ring.capacity() as i32;
+ let first = cap/2;
+ let last = cap - first;
+ for i in 0..first {
+ ring.push_back(i);
+
+ let (left, right) = ring.as_mut_slices();
+ let expected: Vec<_> = (0..i+1).collect();
+ assert_eq!(left, expected);
+ assert_eq!(right, []);
+ }
+
+ for j in -last..0 {
+ ring.push_front(j);
+ let (left, right) = ring.as_mut_slices();
+ let expected_left: Vec<_> = (-last..j+1).rev().collect();
+ let expected_right: Vec<_> = (0..first).collect();
+ assert_eq!(left, expected_left);
+ assert_eq!(right, expected_right);
+ }
+
+ assert_eq!(ring.len() as i32, cap);
+ assert_eq!(ring.capacity() as i32, cap);
+}
+
+// FIXME(japaric) privacy
+/*
+#[test]
+fn test_split_off() {
+ // This test checks that every single combination of tail position, length, and
+ // split position is tested. Capacity 15 should be large enough to cover every case.
+
+ let mut tester = VecDeque::with_capacity(15);
+ // can't guarantee we got 15, so have to get what we got.
+ // 15 would be great, but we will definitely get 2^k - 1, for k >= 4, or else
+ // this test isn't covering what it wants to
+ let cap = tester.capacity();
+
+ // len is the length *before* splitting
+ for len in 0..cap {
+ // index to split at
+ for at in 0..len + 1 {
+ // 0, 1, 2, .., at - 1 (may be empty)
+ let expected_self = iter::count(0, 1).take(at).collect();
+ // at, at + 1, .., len - 1 (may be empty)
+ let expected_other = iter::count(at, 1).take(len - at).collect();
+
+ for tail_pos in 0..cap {
+ tester.tail = tail_pos;
+ tester.head = tail_pos;
+ for i in 0..len {
+ tester.push_back(i);
+ }
+ let result = tester.split_off(at);
+ assert!(tester.tail < tester.cap);
+ assert!(tester.head < tester.cap);
+ assert!(result.tail < result.cap);
+ assert!(result.head < result.cap);
+ assert_eq!(tester, expected_self);
+ assert_eq!(result, expected_other);
+ }
+ }
+ }
+}
+*/
+
+#[test]
+fn test_append() {
+ let mut a: VecDeque<_> = vec![1, 2, 3].into_iter().collect();
+ let mut b: VecDeque<_> = vec![4, 5, 6].into_iter().collect();
+
+ // normal append
+ a.append(&mut b);
+ assert_eq!(a.iter().cloned().collect::<Vec<_>>(), [1, 2, 3, 4, 5, 6]);
+ assert_eq!(b.iter().cloned().collect::<Vec<_>>(), []);
+
+ // append nothing to something
+ a.append(&mut b);
+ assert_eq!(a.iter().cloned().collect::<Vec<_>>(), [1, 2, 3, 4, 5, 6]);
+ assert_eq!(b.iter().cloned().collect::<Vec<_>>(), []);
+
+ // append something to nothing
+ b.append(&mut a);
+ assert_eq!(b.iter().cloned().collect::<Vec<_>>(), [1, 2, 3, 4, 5, 6]);
+ assert_eq!(a.iter().cloned().collect::<Vec<_>>(), []);
+}
--- /dev/null
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::collections::VecMap;
+use std::collections::vec_map::Entry::{Occupied, Vacant};
+use std::hash::{SipHasher, hash};
+
+#[test]
+fn test_get_mut() {
+ let mut m = VecMap::new();
+ assert!(m.insert(1, 12).is_none());
+ assert!(m.insert(2, 8).is_none());
+ assert!(m.insert(5, 14).is_none());
+ let new = 100;
+ match m.get_mut(&5) {
+ None => panic!(), Some(x) => *x = new
+ }
+ assert_eq!(m.get(&5), Some(&new));
+}
+
+#[test]
+fn test_len() {
+ let mut map = VecMap::new();
+ assert_eq!(map.len(), 0);
+ assert!(map.is_empty());
+ assert!(map.insert(5, 20).is_none());
+ assert_eq!(map.len(), 1);
+ assert!(!map.is_empty());
+ assert!(map.insert(11, 12).is_none());
+ assert_eq!(map.len(), 2);
+ assert!(!map.is_empty());
+ assert!(map.insert(14, 22).is_none());
+ assert_eq!(map.len(), 3);
+ assert!(!map.is_empty());
+}
+
+#[test]
+fn test_clear() {
+ let mut map = VecMap::new();
+ assert!(map.insert(5, 20).is_none());
+ assert!(map.insert(11, 12).is_none());
+ assert!(map.insert(14, 22).is_none());
+ map.clear();
+ assert!(map.is_empty());
+ assert!(map.get(&5).is_none());
+ assert!(map.get(&11).is_none());
+ assert!(map.get(&14).is_none());
+}
+
+#[test]
+fn test_insert() {
+ let mut m = VecMap::new();
+ assert_eq!(m.insert(1, 2), None);
+ assert_eq!(m.insert(1, 3), Some(2));
+ assert_eq!(m.insert(1, 4), Some(3));
+}
+
+#[test]
+fn test_remove() {
+ let mut m = VecMap::new();
+ m.insert(1, 2);
+ assert_eq!(m.remove(&1), Some(2));
+ assert_eq!(m.remove(&1), None);
+}
+
+#[test]
+fn test_keys() {
+ let mut map = VecMap::new();
+ map.insert(1, 'a');
+ map.insert(2, 'b');
+ map.insert(3, 'c');
+ let keys: Vec<_> = map.keys().collect();
+ assert_eq!(keys.len(), 3);
+ assert!(keys.contains(&1));
+ assert!(keys.contains(&2));
+ assert!(keys.contains(&3));
+}
+
+#[test]
+fn test_values() {
+ let mut map = VecMap::new();
+ map.insert(1, 'a');
+ map.insert(2, 'b');
+ map.insert(3, 'c');
+ let values: Vec<_> = map.values().cloned().collect();
+ assert_eq!(values.len(), 3);
+ assert!(values.contains(&'a'));
+ assert!(values.contains(&'b'));
+ assert!(values.contains(&'c'));
+}
+
+#[test]
+fn test_iterator() {
+ let mut m = VecMap::new();
+
+ assert!(m.insert(0, 1).is_none());
+ assert!(m.insert(1, 2).is_none());
+ assert!(m.insert(3, 5).is_none());
+ assert!(m.insert(6, 10).is_none());
+ assert!(m.insert(10, 11).is_none());
+
+ let mut it = m.iter();
+ assert_eq!(it.size_hint(), (0, Some(11)));
+ assert_eq!(it.next().unwrap(), (0, &1));
+ assert_eq!(it.size_hint(), (0, Some(10)));
+ assert_eq!(it.next().unwrap(), (1, &2));
+ assert_eq!(it.size_hint(), (0, Some(9)));
+ assert_eq!(it.next().unwrap(), (3, &5));
+ assert_eq!(it.size_hint(), (0, Some(7)));
+ assert_eq!(it.next().unwrap(), (6, &10));
+ assert_eq!(it.size_hint(), (0, Some(4)));
+ assert_eq!(it.next().unwrap(), (10, &11));
+ assert_eq!(it.size_hint(), (0, Some(0)));
+ assert!(it.next().is_none());
+}
+
+#[test]
+fn test_iterator_size_hints() {
+ let mut m = VecMap::new();
+
+ assert!(m.insert(0, 1).is_none());
+ assert!(m.insert(1, 2).is_none());
+ assert!(m.insert(3, 5).is_none());
+ assert!(m.insert(6, 10).is_none());
+ assert!(m.insert(10, 11).is_none());
+
+ assert_eq!(m.iter().size_hint(), (0, Some(11)));
+ assert_eq!(m.iter().rev().size_hint(), (0, Some(11)));
+ assert_eq!(m.iter_mut().size_hint(), (0, Some(11)));
+ assert_eq!(m.iter_mut().rev().size_hint(), (0, Some(11)));
+}
+
+#[test]
+fn test_mut_iterator() {
+ let mut m = VecMap::new();
+
+ assert!(m.insert(0, 1).is_none());
+ assert!(m.insert(1, 2).is_none());
+ assert!(m.insert(3, 5).is_none());
+ assert!(m.insert(6, 10).is_none());
+ assert!(m.insert(10, 11).is_none());
+
+ for (k, v) in &mut m {
+ *v += k as isize;
+ }
+
+ let mut it = m.iter();
+ assert_eq!(it.next().unwrap(), (0, &1));
+ assert_eq!(it.next().unwrap(), (1, &3));
+ assert_eq!(it.next().unwrap(), (3, &8));
+ assert_eq!(it.next().unwrap(), (6, &16));
+ assert_eq!(it.next().unwrap(), (10, &21));
+ assert!(it.next().is_none());
+}
+
+#[test]
+fn test_rev_iterator() {
+ let mut m = VecMap::new();
+
+ assert!(m.insert(0, 1).is_none());
+ assert!(m.insert(1, 2).is_none());
+ assert!(m.insert(3, 5).is_none());
+ assert!(m.insert(6, 10).is_none());
+ assert!(m.insert(10, 11).is_none());
+
+ let mut it = m.iter().rev();
+ assert_eq!(it.next().unwrap(), (10, &11));
+ assert_eq!(it.next().unwrap(), (6, &10));
+ assert_eq!(it.next().unwrap(), (3, &5));
+ assert_eq!(it.next().unwrap(), (1, &2));
+ assert_eq!(it.next().unwrap(), (0, &1));
+ assert!(it.next().is_none());
+}
+
+#[test]
+fn test_mut_rev_iterator() {
+ let mut m = VecMap::new();
+
+ assert!(m.insert(0, 1).is_none());
+ assert!(m.insert(1, 2).is_none());
+ assert!(m.insert(3, 5).is_none());
+ assert!(m.insert(6, 10).is_none());
+ assert!(m.insert(10, 11).is_none());
+
+ for (k, v) in m.iter_mut().rev() {
+ *v += k as isize;
+ }
+
+ let mut it = m.iter();
+ assert_eq!(it.next().unwrap(), (0, &1));
+ assert_eq!(it.next().unwrap(), (1, &3));
+ assert_eq!(it.next().unwrap(), (3, &8));
+ assert_eq!(it.next().unwrap(), (6, &16));
+ assert_eq!(it.next().unwrap(), (10, &21));
+ assert!(it.next().is_none());
+}
+
+#[test]
+fn test_move_iter() {
+ let mut m: VecMap<Box<_>> = VecMap::new();
+ m.insert(1, box 2);
+ let mut called = false;
+ for (k, v) in m {
+ assert!(!called);
+ called = true;
+ assert_eq!(k, 1);
+ assert_eq!(v, box 2);
+ }
+ assert!(called);
+}
+
+#[test]
+fn test_drain_iterator() {
+ let mut map = VecMap::new();
+ map.insert(1, "a");
+ map.insert(3, "c");
+ map.insert(2, "b");
+
+ let vec: Vec<_> = map.drain().collect();
+
+ assert_eq!(vec, [(1, "a"), (2, "b"), (3, "c")]);
+ assert_eq!(map.len(), 0);
+}
+
+#[test]
+fn test_append() {
+ let mut a = VecMap::new();
+ a.insert(1, "a");
+ a.insert(2, "b");
+ a.insert(3, "c");
+
+ let mut b = VecMap::new();
+ b.insert(3, "d"); // Overwrite element from a
+ b.insert(4, "e");
+ b.insert(5, "f");
+
+ a.append(&mut b);
+
+ assert_eq!(a.len(), 5);
+ assert_eq!(b.len(), 0);
+ // Capacity shouldn't change for possible reuse
+ assert!(b.capacity() >= 4);
+
+ assert_eq!(a[1], "a");
+ assert_eq!(a[2], "b");
+ assert_eq!(a[3], "d");
+ assert_eq!(a[4], "e");
+ assert_eq!(a[5], "f");
+}
+
+#[test]
+fn test_split_off() {
+ // Split within the key range
+ let mut a = VecMap::new();
+ a.insert(1, "a");
+ a.insert(2, "b");
+ a.insert(3, "c");
+ a.insert(4, "d");
+
+ let b = a.split_off(3);
+
+ assert_eq!(a.len(), 2);
+ assert_eq!(b.len(), 2);
+
+ assert_eq!(a[1], "a");
+ assert_eq!(a[2], "b");
+
+ assert_eq!(b[3], "c");
+ assert_eq!(b[4], "d");
+
+ // Split at 0
+ a.clear();
+ a.insert(1, "a");
+ a.insert(2, "b");
+ a.insert(3, "c");
+ a.insert(4, "d");
+
+ let b = a.split_off(0);
+
+ assert_eq!(a.len(), 0);
+ assert_eq!(b.len(), 4);
+ assert_eq!(b[1], "a");
+ assert_eq!(b[2], "b");
+ assert_eq!(b[3], "c");
+ assert_eq!(b[4], "d");
+
+ // Split behind max_key
+ a.clear();
+ a.insert(1, "a");
+ a.insert(2, "b");
+ a.insert(3, "c");
+ a.insert(4, "d");
+
+ let b = a.split_off(5);
+
+ assert_eq!(a.len(), 4);
+ assert_eq!(b.len(), 0);
+ assert_eq!(a[1], "a");
+ assert_eq!(a[2], "b");
+ assert_eq!(a[3], "c");
+ assert_eq!(a[4], "d");
+}
+
+#[test]
+fn test_show() {
+ let mut map = VecMap::new();
+ let empty = VecMap::<i32>::new();
+
+ map.insert(1, 2);
+ map.insert(3, 4);
+
+ let map_str = format!("{:?}", map);
+ assert!(map_str == "{1: 2, 3: 4}" || map_str == "{3: 4, 1: 2}");
+ assert_eq!(format!("{:?}", empty), "{}");
+}
+
+#[test]
+fn test_clone() {
+ let mut a = VecMap::new();
+
+ a.insert(1, 'x');
+ a.insert(4, 'y');
+ a.insert(6, 'z');
+
+ assert!(a.clone() == a);
+}
+
+#[test]
+fn test_eq() {
+ let mut a = VecMap::new();
+ let mut b = VecMap::new();
+
+ assert!(a == b);
+ assert!(a.insert(0, 5).is_none());
+ assert!(a != b);
+ assert!(b.insert(0, 4).is_none());
+ assert!(a != b);
+ assert!(a.insert(5, 19).is_none());
+ assert!(a != b);
+ assert!(!b.insert(0, 5).is_none());
+ assert!(a != b);
+ assert!(b.insert(5, 19).is_none());
+ assert!(a == b);
+
+ a = VecMap::new();
+ b = VecMap::with_capacity(1);
+ assert!(a == b);
+}
+
+#[test]
+fn test_lt() {
+ let mut a = VecMap::new();
+ let mut b = VecMap::new();
+
+ assert!(!(a < b) && !(b < a));
+ assert!(b.insert(2, 5).is_none());
+ assert!(a < b);
+ assert!(a.insert(2, 7).is_none());
+ assert!(!(a < b) && b < a);
+ assert!(b.insert(1, 0).is_none());
+ assert!(b < a);
+ assert!(a.insert(0, 6).is_none());
+ assert!(a < b);
+ assert!(a.insert(6, 2).is_none());
+ assert!(a < b && !(b < a));
+}
+
+#[test]
+fn test_ord() {
+ let mut a = VecMap::new();
+ let mut b = VecMap::new();
+
+ assert!(a <= b && a >= b);
+ assert!(a.insert(1, 1).is_none());
+ assert!(a > b && a >= b);
+ assert!(b < a && b <= a);
+ assert!(b.insert(2, 2).is_none());
+ assert!(b > a && b >= a);
+ assert!(a < b && a <= b);
+}
+
+#[test]
+fn test_hash() {
+ let mut x = VecMap::new();
+ let mut y = VecMap::new();
+
+ assert!(hash::<_, SipHasher>(&x) == hash::<_, SipHasher>(&y));
+ x.insert(1, 'a');
+ x.insert(2, 'b');
+ x.insert(3, 'c');
+
+ y.insert(3, 'c');
+ y.insert(2, 'b');
+ y.insert(1, 'a');
+
+ assert!(hash::<_, SipHasher>(&x) == hash::<_, SipHasher>(&y));
+
+ x.insert(1000, 'd');
+ x.remove(&1000);
+
+ assert!(hash::<_, SipHasher>(&x) == hash::<_, SipHasher>(&y));
+}
+
+#[test]
+fn test_from_iter() {
+ let xs = vec![(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')];
+
+ let map: VecMap<_> = xs.iter().cloned().collect();
+
+ for &(k, v) in &xs {
+ assert_eq!(map.get(&k), Some(&v));
+ }
+}
+
+#[test]
+fn test_index() {
+ let mut map = VecMap::new();
+
+ map.insert(1, 2);
+ map.insert(2, 1);
+ map.insert(3, 4);
+
+ assert_eq!(map[3], 4);
+}
+
+#[test]
+#[should_panic]
+fn test_index_nonexistent() {
+ let mut map = VecMap::new();
+
+ map.insert(1, 2);
+ map.insert(2, 1);
+ map.insert(3, 4);
+
+ map[4];
+}
+
+#[test]
+fn test_entry(){
+ let xs = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)];
+
+ let mut map: VecMap<_> = xs.iter().cloned().collect();
+
+ // Existing key (insert)
+ match map.entry(1) {
+ Vacant(_) => unreachable!(),
+ Occupied(mut view) => {
+ assert_eq!(view.get(), &10);
+ assert_eq!(view.insert(100), 10);
+ }
+ }
+ assert_eq!(map.get(&1).unwrap(), &100);
+ assert_eq!(map.len(), 6);
+
+
+ // Existing key (update)
+ match map.entry(2) {
+ Vacant(_) => unreachable!(),
+ Occupied(mut view) => {
+ let v = view.get_mut();
+ *v *= 10;
+ }
+ }
+ assert_eq!(map.get(&2).unwrap(), &200);
+ assert_eq!(map.len(), 6);
+
+ // Existing key (take)
+ match map.entry(3) {
+ Vacant(_) => unreachable!(),
+ Occupied(view) => {
+ assert_eq!(view.remove(), 30);
+ }
+ }
+ assert_eq!(map.get(&3), None);
+ assert_eq!(map.len(), 5);
+
+
+ // Inexistent key (insert)
+ match map.entry(10) {
+ Occupied(_) => unreachable!(),
+ Vacant(view) => {
+ assert_eq!(*view.insert(1000), 1000);
+ }
+ }
+ assert_eq!(map.get(&10).unwrap(), &1000);
+ assert_eq!(map.len(), 6);
+}
+
+mod bench {
+ use std::collections::VecMap;
+
+ map_insert_rand_bench!{insert_rand_100, 100, VecMap}
+ map_insert_rand_bench!{insert_rand_10_000, 10_000, VecMap}
+
+ map_insert_seq_bench!{insert_seq_100, 100, VecMap}
+ map_insert_seq_bench!{insert_seq_10_000, 10_000, VecMap}
+
+ map_find_rand_bench!{find_rand_100, 100, VecMap}
+ map_find_rand_bench!{find_rand_10_000, 10_000, VecMap}
+
+ map_find_seq_bench!{find_seq_100, 100, VecMap}
+ map_find_seq_bench!{find_seq_10_000, 10_000, VecMap}
+}
projects / rust.git / commitdiff