Merge commit from fork

* Fix BoundedInputStream not counting null-bytes

Motivation:
The `InputStream.read()` method returns the byte value as an `int` in the range 0 to 255.

The `BoundedInputStream` has a bug in counting the number of bytes read, where valid 0-bytes were not counted toward the limit.

Modification:
The `BoundedInputStream` is changed to only consider -1 as EOF, which is exactly as documented on `InputStream`.
The `BoundedInputStream` is also changed to truncate and allow reads up to the limit, and then only trip the exception when it is at the limit and reads beyond.

The `BoundedInputStreamTest` has also been made repeating, because it was already occasionally finding this problem.
The test now passes consistently with the fixes.

Result:
The `BoundedInputStream` now counts all byte values toward the limit.

* Add deterministic test

* Refine deterministic test

---------

Co-authored-by: Chris Vest <[email protected]>

Author: normanmaurer

common/src/main/java/io/netty/util/internal/BoundedInputStream.java

@@ -40,11 +40,9 @@ public int read() throws IOException {
         checkMaxBytesRead();
 
         int b = super.read();
-        if (b > 0) {
+        if (b != -1) {
             numRead++;
         }
-
-        checkMaxBytesRead();
         return b;
     }
 
@@ -57,11 +55,9 @@ public int read(byte[] buf, int off, int len) throws IOException {
 
         int b = super.read(buf, off, num);
 
-        if (b > 0) {
+        if (b != -1) {
             numRead += b;
         }
-
-        checkMaxBytesRead();
         return b;
     }
 

common/src/test/java/io/netty/util/internal/BoundedInputStreamTest.java

@@ -15,20 +15,22 @@
  */
 package io.netty.util.internal;
 
+import org.junit.jupiter.api.RepeatedTest;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.function.Executable;
 
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.util.Arrays;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
 public class BoundedInputStreamTest {
 
-    @Test
+    @RepeatedTest(50)
     void testBoundEnforced() throws IOException {
         final byte[] bytes = new byte[64];
         PlatformDependent.threadLocalRandom().nextBytes(bytes);
@@ -38,19 +40,50 @@ void testBoundEnforced() throws IOException {
         assertThrows(IOException.class, new Executable() {
             @Override
             public void execute() throws Throwable {
-                reader.read(new byte[64], 0, 64);
+                int max = bytes.length;
+                do {
+                    int result = reader.read(new byte[max], 0, max);
+                    assertThat(result).isNotEqualTo(-1);
+                    max -= result;
+                } while (max > 0);
             }
         });
         reader.close();
     }
 
     @Test
+    void testBoundEnforced256() throws IOException {
+        final byte[] bytes = new byte[256];
+        for (int i = 0; i < bytes.length; i++) {
+            bytes[i] = (byte) i;
+        }
+        final BoundedInputStream reader = new BoundedInputStream(new ByteArrayInputStream(bytes), bytes.length - 1);
+        for (byte expectedByte : bytes) {
+            assertEquals(expectedByte, (byte) reader.read());
+        }
+
+        assertThrows(IOException.class, new Executable() {
+            @Override
+            public void execute() throws Throwable {
+                reader.read();
+            }
+        });
+        assertThrows(IOException.class, new Executable() {
+            @Override
+            public void execute() throws Throwable {
+                reader.read(new byte[1], 0, 1);
+            }
+        });
+        reader.close();
+    }
+
+    @RepeatedTest(50)
     void testBigReadsPermittedIfUnderlyingStreamIsSmall() throws IOException {
         final byte[] bytes = new byte[64];
         PlatformDependent.threadLocalRandom().nextBytes(bytes);
         final BoundedInputStream reader = new BoundedInputStream(new ByteArrayInputStream(bytes), 8192);
         final byte[] buffer = new byte[10000];
-        reader.read(buffer, 0, 10000);
+        assertThat(reader.read(buffer, 0, 10000)).isEqualTo(64);
         assertArrayEquals(bytes, Arrays.copyOfRange(buffer, 0, 64));
         reader.close();
     }