size_hint() and .. for drain

* Replaced unit tests with quickcheck tests.
* Added a size_hint method.
* drain now takes a `..` argument.

Author: Steve Jenson

src/lib.rs

@@ -9,6 +9,7 @@ use std::hash::BuildHasher;
 use std::hash::Hasher;
 use std::collections::hash_map::RandomState;
 use std::borrow::Borrow;
+use std::ops::RangeFull;
 
 use std::cmp::{max, Ordering};
 use std::fmt;
@@ -400,18 +401,6 @@ impl<K, V, S> OrderMap<K, V, S>
     pub fn capacity(&self) -> usize {
         usable_capacity(self.raw_capacity())
     }
-
-    /// Clears the `OrderMap`, returning all key-value pairs as a `Drain`.
-    /// Keeps the allocated memory for reuse.
-    pub fn drain(&mut self) -> Drain<K, V> {
-        for i in &mut self.indices {
-            *i = Pos::none();
-        }
-
-        Drain {
-            inner: self.entries.drain(..),
-        }
-    }
 }
 
 /// Trait for the "size class". Either u32 or u64 depending on the index
@@ -991,6 +980,17 @@ impl<K, V, S> OrderMap<K, V, S>
         self.entries.sort_by(move |a, b| cmp(&a.key, &a.value, &b.key, &b.value));
         self.into_iter()
     }
+    /// Clears the `OrderMap`, returning all key-value pairs as a drain iterator.
+    /// Keeps the allocated memory for reuse.
+    pub fn drain(&mut self, range: RangeFull) -> Drain<K, V> {
+        for i in &mut self.indices {
+            *i = Pos::none();
+        }
+
+        Drain {
+            inner: self.entries.drain(range),
+        }
+    }
 }
 
 impl<K, V, S> OrderMap<K, V, S> {
@@ -1517,6 +1517,9 @@ impl<'a, K, V> Iterator for Drain<'a, K, V> {
     fn next(&mut self) -> Option<Self::Item> {
         self.inner.next().map(|bucket| (bucket.key, bucket.value))
     }
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.inner.size_hint()
+    }
 }
 
 #[cfg(test)]
@@ -1713,39 +1716,4 @@ mod tests {
         assert_ne!(map_a, map_c);
         assert_ne!(map_c, map_a);
     }
-
-
-    #[test]
-    fn drain_basic() {
-        let mut map_a = OrderMap::new();
-        map_a.insert(1, "1");
-        map_a.insert(2, "2");
-        let entries: Vec<(u32, &str)> = map_a.drain().collect();
-        assert!(map_a.is_empty());
-        assert_eq!(entries.len(), 2);
-        assert!(map_a.is_empty());
-
-        map_a.insert(3, "3");
-        assert!(!map_a.is_empty());
-        assert_eq!(map_a.len(), 1);
-        assert!(map_a.get(&3).is_some());
-        assert!(map_a.get(&1).is_none());
-    }
-
-    #[test]
-    fn drain_after_resize() {
-        let mut map_a = OrderMap::with_capacity(2);
-        map_a.insert(1, "1");
-        map_a.insert(2, "2");
-        map_a.insert(3, "3");
-        let entries: Vec<(u32, &str)> = map_a.drain().collect();
-        assert!(map_a.is_empty());
-        assert_eq!(entries.len(), 3);
-
-        map_a.insert(4, "4");
-        assert!(!map_a.is_empty());
-        assert_eq!(map_a.len(), 1);
-        assert!(map_a.get(&4).is_some());
-        assert!(map_a.get(&1).is_none());
-    }
 }

tests/quick.rs

@@ -105,6 +105,18 @@ quickcheck! {
         map.capacity() >= cap
     }
 
+    fn drain(insert: Vec<u8>) -> bool {
+        let mut map = OrderMap::new();
+        for &key in &insert {
+            map.insert(key, ());
+        }
+        let mut clone = map.clone();
+        let drained = clone.drain(..);
+        for (key, _) in drained {
+            map.remove(&key);
+        }
+        map.is_empty()
+    }
 }
 
 use Op::*;