From 92b8adebd1940bbb9e496a0fd641084f12b9a2d0 Mon Sep 17 00:00:00 2001 From: Julian Reschke Date: Tue, 7 Apr 2026 13:38:52 +0100 Subject: [PATCH 01/14] equals() and hashCode() for items (wip) --- .../org/greenbytes/http/sfv/BooleanItem.java | 15 +++++ .../org/greenbytes/http/sfv/StringItem.java | 15 +++++ .../org/greenbytes/http/sfv/ItemAPITests.java | 60 +++++++++++++++++++ 3 files changed, 90 insertions(+) diff --git a/src/main/java/org/greenbytes/http/sfv/BooleanItem.java b/src/main/java/org/greenbytes/http/sfv/BooleanItem.java index 41485cb..6ff222b 100644 --- a/src/main/java/org/greenbytes/http/sfv/BooleanItem.java +++ b/src/main/java/org/greenbytes/http/sfv/BooleanItem.java @@ -63,4 +63,19 @@ public String serialize() { public Boolean get() { return value; } + + @Override + public boolean equals(Object o) { + if (!(o instanceof BooleanItem)) { + return false; + } else { + BooleanItem that = (BooleanItem) o; + return value == that.value && Objects.equals(params, that.params); + } + } + + @Override + public int hashCode() { + return Objects.hash(value, params); + } } diff --git a/src/main/java/org/greenbytes/http/sfv/StringItem.java b/src/main/java/org/greenbytes/http/sfv/StringItem.java index cc0323f..e859f9f 100644 --- a/src/main/java/org/greenbytes/http/sfv/StringItem.java +++ b/src/main/java/org/greenbytes/http/sfv/StringItem.java @@ -79,4 +79,19 @@ private static String checkParam(String value) { } return value; } + + @Override + public boolean equals(Object o) { + if (!(o instanceof StringItem)) { + return false; + } else { + StringItem that = (StringItem) o; + return Objects.equals(value, that.value) && Objects.equals(params, that.params); + } + } + + @Override + public int hashCode() { + return Objects.hash(value, params); + } } diff --git a/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java b/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java index 39d1df3..94a1a68 100644 --- a/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java +++ b/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java @@ -2,7 +2,10 @@ import static org.junit.Assert.assertArrayEquals; import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotEquals; import static org.junit.Assert.assertThrows; +import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; import java.math.BigDecimal; @@ -239,4 +242,61 @@ public void testInvalidParameterValues() { } catch (IllegalArgumentException expected) { } } + + @Test + public void testParametersEquality() { + HashMap m1 = new LinkedHashMap<>(); + m1.put("a", "b"); + HashMap m2 = new LinkedHashMap<>(); + m2.put("a", "b"); + Parameters p1 = Parameters.valueOf(m1); + Parameters p2 = Parameters.valueOf(m2); + assertFalse(p1 == p2); + assertEquals(p1, p2); + } + + @Test + public void testStringItemEquality() { + StringItem s1 = StringItem.valueOf("a"); + StringItem s2 = StringItem.valueOf("a"); + assertFalse(s1 == s2); + assertEquals(s1, s2); + StringItem s3 = StringItem.valueOf("b"); + assertNotEquals(s1, s3); + + HashMap m4 = new LinkedHashMap<>(); + m4.put("a", "b"); + Parameters p4 = Parameters.valueOf(m4); + StringItem s4 = StringItem.valueOf("a").withParams(p4); + assertFalse(s1 == s4); + assertNotEquals(s1, s4); + + HashMap m5 = new LinkedHashMap<>(); + m5.put("c", "d"); + Parameters p5 = Parameters.valueOf(m5); + StringItem s5 = StringItem.valueOf("a").withParams(p5); + assertFalse(s4 == s5); + assertNotEquals(s4, s5); + } + + @Test + public void testBooleanItemEquality() { + BooleanItem b1 = BooleanItem.valueOf(true); + BooleanItem b2 = BooleanItem.valueOf(true); + BooleanItem b3 = BooleanItem.valueOf(false); + + // FALSE and TRUE are singletons + assertTrue(b1 == b2); + assertEquals(b1, b2); + + assertFalse(b1 == b3); + assertNotEquals(b1, b3); + + HashMap m4 = new LinkedHashMap<>(); + m4.put("c", "d"); + Parameters p4 = Parameters.valueOf(m4); + BooleanItem b4 = BooleanItem.valueOf(false).withParams(p4); + assertFalse(b1 == b4); + assertNotEquals(b1, b4); + } } From 47e26adc481b3d1bee7c5e056cfded9f617baa78 Mon Sep 17 00:00:00 2001 From: Julian Reschke Date: Wed, 8 Apr 2026 18:55:49 +0100 Subject: [PATCH 02/14] equals() and hashCode() for items (wip) --- .../org/greenbytes/http/sfv/DateItem.java | 15 +++++++++++++ .../org/greenbytes/http/sfv/ItemAPITests.java | 21 +++++++++++++++++++ 2 files changed, 36 insertions(+) diff --git a/src/main/java/org/greenbytes/http/sfv/DateItem.java b/src/main/java/org/greenbytes/http/sfv/DateItem.java index 3874bd5..f29d50c 100644 --- a/src/main/java/org/greenbytes/http/sfv/DateItem.java +++ b/src/main/java/org/greenbytes/http/sfv/DateItem.java @@ -77,4 +77,19 @@ public long getAsLong() { public int getDivisor() { return 1; } + + @Override + public boolean equals(Object o) { + if (!(o instanceof DateItem)) { + return false; + } else { + DateItem dateItem = (DateItem) o; + return value == dateItem.value && Objects.equals(params, dateItem.params); + } + } + + @Override + public int hashCode() { + return Objects.hash(value, params); + } } diff --git a/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java b/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java index 94a1a68..2d2b74a 100644 --- a/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java +++ b/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java @@ -299,4 +299,25 @@ public void testBooleanItemEquality() { assertFalse(b1 == b4); assertNotEquals(b1, b4); } + + @Test + public void testDateItemEquality() { + DateItem d1 = DateItem.valueOf(0); + DateItem d2 = DateItem.valueOf(0); + DateItem d3 = DateItem.valueOf(1000); + + assertFalse(d1 == d2); + assertEquals(d1, d2); + + assertFalse(d1 == d3); + assertNotEquals(d1, d3); + + HashMap m4 = new LinkedHashMap<>(); + m4.put("c", "d"); + Parameters p4 = Parameters.valueOf(m4); + + DateItem d4 = d1.withParams(p4); + assertFalse(d1 == d4); + assertNotEquals(d1, d4); + } } From d2321e07bb946386ffcc78bcebd449c757a93da5 Mon Sep 17 00:00:00 2001 From: Julian Reschke Date: Wed, 8 Apr 2026 19:00:31 +0100 Subject: [PATCH 03/14] equals() and hashCode() for items (wip) --- .../org/greenbytes/http/sfv/DecimalItem.java | 15 +++++++++++++ .../org/greenbytes/http/sfv/ItemAPITests.java | 21 +++++++++++++++++++ 2 files changed, 36 insertions(+) diff --git a/src/main/java/org/greenbytes/http/sfv/DecimalItem.java b/src/main/java/org/greenbytes/http/sfv/DecimalItem.java index 6a8c265..515e7e6 100644 --- a/src/main/java/org/greenbytes/http/sfv/DecimalItem.java +++ b/src/main/java/org/greenbytes/http/sfv/DecimalItem.java @@ -120,4 +120,19 @@ public long getAsLong() { public int getDivisor() { return 1000; } + + @Override + public boolean equals(Object o) { + if (!(o instanceof DecimalItem)) { + return false; + } else { + DecimalItem that = (DecimalItem) o; + return value == that.value && Objects.equals(params, that.params); + } + } + + @Override + public int hashCode() { + return Objects.hash(value, params); + } } diff --git a/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java b/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java index 2d2b74a..1ff86f3 100644 --- a/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java +++ b/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java @@ -320,4 +320,25 @@ public void testDateItemEquality() { assertFalse(d1 == d4); assertNotEquals(d1, d4); } + + @Test + public void testDecimalItemEquality() { + DecimalItem d1 = DecimalItem.valueOf(BigDecimal.valueOf(10.5)); + DecimalItem d2 = DecimalItem.valueOf(BigDecimal.valueOf(10.5)); + DecimalItem d3 = DecimalItem.valueOf(BigDecimal.valueOf(10.6)); + + assertFalse(d1 == d2); + assertEquals(d1, d2); + + assertFalse(d1 == d3); + assertNotEquals(d1, d3); + + HashMap m4 = new LinkedHashMap<>(); + m4.put("c", "d"); + Parameters p4 = Parameters.valueOf(m4); + + DecimalItem d4 = d1.withParams(p4); + assertFalse(d1 == d4); + assertNotEquals(d1, d4); + } } From 79840b90bedf386415e286074c6fb107cae1899b Mon Sep 17 00:00:00 2001 From: Julian Reschke Date: Wed, 8 Apr 2026 19:05:33 +0100 Subject: [PATCH 04/14] equals() and hashCode() for items (wip) --- .../http/sfv/DisplayStringItem.java | 15 +++++++++++++ .../org/greenbytes/http/sfv/ItemAPITests.java | 21 +++++++++++++++++++ 2 files changed, 36 insertions(+) diff --git a/src/main/java/org/greenbytes/http/sfv/DisplayStringItem.java b/src/main/java/org/greenbytes/http/sfv/DisplayStringItem.java index bd92f10..2ef008c 100755 --- a/src/main/java/org/greenbytes/http/sfv/DisplayStringItem.java +++ b/src/main/java/org/greenbytes/http/sfv/DisplayStringItem.java @@ -72,4 +72,19 @@ public String serialize() { public String get() { return this.value; } + + @Override + public boolean equals(Object o) { + if (!(o instanceof DisplayStringItem)) { + return false; + } else { + DisplayStringItem that = (DisplayStringItem) o; + return Objects.equals(value, that.value) && Objects.equals(params, that.params); + } + } + + @Override + public int hashCode() { + return Objects.hash(value, params); + } } diff --git a/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java b/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java index 1ff86f3..dc6b31c 100644 --- a/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java +++ b/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java @@ -341,4 +341,25 @@ public void testDecimalItemEquality() { assertFalse(d1 == d4); assertNotEquals(d1, d4); } + + @Test + public void testDisplayStringItemEquality() { + DisplayStringItem d1 = DisplayStringItem.valueOf("abc"); + DisplayStringItem d2 = DisplayStringItem.valueOf("abc"); + DisplayStringItem d3 = DisplayStringItem.valueOf("def"); + + assertFalse(d1 == d2); + assertEquals(d1, d2); + + assertFalse(d1 == d3); + assertNotEquals(d1, d3); + + HashMap m4 = new LinkedHashMap<>(); + m4.put("c", "d"); + Parameters p4 = Parameters.valueOf(m4); + + DisplayStringItem d4 = d1.withParams(p4); + assertFalse(d1 == d4); + assertNotEquals(d1, d4); + } } From 9e9974653b5888a496485b9c4bf6cb7741204601 Mon Sep 17 00:00:00 2001 From: Julian Reschke Date: Wed, 8 Apr 2026 19:59:10 +0100 Subject: [PATCH 05/14] equals() and hashCode() for items (wip) --- .../org/greenbytes/http/sfv/IntegerItem.java | 15 +++++++++++++ .../org/greenbytes/http/sfv/ItemAPITests.java | 21 +++++++++++++++++++ 2 files changed, 36 insertions(+) diff --git a/src/main/java/org/greenbytes/http/sfv/IntegerItem.java b/src/main/java/org/greenbytes/http/sfv/IntegerItem.java index 959f193..d261f7b 100644 --- a/src/main/java/org/greenbytes/http/sfv/IntegerItem.java +++ b/src/main/java/org/greenbytes/http/sfv/IntegerItem.java @@ -76,4 +76,19 @@ public long getAsLong() { public int getDivisor() { return 1; } + + @Override + public boolean equals(Object o) { + if (!(o instanceof IntegerItem)) { + return false; + } else { + IntegerItem that = (IntegerItem) o; + return value == that.value && Objects.equals(params, that.params); + } + } + + @Override + public int hashCode() { + return Objects.hash(value, params); + } } diff --git a/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java b/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java index dc6b31c..3286dc5 100644 --- a/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java +++ b/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java @@ -362,4 +362,25 @@ public void testDisplayStringItemEquality() { assertFalse(d1 == d4); assertNotEquals(d1, d4); } + + @Test + public void testIntegerItemEquality() { + IntegerItem i1 = IntegerItem.valueOf(1); + IntegerItem i2 = IntegerItem.valueOf(1); + IntegerItem i3 = IntegerItem.valueOf(2); + + assertFalse(i1 == i2); + assertEquals(i1, i2); + + assertFalse(i1 == i3); + assertNotEquals(i1, i3); + + HashMap m4 = new LinkedHashMap<>(); + m4.put("c", "d"); + Parameters p4 = Parameters.valueOf(m4); + + IntegerItem d4 = i1.withParams(p4); + assertFalse(i1 == d4); + assertNotEquals(i1, d4); + } } From f7e9a2f29bd7c6fc03ee67b778c2398d02adaa2e Mon Sep 17 00:00:00 2001 From: Julian Reschke Date: Wed, 8 Apr 2026 20:03:28 +0100 Subject: [PATCH 06/14] equals() and hashCode() for items (wip) --- .../org/greenbytes/http/sfv/TokenItem.java | 15 ++++++++++++ .../org/greenbytes/http/sfv/ItemAPITests.java | 24 +++++++++++++++++++ 2 files changed, 39 insertions(+) diff --git a/src/main/java/org/greenbytes/http/sfv/TokenItem.java b/src/main/java/org/greenbytes/http/sfv/TokenItem.java index fac9dc6..899677a 100644 --- a/src/main/java/org/greenbytes/http/sfv/TokenItem.java +++ b/src/main/java/org/greenbytes/http/sfv/TokenItem.java @@ -74,4 +74,19 @@ private static String checkParam(String value) { } return value; } + + @Override + public boolean equals(Object o) { + if (!(o instanceof TokenItem)) { + return false; + } else { + TokenItem tokenItem = (TokenItem) o; + return Objects.equals(value, tokenItem.value) && Objects.equals(params, tokenItem.params); + } + } + + @Override + public int hashCode() { + return Objects.hash(value, params); + } } diff --git a/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java b/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java index 3286dc5..cdb86b1 100644 --- a/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java +++ b/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java @@ -279,6 +279,30 @@ public void testStringItemEquality() { assertNotEquals(s4, s5); } + @Test + public void testTokenItemEquality() { + TokenItem t1 = TokenItem.valueOf("a"); + TokenItem t = TokenItem.valueOf("a"); + assertFalse(t1 == t); + assertEquals(t1, t); + TokenItem t3 = TokenItem.valueOf("b"); + assertNotEquals(t1, t3); + + HashMap m4 = new LinkedHashMap<>(); + m4.put("a", "b"); + Parameters p4 = Parameters.valueOf(m4); + TokenItem t4 = TokenItem.valueOf("a").withParams(p4); + assertFalse(t1 == t4); + assertNotEquals(t1, t4); + + HashMap m5 = new LinkedHashMap<>(); + m5.put("c", "d"); + Parameters p5 = Parameters.valueOf(m5); + TokenItem t5 = TokenItem.valueOf("a").withParams(p5); + assertFalse(t4 == t5); + assertNotEquals(t4, t5); + } + @Test public void testBooleanItemEquality() { BooleanItem b1 = BooleanItem.valueOf(true); From 6e72c8d2dfcb75280badb35a9a9c4fb0a9e8a97b Mon Sep 17 00:00:00 2001 From: Julian Reschke Date: Wed, 8 Apr 2026 20:11:25 +0100 Subject: [PATCH 07/14] equals() and hashCode() for items (wip) --- .../greenbytes/http/sfv/ByteSequenceItem.java | 16 +++++++++++++++ .../org/greenbytes/http/sfv/ItemAPITests.java | 20 +++++++++++++++++++ 2 files changed, 36 insertions(+) diff --git a/src/main/java/org/greenbytes/http/sfv/ByteSequenceItem.java b/src/main/java/org/greenbytes/http/sfv/ByteSequenceItem.java index c0fcd29..e92b16a 100644 --- a/src/main/java/org/greenbytes/http/sfv/ByteSequenceItem.java +++ b/src/main/java/org/greenbytes/http/sfv/ByteSequenceItem.java @@ -1,6 +1,7 @@ package org.greenbytes.http.sfv; import java.nio.ByteBuffer; +import java.util.Arrays; import java.util.Base64; import java.util.Objects; @@ -68,4 +69,19 @@ public ByteBuffer get() { // stays immutable return ByteBuffer.wrap(this.value.clone()); } + + @Override + public boolean equals(Object o) { + if (!(o instanceof ByteSequenceItem)) { + return false; + } else { + ByteSequenceItem that = (ByteSequenceItem) o; + return Objects.deepEquals(value, that.value) && Objects.equals(params, that.params); + } + } + + @Override + public int hashCode() { + return Objects.hash(Arrays.hashCode(value), params); + } } diff --git a/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java b/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java index cdb86b1..c430f03 100644 --- a/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java +++ b/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java @@ -324,6 +324,26 @@ public void testBooleanItemEquality() { assertNotEquals(b1, b4); } + @Test + public void testByteSequenceItemEquality() { + ByteSequenceItem b1 = ByteSequenceItem.valueOf("x".getBytes()); + ByteSequenceItem b2 = ByteSequenceItem.valueOf("x".getBytes()); + ByteSequenceItem b3 = ByteSequenceItem.valueOf("y".getBytes()); + + assertFalse(b1 == b2); + assertEquals(b1, b2); + + assertFalse(b1 == b3); + assertNotEquals(b1, b3); + + HashMap m4 = new LinkedHashMap<>(); + m4.put("c", "d"); + Parameters p4 = Parameters.valueOf(m4); + ByteSequenceItem b4 = b1.withParams(p4); + assertFalse(b1 == b4); + assertNotEquals(b1, b4); + } + @Test public void testDateItemEquality() { DateItem d1 = DateItem.valueOf(0); From bc6a07c992bf5d86490b637a266d2fe3ec12253f Mon Sep 17 00:00:00 2001 From: Julian Reschke Date: Wed, 8 Apr 2026 20:27:46 +0100 Subject: [PATCH 08/14] equals() and hashCode() for items (wip) --- .../org/greenbytes/http/sfv/OuterList.java | 15 +++++++++++++++ .../org/greenbytes/http/sfv/ItemAPITests.java | 18 ++++++++++++++++++ 2 files changed, 33 insertions(+) diff --git a/src/main/java/org/greenbytes/http/sfv/OuterList.java b/src/main/java/org/greenbytes/http/sfv/OuterList.java index dd8dbc0..3faa40b 100644 --- a/src/main/java/org/greenbytes/http/sfv/OuterList.java +++ b/src/main/java/org/greenbytes/http/sfv/OuterList.java @@ -51,4 +51,19 @@ public String serialize() { public List> get() { return value; } + + @Override + public boolean equals(Object o) { + if (!(o instanceof OuterList)) { + return false; + } else { + OuterList list = (OuterList) o; + return Objects.equals(value, list.value); + } + } + + @Override + public int hashCode() { + return Objects.hashCode(value); + } } diff --git a/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java b/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java index c430f03..6ce2b9d 100644 --- a/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java +++ b/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java @@ -9,6 +9,8 @@ import static org.junit.Assert.fail; import java.math.BigDecimal; +import java.util.ArrayList; +import java.util.Arrays; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.Map; @@ -427,4 +429,20 @@ public void testIntegerItemEquality() { assertFalse(i1 == d4); assertNotEquals(i1, d4); } + + @Test + public void testOuterListEquality() { + BooleanItem b = BooleanItem.valueOf(true); + DecimalItem d = DecimalItem.valueOf(BigDecimal.valueOf(10.5)); + + OuterList l1 = OuterList.valueOf((Arrays.asList(b, d))); + OuterList l2 = OuterList.valueOf((Arrays.asList(b, d))); + OuterList l3 = OuterList.valueOf((Arrays.asList(b, d, b))); + + assertFalse(l1 == l2); + assertEquals(l1, l2); + + assertFalse(l1 == l3); + assertNotEquals(l1, l3); + } } From 417ea05adb4f3c64d14ff4506b5fff09e84f5cf3 Mon Sep 17 00:00:00 2001 From: Julian Reschke Date: Wed, 8 Apr 2026 20:38:13 +0100 Subject: [PATCH 09/14] equals() and hashCode() for items (wip) --- .../greenbytes/http/sfv/ParametersTest.java | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/src/test/java/org/greenbytes/http/sfv/ParametersTest.java b/src/test/java/org/greenbytes/http/sfv/ParametersTest.java index c88f86c..3193408 100644 --- a/src/test/java/org/greenbytes/http/sfv/ParametersTest.java +++ b/src/test/java/org/greenbytes/http/sfv/ParametersTest.java @@ -2,7 +2,14 @@ import org.junit.Test; +import java.math.BigDecimal; +import java.util.Arrays; import java.util.HashMap; +import java.util.Map; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotEquals; public class ParametersTest { @@ -54,4 +61,24 @@ public void testReplace3() { public void testReplaceAll1() { params.replaceAll(null); } + + + @Test + public void testParametersEquality() { + Map m1 = new HashMap(); + m1.put("a", BooleanItem.valueOf(true)); + Map m2 = new HashMap(); + m2.put("b", IntegerItem.valueOf(12)); + m2.put("c", StringItem.valueOf("hello")); + + Parameters p1 = Parameters.valueOf(m1); + Parameters p2 = Parameters.valueOf(m1); + Parameters p3 = Parameters.valueOf(m2); + + assertFalse(p1 == p2); + assertEquals(p1, p2); + + assertFalse(p1 == p3); + assertNotEquals(p1, p3); + } } \ No newline at end of file From af32675219674d8e0dfe4012fb3ca6777c82b0d2 Mon Sep 17 00:00:00 2001 From: Julian Reschke Date: Wed, 8 Apr 2026 22:25:15 +0100 Subject: [PATCH 10/14] equals() and hashCode() for items (wip) --- .../org/greenbytes/http/sfv/InnerList.java | 15 ++++++++++ .../greenbytes/http/sfv/InnerListTest.java | 28 +++++++++++++++++++ 2 files changed, 43 insertions(+) create mode 100755 src/test/java/org/greenbytes/http/sfv/InnerListTest.java diff --git a/src/main/java/org/greenbytes/http/sfv/InnerList.java b/src/main/java/org/greenbytes/http/sfv/InnerList.java index 1ef0b4f..648677d 100644 --- a/src/main/java/org/greenbytes/http/sfv/InnerList.java +++ b/src/main/java/org/greenbytes/http/sfv/InnerList.java @@ -74,4 +74,19 @@ public String serialize() { public List> get() { return value; } + + @Override + public boolean equals(Object o) { + if (!(o instanceof InnerList)) { + return false; + } else { + InnerList innerList = (InnerList) o; + return Objects.equals(value, innerList.value) && Objects.equals(params, innerList.params); + } + } + + @Override + public int hashCode() { + return Objects.hash(value, params); + } } diff --git a/src/test/java/org/greenbytes/http/sfv/InnerListTest.java b/src/test/java/org/greenbytes/http/sfv/InnerListTest.java new file mode 100755 index 0000000..cb20a1f --- /dev/null +++ b/src/test/java/org/greenbytes/http/sfv/InnerListTest.java @@ -0,0 +1,28 @@ +package org.greenbytes.http.sfv; + +import junit.framework.TestCase; +import org.junit.Test; + +import java.math.BigDecimal; +import java.util.Arrays; + +import static org.junit.Assert.assertNotEquals; + +public class InnerListTest extends TestCase { + + @Test + public void testOuterListEquality() { + BooleanItem b = BooleanItem.valueOf(true); + DecimalItem d = DecimalItem.valueOf(BigDecimal.valueOf(10.5)); + + InnerList l1 = InnerList.valueOf((Arrays.asList(b, d))); + InnerList l2 = InnerList.valueOf((Arrays.asList(b, d))); + InnerList l3 = InnerList.valueOf((Arrays.asList(b, d, b))); + + assertFalse(l1 == l2); + assertEquals(l1, l2); + + assertFalse(l1 == l3); + assertNotEquals(l1, l3); + } +} \ No newline at end of file From fb70d98e46a7018f63ddc80c8d5484180a24fa20 Mon Sep 17 00:00:00 2001 From: Julian Reschke Date: Wed, 8 Apr 2026 22:25:33 +0100 Subject: [PATCH 11/14] equals() and hashCode() for items (wip) --- .../greenbytes/http/sfv/InnerListTest.java | 54 +++++++++---------- 1 file changed, 27 insertions(+), 27 deletions(-) mode change 100755 => 100644 src/test/java/org/greenbytes/http/sfv/InnerListTest.java diff --git a/src/test/java/org/greenbytes/http/sfv/InnerListTest.java b/src/test/java/org/greenbytes/http/sfv/InnerListTest.java old mode 100755 new mode 100644 index cb20a1f..6363fbc --- a/src/test/java/org/greenbytes/http/sfv/InnerListTest.java +++ b/src/test/java/org/greenbytes/http/sfv/InnerListTest.java @@ -1,28 +1,28 @@ -package org.greenbytes.http.sfv; - -import junit.framework.TestCase; -import org.junit.Test; - -import java.math.BigDecimal; -import java.util.Arrays; - -import static org.junit.Assert.assertNotEquals; - -public class InnerListTest extends TestCase { - - @Test - public void testOuterListEquality() { - BooleanItem b = BooleanItem.valueOf(true); - DecimalItem d = DecimalItem.valueOf(BigDecimal.valueOf(10.5)); - - InnerList l1 = InnerList.valueOf((Arrays.asList(b, d))); - InnerList l2 = InnerList.valueOf((Arrays.asList(b, d))); - InnerList l3 = InnerList.valueOf((Arrays.asList(b, d, b))); - - assertFalse(l1 == l2); - assertEquals(l1, l2); - - assertFalse(l1 == l3); - assertNotEquals(l1, l3); - } +package org.greenbytes.http.sfv; + +import junit.framework.TestCase; +import org.junit.Test; + +import java.math.BigDecimal; +import java.util.Arrays; + +import static org.junit.Assert.assertNotEquals; + +public class InnerListTest extends TestCase { + + @Test + public void testOuterListEquality() { + BooleanItem b = BooleanItem.valueOf(true); + DecimalItem d = DecimalItem.valueOf(BigDecimal.valueOf(10.5)); + + InnerList l1 = InnerList.valueOf((Arrays.asList(b, d))); + InnerList l2 = InnerList.valueOf((Arrays.asList(b, d))); + InnerList l3 = InnerList.valueOf((Arrays.asList(b, d, b))); + + assertFalse(l1 == l2); + assertEquals(l1, l2); + + assertFalse(l1 == l3); + assertNotEquals(l1, l3); + } } \ No newline at end of file From 4eb93ee4e46301e554dd27704a1f4ffb49b76c74 Mon Sep 17 00:00:00 2001 From: Julian Reschke Date: Thu, 9 Apr 2026 11:35:24 +0100 Subject: [PATCH 12/14] equals() and hashCode() for items (wip) --- .../org/greenbytes/http/sfv/EqualityTest.java | 193 +++++++++++++++++ .../org/greenbytes/http/sfv/ItemAPITests.java | 202 ------------------ 2 files changed, 193 insertions(+), 202 deletions(-) create mode 100644 src/test/java/org/greenbytes/http/sfv/EqualityTest.java diff --git a/src/test/java/org/greenbytes/http/sfv/EqualityTest.java b/src/test/java/org/greenbytes/http/sfv/EqualityTest.java new file mode 100644 index 0000000..dfdee17 --- /dev/null +++ b/src/test/java/org/greenbytes/http/sfv/EqualityTest.java @@ -0,0 +1,193 @@ +package org.greenbytes.http.sfv; + +import org.junit.Test; + +import java.math.BigDecimal; +import java.util.Arrays; +import java.util.HashMap; +import java.util.LinkedHashMap; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotEquals; +import static org.junit.Assert.assertTrue; + +public class EqualityTest { + + + @Test + public void testParametersEquality() { + HashMap m1 = new LinkedHashMap<>(); + m1.put("a", "b"); + HashMap m2 = new LinkedHashMap<>(); + m2.put("a", "b"); + Parameters p1 = Parameters.valueOf(m1); + Parameters p2 = Parameters.valueOf(m2); + assertFalse(p1 == p2); + assertEquals(p1, p2); + } + + @Test + public void testStringItemEquality() { + StringItem s1 = StringItem.valueOf("a"); + StringItem s2 = StringItem.valueOf("a"); + assertFalse(s1 == s2); + assertEquals(s1, s2); + StringItem s3 = StringItem.valueOf("b"); + assertNotEquals(s1, s3); + + StringItem s4 = StringItem.valueOf("a").withParams(getParameters("a", "b")); + assertFalse(s1 == s4); + assertNotEquals(s1, s4); + + HashMap m5 = new LinkedHashMap<>(); + m5.put("c", "d"); + Parameters p5 = Parameters.valueOf(m5); + StringItem s5 = StringItem.valueOf("a").withParams(p5); + assertFalse(s4 == s5); + assertNotEquals(s4, s5); + } + + @Test + public void testTokenItemEquality() { + TokenItem t1 = TokenItem.valueOf("a"); + TokenItem t = TokenItem.valueOf("a"); + assertFalse(t1 == t); + assertEquals(t1, t); + TokenItem t3 = TokenItem.valueOf("b"); + assertNotEquals(t1, t3); + + TokenItem t4 = TokenItem.valueOf("a").withParams(getParameters("a", "b")); + assertFalse(t1 == t4); + assertNotEquals(t1, t4); + + TokenItem t5 = TokenItem.valueOf("a").withParams(getParameters("c", "d")); + assertFalse(t4 == t5); + assertNotEquals(t4, t5); + } + + @Test + public void testBooleanItemEquality() { + BooleanItem b1 = BooleanItem.valueOf(true); + BooleanItem b2 = BooleanItem.valueOf(true); + BooleanItem b3 = BooleanItem.valueOf(false); + + // FALSE and TRUE are singletons + assertTrue(b1 == b2); + assertEquals(b1, b2); + + assertFalse(b1 == b3); + assertNotEquals(b1, b3); + + BooleanItem b4 = BooleanItem.valueOf(false).withParams(getParameters("c", "d")); + assertFalse(b1 == b4); + assertNotEquals(b1, b4); + } + + @Test + public void testByteSequenceItemEquality() { + ByteSequenceItem b1 = ByteSequenceItem.valueOf("x".getBytes()); + ByteSequenceItem b2 = ByteSequenceItem.valueOf("x".getBytes()); + ByteSequenceItem b3 = ByteSequenceItem.valueOf("y".getBytes()); + + assertFalse(b1 == b2); + assertEquals(b1, b2); + + assertFalse(b1 == b3); + assertNotEquals(b1, b3); + + ByteSequenceItem b4 = b1.withParams(getParameters("c", "d")); + assertFalse(b1 == b4); + assertNotEquals(b1, b4); + } + + @Test + public void testDateItemEquality() { + DateItem d1 = DateItem.valueOf(0); + DateItem d2 = DateItem.valueOf(0); + DateItem d3 = DateItem.valueOf(1000); + + assertFalse(d1 == d2); + assertEquals(d1, d2); + + assertFalse(d1 == d3); + assertNotEquals(d1, d3); + + DateItem d4 = d1.withParams(getParameters("c", "d")); + assertFalse(d1 == d4); + assertNotEquals(d1, d4); + } + + @Test + public void testDecimalItemEquality() { + DecimalItem d1 = DecimalItem.valueOf(BigDecimal.valueOf(10.5)); + DecimalItem d2 = DecimalItem.valueOf(BigDecimal.valueOf(10.5)); + DecimalItem d3 = DecimalItem.valueOf(BigDecimal.valueOf(10.6)); + + assertFalse(d1 == d2); + assertEquals(d1, d2); + + assertFalse(d1 == d3); + assertNotEquals(d1, d3); + + DecimalItem d4 = d1.withParams(getParameters("c", "d")); + assertFalse(d1 == d4); + assertNotEquals(d1, d4); + } + + @Test + public void testDisplayStringItemEquality() { + DisplayStringItem d1 = DisplayStringItem.valueOf("abc"); + DisplayStringItem d2 = DisplayStringItem.valueOf("abc"); + DisplayStringItem d3 = DisplayStringItem.valueOf("def"); + + assertFalse(d1 == d2); + assertEquals(d1, d2); + + assertFalse(d1 == d3); + assertNotEquals(d1, d3); + + DisplayStringItem d4 = d1.withParams(getParameters("c", "d")); + assertFalse(d1 == d4); + assertNotEquals(d1, d4); + } + + @Test + public void testIntegerItemEquality() { + IntegerItem i1 = IntegerItem.valueOf(1); + IntegerItem i2 = IntegerItem.valueOf(1); + IntegerItem i3 = IntegerItem.valueOf(2); + + assertFalse(i1 == i2); + assertEquals(i1, i2); + + assertFalse(i1 == i3); + assertNotEquals(i1, i3); + + IntegerItem d4 = i1.withParams(getParameters("a", "b")); + assertFalse(i1 == d4); + assertNotEquals(i1, d4); + } + + @Test + public void testOuterListEquality() { + BooleanItem b = BooleanItem.valueOf(true); + DecimalItem d = DecimalItem.valueOf(BigDecimal.valueOf(10.5)); + + OuterList l1 = OuterList.valueOf((Arrays.asList(b, d))); + OuterList l2 = OuterList.valueOf((Arrays.asList(b, d))); + OuterList l3 = OuterList.valueOf((Arrays.asList(b, d, b))); + + assertFalse(l1 == l2); + assertEquals(l1, l2); + + assertFalse(l1 == l3); + assertNotEquals(l1, l3); + } + + private static Parameters getParameters(String a, String b) { + HashMap m = new LinkedHashMap<>(); + m.put(a, b); + return Parameters.valueOf(m); + } +} diff --git a/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java b/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java index 6ce2b9d..8dcc1d2 100644 --- a/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java +++ b/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java @@ -9,7 +9,6 @@ import static org.junit.Assert.fail; import java.math.BigDecimal; -import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.LinkedHashMap; @@ -244,205 +243,4 @@ public void testInvalidParameterValues() { } catch (IllegalArgumentException expected) { } } - - @Test - public void testParametersEquality() { - HashMap m1 = new LinkedHashMap<>(); - m1.put("a", "b"); - HashMap m2 = new LinkedHashMap<>(); - m2.put("a", "b"); - Parameters p1 = Parameters.valueOf(m1); - Parameters p2 = Parameters.valueOf(m2); - assertFalse(p1 == p2); - assertEquals(p1, p2); - } - - @Test - public void testStringItemEquality() { - StringItem s1 = StringItem.valueOf("a"); - StringItem s2 = StringItem.valueOf("a"); - assertFalse(s1 == s2); - assertEquals(s1, s2); - StringItem s3 = StringItem.valueOf("b"); - assertNotEquals(s1, s3); - - HashMap m4 = new LinkedHashMap<>(); - m4.put("a", "b"); - Parameters p4 = Parameters.valueOf(m4); - StringItem s4 = StringItem.valueOf("a").withParams(p4); - assertFalse(s1 == s4); - assertNotEquals(s1, s4); - - HashMap m5 = new LinkedHashMap<>(); - m5.put("c", "d"); - Parameters p5 = Parameters.valueOf(m5); - StringItem s5 = StringItem.valueOf("a").withParams(p5); - assertFalse(s4 == s5); - assertNotEquals(s4, s5); - } - - @Test - public void testTokenItemEquality() { - TokenItem t1 = TokenItem.valueOf("a"); - TokenItem t = TokenItem.valueOf("a"); - assertFalse(t1 == t); - assertEquals(t1, t); - TokenItem t3 = TokenItem.valueOf("b"); - assertNotEquals(t1, t3); - - HashMap m4 = new LinkedHashMap<>(); - m4.put("a", "b"); - Parameters p4 = Parameters.valueOf(m4); - TokenItem t4 = TokenItem.valueOf("a").withParams(p4); - assertFalse(t1 == t4); - assertNotEquals(t1, t4); - - HashMap m5 = new LinkedHashMap<>(); - m5.put("c", "d"); - Parameters p5 = Parameters.valueOf(m5); - TokenItem t5 = TokenItem.valueOf("a").withParams(p5); - assertFalse(t4 == t5); - assertNotEquals(t4, t5); - } - - @Test - public void testBooleanItemEquality() { - BooleanItem b1 = BooleanItem.valueOf(true); - BooleanItem b2 = BooleanItem.valueOf(true); - BooleanItem b3 = BooleanItem.valueOf(false); - - // FALSE and TRUE are singletons - assertTrue(b1 == b2); - assertEquals(b1, b2); - - assertFalse(b1 == b3); - assertNotEquals(b1, b3); - - HashMap m4 = new LinkedHashMap<>(); - m4.put("c", "d"); - Parameters p4 = Parameters.valueOf(m4); - BooleanItem b4 = BooleanItem.valueOf(false).withParams(p4); - assertFalse(b1 == b4); - assertNotEquals(b1, b4); - } - - @Test - public void testByteSequenceItemEquality() { - ByteSequenceItem b1 = ByteSequenceItem.valueOf("x".getBytes()); - ByteSequenceItem b2 = ByteSequenceItem.valueOf("x".getBytes()); - ByteSequenceItem b3 = ByteSequenceItem.valueOf("y".getBytes()); - - assertFalse(b1 == b2); - assertEquals(b1, b2); - - assertFalse(b1 == b3); - assertNotEquals(b1, b3); - - HashMap m4 = new LinkedHashMap<>(); - m4.put("c", "d"); - Parameters p4 = Parameters.valueOf(m4); - ByteSequenceItem b4 = b1.withParams(p4); - assertFalse(b1 == b4); - assertNotEquals(b1, b4); - } - - @Test - public void testDateItemEquality() { - DateItem d1 = DateItem.valueOf(0); - DateItem d2 = DateItem.valueOf(0); - DateItem d3 = DateItem.valueOf(1000); - - assertFalse(d1 == d2); - assertEquals(d1, d2); - - assertFalse(d1 == d3); - assertNotEquals(d1, d3); - - HashMap m4 = new LinkedHashMap<>(); - m4.put("c", "d"); - Parameters p4 = Parameters.valueOf(m4); - - DateItem d4 = d1.withParams(p4); - assertFalse(d1 == d4); - assertNotEquals(d1, d4); - } - - @Test - public void testDecimalItemEquality() { - DecimalItem d1 = DecimalItem.valueOf(BigDecimal.valueOf(10.5)); - DecimalItem d2 = DecimalItem.valueOf(BigDecimal.valueOf(10.5)); - DecimalItem d3 = DecimalItem.valueOf(BigDecimal.valueOf(10.6)); - - assertFalse(d1 == d2); - assertEquals(d1, d2); - - assertFalse(d1 == d3); - assertNotEquals(d1, d3); - - HashMap m4 = new LinkedHashMap<>(); - m4.put("c", "d"); - Parameters p4 = Parameters.valueOf(m4); - - DecimalItem d4 = d1.withParams(p4); - assertFalse(d1 == d4); - assertNotEquals(d1, d4); - } - - @Test - public void testDisplayStringItemEquality() { - DisplayStringItem d1 = DisplayStringItem.valueOf("abc"); - DisplayStringItem d2 = DisplayStringItem.valueOf("abc"); - DisplayStringItem d3 = DisplayStringItem.valueOf("def"); - - assertFalse(d1 == d2); - assertEquals(d1, d2); - - assertFalse(d1 == d3); - assertNotEquals(d1, d3); - - HashMap m4 = new LinkedHashMap<>(); - m4.put("c", "d"); - Parameters p4 = Parameters.valueOf(m4); - - DisplayStringItem d4 = d1.withParams(p4); - assertFalse(d1 == d4); - assertNotEquals(d1, d4); - } - - @Test - public void testIntegerItemEquality() { - IntegerItem i1 = IntegerItem.valueOf(1); - IntegerItem i2 = IntegerItem.valueOf(1); - IntegerItem i3 = IntegerItem.valueOf(2); - - assertFalse(i1 == i2); - assertEquals(i1, i2); - - assertFalse(i1 == i3); - assertNotEquals(i1, i3); - - HashMap m4 = new LinkedHashMap<>(); - m4.put("c", "d"); - Parameters p4 = Parameters.valueOf(m4); - - IntegerItem d4 = i1.withParams(p4); - assertFalse(i1 == d4); - assertNotEquals(i1, d4); - } - - @Test - public void testOuterListEquality() { - BooleanItem b = BooleanItem.valueOf(true); - DecimalItem d = DecimalItem.valueOf(BigDecimal.valueOf(10.5)); - - OuterList l1 = OuterList.valueOf((Arrays.asList(b, d))); - OuterList l2 = OuterList.valueOf((Arrays.asList(b, d))); - OuterList l3 = OuterList.valueOf((Arrays.asList(b, d, b))); - - assertFalse(l1 == l2); - assertEquals(l1, l2); - - assertFalse(l1 == l3); - assertNotEquals(l1, l3); - } } From 6b3c2f5662f96f6d46354af4b7772dcb47c9f854 Mon Sep 17 00:00:00 2001 From: Julian Reschke Date: Thu, 9 Apr 2026 11:39:43 +0100 Subject: [PATCH 13/14] equals() and hashCode() for items (wip) --- .../greenbytes/http/sfv/InnerListTest.java | 28 ------------------- 1 file changed, 28 deletions(-) delete mode 100644 src/test/java/org/greenbytes/http/sfv/InnerListTest.java diff --git a/src/test/java/org/greenbytes/http/sfv/InnerListTest.java b/src/test/java/org/greenbytes/http/sfv/InnerListTest.java deleted file mode 100644 index 6363fbc..0000000 --- a/src/test/java/org/greenbytes/http/sfv/InnerListTest.java +++ /dev/null @@ -1,28 +0,0 @@ -package org.greenbytes.http.sfv; - -import junit.framework.TestCase; -import org.junit.Test; - -import java.math.BigDecimal; -import java.util.Arrays; - -import static org.junit.Assert.assertNotEquals; - -public class InnerListTest extends TestCase { - - @Test - public void testOuterListEquality() { - BooleanItem b = BooleanItem.valueOf(true); - DecimalItem d = DecimalItem.valueOf(BigDecimal.valueOf(10.5)); - - InnerList l1 = InnerList.valueOf((Arrays.asList(b, d))); - InnerList l2 = InnerList.valueOf((Arrays.asList(b, d))); - InnerList l3 = InnerList.valueOf((Arrays.asList(b, d, b))); - - assertFalse(l1 == l2); - assertEquals(l1, l2); - - assertFalse(l1 == l3); - assertNotEquals(l1, l3); - } -} \ No newline at end of file From e329d5284f6f83b9a09c15076718d1668ce5cc11 Mon Sep 17 00:00:00 2001 From: Julian Reschke Date: Thu, 9 Apr 2026 12:26:48 +0100 Subject: [PATCH 14/14] equals() and hashCode() for items (wip) --- src/test/java/org/greenbytes/http/sfv/ItemAPITests.java | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java b/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java index 8dcc1d2..39d1df3 100644 --- a/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java +++ b/src/test/java/org/greenbytes/http/sfv/ItemAPITests.java @@ -2,14 +2,10 @@ import static org.junit.Assert.assertArrayEquals; import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotEquals; import static org.junit.Assert.assertThrows; -import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; import java.math.BigDecimal; -import java.util.Arrays; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.Map;