fixes, tests

Author: pczarn

src/libstd/collections/hash/map.rs

@@ -96,7 +96,8 @@ fn test_resize_policy() {
 }
 
 // The main performance trick in this hashmap is called Robin Hood linear
-// probing. It gains its excellent performance from one essential operation:
+// probing hashing. It gains its excellent performance from one essential
+// operation:
 //
 //    If an insertion collides with an existing element, and that element's
 //    "displacement" (how far away the element is from its ideal location)
@@ -226,11 +227,12 @@ fn test_resize_policy() {
 ///
 /// Relevant papers/articles:
 ///
-/// 1. Emmanuel Goossaert. ["Robin Hood
+/// 1. Pedro Celis. ["Robin Hood Hashing"](https://cs.uwaterloo.ca/research/tr/1986/CS-86-14.pdf)
+/// 2. Emmanuel Goossaert. ["Robin Hood
 ///    hashing"](http://codecapsule.com/2013/11/11/robin-hood-hashing/)
-/// 2. Emmanuel Goossaert. ["Robin Hood hashing: backward shift
+/// 3. Emmanuel Goossaert. ["Robin Hood hashing: backward shift
 ///    deletion"](http://codecapsule.com/2013/11/17/robin-hood-hashing-backward-shift-deletion/)
-/// 3. Alfredo Viola (2005). Distributional analysis of Robin Hood linear probing
+/// 4. Alfredo Viola (2005). Distributional analysis of Robin Hood linear probing
 ///    hashing with buckets.
 ///
 /// # Example
@@ -324,10 +326,9 @@ fn search_hashed<K, V, M, F>(table: M,
 {
     // Worst case, we'll find one empty bucket among `size + 1` buckets.
     let size = table.size();
-    let mut probe = if let Some(probe) = Bucket::new(table, hash) {
-        probe
-    } else {
-        return InternalEntry::TableIsEmpty;
+    let mut probe = match Bucket::new(table, hash) {
+        Some(probe) => probe,
+        None => return InternalEntry::TableIsEmpty,
     };
     let ib = probe.index();
 
@@ -1468,7 +1469,7 @@ impl<'a, K, V> ExactSizeIterator for Values<'a, K, V> {
     #[inline] fn len(&self) -> usize { self.inner.len() }
 }
 
-
+#[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, K, V> Iterator for Drain<'a, K, V> {
     type Item = (K, V);
 
@@ -1490,6 +1491,7 @@ impl<'a, K, V> Iterator for Drain<'a, K, V> {
     }
 }
 
+#[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, K, V> ExactSizeIterator for Drain<'a, K, V> {
     fn len(&self) -> usize { self.inner.table().size() }
 }
@@ -1874,11 +1876,32 @@ mod test_map {
     }
 
     #[test]
-    fn test_empty_pop() {
+    fn test_empty_remove() {
         let mut m: HashMap<int, bool> = HashMap::new();
         assert_eq!(m.remove(&0), None);
     }
 
+    #[test]
+    fn test_empty_entry() {
+        let mut m: HashMap<int, bool> = HashMap::new();
+        assert!(m.entry(&0).is_err());
+        assert!(*m.entry(&0).get().unwrap_or_else(|e| e.insert(true)));
+        assert_eq!(m.len(), 1);
+    }
+
+    #[test]
+    fn test_empty_iter() {
+        let m: HashMap<int, bool> = HashMap::new();
+        assert_eq!(m.drain().next(), None);
+        assert_eq!(m.keys().next(), None);
+        assert_eq!(m.values().next(), None);
+        assert_eq!(m.iter().next(), None);
+        assert_eq!(m.iter_mut().next(), None);
+        assert_eq!(m.len(), 0);
+        assert!(m.is_empty());
+        assert_eq!(m.into_iter().next(), None);
+    }
+
     #[test]
     fn test_lots_of_insertions() {
         let mut m = HashMap::new();