Merge rust-bitcoin#4532: units: Kill mutants found in weekly mutation testing

b538a10 Add deprecated functions to mutants exclude list (Jamil Lambert, PhD)
fd0a756 Add tests to relative locktime (Jamil Lambert, PhD)
24cc059 Add tests to result (Jamil Lambert, PhD)
c1d2f03 Add tests to block (Jamil Lambert, PhD)

Pull request description:

  Weekly mutation testing found new mutants.

  Add tests to kill the valid mutants.

  Add deprecated functions to the exclude list so they are not mutated.

  Closes rust-bitcoin#4488, Closes rust-bitcoin#4528

ACKs for top commit:
  apoelstra:
    ACK b538a10; successfully ran local tests
  tcharding:
    ACK b538a10

Tree-SHA512: 8393ded6c073b2580fbb0fde9a8ce702a3d1e8c581c035870c2ba6a12d718cee577e345c9d92d0761552765248a6fb5ae9bbacbc88cac75e7153516de46de4ca

Author: apoelstra

.cargo/mutants.toml

@@ -23,6 +23,8 @@ exclude_re = [
     "FeeRate::fee_vb", # Deprecated
     "FeeRate::fee_wu", # Deprecated
     "SignedAmount::checked_abs", # Deprecated
+    "NumberOfBlocks::value", # Deprecated
+    "NumberOf512Seconds::to_consensus_u32", # Deprecated
 
     # primitives
     "Sequence::from_512_second_intervals", # Mutant from replacing | with ^, this returns the same value since the XOR is taken against the u16 with an all-zero bitmask

units/src/block.rs

@@ -439,6 +439,7 @@ impl<'a> core::iter::Sum<&'a BlockMtpInterval> for BlockMtpInterval {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::locktime::relative::NumberOf512Seconds;
 
     #[test]
     fn sanity_check() {
@@ -479,6 +480,7 @@ mod tests {
         // interval - interval = interval
         assert!(BlockHeightInterval(10) - BlockHeightInterval(7) == BlockHeightInterval(3));
 
+        // Sum for BlockHeightInterval by reference and by value
         assert!(
             [BlockHeightInterval(1), BlockHeightInterval(2), BlockHeightInterval(3)]
                 .iter()
@@ -492,6 +494,20 @@ mod tests {
                 == BlockHeightInterval(15)
         );
 
+        // Sum for BlockMtpInterval by reference and by value
+        assert!(
+            [BlockMtpInterval(1), BlockMtpInterval(2), BlockMtpInterval(3)]
+                .iter()
+                .sum::<BlockMtpInterval>()
+                == BlockMtpInterval(6)
+        );
+        assert!(
+            [BlockMtpInterval(4), BlockMtpInterval(5), BlockMtpInterval(6)]
+                .into_iter()
+                .sum::<BlockMtpInterval>()
+                == BlockMtpInterval(15)
+        );
+
         // interval += interval
         let mut int = BlockHeightInterval(1);
         int += BlockHeightInterval(2);
@@ -502,4 +518,54 @@ mod tests {
         int -= BlockHeightInterval(7);
         assert_eq!(int, BlockHeightInterval(3));
     }
+
+    #[test]
+    fn block_height_checked() {
+        let a = BlockHeight(10);
+        let b = BlockHeight(5);
+        assert_eq!(a.checked_sub(b), Some(BlockHeightInterval(5)));
+        assert_eq!(a.checked_add(BlockHeightInterval(5)), Some(BlockHeight(15)));
+        assert_eq!(a.checked_sub(BlockHeight(11)), None);
+        assert_eq!(a.checked_add(BlockHeightInterval(u32::MAX - 5)), None);
+    }
+
+    #[test]
+    fn block_height_interval_checked() {
+        let a = BlockHeightInterval(10);
+        let b = BlockHeightInterval(5);
+        assert_eq!(a.checked_sub(b), Some(BlockHeightInterval(5)));
+        assert_eq!(a.checked_add(b), Some(BlockHeightInterval(15)));
+        assert_eq!(a.checked_sub(BlockHeightInterval(11)), None);
+        assert_eq!(a.checked_add(BlockHeightInterval(u32::MAX - 5)), None);
+    }
+
+    #[test]
+    fn block_mtp_interval_checked() {
+        let a = BlockMtpInterval(10);
+        let b = BlockMtpInterval(5);
+        assert_eq!(a.checked_sub(b), Some(BlockMtpInterval(5)));
+        assert_eq!(a.checked_add(b), Some(BlockMtpInterval(15)));
+        assert_eq!(a.checked_sub(BlockMtpInterval(11)), None);
+        assert_eq!(a.checked_add(BlockMtpInterval(u32::MAX - 5)), None);
+    }
+
+    #[test]
+    fn block_mtp_checked() {
+        let a = BlockMtp(10);
+        let b = BlockMtp(5);
+        assert_eq!(a.checked_sub(b), Some(BlockMtpInterval(5)));
+        assert_eq!(a.checked_add(BlockMtpInterval(5)), Some(BlockMtp(15)));
+        assert_eq!(a.checked_sub(BlockMtp(11)), None);
+        assert_eq!(a.checked_add(BlockMtpInterval(u32::MAX - 5)), None);
+    }
+
+    #[test]
+    fn block_mtp_interval_from_number_of_512seconds() {
+        let n = NumberOf512Seconds::from_seconds_floor(0).unwrap();
+        let interval = BlockMtpInterval::from(n);
+        assert_eq!(interval, BlockMtpInterval(0));
+        let n = NumberOf512Seconds::from_seconds_floor(1024).unwrap();
+        let interval = BlockMtpInterval::from(n);
+        assert_eq!(interval, BlockMtpInterval(1024));
+    }
 }

units/src/locktime/relative.rs

@@ -333,6 +333,7 @@ mod tests {
             NumberOf512Seconds::from_512_second_intervals(100).to_consensus_u32(),
             4_194_404u32
         ); // 0x400064
+        assert_eq!(NumberOf512Seconds::from_512_second_intervals(1).to_seconds(), 512);
     }
 
     #[test]

units/src/result.rs

@@ -310,3 +310,34 @@ impl fmt::Display for MathOp {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::MathOp;
+
+    #[test]
+    fn mathop_predicates() {
+        assert!(MathOp::Add.is_overflow());
+        assert!(MathOp::Sub.is_overflow());
+        assert!(MathOp::Mul.is_overflow());
+        assert!(MathOp::Neg.is_overflow());
+        assert!(!MathOp::Div.is_overflow());
+        assert!(!MathOp::Rem.is_overflow());
+
+        assert!(MathOp::Div.is_div_by_zero());
+        assert!(MathOp::Rem.is_div_by_zero());
+        assert!(!MathOp::Add.is_div_by_zero());
+
+        assert!(MathOp::Add.is_addition());
+        assert!(!MathOp::Sub.is_addition());
+
+        assert!(MathOp::Sub.is_subtraction());
+        assert!(!MathOp::Add.is_subtraction());
+
+        assert!(MathOp::Mul.is_multiplication());
+        assert!(!MathOp::Div.is_multiplication());
+
+        assert!(MathOp::Neg.is_negation());
+        assert!(!MathOp::Add.is_negation());
+    }
+}