From 931f56626737d912ca8b09deeaab89d36b5054e2 Mon Sep 17 00:00:00 2001
From: Sylvain Jermini <sylvain.jermini@syjer.com>
Date: Wed, 7 Oct 2026 23:17:21 +0200
Subject: [PATCH 1/2] refactored input stream

---
 .../ch/digitalfondue/jfiveparse/Parser.java   |   9 +-
 .../jfiveparse/ProcessedInputStream.java      | 403 ++++++++----------
 .../jfiveparse/ProcessedInputStreamTest.java  | 125 ++++++
 .../ProcessedInputStreamWithParseError.java   |  30 +-
 4 files changed, 332 insertions(+), 235 deletions(-)
 create mode 100644 src/test/java/ch/digitalfondue/jfiveparse/ProcessedInputStreamTest.java

diff --git a/src/main/java/ch/digitalfondue/jfiveparse/Parser.java b/src/main/java/ch/digitalfondue/jfiveparse/Parser.java
index e9ecbb0..c8a0275 100644
--- a/src/main/java/ch/digitalfondue/jfiveparse/Parser.java
+++ b/src/main/java/ch/digitalfondue/jfiveparse/Parser.java
@@ -16,6 +16,7 @@
 package ch.digitalfondue.jfiveparse;
 
 import java.io.Reader;
