Skip to content

Commit

Permalink
Increase code coverage in some modules
Browse files Browse the repository at this point in the history 
- version.rs
- fill_value_metadata.rs
- memory_store.rs
  • Loading branch information
@LDeakin
LDeakin committed Dec 21, 2023
1 parent d8fbc89 commit 7f71e53
Show file tree
Hide file tree
Showing 4 changed files with 92 additions and 33 deletions.
3 changes: 2 additions & 1 deletion CHANGELOG.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down
77 changes: 47 additions & 30 deletions src/array/fill_value_metadata.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -316,189 +316,206 @@ 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());
let fill_value = FillValue::from(fill_value);
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());
let fill_value = FillValue::from(fill_value);
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) => {
match re {
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!(),
}
}
}
44 changes: 42 additions & 2 deletions src/storage/store/store_sync/memory_store.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -221,15 +221,41 @@ 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(())
}

#[test]
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()?)?;
Expand All @@ -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(())
}

Expand All @@ -262,13 +294,21 @@ 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()?,]);
assert_eq!(
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(())
}
}
1 change: 1 addition & 0 deletions src/version.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand Down

0 comments on commit 7f71e53

Please sign in to comment.