From 2c73546454cf39cc4759a99ef6f1caf63b8da584 Mon Sep 17 00:00:00 2001 From: "Jamil Lambert, PhD" Date: Thu, 23 Jan 2025 18:35:21 +0000 Subject: [PATCH 1/2] Improve absolute::LockTime tests Cargo mutants found some untested mutants. Add test cases and refactor to improve readability. --- primitives/src/locktime/absolute.rs | 34 +++++++++++++++++++---------- 1 file changed, 22 insertions(+), 12 deletions(-) diff --git a/primitives/src/locktime/absolute.rs b/primitives/src/locktime/absolute.rs index 02196da7a..679d3218b 100644 --- a/primitives/src/locktime/absolute.rs +++ b/primitives/src/locktime/absolute.rs @@ -447,40 +447,50 @@ mod tests { #[test] fn parses_correctly_to_height_or_time() { - let lock = LockTime::from_consensus(750_000); + let lock_height = LockTime::from_consensus(750_000); - assert!(lock.is_block_height()); - assert!(!lock.is_block_time()); + assert!(lock_height.is_block_height()); + assert!(!lock_height.is_block_time()); let t: u32 = 1653195600; // May 22nd, 5am UTC. - let lock = LockTime::from_consensus(t); + let lock_time = LockTime::from_consensus(t); - assert!(!lock.is_block_height()); - assert!(lock.is_block_time()); + assert!(!lock_time.is_block_height()); + assert!(lock_time.is_block_time()); + + // Test is_same_unit() logic + assert!(lock_height.is_same_unit(LockTime::from_consensus(800_000))); + assert!(!lock_height.is_same_unit(lock_time)); + assert!(lock_time.is_same_unit(LockTime::from_consensus(1653282000))); + assert!(!lock_time.is_same_unit(lock_height)); } #[test] fn satisfied_by_height() { let lock = LockTime::from_consensus(750_000); - let height = Height::from_consensus(800_000).expect("failed to parse height"); + let height_above = Height::from_consensus(800_000).expect("failed to parse height"); + let height_below = Height::from_consensus(700_000).expect("failed to parse height"); let t: u32 = 1653195600; // May 22nd, 5am UTC. let time = Time::from_consensus(t).expect("invalid time value"); - assert!(lock.is_satisfied_by(height, time)) + assert!(lock.is_satisfied_by(height_above, time)); + assert!(!lock.is_satisfied_by(height_below, time)); } #[test] fn satisfied_by_time() { - let lock = LockTime::from_consensus(1053195600); + let lock_time = LockTime::from_consensus(1653195600); // May 22nd 2022, 5am UTC. - let t: u32 = 1653195600; // May 22nd, 5am UTC. - let time = Time::from_consensus(t).expect("invalid time value"); + let day_after = Time::from_consensus(1653282000).expect("May 23rd 2022, 5am UTC"); + let day_before = Time::from_consensus(1653109200).expect("May 21th 2022, 5am UTC"); let height = Height::from_consensus(800_000).expect("failed to parse height"); - assert!(lock.is_satisfied_by(height, time)) + assert!(lock_time.is_satisfied_by(height, day_after)); + assert!(!lock_time.is_satisfied_by(height, day_before)); + } #[test] From 40dc8969322f18bd2f4cb8d9a49eee0b4ed927cc Mon Sep 17 00:00:00 2001 From: "Jamil Lambert, PhD" Date: Thu, 23 Jan 2025 18:49:04 +0000 Subject: [PATCH 2/2] Improve relative::LockTime tests Cargo mutants found some untested mutants. Add test cases to kill the mutants. --- primitives/src/locktime/relative.rs | 43 +++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) diff --git a/primitives/src/locktime/relative.rs b/primitives/src/locktime/relative.rs index 7e8d968e8..8b4a21915 100644 --- a/primitives/src/locktime/relative.rs +++ b/primitives/src/locktime/relative.rs @@ -425,6 +425,31 @@ impl std::error::Error for IncompatibleTimeError {} mod tests { use super::*; + #[test] + fn parses_correctly_to_height_or_time() { + let height1 = Height::from(10); + let height2 = Height::from(11); + let time1 = Time::from_512_second_intervals(70); + let time2 = Time::from_512_second_intervals(71); + + let lock_height1 = LockTime::from(height1); + let lock_height2 = LockTime::from(height2); + let lock_time1 = LockTime::from(time1); + let lock_time2 = LockTime::from(time2); + + assert!(lock_height1.is_block_height()); + assert!(!lock_height1.is_block_time()); + + assert!(!lock_time1.is_block_height()); + assert!(lock_time1.is_block_time()); + + // Test is_same_unit() logic + assert!(lock_height1.is_same_unit(lock_height2)); + assert!(!lock_height1.is_same_unit(lock_time1)); + assert!(lock_time1.is_same_unit(lock_time2)); + assert!(!lock_time1.is_same_unit(lock_height1)); + } + #[test] fn satisfied_by_height() { let height = Height::from(10); @@ -469,6 +494,24 @@ mod tests { assert!(lock.is_implied_by(LockTime::from(Time::from_512_second_intervals(71)))); } + #[test] + fn sequence_correctly_implies() { + let height = Height::from(10); + let time = Time::from_512_second_intervals(70); + + let lock_height = LockTime::from(height); + let lock_time = LockTime::from(time); + + let seq_height = Sequence::from(lock_height); + let seq_time = Sequence::from(lock_time); + + assert!(lock_height.is_implied_by_sequence(seq_height)); + assert!(!lock_height.is_implied_by_sequence(seq_time)); + + assert!(lock_time.is_implied_by_sequence(seq_time)); + assert!(!lock_time.is_implied_by_sequence(seq_height)); + } + #[test] fn incorrect_units_do_not_imply() { let time = Time::from_512_second_intervals(70);