+import java.io.StringReader;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Set;
@@ -75,7 +76,7 @@ public Parser(Set<Option> options) {
      * @return the parsed {@link Document}
      */
     public Document parse(String input) {
-        return parse(new ProcessedInputStream.StringProcessedInputStream(input));
+        return parse(new ProcessedInputStream(new StringReader(input)));
     }
 
     /**
@@ -87,7 +88,7 @@ public Document parse(String input) {
      * @return the parsed {@link Document}
      */
     public Document parse(Reader input) {
-        return parse(new ProcessedInputStream.ReaderProcessedInputStream(input));
+        return parse(new ProcessedInputStream(input));
     }
 
     /***
@@ -101,7 +102,7 @@ public Document parse(Reader input) {
      * @return
      */
     public List<Node> parseFragment(Element node, String input) {
-        return parseFragment(new ProcessedInputStream.StringProcessedInputStream(input), node);
+        return parseFragment(new ProcessedInputStream(new StringReader(input)), node);
     }
 
     /**
@@ -112,7 +113,7 @@ public List<Node> parseFragment(Element node, String input) {
      * @return
      */
     public List<Node> parseFragment(Element node, Reader input) {
-        return parseFragment(new ProcessedInputStream.ReaderProcessedInputStream(input), node);
+        return parseFragment(new ProcessedInputStream(input), node);
     }
 
     private List<Node> parseFragment(ProcessedInputStream is, Element node) {
diff --git a/src/main/java/ch/digitalfondue/jfiveparse/ProcessedInputStream.java b/src/main/java/ch/digitalfondue/jfiveparse/ProcessedInputStream.java
index 2c07b72..1d7d92e 100644
--- a/src/main/java/ch/digitalfondue/jfiveparse/ProcessedInputStream.java
+++ b/src/main/java/ch/digitalfondue/jfiveparse/ProcessedInputStream.java
@@ -19,13 +19,71 @@
 import java.io.Reader;
 
 /**
- * Wrapped and abstracted input. Can most likely be optimized.
+ * Wrapped and abstracted input with on-demand buffering from a {@link Reader}.
  */
-abstract class ProcessedInputStream {
+class ProcessedInputStream {
+
+    private static final int BUFFER_SIZE = 8192;
 
     protected final ResizableIntBuffer buffer = new ResizableIntBuffer();
 
-    protected abstract int read();
+    private final Reader reader;
+    private final char[] buff = new char[BUFFER_SIZE];
+    private int buffPos = 0;
+    private int buffCount = 0;
+    private boolean eof = false;
+    private boolean crFound = false;
+
+    ProcessedInputStream(Reader reader) {
+        this.reader = reader;
+    }
+
+    protected int read() {
+        if (buffPos < buffCount) {
+            return buff[buffPos++];
+        }
+        if (fill()) {
+            return buff[buffPos++];
+        }
+        return Characters.EOF;
+    }
+
+    private boolean fill() {
+        if (eof) {
+            return false;
+        }
+        try {
+            int out = 0;
+            while (out == 0) {
+                int read = reader.read(buff);
+                if (read == -1) {
+                    eof = true;
+                    buffCount = 0;
+                    buffPos = 0;
+                    return false;
+                }
+                for (int in = 0; in < read; in++) {
+                    char c = buff[in];
+                    if (crFound) {
+                        crFound = false;
+                        if (c == Characters.LF) {
+                            continue;
+                        }
+                    }
+                    if (c == Characters.CR) {
+                        crFound = true;
+                        c = Characters.LF;
+                    }
+                    buff[out++] = c;
+                }
+            }
+            buffPos = 0;
+            buffCount = out;
+            return true;
+        } catch (IOException ioe) {
+            throw new ParserException(ioe);
+        }
+    }
 
     int readUntil(ResizableCharBuilder builder, boolean stopAtAmpersand, boolean stopAtLessThan) {
         int chr;
@@ -111,286 +169,175 @@ int readUntilComment(ResizableCharBuilder builder) {
         return readUntilCommentInternal(builder);
     }
 
-    protected int readUntilInternal(ResizableCharBuilder builder, boolean stopAtAmpersand, boolean stopAtLessThan) {
-        int chr;
-        while ((chr = read()) != Characters.EOF) {
-            if ((stopAtAmpersand && chr == Characters.AMPERSAND) || (stopAtLessThan && chr == Characters.LESSTHAN_SIGN) || chr == Characters.NULL) {
-                return chr;
-            }
-            builder.append((char) chr);
-        }
-        return Characters.EOF;
-    }
-
-    protected int readUntilAttributeValueInternal(ResizableCharBuilder builder, int quoteChar, boolean stopAtAmpersand) {
-        int chr;
-        while ((chr = read()) != Characters.EOF) {
-            if (chr == quoteChar || (stopAtAmpersand && chr == Characters.AMPERSAND) || chr == Characters.NULL) {
-                return chr;
-            }
-            builder.append((char) chr);
-        }
-        return Characters.EOF;
-    }
-
-    protected int readUntilAttributeValueUnquotedInternal(ResizableCharBuilder builder) {
-        int chr;
-        while ((chr = read()) != Characters.EOF) {
-            if (mustStopReadUntilAttributeValueUnquoted(chr)) {
-                return chr;
-            }
-            builder.append((char) chr);
-        }
-        return Characters.EOF;
-    }
-
-    protected int readUntilTagNameInternal(ResizableCharBuilder builder) {
-        int chr;
-        while ((chr = read()) != Characters.EOF) {
-            if (Common.isTabLfFfCrOrSpace(chr) || chr == Characters.SOLIDUS || chr == Characters.GREATERTHAN_SIGN || chr == Characters.NULL) {
-                return chr;
-            }
-            builder.append((char) chr);
-        }
-        return Characters.EOF;
-    }
-
-    protected int readUntilAttributeNameInternal(ResizableCharBuilder builder) {
-        int chr;
-        while ((chr = read()) != Characters.EOF) {
-            if (mustStopReadUntilAttributeName(chr)) {
-                return chr;
-            }
-            builder.append((char) chr);
-        }
-        return Characters.EOF;
-    }
-
-    protected int readUntilCommentInternal(ResizableCharBuilder builder) {
-        int chr;
-        while ((chr = read()) != Characters.EOF) {
-            if (chr == Characters.HYPHEN_MINUS || chr == Characters.NULL) {
-                return chr;
-            }
-            builder.append((char) chr);
-        }
-        return Characters.EOF;
-    }
-
-    //
-    int peekNextInputCharacter(int offset) {
-        if (buffer.length() < offset) {
-            // fill buffer
-            for (int i = buffer.length(); i < offset; i++) {
-                buffer.add(read());
-            }
-        }
-        return buffer.getCharAt(offset);
-    }
-
-    /**
-     * Ideally, it's a combination of getNextInputCharacter + consume in terms of
-     * behavior.
-     * 
-     * @return
-     */
-    int getNextInputCharacterAndConsume() {
-        return consume();
-    }
-
-    int consume() {
-        return buffer.isEmpty ? read() : buffer.removeFirst();
-    }
-
-    void reconsume(int chr) {
-        buffer.addFirst(chr);
-    }
-
-    void consume(int count) {
-        for (int i = 0; i < count; i++) {
-            consume();
-        }
-    }
-
-
-
-    static class StringProcessedInputStream extends ProcessedInputStream {
-        private int pos = 0;
-        private final char[] input;
-        private final int length;
-
-
-        StringProcessedInputStream(String input) {
-            char[] toNormalize = input.toCharArray();
-            int j = 0;
-            for (int i = 0; i < toNormalize.length; i++) {
-                char c = toNormalize[i];
-                if (c == Characters.CR) {
-                    toNormalize[j++] = Characters.LF;
-                    if (i + 1 < toNormalize.length && toNormalize[i + 1] == Characters.LF) {
-                        i++;
-                    }
-                } else {
-                    toNormalize[j++] = c;
+    private int readUntilInternal(ResizableCharBuilder builder, boolean stopAtAmpersand, boolean stopAtLessThan) {
+        for (;;) {
+            if (buffPos >= buffCount) {
+                if (!fill()) {
+                    return Characters.EOF;
                 }
             }
-            this.input = toNormalize;
-            this.length = j;
-        }
-
-        // used for test
-        protected int getCharAt(int pos) {
-            if (pos >= length) {
-                return Characters.EOF;
-            }
-            return input[pos];
-        }
-
-        @Override
-        protected int read() {
-            if (pos < length) {
-                return input[pos++];
-            }
-            return Characters.EOF;
-        }
-
-        @Override
-        protected int readUntilInternal(ResizableCharBuilder builder, boolean stopAtAmpersand, boolean stopAtLessThan) {
-            int n = length;
-            int i = pos;
+            int n = buffCount;
+            int i = buffPos;
             while (i < n) {
-                char c = input[i];
+                char c = buff[i];
                 if ((stopAtAmpersand && c == Characters.AMPERSAND) || (stopAtLessThan && c == Characters.LESSTHAN_SIGN) || c == Characters.NULL) {
-                    builder.append(input, pos, i - pos);
-                    pos = i + 1;
+                    builder.append(buff, buffPos, i - buffPos);
+                    buffPos = i + 1;
                     return c;
                 }
                 i++;
             }
-            builder.append(input, pos, n - pos);
-            pos = n;
-            return Characters.EOF;
+            builder.append(buff, buffPos, n - buffPos);
+            buffPos = n;
         }
+    }
 
-        @Override
-        protected int readUntilAttributeValueInternal(ResizableCharBuilder builder, int quoteChar, boolean stopAtAmpersand) {
-            int n = length;
-            int i = pos;
+    private int readUntilAttributeValueInternal(ResizableCharBuilder builder, int quoteChar, boolean stopAtAmpersand) {
+        for (;;) {
+            if (buffPos >= buffCount) {
+                if (!fill()) {
+                    return Characters.EOF;
+                }
+            }
+            int n = buffCount;
+            int i = buffPos;
             while (i < n) {
-                char c = input[i];
+                char c = buff[i];
                 if (c == quoteChar || (stopAtAmpersand && c == Characters.AMPERSAND) || c == Characters.NULL) {
-                    builder.append(input, pos, i - pos);
-                    pos = i + 1;
+                    builder.append(buff, buffPos, i - buffPos);
+                    buffPos = i + 1;
                     return c;
                 }
                 i++;
             }
-            builder.append(input, pos, n - pos);
-            pos = n;
-            return Characters.EOF;
+            builder.append(buff, buffPos, n - buffPos);
+            buffPos = n;
         }
+    }
 
-        @Override
-        protected int readUntilAttributeValueUnquotedInternal(ResizableCharBuilder builder) {
-            int n = length;
-            int i = pos;
+    private int readUntilAttributeValueUnquotedInternal(ResizableCharBuilder builder) {
+        for (;;) {
+            if (buffPos >= buffCount) {
+                if (!fill()) {
+                    return Characters.EOF;
+                }
+            }
+            int n = buffCount;
+            int i = buffPos;
             while (i < n) {
-                char c = input[i];
+                char c = buff[i];
                 if (mustStopReadUntilAttributeValueUnquoted(c)) {
-                    builder.append(input, pos, i - pos);
-                    pos = i + 1;
+                    builder.append(buff, buffPos, i - buffPos);
+                    buffPos = i + 1;
                     return c;
                 }
                 i++;
             }
-            builder.append(input, pos, n - pos);
-            pos = n;
-            return Characters.EOF;
+            builder.append(buff, buffPos, n - buffPos);
+            buffPos = n;
         }
+    }
 
-        @Override
-        protected int readUntilTagNameInternal(ResizableCharBuilder builder) {
-            int n = length;
-            int i = pos;
+    private int readUntilTagNameInternal(ResizableCharBuilder builder) {
+        for (;;) {
+            if (buffPos >= buffCount) {
+                if (!fill()) {
+                    return Characters.EOF;
+                }
+            }
+            int n = buffCount;
+            int i = buffPos;
             while (i < n) {
-                char c = input[i];
+                char c = buff[i];
                 if (Common.isTabLfFfCrOrSpace(c) || c == Characters.SOLIDUS || c == Characters.GREATERTHAN_SIGN || c == Characters.NULL) {
-                    builder.append(input, pos, i - pos);
-                    pos = i + 1;
+                    builder.append(buff, buffPos, i - buffPos);
+                    buffPos = i + 1;
                     return c;
                 }
                 i++;
             }
-            builder.append(input, pos, n - pos);
-            pos = n;
-            return Characters.EOF;
+            builder.append(buff, buffPos, n - buffPos);
+            buffPos = n;
         }
+    }
 
-        @Override
-        protected int readUntilAttributeNameInternal(ResizableCharBuilder builder) {
-            int n = length;
-            int i = pos;
+    private int readUntilAttributeNameInternal(ResizableCharBuilder builder) {
+        for (;;) {
+            if (buffPos >= buffCount) {
+                if (!fill()) {
+                    return Characters.EOF;
+                }
+            }
+            int n = buffCount;
+            int i = buffPos;
             while (i < n) {
-                char c = input[i];
+                char c = buff[i];
                 if (mustStopReadUntilAttributeName(c)) {
-                    builder.append(input, pos, i - pos); // append remaining
-                    pos = i + 1;
+                    builder.append(buff, buffPos, i - buffPos);
+                    buffPos = i + 1;
                     return c;
                 }
                 i++;
             }
-            builder.append(input, pos, n - pos);
-            pos = n;
-            return Characters.EOF;
+            builder.append(buff, buffPos, n - buffPos);
+            buffPos = n;
         }
+    }
 
-        @Override
-        protected int readUntilCommentInternal(ResizableCharBuilder builder) {
-            int n = length;
-            int i = pos;
+    private int readUntilCommentInternal(ResizableCharBuilder builder) {
+        for (;;) {
+            if (buffPos >= buffCount) {
+                if (!fill()) {
+                    return Characters.EOF;
+                }
+            }
+            int n = buffCount;
+            int i = buffPos;
             while (i < n) {
-                char c = input[i];
+                char c = buff[i];
                 if (c == Characters.HYPHEN_MINUS || c == Characters.NULL) {
-                    builder.append(input, pos, i - pos);
-                    pos = i + 1;
+                    builder.append(buff, buffPos, i - buffPos);
+                    buffPos = i + 1;
                     return c;
                 }
                 i++;
             }
-            builder.append(input, pos, n - pos);
-            pos = n;
-            return Characters.EOF;
+            builder.append(buff, buffPos, n - buffPos);
+            buffPos = n;
         }
     }
 
-    static final class ReaderProcessedInputStream extends ProcessedInputStream {
+    int peekNextInputCharacter(int offset) {
+        if (buffer.length() < offset) {
+            // fill buffer
+            for (int i = buffer.length(); i < offset; i++) {
+                buffer.add(read());
+            }
+        }
+        return buffer.getCharAt(offset);
+    }
 
-        private final Reader reader;
-        private boolean crFound;
+    /**
+     * Ideally, it's a combination of getNextInputCharacter + consume in terms of
+     * behavior.
+     * 
+     * @return
+     */
+    int getNextInputCharacterAndConsume() {
+        return consume();
+    }
 
-        ReaderProcessedInputStream(Reader reader) {
-            this.reader = reader;
-        }
+    int consume() {
+        return buffer.isEmpty ? read() : buffer.removeFirst();
+    }
 
-        @Override
-        protected int read() {
-            try {
-                int chr = reader.read();
-                if (crFound) {
-                    crFound = false;
-                    if (chr == Characters.LF) {
-                        chr = reader.read();
-                    }
-                }
+    void reconsume(int chr) {
+        buffer.addFirst(chr);
+    }
 
-                if (chr == Characters.CR) {
-                    crFound = true;
-                    chr = Characters.LF;
-                }
-                return chr;
-            } catch (IOException ioe) {
-                throw new ParserException(ioe);
-            }
+    void consume(int count) {
+        for (int i = 0; i < count; i++) {
+            consume();
         }
     }
 }
diff --git a/src/test/java/ch/digitalfondue/jfiveparse/ProcessedInputStreamTest.java b/src/test/java/ch/digitalfondue/jfiveparse/ProcessedInputStreamTest.java
new file mode 100644
index 0000000..6257d08
--- /dev/null
+++ b/src/test/java/ch/digitalfondue/jfiveparse/ProcessedInputStreamTest.java
@@ -0,0 +1,125 @@
+package ch.digitalfondue.jfiveparse;
+
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.io.Reader;
+import java.io.StringReader;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+class ProcessedInputStreamTest {
+
+    @Test
+    void testEquivalenceStringAndReader() throws IOException {
+        String content = Files.readString(Paths.get("src/test/resources/test.html"));
+        Parser parser = new Parser();
+        Document doc1 = parser.parse(content);
+        Document doc2 = parser.parse(new StringReader(content));
+
+        assertEquals(JFiveParse.serialize(doc1), JFiveParse.serialize(doc2));
+    }
+
+    @Test
+    void testEquivalenceFragment() {
+        Parser parser = new Parser();
+        Element context = new Element("div");
+
+        String fragment = "<p class='test'>Hello <span>world</span></p>";
+        var res1 = parser.parseFragment(context, fragment);
+        var res2 = parser.parseFragment(context, new StringReader(fragment));
+
+        assertEquals(res1.size(), res2.size());
+        for (int i = 0; i < res1.size(); i++) {
+            assertEquals(((Element) res1.get(i)).getOuterHTML(), ((Element) res2.get(i)).getOuterHTML());
+        }
+    }
+
+    @Test
+    void testNewlineNormalization() {
+        Parser parser = new Parser();
+
+        String htmlCrlf = "<div>Line 1\r\nLine 2\rLine 3\nLine 4\r</div>";
+        Document doc1 = parser.parse(htmlCrlf);
+        Document doc2 = parser.parse(new StringReader(htmlCrlf));
+
+        assertEquals(JFiveParse.serialize(doc1), JFiveParse.serialize(doc2));
+
+        String expectedText = "Line 1\nLine 2\nLine 3\nLine 4\n";
+        assertEquals(expectedText, doc1.getElementsByTagName("div").get(0).getTextContent());
+    }
+
+    @Test
+    void testBoundaryAcross8192Buffer() {
+        // Create an input larger than buffer size (8192) with CRLF right around boundary
+        StringBuilder sb = new StringBuilder();
+        sb.append("<div>");
+        while (sb.length() < 8190) {
+            sb.append("a");
+        }
+        sb.append("\r\n"); // spans boundary around 8190-8192
+        sb.append("rest of content</div>");
+
+        String input = sb.toString();
+        Parser parser = new Parser();
+        Document doc1 = parser.parse(input);
+        Document doc2 = parser.parse(new StringReader(input));
+
+        assertEquals(JFiveParse.serialize(doc1), JFiveParse.serialize(doc2));
+    }
+
+    @Test
+    void testSingleCharChunkedReader() {
+        String html = "<!DOCTYPE html><html><head><title>Test</title></head><body><div class=\"foo\" id='bar' data-test=unquoted><!-- a comment -->Text with &amp; entity</div></body></html>";
+
+        // A Reader that returns at most 1 character per read() call
+        Reader slowReader = new Reader() {
+            private int pos = 0;
+
+            @Override
+            public int read(char[] cbuf, int off, int len) {
+                if (pos >= html.length()) {
+                    return -1;
+                }
+                cbuf[off] = html.charAt(pos++);
+                return 1;
+            }
+
+            @Override
+            public void close() {}
+        };
+
+        Parser parser = new Parser();
+        Document doc1 = parser.parse(html);
+        Document doc2 = parser.parse(slowReader);
+
+        assertEquals(JFiveParse.serialize(doc1), JFiveParse.serialize(doc2));
+    }
+
+    @Test
+    void testLargeAttributesAndCommentsAcrossBuffer() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("<!DOCTYPE html><html><body>");
+        sb.append("<div title=\"");
+        sb.append("x".repeat(10000));
+        sb.append("\" data-attr='");
+        sb.append("y".repeat(10000));
+        sb.append("'>");
+        sb.append("<!-- ");
+        sb.append("c".repeat(10000));
+        sb.append(" -->");
+        sb.append("z".repeat(10000));
+        sb.append("</div></body></html>");
+
+        String input = sb.toString();
+        Parser parser = new Parser();
+        Document doc1 = parser.parse(input);
+        Document doc2 = parser.parse(new StringReader(input));
+
+        assertEquals(JFiveParse.serialize(doc1), JFiveParse.serialize(doc2));
+        assertNotNull(doc2.getElementsByTagName("div").get(0));
+    }
+}
diff --git a/src/test/java/ch/digitalfondue/jfiveparse/ProcessedInputStreamWithParseError.java b/src/test/java/ch/digitalfondue/jfiveparse/ProcessedInputStreamWithParseError.java
index 1cd2459..ff78ca5 100644
--- a/src/test/java/ch/digitalfondue/jfiveparse/ProcessedInputStreamWithParseError.java
+++ b/src/test/java/ch/digitalfondue/jfiveparse/ProcessedInputStreamWithParseError.java
@@ -15,17 +15,41 @@
  */
 package ch.digitalfondue.jfiveparse;
 
-import ch.digitalfondue.jfiveparse.ProcessedInputStream.StringProcessedInputStream;
+import java.io.StringReader;
 
-final class ProcessedInputStreamWithParseError extends StringProcessedInputStream {
+final class ProcessedInputStreamWithParseError extends ProcessedInputStream {
 
     private final TreeConstructor tokenHandler;
     private int alreadyVisitedPosition = -1;
     private int position = -1;
+    private final char[] input;
+    private final int length;
 
     ProcessedInputStreamWithParseError(String input, TokenSaver tokenHandler) {
-        super(input);
+        super(new StringReader(input));
         this.tokenHandler = tokenHandler;
+        char[] toNormalize = input.toCharArray();
+        int j = 0;
+        for (int i = 0; i < toNormalize.length; i++) {
+            char c = toNormalize[i];
+            if (c == Characters.CR) {
+                toNormalize[j++] = Characters.LF;
+                if (i + 1 < toNormalize.length && toNormalize[i + 1] == Characters.LF) {
+                    i++;
+                }
+            } else {
+                toNormalize[j++] = c;
+            }
+        }
+        this.input = toNormalize;
+        this.length = j;
+    }
+
+    private int getCharAt(int pos) {
+        if (pos < 0 || pos >= length) {
+            return Characters.EOF;
+        }
+        return input[pos];
     }
 
     private int previousCharacter = -1;

From 0c5192010ad52f87712d6ac6bdbc0b7bf43d1264 Mon Sep 17 00:00:00 2001
From: Sylvain Jermini <sylvain.jermini@syjer.com>
Date: Thu, 8 Oct 2026 20:55:56 +0200
Subject: [PATCH 2/2] cleanup

---
 .../ch/digitalfondue/jfiveparse/ProcessedInputStream.java   | 5 ++---
 .../digitalfondue/jfiveparse/ProcessedInputStreamTest.java  | 6 +-----
 2 files changed, 3 insertions(+), 8 deletions(-)

diff --git a/src/main/java/ch/digitalfondue/jfiveparse/ProcessedInputStream.java b/src/main/java/ch/digitalfondue/jfiveparse/ProcessedInputStream.java
index 1d7d92e..9de3fbc 100644
--- a/src/main/java/ch/digitalfondue/jfiveparse/ProcessedInputStream.java
+++ b/src/main/java/ch/digitalfondue/jfiveparse/ProcessedInputStream.java
@@ -21,14 +21,13 @@
 /**
  * Wrapped and abstracted input with on-demand buffering from a {@link Reader}.
  */
+// can be improved, see SWAR..., also we could improve code sharing with the readUntil*Internal code
 class ProcessedInputStream {
 
-    private static final int BUFFER_SIZE = 8192;
-
     protected final ResizableIntBuffer buffer = new ResizableIntBuffer();
 
     private final Reader reader;
-    private final char[] buff = new char[BUFFER_SIZE];
+    private final char[] buff = new char[8192];
     private int buffPos = 0;
     private int buffCount = 0;
     private boolean eof = false;
diff --git a/src/test/java/ch/digitalfondue/jfiveparse/ProcessedInputStreamTest.java b/src/test/java/ch/digitalfondue/jfiveparse/ProcessedInputStreamTest.java
index 6257d08..2d36d55 100644
--- a/src/test/java/ch/digitalfondue/jfiveparse/ProcessedInputStreamTest.java
+++ b/src/test/java/ch/digitalfondue/jfiveparse/ProcessedInputStreamTest.java
@@ -9,7 +9,6 @@
 import java.nio.file.Paths;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 class ProcessedInputStreamTest {
 
@@ -47,9 +46,7 @@ void testNewlineNormalization() {
         Document doc2 = parser.parse(new StringReader(htmlCrlf));
 
         assertEquals(JFiveParse.serialize(doc1), JFiveParse.serialize(doc2));
-
-        String expectedText = "Line 1\nLine 2\nLine 3\nLine 4\n";
-        assertEquals(expectedText, doc1.getElementsByTagName("div").get(0).getTextContent());
+        assertEquals("Line 1\nLine 2\nLine 3\nLine 4\n", doc1.getElementsByTagName("div").get(0).getTextContent());
     }
 
     @Test
@@ -120,6 +117,5 @@ void testLargeAttributesAndCommentsAcrossBuffer() {
         Document doc2 = parser.parse(new StringReader(input));
 
         assertEquals(JFiveParse.serialize(doc1), JFiveParse.serialize(doc2));
-        assertNotNull(doc2.getElementsByTagName("div").get(0));
     }
 }