Fix DataReader.findNewLine with multiple lone EOL character

When there is multiple lone CR within a buffer, the virtual index is accumulated each time with the relative index.
The virtual index may be incorrectly seen as >= max, which ignores CRLN within max.

- Fix virtual index accumulation
- Re-use the branch that changes the buffer
- Add unit tests

Author: romain-grecourt

common/buffers/src/main/java/io/helidon/common/buffers/DataReader.java

@@ -412,22 +412,13 @@ public int findNewLine(int max) throws IncorrectNewLineException {
                                                                     + ") without preceding CR. :\n" + this.debugDataHex());
                     }
                 }
-                // not found, continue with next buffer
-                idx += maxLength;
-                if (idx >= max) {
-                    // not found and reached the limit
-                    return max;
-                }
-                n = n.next();
-                indexWithinNode = n.position;
-                continue;
             } else {
                 // found, next byte should be LF
                 if (crIndex == barr.length - 1) {
                     // found CR as the last byte of the current node, peek next node
                     byte nextByte = n.next().peek();
                     if (nextByte == Bytes.LF_BYTE) {
-                        return idx + crIndex - n.position;
+                        return idx + crIndex - indexWithinNode;
                     }
                     if (!ignoreLoneEol) {
                         throw new IncorrectNewLineException("Found CR (" + (idx + crIndex - n.position)
@@ -437,23 +428,25 @@ public int findNewLine(int max) throws IncorrectNewLineException {
                     // found CR within the current array
                     byte nextByte = barr[crIndex + 1];
                     if (nextByte == Bytes.LF_BYTE) {
-                        return idx + crIndex - n.position;
+                        return idx + crIndex - indexWithinNode;
                     }
                     if (!ignoreLoneEol) {
                         throw new IncorrectNewLineException("Found CR (" + idx
                                                                     + ") without following LF. :\n" + this.debugDataHex());
                     }
+                    idx += (crIndex - indexWithinNode + 1);
                     indexWithinNode = crIndex + 1;
-                    idx += indexWithinNode;
                     if (idx >= max) {
                         return max;
                     }
                     continue;
                 }
             }
 
+            // not found, continue with next buffer
             idx += maxLength;
             if (idx >= max) {
+                // not found and reached the limit
                 return max;
             }
             n = n.next();

common/buffers/src/test/java/io/helidon/common/buffers/DataReaderTest.java

@@ -16,6 +16,7 @@
 
 package io.helidon.common.buffers;
 
+import java.nio.charset.StandardCharsets;
 import java.util.concurrent.atomic.AtomicReference;
 
 import org.junit.jupiter.api.Test;
@@ -30,7 +31,7 @@ void testFindNewLineWithLoneCR() {
         // reading N bytes at a time until a new line is found
         // with data containing a lone CR
 
-        byte[] data = new byte[] {0, 0, (byte) '\r', 0, (byte) '\r', (byte) '\n'};
+        byte[] data = "00\r0\r\n".getBytes(StandardCharsets.US_ASCII);
         AtomicReference<byte[]> ref = new AtomicReference<>(data);
         DataReader dataReader = new DataReader(() -> ref.getAndSet(null), true);
 
@@ -41,4 +42,32 @@ void testFindNewLineWithLoneCR() {
         dataReader.skip(n);
         assertThat(dataReader.findNewLine(n), is(0));
     }
+
+    @Test
+    void testFindNewLineWithMultipleLoneCR() {
+        // if the virtual index is accumulated with the relative index for each lone CR
+        // it may exceed max and the new line is ignored
+
+        byte[] data = "00\r\r\r\n".getBytes(StandardCharsets.US_ASCII);
+        AtomicReference<byte[]> ref = new AtomicReference<>(data);
+        DataReader dataReader = new DataReader(() -> ref.getAndSet(null), true);
+
+        int n = 5;
+        assertThat(dataReader.findNewLine(n), is(4));
+    }
+
+    @Test
+    void testFindNewLineWithMultipleLoneWithinMax() {
+        // if the virtual index is not updated for each lone CR
+        // the computed search range is too big and a value greater than max is returned
+
+        byte[] data = "00\r00\r\n00".getBytes(StandardCharsets.US_ASCII);
+        AtomicReference<byte[]> ref = new AtomicReference<>(data);
+        DataReader dataReader = new DataReader(() -> ref.getAndSet(null), true);
+
+        int n = 4;
+        assertThat(dataReader.findNewLine(n), is(n));
+        dataReader.skip(n);
+        assertThat(dataReader.findNewLine(n), is(1));
+    }
 }