Merge rust-bitcoin#5588: primitives: Improve test coverage of witness

5a834e2 Add test of error display and source (Jamil Lambert, PhD)
f408b24 Split out error test into its own test (Jamil Lambert, PhD)
834e832 Improve test coverage of witness (Jamil Lambert, PhD)

Pull request description:

  Add tests to increase the coverage of witness to 100% excluding one `unreachable!`.
  
  Split out the error check of an existing test into its own test.
  
  Add tests of the error display and source, can be removed if required.


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


Tree-SHA512: fb8fa9159e9ef2ad08dd94d33422f7ab453f43de457cb77bf3e53afea22be932b3417e19b47e2e61831f497f4ba01ca7c9ca3d09e807bbde200fa18d14112c47

Author: apoelstra

primitives/src/witness.rs

@@ -958,7 +958,14 @@ fn decode_unchecked(slice: &mut &[u8]) -> u64 {
 #[cfg(test)]
 mod test {
     #[cfg(feature = "alloc")]
-    use alloc::vec;
+    use alloc::string::ToString;
+    #[cfg(feature = "alloc")]
+    use alloc::{format, vec};
+    #[cfg(feature = "std")]
+    use std::error::Error as _;
+
+    #[cfg(feature = "alloc")]
+    use encoding::Decodable as _;
 
     use super::*;
 
@@ -1193,6 +1200,13 @@ mod test {
         assert_ne!(*different, witness);
     }
 
+    #[test]
+    fn partial_eq_len_mismatch() {
+        let witness = Witness::from_slice(&[&[1u8][..]]);
+        let rhs = vec![vec![1u8], vec![2u8]];
+        assert_ne!(witness, rhs.as_slice());
+    }
+
     #[test]
     #[cfg(feature = "serde")]
     fn serde_bincode_backward_compatibility() {
@@ -1410,7 +1424,11 @@ mod test {
         decoder.push_bytes(&mut slice).unwrap();
         let witness = decoder.end().unwrap();
         assert_eq!(witness[0].len(), 4_000_000);
+    }
 
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn decode_length_prefix_error() {
         let mut encoded = Vec::new();
         encoded.extend_from_slice(crate::compact_size_encode(1usize).as_slice());
         encoded.extend_from_slice(crate::compact_size_encode(4_000_001usize).as_slice());
@@ -1422,6 +1440,9 @@ mod test {
             err,
             WitnessDecoderError(WitnessDecoderErrorInner::LengthPrefixDecode(_))
         ));
+        assert!(!err.to_string().is_empty());
+        #[cfg(feature = "std")]
+        assert!(err.source().is_some());
     }
 
     #[test]
@@ -1528,6 +1549,86 @@ mod test {
         assert!(matches!(err, WitnessDecoderError(WitnessDecoderErrorInner::UnexpectedEof(_))));
     }
 
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn decoder_read_limit() {
+        let mut decoder = Witness::decoder();
+        // witness_count_decoder is CompactSize: needs 1 byte.
+        assert_eq!(decoder.read_limit(), 1);
+
+        // Set witness count = 1.
+        let mut bytes = [0x01u8].as_slice();
+        decoder.push_bytes(&mut bytes).unwrap();
+        // element_length_decoder is CompactSize: needs 1 byte..
+        assert_eq!(decoder.read_limit(), 1);
+
+        // Provide only first byte of a 3 byte CompactSize.
+        let mut bytes = [0xFDu8].as_slice();
+        decoder.push_bytes(&mut bytes).unwrap();
+        assert_eq!(decoder.read_limit(), 2);
+
+        // Set element length to 500 (0x01F4 little-endian).
+        let mut bytes = [0xF4u8, 0x01].as_slice();
+        decoder.push_bytes(&mut bytes).unwrap();
+        // Decoder now reads element data and the limit becomes the element length.
+        assert_eq!(decoder.read_limit(), 500);
+
+        // Provide 1 byte of element data decreasing the read limit by 1.
+        let mut bytes = [0xAAu8].as_slice();
+        decoder.push_bytes(&mut bytes).unwrap();
+        assert_eq!(decoder.read_limit(), 499);
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn decoder_end_without_witness_count_errors() {
+        let err = WitnessDecoder::new().end().unwrap_err();
+        assert!(matches!(
+            err,
+            WitnessDecoderError(WitnessDecoderErrorInner::UnexpectedEof(UnexpectedEofError {
+                missing_elements: 0
+            }))
+        ));
+        assert!(!err.to_string().is_empty());
+        #[cfg(feature = "std")]
+        assert!(err.source().is_some());
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn decoder_unexpected_eof_error() {
+        let mut decoder = WitnessDecoder::new();
+        let mut slice = [0x01].as_slice(); // witness element count = 1.
+        assert!(decoder.push_bytes(&mut slice).unwrap());
+
+        let inner = match decoder.end().unwrap_err() {
+            WitnessDecoderError(WitnessDecoderErrorInner::UnexpectedEof(inner)) => inner,
+            err => panic!("unexpected error: {err}"),
+        };
+        assert!(!inner.to_string().is_empty());
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn reserve_batch_returns_existing_len() {
+        let mut decoder = WitnessDecoder::new();
+        decoder.content = vec![0u8; 4];
+        assert_eq!(decoder.reserve_batch(4), 4);
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn reserve_batch_reserves_when_full() {
+        let mut decoder = WitnessDecoder::new();
+        let content = vec![0; 1];
+        decoder.content = content;
+        assert_eq!(decoder.content.capacity(), decoder.content.len());
+
+        let new_len = decoder.reserve_batch(2);
+        assert_eq!(decoder.content.len(), new_len);
+        assert!(decoder.content.len() >= 2);
+    }
+
     #[test]
     #[cfg(feature = "alloc")]
     fn decode_buffer_resizing() {
@@ -1549,6 +1650,34 @@ mod test {
         assert_eq!(&witness[1], large_element.as_slice());
     }
 
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn iter_next_none_if_cursor_decode_fails() {
+        let witness = Witness { content: vec![], witness_elements: 1, indices_start: 0 };
+        assert!(witness.iter().next().is_none());
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn iter_next_none_if_element_len_too_big() {
+        // Element length = 4_000_001 which is larger than MAX_VEC_SIZE (4_000_000).
+        let mut content = vec![0xFE];
+        content.extend_from_slice(&4_000_001u32.to_le_bytes());
+        let indices_start = content.len();
+        content.extend_from_slice(&u32::to_ne_bytes(0));
+
+        let witness = Witness { content, witness_elements: 1, indices_start };
+        assert!(witness.iter().next().is_none());
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn witness_debug() {
+        let witness = Witness::from_slice(&[&[0xAAu8][..]]);
+        let s = format!("{:?}", witness);
+        assert!(!s.is_empty());
+    }
+
     #[test]
     fn size_matches_encoding_length() {
         let empty = Witness::new();