From b73ecafd489792fb3fabac47276eb01e45e4288f Mon Sep 17 00:00:00 2001
From: Andrew Paseltiner <apaseltiner@gmail.com>
Date: Sat, 11 Jul 2015 13:51:47 -0400
Subject: [PATCH] fix spacing
---
src/lib.rs | 998 ++++++++++++++++++++++++++---------------------------
1 file changed, 496 insertions(+), 502 deletions(-)
diff --git a/src/lib.rs b/src/lib.rs
index a2ac460..629d76f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -65,7 +65,6 @@ pub struct VecMap<V> {
}
/// A view into a single entry in a map, which may either be vacant or occupied.
-
pub enum Entry<'a, V:'a> {
/// A vacant Entry
Vacant(VacantEntry<'a, V>),
@@ -75,7 +74,6 @@ pub enum Entry<'a, V:'a> {
}
/// A vacant Entry.
-
pub struct VacantEntry<'a, V:'a> {
map: &'a mut VecMap<V>,
index: usize,
@@ -567,7 +565,6 @@ impl<V> VecMap<V> {
}
}
-
impl<'a, V> Entry<'a, V> {
/// Ensures a value is in the entry by inserting the default if empty, and
/// returns a mutable reference to the value in the entry.
@@ -928,6 +925,7 @@ impl<'a, V> Iterator for Keys<'a, V> {
fn next(&mut self) -> Option<usize> { self.iter.next() }
fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
}
+
impl<'a, V> DoubleEndedIterator for Keys<'a, V> {
fn next_back(&mut self) -> Option<usize> { self.iter.next_back() }
}
@@ -938,6 +936,7 @@ impl<'a, V> Iterator for Values<'a, V> {
fn next(&mut self) -> Option<(&'a V)> { self.iter.next() }
fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
}
+
impl<'a, V> DoubleEndedIterator for Values<'a, V> {
fn next_back(&mut self) -> Option<(&'a V)> { self.iter.next_back() }
}
@@ -948,524 +947,519 @@ impl<V> Iterator for IntoIter<V> {
fn next(&mut self) -> Option<(usize, V)> { self.iter.next() }
fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
}
+
impl<V> DoubleEndedIterator for IntoIter<V> {
fn next_back(&mut self) -> Option<(usize, V)> { self.iter.next_back() }
}
+#[cfg(test)]
+mod test {
+ use super::VecMap;
+ use super::Entry::{Occupied, Vacant};
+ #[cfg(feature = "nightly")] 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)));
+ }
-#[cfg(test)]
-mod test {
+ #[test]
+ fn test_mut_iterator() {
+ let mut m = VecMap::new();
- use super::VecMap;
- use super::Entry::{Occupied, Vacant};
- #[cfg(feature = "nightly")] 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::new(2));
- let mut called = false;
- for (k, v) in m {
- assert!(!called);
- called = true;
- assert_eq!(k, 1);
- assert_eq!(v, Box::new(2));
- }
- assert!(called);
- }
-
- #[test]
+ 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::new(2));
+ let mut called = false;
+ for (k, v) in m {
+ assert!(!called);
+ called = true;
+ assert_eq!(k, 1);
+ assert_eq!(v, Box::new(2));
+ }
+ assert!(called);
+ }
+
+ #[test]
#[cfg(feature = "nightly")]
- fn test_drain_iterator() {
- let mut map = VecMap::new();
- map.insert(1, "a");
- map.insert(3, "c");
- map.insert(2, "b");
+ 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();
+ let vec: Vec<_> = map.drain().collect();
- assert_eq!(vec, [(1, "a"), (2, "b"), (3, "c")]);
- assert_eq!(map.len(), 0);
- }
+ assert_eq!(vec, [(1, "a"), (2, "b"), (3, "c")]);
+ assert_eq!(map.len(), 0);
+ }
- #[test]
+ #[test]
#[cfg(feature = "nightly")]
- 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_eq!(a.clone().iter().collect::<Vec<_>>(), [(1, &'x'), (4, &'y'), (6, &'z')]);
- }
-
- #[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_eq!(a.clone().iter().collect::<Vec<_>>(), [(1, &'x'), (4, &'y'), (6, &'z')]);
+ }
+
+ #[test]
#[cfg(feature = "nightly")]
- 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_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]
#[cfg(feature = "nightly")]
- 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_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]
#[cfg(feature = "nightly")]
- 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_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]
#[cfg(feature = "nightly")]
- 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);
- }
-
- #[test]
- fn test_extend_ref() {
- let mut a = VecMap::new();
- a.insert(1, "one");
- let mut b = VecMap::new();
- b.insert(2, "two");
- b.insert(3, "three");
-
- a.extend(&b);
-
- assert_eq!(a.len(), 3);
- assert_eq!(a[&1], "one");
- assert_eq!(a[&2], "two");
- assert_eq!(a[&3], "three");
- }
+ 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);
+ }
+
+ #[test]
+ fn test_extend_ref() {
+ let mut a = VecMap::new();
+ a.insert(1, "one");
+ let mut b = VecMap::new();
+ b.insert(2, "two");
+ b.insert(3, "three");
+
+ a.extend(&b);
+
+ assert_eq!(a.len(), 3);
+ assert_eq!(a[&1], "one");
+ assert_eq!(a[&2], "two");
+ assert_eq!(a[&3], "three");
+ }
}
--
GitLab