From 7f71e53c5a7c1671c12af6d03d1bacff465c243f Mon Sep 17 00:00:00 2001 From: Lachlan Deakin Date: Thu, 21 Dec 2023 15:31:40 +1100 Subject: [PATCH] Increase code coverage in some modules - version.rs - fill_value_metadata.rs - memory_store.rs --- CHANGELOG.md | 3 +- src/array/fill_value_metadata.rs | 77 ++++++++++++-------- src/storage/store/store_sync/memory_store.rs | 44 ++++++++++- src/version.rs | 1 + 4 files changed, 92 insertions(+), 33 deletions(-) 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::() + .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::() + .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::() + .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> { 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;