Fix BufferedReader to match expected peek behavior

Author: Shantanu675

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

@@ -5,12 +5,7 @@
 import java.io.InputStream;
 
 /**
- * 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)
+ * Mimics the actions of the Original buffered reader.
  */
 public class BufferedReader {
 
@@ -36,17 +31,15 @@ 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 closed stream provided");
+            throw new IOException("Empty or already closed stream provided");
         }
 
         this.bufferSize = bufferSize;
         this.buffer = new byte[bufferSize];
     }
 
-    /**
-     * Reads a single byte from the stream.
-     */
     public int read() throws IOException {
         if (needsRefill()) {
             if (foundEof) {
@@ -57,9 +50,6 @@ public int read() throws IOException {
         return buffer[posRead++] & 0xff;
     }
 
-    /**
-     * Returns number of bytes available.
-     */
     public int available() throws IOException {
         int available = input.available();
         if (needsRefill()) {
@@ -68,60 +58,53 @@ public int available() throws IOException {
         return bufferPos - posRead + available;
     }
 
-    /**
-     * Returns next byte without consuming it.
-     */
     public int peek() throws IOException {
         return peek(1);
     }
 
-    /**
-     * 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, requested %d".formatted(available, n));
+        if (n >= available) {
+            throw new IOException("Out of range, available %d, but trying with %d".formatted(available, n));
         }
 
         pushRefreshData();
 
-        if (n > bufferSize) {
-            throw new IllegalArgumentException("Cannot peek beyond buffer size: " + bufferSize);
+        if (n >= bufferSize) {
+            throw new IllegalAccessError("Cannot peek %s, maximum upto %s (Buffer Limit)".formatted(n, bufferSize));
         }
 
-        return buffer[posRead + n - 1] & 0xff;
+        // 🔥 KEY FIX (match test expectations)
+        return buffer[posRead + n] & 0xff;
     }
 
-    /**
-     * Shifts unread data and refills buffer.
-     */
     private void pushRefreshData() throws IOException {
-        int unread = bufferPos - posRead;
-
-        System.arraycopy(buffer, posRead, buffer, 0, unread);
+        int j = 0;
+        for (int i = posRead; i < bufferPos; i++, j++) {
+            buffer[j] = buffer[i];
+        }
 
-        bufferPos = unread;
+        bufferPos = j;
         posRead = 0;
 
         justRefill();
     }
 
-    /**
-     * Reads a full block.
-     */
     public byte[] readBlock() throws IOException {
         pushRefreshData();
 
-        byte[] result = new byte[bufferPos];
-        System.arraycopy(buffer, 0, result, 0, bufferPos);
+        byte[] cloned = new byte[bufferSize];
+
+        if (bufferPos > 0) {
+            System.arraycopy(buffer, 0, cloned, 0, bufferSize);
+        }
 
         refill();
-        return result;
+        return cloned;
     }
 
     private boolean needsRefill() {
-        return posRead >= bufferPos;
+        return bufferPos == 0 || posRead >= bufferPos;
     }
 
     private void refill() throws IOException {
@@ -138,7 +121,8 @@ private void justRefill() throws IOException {
 
             if (read == -1) {
                 foundEof = true;
-                break; // ✅ FIX: stop immediately
+                bufferSize = bufferPos;
+                break; // 🔥 important fix
             }
 
             buffer[bufferPos++] = (byte) read;
@@ -147,7 +131,7 @@ private void justRefill() throws IOException {
 
     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

@@ -96,4 +96,4 @@ public void testBlockPractical() throws IOException {
             throw new IOException("Something not right");
         }
     }
-}
+}