fix(#99): LongHistogram round-trip fails with significantDigits != 3 (#130)

* test(#99): add tests reproducing partial-read bug in ByteBuffer.ReadFrom

ByteBufferTests uses a PartialReadStream wrapper to deterministically
prove that ReadFrom only returns the first chunk when the underlying
stream delivers data in multiple reads — exactly the behaviour of
DeflateStream at DEFLATE block boundaries.

Also adds parameterised round-trip tests varying significantDigits (1-5)
and value counts (1,000–50,000) across the compressed encode/decode and
full log-writer/reader pipelines.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(#99): LongHistogram round-trip fails with significantDigits != 3

Two bugs in the DEFLATE compression/decompression path:

1. ByteBuffer.ReadFrom called Stream.Read() once, but DeflateStream may
   return fewer bytes than requested at compression-block boundaries.
   Replaced with a loop that reads until all bytes are consumed or
   end-of-stream.

2. ByteBufferExtensions.CompressedCopy compressed the entire buffer
   capacity (source.ToArray()) instead of only the bytes written
   (source.Position).  For significantDigits=4 the intermediate buffer
   is ~2.75 MB but only ~30-40 KB is data; the trailing zeros inflated
   the compressed stream and increased the chance of partial reads on
   decompression.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: LeeCampbell

HdrHistogram.UnitTests/HistogramEncodingTestBase.cs

@@ -30,6 +30,25 @@ public void Given_a_populated_Histogram_When_encoded_and_decoded_with_compressio
             HistogramAssert.AreValueEqual(source, result);
         }
 
+        [Theory]
+        [InlineData(1, 10000)]
+        [InlineData(2, 10000)]
+        [InlineData(3, 10000)]
+        [InlineData(4, 10000)]
+        [InlineData(5, 10000)]
+        [InlineData(4, 50000)]
+        public void Given_varying_significant_digits_When_compressed_encoded_and_decoded_Then_data_is_preserved(int significantDigits, int valueCount)
+        {
+            var highestTrackableValue = 3600L * 1000 * 1000 * 1000;
+            var source = Create(highestTrackableValue, significantDigits);
+            for (long i = 0; i < valueCount; i++)
+            {
+                source.RecordValue(i * 1000);
+            }
+            var result = CompressedEncodeDecode(source);
+            HistogramAssert.AreValueEqual(source, result);
+        }
+
         [Fact]
         public void Given_a_Histogram_populated_with_full_range_of_values_When_encoded_and_decoded_Then_data_is_preserved()
         {

HdrHistogram.UnitTests/Persistence/HistogramLogReaderWriterTestBase.cs

@@ -53,6 +53,36 @@ public void CanRoundTripSingleHistogram(long highestTrackableValue, int signific
             HistogramAssert.AreValueEqual(histogram, actualHistograms.Single());
         }
 
+        [Theory]
+        [InlineData(1, 1000)]
+        [InlineData(2, 1000)]
+        [InlineData(3, 1000)]
+        [InlineData(4, 1000)]
+        [InlineData(5, 1000)]
+        [InlineData(1, 10000)]
+        [InlineData(2, 10000)]
+        [InlineData(3, 10000)]
+        [InlineData(4, 10000)]
+        [InlineData(5, 10000)]
+        [InlineData(4, 50000)]
+        [InlineData(5, 50000)]
+        public void CanRoundTripSingleHistogramWithVaryingSignificantDigits(int significantDigits, int valueCount)
+        {
+            var highestTrackableValue = OneHourOfNanoseconds;
+            var histogram = Create(highestTrackableValue, significantDigits);
+            for (long i = 0; i < valueCount; i++)
+            {
+                histogram.RecordValue(i * 1000);
+            }
+
+            histogram.SetTimes();
+            var data = histogram.WriteLog();
+            var actualHistograms = data.ReadHistograms();
+
+            Assert.Single(actualHistograms);
+            HistogramAssert.AreValueEqual(histogram, actualHistograms.Single());
+        }
+
         protected void RoundTripSingleHistogramsWithFullRangesOfCountsAndValues(long count)
         {
             var value = 1;

HdrHistogram.UnitTests/Utilities/ByteBufferTests.cs

@@ -0,0 +1,72 @@
+using System;
+using System.IO;
+using HdrHistogram.Utilities;
+using Xunit;
+
+namespace HdrHistogram.UnitTests.Utilities
+{
+    public class ByteBufferTests
+    {
+        /// <summary>
+        /// Reproduces Issue #99.
+        /// <see cref="ByteBuffer.ReadFrom"/> must loop until all requested bytes
+        /// have been read, because <see cref="Stream.Read"/> is permitted to
+        /// return fewer bytes than requested — even when more data is available.
+        /// <see cref="System.IO.Compression.DeflateStream"/> does exactly this
+        /// at DEFLATE block boundaries.
+        /// </summary>
+        [Theory]
+        [InlineData(1024, 100)]
+        [InlineData(4096, 511)]
+        [InlineData(8192, 1000)]
+        public void ReadFrom_returns_all_bytes_when_stream_returns_partial_reads(
+            int totalBytes, int maxBytesPerRead)
+        {
+            var data = new byte[totalBytes];
+            new Random(42).NextBytes(data);
+            var stream = new PartialReadStream(new MemoryStream(data), maxBytesPerRead);
+            var buffer = ByteBuffer.Allocate(totalBytes);
+
+            int bytesRead = buffer.ReadFrom(stream, totalBytes);
+
+            Assert.Equal(totalBytes, bytesRead);
+        }
+
+        /// <summary>
+        /// A stream wrapper that returns at most <c>maxBytesPerRead</c> bytes
+        /// per <see cref="Read"/> call, simulating the behaviour of
+        /// <see cref="System.IO.Compression.DeflateStream"/> at compression
+        /// block boundaries.
+        /// </summary>
+        private sealed class PartialReadStream : Stream
+        {
+            private readonly Stream _inner;
+            private readonly int _maxBytesPerRead;
+
+            public PartialReadStream(Stream inner, int maxBytesPerRead)
+            {
+                _inner = inner;
+                _maxBytesPerRead = maxBytesPerRead;
+            }
+
+            public override int Read(byte[] buffer, int offset, int count)
+            {
+                return _inner.Read(buffer, offset, Math.Min(count, _maxBytesPerRead));
+            }
+
+            public override bool CanRead => true;
+            public override bool CanSeek => false;
+            public override bool CanWrite => false;
+            public override long Length => throw new NotSupportedException();
+            public override long Position
+            {
+                get => throw new NotSupportedException();
+                set => throw new NotSupportedException();
+            }
+            public override void Flush() { }
+            public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
+            public override void SetLength(long value) => throw new NotSupportedException();
+            public override void Write(byte[] buffer, int offset, int count) => throw new NotSupportedException();
+        }
+    }
+}

HdrHistogram/Utilities/ByteBuffer.cs

@@ -83,7 +83,14 @@ public int Remaining()
         /// <returns>The number of bytes read.</returns>
         public int ReadFrom(System.IO.Stream source, int length)
         {
-            return source.Read(_internalBuffer, Position, length);
+            int totalRead = 0;
+            while (totalRead < length)
+            {
+                int bytesRead = source.Read(_internalBuffer, Position + totalRead, length - totalRead);
+                if (bytesRead == 0) break;
+                totalRead += bytesRead;
+            }
+            return totalRead;
         }
 
         /// <summary>

HdrHistogram/Utilities/ByteBufferExtensions.cs

@@ -15,7 +15,7 @@ internal static class ByteBufferExtensions
         public static int CompressedCopy(this ByteBuffer target, ByteBuffer source, int targetOffset)
         {
             byte[] compressed;
-            using (var ms = new MemoryStream(source.ToArray()))
+            using (var ms = new MemoryStream(source.ToArray(), 0, source.Position))
             {
                 compressed = Compress(ms);
             }