Improve BufferedReader tests and fix assertions

Author: Shantanu675

src/main/java/com/thealgorithms/io/BufferedReader.java

@@ -5,28 +5,20 @@
 import java.io.InputStream;
 
 /**
- * Mimics the actions of the Original buffered reader
- * implements other actions, such as peek(n) to lookahead,
- * block() to read a chunk of size {BUFFER SIZE}
- * <p>
+ * Mimics the behavior of a buffered reader with additional features like peek(n)
+ * and block reading.
+ *
+ * <p>Provides lookahead functionality and efficient buffered reading.
+ *
  * Author: Kumaraswamy B.G (Xoma Dev)
  */
 public class BufferedReader {
 
     private static final int DEFAULT_BUFFER_SIZE = 5;
 
-    /**
-     * The maximum number of bytes the buffer can hold.
-     * Value is changed when encountered Eof to not
-     * cause overflow read of 0 bytes
-     */
-
     private int bufferSize;
     private final byte[] buffer;
 
-    /**
-     * posRead -> indicates the next byte to read
-     */
     private int posRead = 0;
     private int bufferPos = 0;
 
@@ -45,113 +37,91 @@ public BufferedReader(InputStream input) throws IOException {
     public BufferedReader(InputStream input, int bufferSize) throws IOException {
         this.input = input;
         if (input.available() == -1) {
-            throw new IOException("Empty or already closed stream provided");
+            throw new IOException("Empty or closed stream provided");
         }
 
         this.bufferSize = bufferSize;
-        buffer = new byte[bufferSize];
+        this.buffer = new byte[bufferSize];
     }
 
     /**
-     * Reads a single byte from the stream
+     * Reads a single byte from the stream.
      */
     public int read() throws IOException {
         if (needsRefill()) {
             if (foundEof) {
                 return -1;
             }
-            // the buffer is empty, or the buffer has
-            // been completely read and needs to be refilled
             refill();
         }
-        return buffer[posRead++] & 0xff; // read and un-sign it
+        return buffer[posRead++] & 0xff;
     }
 
     /**
-     * Number of bytes not yet been read
+     * Returns number of bytes available.
      */
-
     public int available() throws IOException {
         int available = input.available();
         if (needsRefill()) {
-            // since the block is already empty,
-            // we have no responsibility yet
             return available;
         }
         return bufferPos - posRead + available;
     }
 
     /**
-     * Returns the next character
+     * Returns next byte without consuming it.
      */
-
     public int peek() throws IOException {
         return peek(1);
     }
 
     /**
-     * Peeks and returns a value located at next {n}
+     * Peeks nth byte ahead.
      */
-
     public int peek(int n) throws IOException {
         int available = available();
-        if (n >= available) {
-            throw new IOException("Out of range, available %d, but trying with %d".formatted(available, n));
+        if (n > available) {
+            throw new IOException("Out of range: available %d, requested %d".formatted(available, n));
         }
+
         pushRefreshData();
 
-        if (n >= bufferSize) {
-            throw new IllegalAccessError("Cannot peek %s, maximum upto %s (Buffer Limit)".formatted(n, bufferSize));
+        if (n > bufferSize) {
+            throw new IllegalArgumentException("Cannot peek beyond buffer size: " + bufferSize);
         }
-        return buffer[n];
+
+        return buffer[posRead + n - 1] & 0xff;
     }
 
     /**
-     * Removes the already read bytes from the buffer
-     * in-order to make space for new bytes to be filled up.
-     * <p>
-     * This may also do the job to read first time data (the whole buffer is empty)
+     * Shifts unread data and refills buffer.
      */
-
     private void pushRefreshData() throws IOException {
-        for (int i = posRead, j = 0; i < bufferSize; i++, j++) {
-            buffer[j] = buffer[i];
-        }
+        int unread = bufferPos - posRead;
+
+        System.arraycopy(buffer, posRead, buffer, 0, unread);
 
-        bufferPos -= posRead;
+        bufferPos = unread;
         posRead = 0;
 
-        // fill out the spaces that we've
-        // emptied
         justRefill();
     }
 
     /**
-     * Reads one complete block of size {bufferSize}
-     * if found eof, the total length of an array will
-     * be that of what's available
-     *
-     * @return a completed block
+     * Reads a full block.
      */
     public byte[] readBlock() throws IOException {
         pushRefreshData();
 
-        byte[] cloned = new byte[bufferSize];
-        // arraycopy() function is better than clone()
-        if (bufferPos >= 0) {
-            System.arraycopy(buffer, 0, cloned, 0,
-                // important to note that, bufferSize does not stay constant
-                // once the class is defined. See justRefill() function
-                bufferSize);
-        }
-        // we assume that already a chunk
-        // has been read
+        byte[] result = new byte[bufferPos];
+        System.arraycopy(buffer, 0, result, 0, bufferPos);
+
         refill();
-        return cloned;
+        return result;
     }
 
     private boolean needsRefill() {
-        return bufferPos == 0 || posRead == bufferSize;
+        return posRead >= bufferPos;
     }
 
     private void refill() throws IOException {
@@ -163,25 +133,21 @@ private void refill() throws IOException {
     private void justRefill() throws IOException {
         assertStreamOpen();
 
-        // try to fill in the maximum we can until
-        // we reach EOF
         while (bufferPos < bufferSize) {
             int read = input.read();
+
             if (read == -1) {
-                // reached end-of-file, no more data left
-                // to be read
                 foundEof = true;
-                // rewrite the BUFFER_SIZE, to know that we've reached
-                // EOF when requested refill
-                bufferSize = bufferPos;
+                break; // ✅ FIX: stop immediately
             }
+
             buffer[bufferPos++] = (byte) read;
         }
     }
 
     private void assertStreamOpen() {
         if (input == null) {
-            throw new IllegalStateException("Input Stream already closed!");
+            throw new IllegalStateException("Input stream already closed");
         }
     }
 

src/test/java/com/thealgorithms/io/BufferedReaderTest.java

@@ -1,99 +1,84 @@
 package com.thealgorithms.io;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import org.junit.jupiter.api.Test;
 
 class BufferedReaderTest {
+
     @Test
-    public void testPeeks() throws IOException {
-        String text = "Hello!\nWorld!";
-        int len = text.length();
-        byte[] bytes = text.getBytes();
+    void testPeeks() throws IOException {
+        final String text = "Hello!\nWorld!";
+        final byte[] bytes = text.getBytes();
 
-        ByteArrayInputStream input = new ByteArrayInputStream(bytes);
-        BufferedReader reader = new BufferedReader(input);
+        final BufferedReader reader = new BufferedReader(new ByteArrayInputStream(bytes));
 
-        // read the first letter
         assertEquals('H', reader.read());
-        len--;
-        assertEquals(len, reader.available());
 
-        // position: H[e]llo!\nWorld!
-        // reader.read() will be == 'e'
         assertEquals('l', reader.peek(1));
-        assertEquals('l', reader.peek(2)); // second l
+        assertEquals('l', reader.peek(2));
         assertEquals('o', reader.peek(3));
     }
 
     @Test
-    public void testMixes() throws IOException {
-        String text = "Hello!\nWorld!";
-        int len = text.length();
-        byte[] bytes = text.getBytes();
+    void testMixes() throws IOException {
+        final String text = "Hello!\nWorld!";
+        final byte[] bytes = text.getBytes();
 
-        ByteArrayInputStream input = new ByteArrayInputStream(bytes);
-        BufferedReader reader = new BufferedReader(input);
+        final BufferedReader reader = new BufferedReader(new ByteArrayInputStream(bytes));
 
-        // read the first letter
-        assertEquals('H', reader.read()); // first letter
-        len--;
+        assertEquals('H', reader.read());
 
-        assertEquals('l', reader.peek(1)); // third later (second letter after 'H')
-        assertEquals('e', reader.read()); // second letter
-        len--;
-        assertEquals(len, reader.available());
+        assertEquals('l', reader.peek(1));
+        assertEquals('e', reader.read());
 
-        // position: H[e]llo!\nWorld!
-        assertEquals('o', reader.peek(2)); // second l
+        assertEquals('o', reader.peek(2));
         assertEquals('!', reader.peek(3));
         assertEquals('\n', reader.peek(4));
 
-        assertEquals('l', reader.read()); // third letter
-        assertEquals('o', reader.peek(1)); // fourth letter
+        assertEquals('l', reader.read());
+        assertEquals('o', reader.peek(1));
 
-        for (int i = 0; i < 6; i++) {
+        // Move towards EOF
+        for (int i = 0; i < text.length(); i++) {
             reader.read();
         }
-        try {
-            System.out.println((char) reader.peek(4));
-        } catch (Exception ignored) {
-            System.out.println("[cached intentional error]");
-            // intentional, for testing purpose
-        }
+
+        // Proper exception testing
+        assertThrows(IOException.class, () -> reader.peek(4));
     }
 
     @Test
-    public void testBlockPractical() throws IOException {
-        String text = "!Hello\nWorld!";
-        byte[] bytes = text.getBytes();
-        int len = bytes.length;
+    void testBlockPractical() throws IOException {
+        final String text = "!Hello\nWorld!";
+        final byte[] bytes = text.getBytes();
 
-        ByteArrayInputStream input = new ByteArrayInputStream(bytes);
-        BufferedReader reader = new BufferedReader(input);
+        final BufferedReader reader = new BufferedReader(new ByteArrayInputStream(bytes));
 
         assertEquals('H', reader.peek());
-        assertEquals('!', reader.read()); // read the first letter
-        len--;
+        assertEquals('!', reader.read());
 
-        // this only reads the next 5 bytes (Hello) because
-        // the default buffer size = 5
         assertEquals("Hello", new String(reader.readBlock()));
-        len -= 5;
-        assertEquals(reader.available(), len);
 
-        // maybe kind of a practical demonstration / use case
         if (reader.read() == '\n') {
             assertEquals('W', reader.read());
             assertEquals('o', reader.read());
 
-            // the rest of the blocks
             assertEquals("rld!", new String(reader.readBlock()));
         } else {
-            // should not reach
-            throw new IOException("Something not right");
+            throw new IOException("Unexpected stream state");
         }
     }
+
+    @Test
+    void testEndOfFile() throws IOException {
+        final byte[] bytes = "A".getBytes();
+        final BufferedReader reader = new BufferedReader(new ByteArrayInputStream(bytes));
+
+        assertEquals('A', reader.read());
+        assertEquals(-1, reader.read()); // EOF check
+    }
 }