Crank up coverage

frozen-collections-core/src/fz_maps/fz_hash_map.rs

@@ -361,7 +361,7 @@ where
     type Value = FzHashMap<K, V, BH>;
 
     fn expecting(&self, formatter: &mut Formatter) -> Result {
-        formatter.write_str("A map with hashable keys")
+        formatter.write_str("a map with hashable keys")
     }
 
     fn visit_map<M>(self, mut access: M) -> core::result::Result<Self::Value, M::Error>

frozen-collections-core/src/fz_maps/fz_ordered_map.rs

@@ -361,7 +361,7 @@ where
     type Value = FzOrderedMap<K, V>;
 
     fn expecting(&self, formatter: &mut Formatter) -> Result {
-        formatter.write_str("A map with ordered keys")
+        formatter.write_str("a map with ordered keys")
     }
 
     fn visit_map<M>(self, mut access: M) -> core::result::Result<Self::Value, M::Error>

frozen-collections-core/src/fz_maps/fz_scalar_map.rs

@@ -363,7 +363,7 @@ where
     type Value = FzScalarMap<K, V>;
 
     fn expecting(&self, formatter: &mut Formatter) -> Result {
-        formatter.write_str("A map with scalar keys")
+        formatter.write_str("a map with scalar keys")
     }
 
     fn visit_map<M>(self, mut access: M) -> core::result::Result<Self::Value, M::Error>

frozen-collections-core/src/fz_maps/fz_string_map.rs

@@ -393,7 +393,7 @@ where
     type Value = FzStringMap<&'de str, V, BH>;
 
     fn expecting(&self, formatter: &mut Formatter) -> Result {
-        formatter.write_str("A map with string keys")
+        formatter.write_str("a map with string keys")
     }
 
     fn visit_map<M>(self, mut access: M) -> core::result::Result<Self::Value, M::Error>

frozen-collections-core/src/fz_sets/fz_hash_set.rs

@@ -236,7 +236,7 @@ where
     type Value = FzHashSet<T, BH>;
 
     fn expecting(&self, formatter: &mut Formatter) -> core::fmt::Result {
-        formatter.write_str("A set with hashable values")
+        formatter.write_str("a set with hashable values")
     }
 
     fn visit_seq<M>(self, mut access: M) -> core::result::Result<Self::Value, M::Error>

frozen-collections-core/src/fz_sets/fz_ordered_set.rs

@@ -207,7 +207,7 @@ where
     type Value = FzOrderedSet<T>;
 
     fn expecting(&self, formatter: &mut Formatter) -> core::fmt::Result {
-        formatter.write_str("A set with ordered values")
+        formatter.write_str("a set with ordered values")
     }
 
     fn visit_seq<M>(self, mut access: M) -> core::result::Result<Self::Value, M::Error>

frozen-collections-core/src/fz_sets/fz_scalar_set.rs

@@ -202,7 +202,7 @@ where
     type Value = FzScalarSet<T>;
 
     fn expecting(&self, formatter: &mut Formatter) -> core::fmt::Result {
-        formatter.write_str("A set with scalar values")
+        formatter.write_str("a set with scalar values")
     }
 
     fn visit_seq<M>(self, mut access: M) -> core::result::Result<Self::Value, M::Error>

frozen-collections-core/src/fz_sets/fz_string_set.rs

@@ -240,7 +240,7 @@ where
     type Value = FzStringSet<&'de str, BH>;
 
     fn expecting(&self, formatter: &mut Formatter) -> core::fmt::Result {
-        formatter.write_str("A set with string values")
+        formatter.write_str("a set with string values")
     }
 
     fn visit_seq<M>(self, mut access: M) -> core::result::Result<Self::Value, M::Error>

frozen-collections/tests/common/map_testing.rs

@@ -1,5 +1,6 @@
 use core::fmt::Debug;
 use frozen_collections_core::traits::Map;
+use serde::de::DeserializeOwned;
 use serde::Serialize;
 use std::collections::HashMap as StdHashMap;
 use std::collections::HashSet as StdHashSet;
