implement test demonstrating the issue

Author: teh-cmc

src/block/compress.rs

@@ -221,7 +221,7 @@ fn count_same_bytes(input: &[u8], cur: &mut usize, source: &[u8], candidate: usi
 /// to produce a total length. When the byte value is 255, another byte must read and added, and so
 /// on. There can be any number of bytes of value "255" following token
 #[inline]
-fn write_integer(output: &mut impl Sink, mut n: usize) {
+pub(super) fn write_integer(output: &mut impl Sink, mut n: usize) {
     // Note: Since `n` is usually < 0xFF and writing multiple bytes to the output
     // requires 2 branches of bound check (due to the possibility of add overflows)
     // the simple byte at a time implementation below is faster in most cases.

src/block/decompress.rs

@@ -128,7 +128,7 @@ unsafe fn copy_from_dict(
 /// is encoded to _255 + 255 + 255 + 4 = 769_. The bytes after the first 4 is ignored, because
 /// 4 is the first non-0xFF byte.
 #[inline]
-fn read_integer_ptr(
+pub(super) fn read_integer_ptr(
     input_ptr: &mut *const u8,
     _input_ptr_end: *const u8,
 ) -> Result<u32, DecompressError> {

src/block/decompress_safe.rs

@@ -25,7 +25,7 @@ use alloc::vec::Vec;
 /// is encoded to _255 + 255 + 255 + 4 = 769_. The bytes after the first 4 is ignored, because
 /// 4 is the first non-0xFF byte.
 #[inline]
-fn read_integer(input: &[u8], input_pos: &mut usize) -> Result<u32, DecompressError> {
+pub(super) fn read_integer(input: &[u8], input_pos: &mut usize) -> Result<u32, DecompressError> {
     // We start at zero and count upwards.
     let mut n: u32 = 0;
     // If this byte takes value 255 (the maximum value it can take), another byte is read

src/block/mod.rs

@@ -152,3 +152,25 @@ pub fn uncompressed_size(input: &[u8]) -> Result<(usize, &[u8]), DecompressError
     let rest = &input[4..];
     Ok((uncompressed_size, rest))
 }
+
+#[test]
+#[cfg(target_pointer_width = "64")] // only relevant for 64bit CPUs
+fn large_integer_roundtrip() {
+    let u32_max = usize::try_from(u32::MAX).unwrap();
+    let value = u32_max + u32_max / 2;
+
+    let mut buf = vec![0u8; value / 255 + 1];
+    let mut sink = crate::sink::SliceSink::new(&mut buf, 0);
+    self::compress::write_integer(&mut sink, value);
+
+    #[cfg(feature = "safe-decode")]
+    let value_decompressed = self::decompress_safe::read_integer(&buf, &mut 0).unwrap();
+
+    #[cfg(not(feature = "safe-decode"))]
+    let value_decompressed = {
+        let mut ptr_range = buf.as_ptr_range();
+        self::decompress::read_integer_ptr(&mut ptr_range.start, ptr_range.end).unwrap()
+    };
+
+    assert_eq!(value, value_decompressed);
+}