Add tests for binary literal parsing

ben221199 · ben221199 · commit 1f7413d84e1c · 2026-05-09T17:11:01.000+02:00
diff --git a/src/main/java/com/yocto/yoclib/imap/protocol/ProtocolBinaryLiteral.java b/src/main/java/com/yocto/yoclib/imap/protocol/ProtocolBinaryLiteral.java
@@ -1,7 +1,9 @@
 package com.yocto.yoclib.imap.protocol;
 
 import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
 import java.util.Base64;
+import java.util.Objects;
 
 public class ProtocolBinaryLiteral extends ProtocolObject {
 
@@ -26,6 +28,18 @@ public ProtocolBinaryLiteral(String value){
         this(value.getBytes(StandardCharsets.ISO_8859_1));
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (!(o instanceof ProtocolBinaryLiteral)) return false;
+        ProtocolBinaryLiteral that = (ProtocolBinaryLiteral) o;
+        return isNonSynchronizing == that.isNonSynchronizing && Objects.deepEquals(value, that.value);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(Arrays.hashCode(value), isNonSynchronizing);
+    }
+
     public byte[] getValue(){
         return this.value;
     }
diff --git a/src/main/java/com/yocto/yoclib/imap/protocol/ProtocolList.java b/src/main/java/com/yocto/yoclib/imap/protocol/ProtocolList.java
@@ -1,6 +1,7 @@
 package com.yocto.yoclib.imap.protocol;
 
 import java.util.Arrays;
+import java.util.Objects;
 import java.util.stream.Collectors;
 
 public class ProtocolList extends ProtocolObject {
@@ -11,6 +12,18 @@ public ProtocolList(ProtocolObject[] objects){
         this.objects = objects;
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (!(o instanceof ProtocolList)) return false;
+        ProtocolList that = (ProtocolList) o;
+        return Objects.deepEquals(objects, that.objects);
+    }
+
+    @Override
+    public int hashCode() {
+        return Arrays.hashCode(objects);
+    }
+
     public ProtocolObject[] getObjects() {
         return this.objects;
     }
diff --git a/src/main/java/com/yocto/yoclib/imap/protocol/ProtocolLiteral.java b/src/main/java/com/yocto/yoclib/imap/protocol/ProtocolLiteral.java
@@ -1,5 +1,7 @@
 package com.yocto.yoclib.imap.protocol;
 
+import java.util.Objects;
+
 public class ProtocolLiteral extends ProtocolString {
 
     private final boolean isNonSynchronizing;
@@ -14,6 +16,19 @@ public ProtocolLiteral(String value){
         this(value,false);
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (!(o instanceof ProtocolLiteral)) return false;
+        if (!super.equals(o)) return false;
+        ProtocolLiteral that = (ProtocolLiteral) o;
+        return isNonSynchronizing == that.isNonSynchronizing;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(super.hashCode(), isNonSynchronizing);
+    }
+
     public boolean isNonSynchronizing(){
         return this.isNonSynchronizing;
     }
diff --git a/src/main/java/com/yocto/yoclib/imap/protocol/ProtocolParser.java b/src/main/java/com/yocto/yoclib/imap/protocol/ProtocolParser.java
@@ -4,7 +4,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
-public class ProtocolParser {
+public final class ProtocolParser {
 
     public static ProtocolObject[] parse(String input) {
         if (input == null || input.trim().isEmpty()) {
@@ -29,8 +29,8 @@ private static ProtocolObject parseToken(Tokenizer t) {
 
         char c = t.peekCharNoSkip();
 
-        // Binary literal: ~{n} or ~{n+}
-        if (c == '~') {
+        // Binary literal: ~{n} or ~{n+}   ← Only if ~ is immediately followed by {
+        if (c == '~' && t.isNextCharAfter('~', '{')) {
             t.consumeNoSkip('~');
             return parseBinaryLiteral(t);
         }
@@ -44,7 +44,7 @@ private static ProtocolObject parseToken(Tokenizer t) {
         if (c == '[') return parseSubordinate(t);
         if (c == '"') return parseQuoted(t);
 
-        // Atom
+        // Atom (includes lone "~", etc.)
         String atomValue = t.readAtom();
         ProtocolAtom atom = new ProtocolAtom(atomValue);
 
@@ -55,36 +55,23 @@ private static ProtocolObject parseToken(Tokenizer t) {
         return atom;
     }
 
-    // ====================== Split Literal Parsers ======================
+    // ====================== Literal Parsers ======================
 
-    /**
-     * Parses regular literals: {n} or {n+}
-     */
     private static ProtocolLiteral parseRegularLiteral(Tokenizer t) {
         LiteralHeader header = parseLiteralHeader(t, false);
         t.skipCRLF();
-
         String data = t.readExactly(header.size);
         return new ProtocolLiteral(data, header.nonSynchronizing);
     }
 
-    /**
-     * Parses binary literals: ~{n} or ~{n+}
-     */
     private static ProtocolBinaryLiteral parseBinaryLiteral(Tokenizer t) {
         LiteralHeader header = parseLiteralHeader(t, true);
         t.skipCRLF();
-
         String rawData = t.readExactly(header.size);
         byte[] binaryData = rawData.getBytes(StandardCharsets.ISO_8859_1);
-
         return new ProtocolBinaryLiteral(binaryData, header.nonSynchronizing);
     }
 
-    /**
-     * Common helper: parses the header part {size} or {size+}
-     * (tilde ~ is already consumed for binary case)
-     */
     private static LiteralHeader parseLiteralHeader(Tokenizer t, boolean isBinary) {
         t.consumeNoSkip('{');
 
@@ -101,7 +88,7 @@ private static LiteralHeader parseLiteralHeader(Tokenizer t, boolean isBinary) {
             } else if (c == '}') {
                 break;
             } else {
-                break; // malformed
+                break;
             }
         }
 
@@ -117,7 +104,7 @@ private static LiteralHeader parseLiteralHeader(Tokenizer t, boolean isBinary) {
         return new LiteralHeader(size, nonSynchronizing);
     }
 
-    // ====================== Other Parsers (unchanged) ======================
+    // ====================== Other Parsers ======================
 
     private static ProtocolList parseList(Tokenizer t) {
         t.consume('(');
@@ -222,7 +209,7 @@ private static ProtocolQuoted parseQuoted(Tokenizer t) {
         return new ProtocolQuoted(sb.toString());
     }
 
-    // ====================== Tokenizer (unchanged) ======================
+    // ====================== Tokenizer ======================
 
     private static class Tokenizer {
         final String input;
@@ -261,6 +248,13 @@ public boolean isNextCharImmediate(char expected) {
             return pos < input.length() && input.charAt(pos) == expected;
         }
 
+        public boolean isNextCharAfter(char current, char expected) {
+            if (pos >= input.length() || input.charAt(pos) != current) {
+                return false;
+            }
+            return pos + 1 < input.length() && input.charAt(pos + 1) == expected;
+        }
+
         public String readAtom() {
             skipWhitespace();
             int start = pos;
diff --git a/src/main/java/com/yocto/yoclib/imap/protocol/ProtocolSectionPartial.java b/src/main/java/com/yocto/yoclib/imap/protocol/ProtocolSectionPartial.java
@@ -1,5 +1,7 @@
 package com.yocto.yoclib.imap.protocol;
 
+import java.util.Objects;
+
 public class ProtocolSectionPartial extends ProtocolObject{
 
     private final ProtocolAtom atom;
@@ -56,6 +58,18 @@ public Integer getPartialLength() {
         return this.partialLength;
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (!(o instanceof ProtocolSectionPartial)) return false;
+        ProtocolSectionPartial that = (ProtocolSectionPartial) o;
+        return Objects.equals(atom, that.atom) && Objects.equals(subordinate, that.subordinate) && Objects.equals(partialOffset, that.partialOffset) && Objects.equals(partialLength, that.partialLength);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(atom, subordinate, partialOffset, partialLength);
+    }
+
     @Override
     public String toProtocolString() {
         StringBuilder sb = new StringBuilder();
diff --git a/src/main/java/com/yocto/yoclib/imap/protocol/ProtocolString.java b/src/main/java/com/yocto/yoclib/imap/protocol/ProtocolString.java
@@ -1,5 +1,7 @@
 package com.yocto.yoclib.imap.protocol;
 
+import java.util.Objects;
+
 public abstract class ProtocolString extends ProtocolObject {
 
     protected final String value;
@@ -8,6 +10,18 @@ protected ProtocolString(String value){
         this.value = value;
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (!(o instanceof ProtocolString)) return false;
+        ProtocolString that = (ProtocolString) o;
+        return Objects.equals(value, that.value);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(value);
+    }
+
     public String getValue(){
         return this.value;
     }
diff --git a/src/main/java/com/yocto/yoclib/imap/protocol/ProtocolSubordinate.java b/src/main/java/com/yocto/yoclib/imap/protocol/ProtocolSubordinate.java
@@ -1,6 +1,7 @@
 package com.yocto.yoclib.imap.protocol;
 
 import java.util.Arrays;
+import java.util.Objects;
 import java.util.stream.Collectors;
 
 public class ProtocolSubordinate extends ProtocolObject {
@@ -15,6 +16,18 @@ public ProtocolObject[] getObjects(){
         return this.objects;
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (!(o instanceof ProtocolSubordinate)) return false;
+        ProtocolSubordinate that = (ProtocolSubordinate) o;
+        return Objects.deepEquals(objects, that.objects);
+    }
+
+    @Override
+    public int hashCode() {
+        return Arrays.hashCode(objects);
+    }
+
     @Override
     public String toProtocolString(){
         return ProtocolConstants.SQUARE_BRACKET_LEFT+ProtocolObject.joinObjects(this.objects)+ProtocolConstants.SQUARE_BRACKET_RIGHT;
diff --git a/src/test/java/com/yocto/yoclib/imap/tests/protocol/ProtocolParserTest.java b/src/test/java/com/yocto/yoclib/imap/tests/protocol/ProtocolParserTest.java
@@ -1,16 +1,47 @@
 package com.yocto.yoclib.imap.tests.protocol;
 
 import com.yocto.yoclib.imap.protocol.ProtocolAtom;
+import com.yocto.yoclib.imap.protocol.ProtocolBinaryLiteral;
 import com.yocto.yoclib.imap.protocol.ProtocolObject;
 import com.yocto.yoclib.imap.protocol.ProtocolParser;
 
 import org.junit.jupiter.api.Test;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 
 public class ProtocolParserTest{
 
+	@Test
+	public void testParsingBinaryLiteral(){
+		assertArrayEquals(new ProtocolObject[]{
+				new ProtocolAtom("~"),
+		},ProtocolParser.parse("~\r\n"));
+
+		assertArrayEquals(new ProtocolObject[]{
+				new ProtocolAtom("~/Mail/foo"),
+		},ProtocolParser.parse("~/Mail/foo\r\n"));
+
+		assertArrayEquals(new ProtocolObject[]{
+				new ProtocolBinaryLiteral(""),
+				new ProtocolAtom("abc"),
+		},ProtocolParser.parse("~{0}\r\n abc\r\n"));
+
+		assertArrayEquals(new ProtocolObject[]{
+				new ProtocolBinaryLiteral("def"),
+				new ProtocolAtom("abc"),
+		},ProtocolParser.parse("~{3}\r\ndef abc\r\n"));
+
+		assertArrayEquals(new ProtocolObject[]{
+				new ProtocolBinaryLiteral("",true),
+				new ProtocolAtom("abc"),
+		},ProtocolParser.parse("~{0+}\r\n abc\r\n"));
+
+		assertArrayEquals(new ProtocolObject[]{
+				new ProtocolBinaryLiteral("def",true),
+				new ProtocolAtom("abc"),
+		},ProtocolParser.parse("~{3+}\r\ndef abc\r\n"));
+	}
+
 	@Test
 	public void testParsingComplexAtom(){
 		//ProtocolObject[] objects = ProtocolParser.parse("!#$$&'+,-.0123456789:;<=>?@^_`|[}");
