Merge rust-bitcoin#5541: primitives: Improve test coverage in hash_types

0dbce2b Improve test coverage for WitnessMerkleNode (Jamil Lambert, PhD)
5fb07d0 Improve test coverage for TxMerkleNode (Jamil Lambert, PhD)
329c2ac Improve test coverage in hash_types (Jamil Lambert, PhD)
70f441f Make test dummy txid hex a const (Jamil Lambert, PhD)
7766f03 Improve test coverage for block_hash (Jamil Lambert, PhD)

Pull request description:

  Add tests to all of the files in `primitives/src/hash_types` to increase the test coverage to 100%.


ACKs for top commit:
  tcharding:
    ACK 0dbce2b
  apoelstra:
    ACK 0dbce2b; successfully ran local tests; all these tests seem pretty compact, nice


Tree-SHA512: 9279839b912dd332c599e7a4abe54b98da3a4a6fdcff9b9905d2b320d7d439dc09358d09d877582d1ca4a2a0450d29d183d9784b15fd918a8d23c7937b331b79

Author: apoelstra

primitives/src/hash_types/block_hash.rs

@@ -99,3 +99,33 @@ impl fmt::Display for BlockHashDecoderError {
 impl std::error::Error for BlockHashDecoderError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { Some(&self.0) }
 }
+
+#[cfg(test)]
+mod tests {
+    use encoding::Decoder as _;
+
+    use super::*;
+
+    #[test]
+    fn decoder_full_read_limit() {
+        assert_eq!(BlockHashDecoder::default().read_limit(), 32);
+        assert_eq!(<BlockHash as encoding::Decodable>::decoder().read_limit(), 32);
+    }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn decoder_error_display() {
+        use std::error::Error as _;
+        use std::string::ToString as _;
+
+        let mut decoder = BlockHashDecoder::new();
+        let mut bytes = &[0u8; 31][..];
+
+        assert!(decoder.push_bytes(&mut bytes).unwrap());
+
+        let err = decoder.end().unwrap_err();
+
+        assert!(!err.to_string().is_empty());
+        assert!(err.source().is_some());
+    }
+}

primitives/src/hash_types/mod.rs

@@ -189,11 +189,13 @@ pub mod serde_details {
 mod tests {
     use super::*;
 
+    #[cfg(feature = "serde")]
+    const DUMMY_TXID_HEX_STR: &str =
+        "e567952fb6cc33857f392efa3a46c995a28f69cca4bb1b37e0204dab1ec7a389";
+
     // Creates an arbitrary dummy hash type object.
     #[cfg(feature = "serde")]
-    fn dummy_test_case() -> Txid {
-        "e567952fb6cc33857f392efa3a46c995a28f69cca4bb1b37e0204dab1ec7a389".parse::<Txid>().unwrap()
-    }
+    fn dummy_test_case() -> Txid { DUMMY_TXID_HEX_STR.parse::<Txid>().unwrap() }
 
     #[test]
     #[cfg(feature = "serde")] // Implies alloc and hex
@@ -224,6 +226,19 @@ mod tests {
         assert_eq!(got, want);
     }
 
+    #[test]
+    fn as_ref_and_borrow_match_as_byte_array() {
+        let tc = Txid::from_byte_array([0x11; 32]);
+
+        let as_array: &[u8; 32] = tc.as_ref();
+        let as_slice: &[u8] = tc.as_ref();
+        let borrowed: &[u8; 32] = core::borrow::Borrow::<[u8; 32]>::borrow(&tc);
+
+        assert_eq!(as_array, tc.as_byte_array());
+        assert_eq!(borrowed, tc.as_byte_array());
+        assert_eq!(as_slice, tc.as_byte_array());
+    }
+
     #[test]
     // This is solely to test that we can debug print WITHOUT "hex" so its ok to require "alloc".
     #[cfg(feature = "alloc")]

primitives/src/hash_types/transaction_merkle_node.rs

@@ -118,3 +118,33 @@ impl fmt::Display for TxMerkleNodeDecoderError {
 impl std::error::Error for TxMerkleNodeDecoderError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { Some(&self.0) }
 }
+
+#[cfg(test)]
+mod tests {
+    use encoding::Decoder as _;
+
+    use super::*;
+
+    #[test]
+    fn decoder_full_read_limit() {
+        assert_eq!(TxMerkleNodeDecoder::default().read_limit(), 32);
+        assert_eq!(<TxMerkleNode as encoding::Decodable>::decoder().read_limit(), 32);
+    }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn decoder_error_display() {
+        use std::error::Error as _;
+        use std::string::ToString as _;
+
+        const NODE_LEN: usize = 32;
+
+        let mut decoder = TxMerkleNodeDecoder::new();
+        let mut bytes = &[0u8; NODE_LEN - 1][..];
+        assert!(decoder.push_bytes(&mut bytes).unwrap());
+
+        let err = decoder.end().unwrap_err();
+        assert!(!err.to_string().is_empty());
+        assert!(err.source().is_some());
+    }
+}

primitives/src/hash_types/witness_merkle_node.rs

@@ -120,3 +120,53 @@ impl fmt::Display for WitnessMerkleNodeDecoderError {
 impl std::error::Error for WitnessMerkleNodeDecoderError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { Some(&self.0) }
 }
+
+#[cfg(test)]
+mod tests {
+    use encoding::Decoder as _;
+
+    use super::*;
+
+    #[test]
+    fn combine_delegates_to_merkle_node_trait() {
+        let a = WitnessMerkleNode::from_leaf(Wtxid::from_byte_array([1; 32]));
+        let b = WitnessMerkleNode::from_leaf(Wtxid::from_byte_array([2; 32]));
+
+        assert_eq!(a.combine(&b), MerkleNode::combine(&a, &b));
+    }
+
+    #[test]
+    fn decoder_full_read_limit() {
+        assert_eq!(WitnessMerkleNodeDecoder::new().read_limit(), 32);
+        // These two are the same decoder but we want 100% coverage.
+        assert_eq!(WitnessMerkleNodeDecoder::default().read_limit(), 32);
+        assert_eq!(<WitnessMerkleNode as encoding::Decodable>::decoder().read_limit(), 32);
+    }
+
+    #[test]
+    fn decoder_successfully_decodes() {
+        let expected = WitnessMerkleNode::from_byte_array([0x55; 32]);
+        let mut decoder = WitnessMerkleNodeDecoder::new();
+        let mut bytes = &[0x55u8; 32][..];
+
+        let _done = decoder.push_bytes(&mut bytes).unwrap();
+
+        assert_eq!(decoder.end().unwrap(), expected);
+    }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn decoder_error_display() {
+        use std::error::Error as _;
+        use std::string::ToString as _;
+
+        let mut decoder = WitnessMerkleNodeDecoder::new();
+        let mut bytes = &[0u8; 31][..];
+
+        assert!(decoder.push_bytes(&mut bytes).unwrap());
+
+        let err = decoder.end().unwrap_err();
+        assert!(!err.to_string().is_empty());
+        assert!(err.source().is_some());
+    }
+}