diff --git a/CHANGELOG.md b/CHANGELOG.md
index ee8c506e..533f5616 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,7 +12,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
  - Add chunk key encoding tests
 
 ### Changed
- - Revise coverage section in `BUILD.md` to use `cargo-llvm-cov`
+ - Revise code coverage section in `BUILD.md` to use `cargo-llvm-cov`
+ - Increased code coverage in some modules
 
 ### Fixed
  - Fixed chunk key encoding for 0 dimensional arrays with `default` and `v2` encoding
diff --git a/src/array/fill_value_metadata.rs b/src/array/fill_value_metadata.rs
index 1d9553e6..869f89a4 100644
--- a/src/array/fill_value_metadata.rs
+++ b/src/array/fill_value_metadata.rs
@@ -316,113 +316,123 @@ mod tests {
     #[test]
     fn fill_value_metadata_bool_false() {
         let json = r#"false"#;
-        let metadata: FillValueMetadata = serde_json::from_str(json).unwrap();
+        let metadata: FillValueMetadata = json.try_into().unwrap();
         assert_eq!(json, serde_json::to_string(&metadata).unwrap());
         match metadata {
             FillValueMetadata::Bool(fill_value) => {
                 assert!(!fill_value);
             }
-            _ => panic!(),
+            _ => unreachable!(),
         }
     }
 
     #[test]
     fn fill_value_metadata_bool_true() {
         let json = r#"true"#;
-        let metadata: FillValueMetadata = serde_json::from_str(json).unwrap();
+        let metadata: FillValueMetadata = json.try_into().unwrap();
         assert_eq!(json, serde_json::to_string(&metadata).unwrap());
         match metadata {
             FillValueMetadata::Bool(fill_value) => {
                 assert!(fill_value);
             }
-            _ => panic!(),
+            _ => unreachable!(),
         }
     }
 
     #[test]
     fn fill_value_metadata_uint() {
         let json = r#"7"#;
-        let metadata: FillValueMetadata = serde_json::from_str(json).unwrap();
+        let metadata: FillValueMetadata = json.try_into().unwrap();
         assert_eq!(json, serde_json::to_string(&metadata).unwrap());
         match metadata {
             FillValueMetadata::UInt(fill_value) => {
                 assert_eq!(fill_value, 7);
             }
-            _ => panic!(),
+            _ => unreachable!(),
         }
     }
 
     #[test]
     fn fill_value_metadata_int() {
         let json = r#"-7"#;
-        let metadata: FillValueMetadata = serde_json::from_str(json).unwrap();
+        let metadata: FillValueMetadata = json.try_into().unwrap();
         assert_eq!(json, serde_json::to_string(&metadata).unwrap());
         match metadata {
             FillValueMetadata::Int(fill_value) => {
                 assert_eq!(fill_value, -7);
             }
-            _ => panic!(),
+            _ => unreachable!(),
         }
     }
 
     #[test]
     fn fill_value_metadata_float_number() {
         let json = r#"7.5"#;
-        let metadata: FillValueMetadata = serde_json::from_str(json).unwrap();
+        let metadata: FillValueMetadata = json.try_into().unwrap();
         assert_eq!(json, serde_json::to_string(&metadata).unwrap());
         match metadata {
             FillValueMetadata::Float(FillValueFloat::Float(fill_value)) => {
                 assert_eq!(fill_value, 7.5);
             }
-            _ => panic!(),
+            _ => unreachable!(),
         }
     }
 
     #[test]
     fn fill_value_metadata_float_infinity() {
         let json = r#""Infinity""#;
-        let metadata: FillValueMetadata = serde_json::from_str(json).unwrap();
+        let metadata: FillValueMetadata = json.try_into().unwrap();
         assert_eq!(json, serde_json::to_string(&metadata).unwrap());
         match metadata {
             FillValueMetadata::Float(FillValueFloat::NonFinite(fill_value)) => {
                 assert_eq!(fill_value, FillValueFloatStringNonFinite::PosInfinity);
             }
-            _ => panic!(),
+            _ => unreachable!(),
         }
+
+        let pos_inf = FillValueFloat::NonFinite(FillValueFloatStringNonFinite::PosInfinity)
+            .to_float::<f32>()
+            .unwrap();
+        assert!(pos_inf.is_infinite() && pos_inf.is_sign_positive());
     }
 
     #[test]
     fn fill_value_metadata_float_neg_infinity() {
         let json = r#""-Infinity""#;
-        let metadata: FillValueMetadata = serde_json::from_str(json).unwrap();
+        let metadata: FillValueMetadata = json.try_into().unwrap();
         assert_eq!(json, serde_json::to_string(&metadata).unwrap());
         match metadata {
             FillValueMetadata::Float(FillValueFloat::NonFinite(fill_value)) => {
                 assert_eq!(fill_value, FillValueFloatStringNonFinite::NegInfinity);
             }
-            _ => panic!(),
+            _ => unreachable!(),
         }
+
+        let neg_inf = FillValueFloat::NonFinite(FillValueFloatStringNonFinite::NegInfinity)
+            .to_float::<f32>()
+            .unwrap();
+        assert!(neg_inf.is_infinite() && neg_inf.is_sign_negative());
     }
 
     #[test]
     fn fill_value_metadata_float_nan() {
         let json = r#""NaN""#;
-        let metadata: FillValueMetadata = serde_json::from_str(json).unwrap();
+        let metadata: FillValueMetadata = json.try_into().unwrap();
         assert_eq!(json, serde_json::to_string(&metadata).unwrap());
         match metadata {
             FillValueMetadata::Float(FillValueFloat::NonFinite(fill_value)) => {
                 assert_eq!(fill_value, FillValueFloatStringNonFinite::NaN);
             }
-            _ => panic!(),
+            _ => unreachable!(),
         }
     }
 
     #[test]
     fn fill_value_metadata_float_nan_standard() {
         let json = r#""0x7fc00000""#;
-        let metadata: FillValueMetadata = serde_json::from_str(json).unwrap();
+        let metadata: FillValueMetadata = json.try_into().unwrap();
         let FillValueMetadata::Float(FillValueFloat::HexString(hex_string)) = metadata else {
-            panic!()
+            unreachable!()
         };
         let fill_value: f32 = f32::from_be_bytes(hex_string.as_be_bytes().try_into().unwrap());
         assert!(fill_value.is_nan());
@@ -430,17 +440,24 @@ mod tests {
         let fill_value_metadata = DataType::Float32.metadata_fill_value(&fill_value);
         let FillValueMetadata::Float(FillValueFloat::NonFinite(fill_value)) = fill_value_metadata
         else {
-            panic!()
+            unreachable!()
         };
         assert_eq!(fill_value, FillValueFloatStringNonFinite::NaN);
+
+        assert!(FillValueFloat::HexString(HexString(
+            hex_string_to_be_bytes(&"0x7fc00000").unwrap()
+        ))
+        .to_float::<f32>()
+        .unwrap()
+        .is_nan());
     }
 
     #[test]
     fn fill_value_metadata_float_nan_nonstandard() {
         let json = r#""0x7fc00001""#;
-        let metadata: FillValueMetadata = serde_json::from_str(json).unwrap();
+        let metadata: FillValueMetadata = json.try_into().unwrap();
         let FillValueMetadata::Float(FillValueFloat::HexString(hex_string)) = metadata else {
-            panic!()
+            unreachable!()
         };
         let fill_value: f32 = f32::from_be_bytes(hex_string.as_be_bytes().try_into().unwrap());
         assert!(fill_value.is_nan());
@@ -448,27 +465,27 @@ mod tests {
         let fill_value_metadata = DataType::Float32.metadata_fill_value(&fill_value);
         let FillValueMetadata::Float(FillValueFloat::HexString(_hex_string)) = fill_value_metadata
         else {
-            panic!()
+            unreachable!()
         };
     }
 
     #[test]
     fn fill_value_metadata_float_hex_string() {
         let json = r#""0x7fc00000""#;
-        let metadata: FillValueMetadata = serde_json::from_str(json).unwrap();
+        let metadata: FillValueMetadata = json.try_into().unwrap();
         assert_eq!(json, serde_json::to_string(&metadata).unwrap());
         match metadata {
             FillValueMetadata::Float(FillValueFloat::HexString(fill_value)) => {
                 assert_eq!(fill_value.0, f32::NAN.to_be_bytes());
             }
-            _ => panic!(),
+            _ => unreachable!(),
         }
     }
 
     #[test]
     fn fill_value_metadata_float_complex() {
         let json = r#"["0x7fc00000","NaN"]"#;
-        let metadata: FillValueMetadata = serde_json::from_str(json).unwrap();
+        let metadata: FillValueMetadata = json.try_into().unwrap();
         assert_eq!(json, serde_json::to_string(&metadata).unwrap());
         match metadata {
             FillValueMetadata::Complex(re, im) => {
@@ -476,29 +493,29 @@ mod tests {
                     FillValueFloat::HexString(fill_value) => {
                         assert_eq!(fill_value.0, f32::NAN.to_be_bytes());
                     }
-                    _ => panic!(),
+                    _ => unreachable!(),
                 };
                 match im {
                     FillValueFloat::NonFinite(fill_value) => {
                         assert_eq!(fill_value, FillValueFloatStringNonFinite::NaN);
                     }
-                    _ => panic!(),
+                    _ => unreachable!(),
                 };
             }
-            _ => panic!(),
+            _ => unreachable!(),
         }
     }
 
     #[test]
     fn fill_value_metadata_raw_bytes() {
         let json = r#"[0,1,2,3]"#;
-        let metadata: FillValueMetadata = serde_json::from_str(json).unwrap();
+        let metadata: FillValueMetadata = json.try_into().unwrap();
         assert_eq!(json, serde_json::to_string(&metadata).unwrap());
         match metadata {
             FillValueMetadata::ByteArray(fill_value) => {
                 assert_eq!(fill_value, [0, 1, 2, 3]);
             }
-            _ => panic!(),
+            _ => unreachable!(),
         }
     }
 }
diff --git a/src/storage/store/store_sync/memory_store.rs b/src/storage/store/store_sync/memory_store.rs
index dc56f117..65a5b53f 100644
--- a/src/storage/store/store_sync/memory_store.rs
+++ b/src/storage/store/store_sync/memory_store.rs
@@ -221,6 +221,32 @@ mod tests {
         assert_eq!(store.get(&key)?.unwrap(), &[0, 1, 2]);
         store.set_partial_values(&[StoreKeyStartValue::new(key.clone(), 1, &[3, 4])])?;
         assert_eq!(store.get(&key)?.unwrap(), &[0, 3, 4]);
+
+        assert_eq!(
+            store
+                .get_partial_values_key(&key, &[ByteRange::FromStart(1, None)])?
+                .unwrap()
+                .first()
+                .unwrap(),
+            &[3, 4]
+        );
+
+        assert!(store
+            .get_partial_values_key(&"a/b/c".try_into()?, &[ByteRange::FromStart(1, None)])?
+            .is_none());
+
+        assert_eq!(
+            store
+                .get_partial_values(&[StoreKeyRange::new(
+                    key.clone(),
+                    ByteRange::FromStart(1, None)
+                )])?
+                .first()
+                .unwrap()
+                .as_ref()
+                .unwrap(),
+            &[3, 4]
+        );
         Ok(())
     }
 
@@ -228,8 +254,8 @@ mod tests {
     fn memory_list() -> Result<(), Box<dyn Error>> {
         let store = MemoryStore::new();
 
-        store.set(&"a/b".try_into()?, &[])?;
-        store.set(&"a/c".try_into()?, &[])?;
+        store.set(&"a/b".try_into()?, &[0])?;
+        store.set(&"a/c".try_into()?, &[0, 0])?;
         store.set(&"a/d/e".try_into()?, &[])?;
         store.set(&"a/d/f".try_into()?, &[])?;
         store.erase(&"a/d/e".try_into()?)?;
@@ -249,6 +275,12 @@ mod tests {
             store.list_prefix(&"".try_into()?)?,
             &["a/b".try_into()?, "a/c".try_into()?, "a/d/f".try_into()?]
         );
+
+        assert_eq!(store.list_prefix(&"b/".try_into()?)?, &[]);
+
+        assert_eq!(store.size()?, 3);
+        assert_eq!(store.size_prefix(&"a/".try_into().unwrap())?, 3);
+        assert_eq!(store.size_key(&"a/b".try_into().unwrap())?, Some(1));
         Ok(())
     }
 
@@ -262,6 +294,9 @@ mod tests {
         store.set(&"a/f/h".try_into()?, &[])?;
         store.set(&"b/c/d".try_into()?, &[])?;
 
+        let list_dir = store.list_dir(&StorePrefix::root())?;
+        assert_eq!(list_dir.prefixes(), &["a/".try_into()?, "b/".try_into()?,]);
+
         let list_dir = store.list_dir(&"a/".try_into()?)?;
 
         assert_eq!(list_dir.keys(), &["a/b".try_into()?, "a/c".try_into()?,]);
@@ -269,6 +304,11 @@ mod tests {
             list_dir.prefixes(),
             &["a/d/".try_into()?, "a/f/".try_into()?,]
         );
+
+        store.erase_prefix(&"b/".try_into()?)?;
+        let list_dir = store.list_dir(&StorePrefix::root())?;
+        assert_eq!(list_dir.prefixes(), &["a/".try_into()?,]);
+
         Ok(())
     }
 }
diff --git a/src/version.rs b/src/version.rs
index fee2fc7d..88245a1c 100644
--- a/src/version.rs
+++ b/src/version.rs
@@ -40,6 +40,7 @@ pub fn version_patch() -> u32 {
 /// # use zarrs::version::version_minor;
 /// # use zarrs::version::version_patch;
 /// # let version = (version_major() << 22) | (version_minor() << 12) | version_patch();
+/// # assert!(version == zarrs::version::version());
 /// let version_major = (version as u32 >> 22) & 0x7F;
 /// # assert!(version_major == zarrs::version::version_major());
 /// let version_minor = (version as u32 >> 12) & 0x3FF;