@@ -15,24 +16,17 @@ pub fn test_map<MT, K, V>(
     V: Hash + Eq + Clone + Debug + Default,
     MT: Map<K, V> + Debug + Clone + Eq + Serialize,
 {
-    assert_same(map, reference);
+    assert_eq_map(map, reference);
 
     let formatted_map = format!("{map:?}");
     for key in map.keys() {
         let key_str = format!("{key:?}");
         assert!(formatted_map.contains(&key_str));
     }
 
-    // for now, we just effectively test that this doesn't crash
-    let j = serde_json::to_string(&map).unwrap();
-    assert!(!j.is_empty());
-
-    //    let m2: StdHashMap<K, V, ahash::RandomState> = serde_json::from_str(&j).unwrap();
-    //    assert_same(map, &m2);
-
     let m2 = map.clone();
     let r2 = reference.clone();
-    assert_same(&m2, &r2);
+    assert_eq_map(&m2, &r2);
 
     let v1: StdHashMap<K, V> = map.iter().map(|(k, v)| (k.clone(), v.clone())).collect();
     let v2: StdHashMap<K, V> = reference
@@ -107,8 +101,8 @@ where
     MT: Map<K, i32> + Debug + Clone + Default + Eq,
 {
     let m = MT::default();
-    let r = StdHashMap::default();
-    assert_same(&m, &r);
+    let r = StdHashMap::<_, _, ahash::RandomState>::default();
+    assert_eq_map(&m, &r);
     assert!(!m.contains_key(&K::default()));
     assert_eq!(0, m.len());
     assert!(m.is_empty());
@@ -188,16 +182,32 @@ where
     assert!(!map.contains_key(&K::default()));
 }
 
-fn assert_same<K, V, MT>(map: &MT, reference: &StdHashMap<K, V, ahash::RandomState>)
+pub fn test_map_serialization<K, V, MT, MT2>(map: &MT)
+where
+    K: Hash + Eq + Clone + Debug + Default,
+    V: Hash + Eq + Clone + Debug + Default,
+    MT: Map<K, V> + Debug + Clone + Eq + Serialize,
+    MT2: Map<K, V> + Debug + Clone + Eq + DeserializeOwned,
+{
+    let json = serde_json::to_string(&map).unwrap();
+    let map2: MT2 = serde_json::from_str(&json).unwrap();
+    assert_eq_map(map, &map2);
+
+    let map2: serde_json::Result<MT2> = serde_json::from_str("{XXX: XXX,}");
+    assert!(map2.is_err());
+}
+
+pub fn assert_eq_map<K, V, MT, MT2>(map: &MT, reference: &MT2)
 where
     K: Hash + Eq + Clone + Debug,
     V: Clone + Eq + Debug,
     MT: Map<K, V> + Clone + IntoIterator<Item = (K, V)>,
+    MT2: Map<K, V> + Clone + IntoIterator<Item = (K, V)>,
 {
     assert_eq!(map.len(), reference.len());
     assert_eq!(map.is_empty(), reference.is_empty());
 
-    for pair in reference {
+    for pair in reference.iter() {
         assert!(map.contains_key(pair.0));
     }
 

frozen-collections/tests/common/set_testing.rs

@@ -1,33 +1,33 @@
 use core::fmt::Debug;
 use core::hash::Hash;
 use core::ops::{BitAnd, BitOr, BitXor, Sub};
-use frozen_collections::Set;
-use frozen_collections_core::traits::SetOps;
+use frozen_collections::{Set, SetOps};
 use hashbrown::HashSet as HashbrownSet;
+use serde::de::DeserializeOwned;
 use serde::Serialize;
 
 pub fn test_set<ST, T>(set: &ST, reference: &HashbrownSet<T>, other: &HashbrownSet<T>)
 where
     T: Hash + Eq + Clone + Debug + Default,
     ST: Set<T> + Debug + Clone + Serialize,
 {
-    assert_same(set, reference);
+    assert_eq_set(set, reference);
 
     let s2: HashbrownSet<&T> = set.symmetric_difference(other).collect();
     let r2: HashbrownSet<&T> = reference.symmetric_difference(other).collect();
-    assert_same(&s2, &r2);
+    assert_eq_set(&s2, &r2);
 
     let s2: HashbrownSet<&T> = set.difference(other).collect();
     let r2: HashbrownSet<&T> = reference.difference(other).collect();
-    assert_same(&s2, &r2);
+    assert_eq_set(&s2, &r2);
 
     let s2: HashbrownSet<&T> = set.union(other).collect();
     let r2: HashbrownSet<&T> = reference.union(other).collect();
-    assert_same(&s2, &r2);
+    assert_eq_set(&s2, &r2);
 
     let s2: HashbrownSet<&T> = set.intersection(other).collect();
     let r2: HashbrownSet<&T> = reference.intersection(other).collect();
-    assert_same(&s2, &r2);
+    assert_eq_set(&s2, &r2);
 
     assert_eq!(set.is_disjoint(other), reference.is_disjoint(other));
     assert_eq!(set.is_subset(other), reference.is_subset(other));
@@ -43,12 +43,12 @@ where
     let j = serde_json::to_string(&set).unwrap();
     assert!(!j.is_empty());
 
-    //    let s2: StdHashSet<T, ahash::RandomState> = serde_json::from_str(&j).unwrap();
+    //    let s2: HashbrownSet<T, ahash::RandomState> = serde_json::from_str(&j).unwrap();
     //    assert_same(set, &s2);
 
     let s2 = set.clone();
     let r2 = reference.clone();
-    assert_same(&s2, &r2);
+    assert_eq_set(&s2, &r2);
 
     let s2 = set.clone();
     let mut r2 = reference.clone();
@@ -65,8 +65,8 @@ where
     ST: Set<T> + Debug + Clone + Default,
 {
     let s = ST::default();
-    let r = HashbrownSet::default();
-    assert_same(&s, &r);
+    let r = HashbrownSet::<_, ahash::RandomState>::default();
+    assert_eq_set(&s, &r);
     assert!(!s.contains(&T::default()));
     assert_eq!(0, s.len());
     assert!(s.is_empty());
@@ -147,15 +147,30 @@ where
     assert!(!set.contains(&T::default()));
 }
 
-fn assert_same<T, ST>(set: &ST, reference: &HashbrownSet<T>)
+pub fn test_set_serialization<T, ST, ST2>(set: &ST)
+where
+    T: Hash + Eq + Clone + Debug + Default,
+    ST: Set<T> + Debug + Clone + Eq + Serialize,
+    ST2: Set<T> + Debug + Clone + Eq + DeserializeOwned,
+{
+    let json = serde_json::to_string(&set).unwrap();
+    let set2: ST2 = serde_json::from_str(&json).unwrap();
+    assert_eq_set(set, &set2);
+
+    let set2: serde_json::Result<ST2> = serde_json::from_str("{XXX: XXX,}");
+    assert!(set2.is_err());
+}
+
+pub fn assert_eq_set<T, ST, ST2>(set: &ST, reference: &ST2)
 where
     T: Hash + Eq + Clone,
     ST: Set<T> + Clone,
+    ST2: Set<T> + Clone,
 {
     assert_eq!(set.len(), reference.len());
     assert_eq!(set.is_empty(), reference.is_empty());
 
-    for value in reference {
+    for value in reference.iter() {
         assert!(set.contains(value));
     }