test: add some test code lines to let the code coverage reach 100% (N…

…ot considering the serde).

src/clone.rs

@@ -15,7 +15,7 @@ impl<K: Clone + PartialEq, V: Clone, const N: usize> Clone for Map<K, V, N> {
 }
 
 #[cfg(test)]
-mod test {
+mod tests {
 
     use super::*;
 

src/ctors.rs

@@ -39,7 +39,7 @@ impl<K: PartialEq, V, const N: usize> Drop for Map<K, V, N> {
 }
 
 #[cfg(test)]
-mod test {
+mod tests {
 
     use super::*;
 

src/debug.rs

@@ -11,7 +11,7 @@ impl<K: PartialEq + Debug, V: Debug, const N: usize> Debug for Map<K, V, N> {
 }
 
 #[cfg(test)]
-mod test {
+mod tests {
 
     use super::*;
 

src/display.rs

@@ -24,7 +24,7 @@ impl<K: PartialEq + Display, V: Display, const N: usize> Display for Map<K, V, N
 }
 
 #[cfg(test)]
-mod test {
+mod tests {
 
     use super::*;
 

src/drain.rs

@@ -34,3 +34,38 @@ impl<K: PartialEq, V> ExactSizeIterator for Drain<'_, K, V> {
 }
 
 impl<K: PartialEq, V> FusedIterator for Drain<'_, K, V> {}
+
+#[cfg(test)]
+mod tests {
+    use crate::Map;
+
+    #[test]
+    fn normal_drain() {
+        let mut map = Map::<char, u8, 10>::from_iter([('a', 97), ('b', 98), ('c', 99), ('d', 100)]);
+        let mut cloned_map = map.clone();
+
+        let mut drain = map.drain();
+
+        // For ExactSizeIterator
+        assert_eq!(drain.len(), drain.size_hint().0);
+
+        // Consume the first two items by iterator
+        assert_eq!(drain.next(), Some(('a', 97)));
+        assert_eq!(drain.next(), Some(('b', 98)));
+
+        // We can fuse the drain
+        let mut fuse_it = drain.fuse();
+        assert_eq!(fuse_it.next(), Some(('c', 99)));
+        assert_eq!(fuse_it.next(), Some(('d', 100)));
+
+        // Further calls to next() should return None
+        assert!(fuse_it.next().is_none());
+        // Then fuse works. (It doesn't make sense in our Drain really, but it can.)
+        assert!(fuse_it.next().is_none());
+
+        let mut drain = cloned_map.drain();
+        assert_eq!(drain.next(), Some(('a', 97)));
+        // Three elements left for Drop
+        drop(drain);
+    }
+}

src/entry.rs

@@ -109,3 +109,62 @@ impl<'a, K: PartialEq, V, const N: usize> VacantEntry<'a, K, V, N> {
         self.table.item_mut(index)
     }
 }
+
+#[cfg(test)]
+mod tests {
+
+    use super::Entry;
+    use crate::Map;
+
+    #[test]
+    fn various() {
+        let mut m: Map<char, u8, 10> =
+            Map::from_iter([('a', 97), ('d', 100), ('c', 99), ('b', 98)]);
+        let e: Entry<'_, char, u8, 10> = m.entry('c');
+        assert_eq!(e.key(), &'c');
+        m.entry('e').or_insert(b'e');
+        m.entry('e').or_insert(b'e');
+        assert_eq!(*m.entry('e').and_modify(|v| *v = 42).or_default(), 42);
+        assert_eq!(m.entry('g').key(), &'g');
+        assert_eq!(
+            *m.entry('g').and_modify(|v| *v = 42).or_default(),
+            u8::default()
+        );
+        let value = if let Entry::Occupied(mut entry) = m.entry('e') {
+            let value = *entry.get();
+            assert_eq!(value, 42);
+
+            *entry.get_mut() = b'E';
+            assert_eq!(*entry.get(), 69);
+            let e = entry.into_mut();
+            *e = b'e';
+            value
+        } else {
+            100
+        };
+        assert_eq!(*m.entry('f').or_insert_with(|| value + 1), 43); // _ -> 43
+        assert_eq!(*m.entry('f').or_insert_with(|| value + 2), 43); // no change
+        assert_eq!(m.remove_entry(&'f'), Some(('f', 43))); // 43 -> _
+        assert_eq!(
+            *m.entry('f')
+                .or_insert_with_key(|&key| key.try_into().unwrap()),
+            102
+        ); // _ -> 102
+        assert_eq!(*m.entry('f').or_insert_with_key(|&_| 255), 102); // no change
+        if let Entry::Occupied(entry) = m.entry('e') {
+            assert_eq!(entry.remove(), 101);
+        }
+        if let Entry::Vacant(entry) = m.entry('e') {
+            assert_eq!(entry.key(), &'e');
+            assert_eq!(entry.into_key(), 'e');
+        }
+        if let Entry::Vacant(entry) = m.entry('e') {
+            assert_eq!(entry.key(), &'e');
+            entry.insert(b'e');
+        }
+        if let Entry::Occupied(mut entry) = m.entry('e') {
+            entry.insert(b'E');
+            assert_eq!(entry.remove_entry(), ('e', b'E'));
+        }
+    }
+}

src/eq.rs

@@ -32,7 +32,7 @@ impl<K: PartialEq, V: PartialEq, const N: usize> PartialEq for Map<K, V, N> {
 impl<K: Eq, V: Eq, const N: usize> Eq for Map<K, V, N> {}
 
 #[cfg(test)]
-mod test {
+mod tests {
 
     use super::*;
 

src/from.rs

@@ -22,7 +22,7 @@ impl<K: PartialEq, V, const N: usize> From<[(K, V); N]> for Map<K, V, N> {
 }
 
 #[cfg(test)]
-mod test {
+mod tests {
 
     use super::*;
 

src/index.rs

@@ -26,7 +26,7 @@ impl<K: PartialEq + Borrow<Q>, Q: PartialEq + ?Sized, V, const N: usize> IndexMu
 }
 
 #[cfg(test)]
-mod test {
+mod tests {
 
     use super::*;
 

src/iterators.rs

@@ -131,7 +131,7 @@ impl<K, V> FusedIterator for IterMut<'_, K, V> {}
 impl<K: PartialEq, V, const N: usize> FusedIterator for IntoIter<K, V, N> {}
 
 #[cfg(test)]
-mod test {
+mod tests {
 
     use super::*;
 
@@ -253,4 +253,23 @@ mod test {
         let _p = m.into_iter().nth(3);
         assert_eq!(Rc::strong_count(&v), 2); // v & p
     }
+
+    #[test]
+    fn iter_size_hint() {
+        let mut m: Map<char, u32, 4> = Map::new();
+        m.insert('a', 97);
+        m.insert('c', 99);
+        let it = m.iter();
+        assert_eq!(it.len(), 2);
+        let mut it_mut = m.iter_mut();
+        assert!(it_mut.next().is_some());
+        assert_eq!(it_mut.len(), 1);
+        assert_eq!(it_mut.len(), it_mut.size_hint().0);
+        let mut it_into = m.into_iter();
+        assert!(it_into.next().is_some());
+        assert!(it_into.next().is_some());
+        assert!(it_into.next().is_none());
+        assert!(it_into.next().is_none());
+        assert_eq!(it_into.len(), 0);
+    }
 }

src/keys.rs

@@ -65,7 +65,7 @@ impl<K, V> FusedIterator for Keys<'_, K, V> {}
 impl<K: PartialEq, V, const N: usize> FusedIterator for IntoKeys<K, V, N> {}
 
 #[cfg(test)]
-mod test {
+mod tests {
 
     use super::*;
 
@@ -74,16 +74,20 @@ mod test {
         let mut m: Map<String, i32, 10> = Map::new();
         m.insert("foo".to_string(), 0);
         m.insert("bar".to_string(), 0);
-        assert_eq!(m.keys().collect::<Vec<_>>(), [&"foo", &"bar"]);
+        let keys = m.keys();
+        assert_eq!(keys.len(), 2);
+        assert_eq!(keys.collect::<Vec<_>>(), [&"foo", &"bar"]);
     }
 
     #[test]
     fn iterate_into_keys() {
         let mut m: Map<String, i32, 10> = Map::new();
         m.insert("foo".to_string(), 0);
         m.insert("bar".to_string(), 0);
+        let keys = m.into_keys();
+        assert_eq!(keys.len(), 2);
         assert_eq!(
-            m.into_keys().collect::<Vec<_>>(),
+            keys.collect::<Vec<_>>(),
             ["bar".to_string(), "foo".to_string()]
         );
     }

src/map.rs

@@ -275,7 +275,7 @@ impl<K: PartialEq, V, const N: usize> Map<K, V, N> {
 }
 
 #[cfg(test)]
-mod test {
+mod tests {
 
     use super::*;
 

src/serialization.rs

@@ -56,21 +56,25 @@ impl<'de, K: PartialEq + Deserialize<'de>, V: Deserialize<'de>, const N: usize>
 }
 
 #[cfg(test)]
-use bincode::{deserialize, serialize};
+mod tests {
 
-#[test]
-fn serialize_and_deserialize() {
-    let mut before: Map<u8, u8, 8> = Map::new();
-    before.insert(1, 42);
-    let bytes: Vec<u8> = serialize(&before).unwrap();
-    let after: Map<u8, u8, 8> = deserialize(&bytes).unwrap();
-    assert_eq!(42, after.into_iter().next().unwrap().1);
-}
+    use crate::Map;
+    use bincode::{deserialize, serialize};
+
+    #[test]
+    fn serialize_and_deserialize() {
+        let mut before: Map<u8, u8, 8> = Map::new();
+        before.insert(1, 42);
+        let bytes: Vec<u8> = serialize(&before).unwrap();
+        let after: Map<u8, u8, 8> = deserialize(&bytes).unwrap();
+        assert_eq!(42, after.into_iter().next().unwrap().1);
+    }
 
-#[test]
-fn empty_map_serde() {
-    let before: Map<u8, u8, 8> = Map::new();
-    let bytes: Vec<u8> = serialize(&before).unwrap();
-    let after: Map<u8, u8, 8> = deserialize(&bytes).unwrap();
-    assert!(after.is_empty());
+    #[test]
+    fn empty_map_serde() {
+        let before: Map<u8, u8, 8> = Map::new();
+        let bytes: Vec<u8> = serialize(&before).unwrap();
+        let after: Map<u8, u8, 8> = deserialize(&bytes).unwrap();
+        assert!(after.is_empty());
+    }
 }

src/set/debug.rs

@@ -11,7 +11,7 @@ impl<T: PartialEq + Debug, const N: usize> Debug for Set<T, N> {
 }
 
 #[cfg(test)]
-mod test {
+mod tests {
 
     use super::*;
 

src/set/display.rs

@@ -22,15 +22,17 @@ impl<T: PartialEq + Display, const N: usize> Display for Set<T, N> {
 }
 
 #[cfg(test)]
-mod test {
+mod tests {
 
     use super::*;
 
     #[test]
     fn displays_set() {
         let mut m: Set<String, 10> = Set::new();
+        assert_eq!(r#"{}"#, format!("{}", m));
         m.insert("one".to_string());
         m.insert("two".to_string());
         assert_eq!(r#"{"one", "two"}"#, format!("{:?}", m));
+        assert_eq!(r#"{one, two}"#, format!("{}", m));
     }
 }

src/set/functions.rs

@@ -35,10 +35,10 @@ impl<T: PartialEq, const N: usize> Set<T, N> {
         }
     }
 
-    /// Does the set contain this key?
+    /// Returns true if the set contains a value.
     #[inline]
     #[must_use]
-    pub fn contains_key<Q: PartialEq + ?Sized>(&self, k: &Q) -> bool
+    pub fn contains<Q: PartialEq + ?Sized>(&self, k: &Q) -> bool
     where
         T: Borrow<Q>,
     {

src/set/mod.rs

@@ -64,3 +64,76 @@ pub struct SetIntoIter<T: PartialEq, const N: usize> {
 pub struct SetDrain<'a, T: PartialEq> {
     iter: crate::Drain<'a, T, ()>,
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::Set;
+
+    #[test]
+    fn various() {
+        let mut set: Set<i32, 10> = Set::new();
+        let set_default: Set<i32, 10> = Set::default();
+        assert!(set == set_default);
+
+        assert_eq!(set.capacity(), 10);
+        assert_eq!(set.len(), 0);
+        assert!(set.is_empty());
+        set.insert(0);
+        assert_eq!(set.len(), 1);
+        set.insert(0);
+        assert_eq!(set.len(), 1);
+        set.insert(1);
+        assert_eq!(set.len(), 2);
+
+        let mut drain = set.drain();
+        assert_eq!(drain.len(), 2);
+        assert!(drain.next().is_some());
+        assert_eq!(drain.len(), 1);
+        assert_eq!(drain.len(), drain.size_hint().0);
+        assert_eq!(drain.len(), drain.size_hint().1.unwrap());
+        drop(drain);
+
+        set.clear();
+
+        for n in 0..10 {
+            set.insert(n);
+        }
+        assert_eq!(set.len(), 10);
+        assert!(set.contains(&0));
+        assert_eq!(set.take(&0), Some(0));
+        assert!(!set.contains(&10));
+
+        assert_eq!(set.remove(&0), false);
+        set.insert(0);
+        assert_eq!(set.remove(&0), true);
+        set.insert(10);
+
+        assert_eq!(set.get(&10), Some(&10));
+        assert_eq!(set.get(&11), None);
+
+        set.retain(|&k| k % 2 == 0);
+
+        let mut it = set.iter();
+        assert!(it.next().is_some());
+        assert_eq!(it.len(), 4);
+        assert_eq!(it.len(), it.size_hint().0);
+        assert_eq!(it.len(), it.size_hint().1.unwrap());
+
+        let mut it_into = set.into_iter();
+        assert!(it_into.next().is_some());
+        assert!(it_into.next().is_some());
+        assert!(it_into.next().is_some());
+        assert_eq!(it_into.len(), 2);
+        assert_eq!(it_into.len(), it_into.size_hint().0);
+        assert_eq!(it_into.len(), it_into.size_hint().1.unwrap());
+    }
+
+    #[test]
+    fn test_set_from() {
+        let set_a = Set::from(['a', 'b', 'c', 'd']);
+        let set_b = Set::from_iter(vec!['a', 'a', 'd', 'b', 'a', 'd', 'c', 'd', 'c']);
+        let set_c = Set::from_iter(set_a.clone());
+        assert_eq!(set_a, set_b);
+        assert_eq!(set_a, set_c);
+    }
+}

src/set/serialization.rs

@@ -52,21 +52,25 @@ impl<'de, T: PartialEq + Deserialize<'de>, const N: usize> Deserialize<'de> for
 }
 
 #[cfg(test)]
-use bincode::{deserialize, serialize};
+mod tests {
 
-#[test]
-fn serialize_and_deserialize() {
-    let mut before: Set<u8, 8> = Set::new();
-    before.insert(1);
-    let bytes: Vec<u8> = serialize(&before).unwrap();
-    let after: Set<u8, 8> = deserialize(&bytes).unwrap();
-    assert_eq!(1, after.into_iter().next().unwrap());
-}
+    use crate::Set;
+    use bincode::{deserialize, serialize};
+
+    #[test]
+    fn serialize_and_deserialize() {
+        let mut before: Set<u8, 8> = Set::new();
+        before.insert(1);
+        let bytes: Vec<u8> = serialize(&before).unwrap();
+        let after: Set<u8, 8> = deserialize(&bytes).unwrap();
+        assert_eq!(1, after.into_iter().next().unwrap());
+    }
 
-#[test]
-fn empty_set_serde() {
-    let before: Set<u8, 8> = Set::new();
-    let bytes: Vec<u8> = serialize(&before).unwrap();
-    let after: Set<u8, 8> = deserialize(&bytes).unwrap();
-    assert!(after.is_empty());
+    #[test]
+    fn empty_set_serde() {
+        let before: Set<u8, 8> = Set::new();
+        let bytes: Vec<u8> = serialize(&before).unwrap();
+        let after: Set<u8, 8> = deserialize(&bytes).unwrap();
+        assert!(after.is_empty());
+    }
 }

src/values.rs

@@ -93,7 +93,7 @@ impl<K, V> FusedIterator for ValuesMut<'_, K, V> {}
 impl<K: PartialEq, V, const N: usize> FusedIterator for IntoValues<K, V, N> {}
 
 #[cfg(test)]
-mod test {
+mod tests {
 
     use super::*;
 
@@ -102,15 +102,21 @@ mod test {
         let mut m: Map<String, i32, 10> = Map::new();
         m.insert("one".to_string(), 42);
         m.insert("two".to_string(), 16);
-        assert_eq!(58, m.values().sum());
+        let it = m.values();
+        assert_eq!(it.len(), 2);
+        assert_eq!(58, it.sum());
     }
 
     #[test]
     fn iterate_values_mut() {
         let mut m: Map<String, i32, 10> = Map::new();
         m.insert("one".to_string(), 42);
         m.insert("two".to_string(), 16);
-        m.values_mut().for_each(|v| *v *= 2);
+        let it_mut = m.values_mut();
+        assert_eq!(it_mut.len(), 2);
+        assert_eq!(it_mut.len(), it_mut.size_hint().0);
+        assert_eq!(it_mut.len(), it_mut.size_hint().1.unwrap());
+        it_mut.for_each(|v| *v *= 2);
         assert_eq!(116, m.values().sum());
     }
 
@@ -133,7 +139,12 @@ mod test {
             m.insert(i, Rc::clone(&v));
         }
         assert_eq!(9, Rc::strong_count(&v));
-        m.into_values();
+        let mut values = m.into_values();
+        assert!(values.next().is_some());
+        assert_eq!(values.len(), 7);
+        assert!(values.next().is_some());
+        assert_eq!(values.len(), values.size_hint().0);
+        drop(values);
         assert_eq!(1, Rc::strong_count(&v));
     }
 }