From 95d8811bcbb799ddc793527ca2b517f6b3e3576b Mon Sep 17 00:00:00 2001 From: Andrea Cavalli Date: Wed, 19 Apr 2023 01:29:45 +0200 Subject: [PATCH] More tests --- data-generator-runtime/pom.xml | 6 + .../main/java/it/cavallium/buffer/Buf.java | 37 ++- .../java/it/cavallium/buffer/ByteListBuf.java | 19 +- .../java/it/cavallium/buffer/TestBuffer.java | 254 ++++++++++++++++-- 4 files changed, 283 insertions(+), 33 deletions(-) diff --git a/data-generator-runtime/pom.xml b/data-generator-runtime/pom.xml index 2221bd8..edbbad7 100644 --- a/data-generator-runtime/pom.xml +++ b/data-generator-runtime/pom.xml @@ -164,6 +164,12 @@ junit-jupiter-params test + + com.google.guava + guava + 31.1-jre + test + diff --git a/data-generator-runtime/src/main/java/it/cavallium/buffer/Buf.java b/data-generator-runtime/src/main/java/it/cavallium/buffer/Buf.java index 5403272..22a5254 100644 --- a/data-generator-runtime/src/main/java/it/cavallium/buffer/Buf.java +++ b/data-generator-runtime/src/main/java/it/cavallium/buffer/Buf.java @@ -95,6 +95,9 @@ public interface Buf extends ByteList, RandomAccess { void writeTo(SafeDataOutput dataOutput); + /** + * @param i byte offset + */ default long getLong(int i) { byte b1 = getByte(i); byte b2 = getByte(i + 1); @@ -114,6 +117,9 @@ public interface Buf extends ByteList, RandomAccess { | (b8 & 0xFFL); } + /** + * @param i byte offset + */ default int getInt(int i) { byte b1 = getByte(i); byte b2 = getByte(i + 1); @@ -122,26 +128,44 @@ public interface Buf extends ByteList, RandomAccess { return b1 << 24 | (b2 & 0xFF) << 16 | (b3 & 0xFF) << 8 | (b4 & 0xFF); } + /** + * @param i byte offset + */ default float getFloat(int i) { return Float.intBitsToFloat(getInt(i)); } + /** + * @param i byte offset + */ default double getDouble(int i) { return Double.longBitsToDouble(getLong(i)); } + /** + * @param i byte offset + */ default boolean getBoolean(int i) { return getByte(i) != 0; } + /** + * @param i byte offset + */ default void setBoolean(int i, boolean val) { set(i, val ? (byte) 1 : 0); } + /** + * @param i byte offset + */ default void setByte(int i, byte val) { set(i, val); } + /** + * @param i byte offset + */ default void setInt(int i, int val) { set(i, (byte) (val >> 24)); set(i + 1, (byte) (val >> 16)); @@ -149,6 +173,9 @@ public interface Buf extends ByteList, RandomAccess { set(i + 3, (byte) val); } + /** + * @param i byte offset + */ default void setLong(int i, long val) { set(i, (byte) (val >> 56)); set(i + 1, (byte) (val >> 48)); @@ -160,10 +187,16 @@ public interface Buf extends ByteList, RandomAccess { set(i + 7, (byte) val); } + /** + * @param i byte offset + */ default void setFloat(int i, float val) { setInt(i, Float.floatToRawIntBits(val)); } + /** + * @param i byte offset + */ default void setDouble(int i, double val) { setLong(i, Double.doubleToRawLongBits(val)); } @@ -182,7 +215,5 @@ public interface Buf extends ByteList, RandomAccess { boolean equals(int aStartIndex, byte[] b, int bStartIndex, int length); - default String toString(Charset charset) { - return new String(this.asArray(), charset); - } + String toString(Charset charset); } diff --git a/data-generator-runtime/src/main/java/it/cavallium/buffer/ByteListBuf.java b/data-generator-runtime/src/main/java/it/cavallium/buffer/ByteListBuf.java index 912cd93..3dcad20 100644 --- a/data-generator-runtime/src/main/java/it/cavallium/buffer/ByteListBuf.java +++ b/data-generator-runtime/src/main/java/it/cavallium/buffer/ByteListBuf.java @@ -1,10 +1,21 @@ package it.cavallium.buffer; +import static it.unimi.dsi.fastutil.Arrays.ensureFromTo; + import it.cavallium.stream.SafeByteArrayInputStream; import it.cavallium.stream.SafeByteArrayOutputStream; import it.cavallium.stream.SafeDataOutput; -import it.unimi.dsi.fastutil.bytes.*; - +import it.unimi.dsi.fastutil.bytes.AbstractByteList; +import it.unimi.dsi.fastutil.bytes.ByteArrayList; +import it.unimi.dsi.fastutil.bytes.ByteArrays; +import it.unimi.dsi.fastutil.bytes.ByteCollection; +import it.unimi.dsi.fastutil.bytes.ByteConsumer; +import it.unimi.dsi.fastutil.bytes.ByteIterator; +import it.unimi.dsi.fastutil.bytes.ByteIterators; +import it.unimi.dsi.fastutil.bytes.ByteList; +import it.unimi.dsi.fastutil.bytes.ByteListIterator; +import it.unimi.dsi.fastutil.bytes.ByteSpliterator; +import it.unimi.dsi.fastutil.bytes.ByteSpliterators; import java.io.Serial; import java.nio.charset.Charset; import java.util.Arrays; @@ -14,8 +25,6 @@ import java.util.NoSuchElementException; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import static it.unimi.dsi.fastutil.Arrays.ensureFromTo; - class ByteListBuf extends ByteArrayList implements Buf { private boolean mutable = true; @@ -470,7 +479,7 @@ class ByteListBuf extends ByteArrayList implements Buf { @Override public String toString(Charset charset) { - return new String(a, from, to, charset); + return new String(a, from, size(), charset); } } } diff --git a/data-generator-runtime/src/test/java/it/cavallium/buffer/TestBuffer.java b/data-generator-runtime/src/test/java/it/cavallium/buffer/TestBuffer.java index 683cbac..a0a38a9 100644 --- a/data-generator-runtime/src/test/java/it/cavallium/buffer/TestBuffer.java +++ b/data-generator-runtime/src/test/java/it/cavallium/buffer/TestBuffer.java @@ -1,16 +1,25 @@ package it.cavallium.buffer; -import it.unimi.dsi.fastutil.bytes.ByteList; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.MethodSource; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import com.google.common.primitives.Longs; +import it.cavallium.stream.SafeByteArrayOutputStream; +import it.unimi.dsi.fastutil.bytes.ByteArrayList; +import it.unimi.dsi.fastutil.bytes.ByteCollections; +import it.unimi.dsi.fastutil.bytes.ByteList; +import java.nio.ByteBuffer; +import java.nio.charset.StandardCharsets; import java.util.Arrays; import java.util.HexFormat; import java.util.List; import java.util.stream.Stream; - -import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class TestBuffer { @@ -62,6 +71,8 @@ public class TestBuffer { public static List createPrimaryBufs() { var emptyBuf = new BufArg("create()", Buf.create(), 0, new byte[0]); + var byteListBuf = new BufArg("createByteListBuf()", ByteListBuf.of(), 0, new byte[0]); + var byteListBufOf = new BufArg("createByteListBuf(0, 1, 2, 3, 4)", ByteListBuf.of((byte) 0, (byte) 1, (byte) 2, (byte) 3, (byte) 4), 5, new byte[] {0, 1, 2, 3, 4}); var def0Buf = new BufArg("create(0)", Buf.create(0), 0, new byte[0]); var def10Buf = new BufArg("create(10)", Buf.create(10), 0, new byte[0]); var def10000Buf = new BufArg("create(10000)", Buf.create(10000), 0, new byte[0]); @@ -75,32 +86,37 @@ public class TestBuffer { for (int i = 0; i < big.length; i++) { big[i] = (byte) (i * i); } - var copyOfBig = new BufArg("copyOfBig(big)", Buf.copyOf(big), big.length, big); - var wrapSmallArray = new BufArg("wrap(small array)", Buf.wrap(small.clone()), small.length, small); - var wrapBigArray = new BufArg("wrap(big array)", Buf.wrap(big.clone()), big.length, big); - var wrapSmallByteList = new BufArg("wrap(small byte list)", Buf.wrap(ByteList.of(small)), small.length, small); - var wrapBigByteList = new BufArg("wrap(big byte list)", Buf.wrap(ByteList.of(big)), big.length, big); + var copyOfBig = new BufArg("copyOfBig(big)", Buf.copyOf(big), big.length, big.clone()); + var wrapByteArrayList = new BufArg("wrap(byte array list)", Buf.wrap(ByteArrayList.of(small)), small.length, small.clone()); + var wrapBufSmall = new BufArg("wrap(wrap(small array))", Buf.wrap(Buf.wrap(small.clone())), small.length, small.clone()); + var wrapSmallArray = new BufArg("wrap(small array)", Buf.wrap(small.clone()), small.length, small.clone()); + var wrapBigArray = new BufArg("wrap(big array)", Buf.wrap(big.clone()), big.length, big.clone()); + var wrapSmallByteList = new BufArg("wrap(small byte list)", Buf.wrap(ByteList.of(small)), small.length, small.clone()); + var wrapBigByteList = new BufArg("wrap(big byte list)", Buf.wrap(ByteList.of(big)), big.length, big.clone()); var wrapSmallCapped = new BufArg("wrap(small array, 10)", Buf.wrap(small.clone(), 10), 10, Arrays.copyOf(small, 10)); var wrapBigCapped = new BufArg("wrap(big array, 10)", Buf.wrap(big.clone(), 10), 10, Arrays.copyOf(big, 10)); - var wrapSmallCappedSame = new BufArg("wrap(small array, same)", Buf.wrap(small.clone(), small.length), small.length, small); - var wrapBigCappedSame = new BufArg("wrap(big array, same)", Buf.wrap(big.clone(), big.length), big.length, big); + var wrapSmallCappedSame = new BufArg("wrap(small array, same)", Buf.wrap(small.clone(), small.length), small.length, small.clone()); + var wrapBigCappedSame = new BufArg("wrap(big array, same)", Buf.wrap(big.clone(), big.length), big.length, big.clone()); var wrapSmallCappedMinusOne = new BufArg("wrap(small array, same-1)", Buf.wrap(small.clone(), small.length - 1), small.length - 1, Arrays.copyOf(small, small.length - 1)); var wrapBigCappedMinusOne = new BufArg("wrap(big array, same-1)", Buf.wrap(big.clone(), big.length - 1), big.length - 1, Arrays.copyOf(big, big.length - 1)); - var wrapSmallCappedRangeSame = new BufArg("wrap(small array, 0, same)", Buf.wrap(small.clone(), 0, small.length), small.length, small); - var wrapBigCappedRangeSame = new BufArg("wrap(big array, 0, same)", Buf.wrap(big.clone(), 0, big.length), big.length, big); + var wrapSmallCappedRangeSame = new BufArg("wrap(small array, 0, same)", Buf.wrap(small.clone(), 0, small.length), small.length, small.clone()); + var wrapBigCappedRangeSame = new BufArg("wrap(big array, 0, same)", Buf.wrap(big.clone(), 0, big.length), big.length, big.clone()); var wrapSmallCappedRangeOffset = new BufArg("wrap(small array, 5, same)", Buf.wrap(small.clone(), 5, small.length), small.length - 5, Arrays.copyOfRange(small, 5, small.length)); var wrapBigCappedRangeOffset = new BufArg("wrap(big array, 500, same)", Buf.wrap(big.clone(), 500, big.length), big.length - 500, Arrays.copyOfRange(big, 500, big.length)); var wrapSmallCappedRangeOffsetAndLen = new BufArg("wrap(small array, 5, same-3)", Buf.wrap(small.clone(), 5, small.length - 3), small.length - 5 - 3, Arrays.copyOfRange(small, 5, small.length - 3)); var wrapBigCappedRangeOffsetAndLen = new BufArg("wrap(big array, 500, same-100)", Buf.wrap(big.clone(), 500, big.length - 100), big.length - 500 - 100, Arrays.copyOfRange(big, 500, big.length - 100)); var wrapSmallCappedRangeLen = new BufArg("wrap(small array, 0, same-5)", Buf.wrap(small.clone(), 0, small.length - 5), small.length - 5, Arrays.copyOf(small, small.length - 5)); var wrapBigCappedRangeLen = new BufArg("wrap(big array, 0, same-500)", Buf.wrap(big.clone(), 0, big.length - 500), big.length - 500, Arrays.copyOf(big, big.length - 500)); + var wrapSmallBufCappedRangeOffsetAndLen = new BufArg("wrap(wrap(small byte array list), 5, same-3)", Buf.wrap(Buf.wrap(small.clone()), 5, small.length - 3), small.length - 5 - 3, Arrays.copyOfRange(small, 5, small.length - 3)); + var wrapSmallByteArrayListCappedRangeOffsetAndLen = new BufArg("wrap(small byte array list, 5, same-3)", Buf.wrap(ByteArrayList.of(small.clone()), 5, small.length - 3), small.length - 5 - 3, Arrays.copyOfRange(small, 5, small.length - 3)); + var wrapSmallByteListCappedRangeOffsetAndLen = new BufArg("wrap(small byte list, 5, same-3)", Buf.wrap(ByteList.of(small.clone()), 5, small.length - 3), small.length - 5 - 3, Arrays.copyOfRange(small, 5, small.length - 3)); - return List.of(emptyBuf, def0Buf, def10Buf, def10000Buf, zeroedBuf, zeroed10Buf, zeroed10000Buf, copyOfEmpty, - copyOfSmall, copyOfBig, wrapSmallArray, wrapBigArray, wrapSmallByteList, wrapBigByteList, + return List.of(emptyBuf, byteListBuf, byteListBufOf, def0Buf, def10Buf, def10000Buf, zeroedBuf, zeroed10Buf, zeroed10000Buf, copyOfEmpty, + copyOfSmall, copyOfBig, wrapByteArrayList, wrapBufSmall, wrapSmallArray, wrapBigArray, wrapSmallByteList, wrapBigByteList, wrapSmallCapped, wrapBigCapped, wrapSmallCappedSame, wrapBigCappedSame, wrapSmallCappedMinusOne, wrapBigCappedMinusOne, wrapSmallCappedRangeSame, wrapBigCappedRangeSame, wrapSmallCappedRangeOffset, wrapBigCappedRangeOffset, wrapSmallCappedRangeOffsetAndLen, wrapBigCappedRangeOffsetAndLen, - wrapSmallCappedRangeLen, wrapBigCappedRangeLen); + wrapSmallCappedRangeLen, wrapBigCappedRangeLen, wrapSmallByteArrayListCappedRangeOffsetAndLen, wrapSmallByteListCappedRangeOffsetAndLen); } public static List createSubListBufs() { @@ -208,7 +224,7 @@ public class TestBuffer { } @ParameterizedTest - @MethodSource("generateWrapped") + @MethodSource("provideWrappedArgs") public void testWrapSubList(BufArg bufArg) { testInitialValidity(bufArg); testAsArray(bufArg.subList(0, 5)); @@ -219,7 +235,7 @@ public class TestBuffer { } @ParameterizedTest - @MethodSource("generateWrapped") + @MethodSource("provideWrappedArgs") public void testWrapCopyOfRange(BufArg bufArg) { testInitialValidity(bufArg); testAsArray(bufArg.copyOfRange(0, 5)); @@ -227,15 +243,203 @@ public class TestBuffer { testAsArray(bufArg.copyOfRange(3, 5)); testAsArray(bufArg.copyOfRange(3, 4)); testAsArray(bufArg.copyOfRange(3, 3)); + testAsArray(bufArg.copyOfRange(0, bufArg.initialSize)); } - public static Stream generateWrapped() { + public static Stream provideWrappedArgs() { byte[] source = new byte[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; return Stream.of( - new BufArg("0-len", Buf.wrap(source), source.length, source), - new BufArg("2-len", Buf.wrap(source, 2, source.length), source.length - 2, Arrays.copyOfRange(source, 2, source.length)), - new BufArg("2-9", Buf.wrap(source, 2, 9), 9 - 2, Arrays.copyOfRange(source, 2, 9)), - new BufArg("0-9", Buf.wrap(source, 0, 9), 9, Arrays.copyOfRange(source, 0, 9)) + new BufArg("0-len", Buf.wrap(source.clone()), source.length, source.clone()), + new BufArg("2-len", Buf.wrap(source.clone(), 2, source.length), source.length - 2, Arrays.copyOfRange(source, 2, source.length)), + new BufArg("2-9", Buf.wrap(source.clone(), 2, 9), 9 - 2, Arrays.copyOfRange(source, 2, 9)), + new BufArg("0-9", Buf.wrap(source.clone(), 0, 9), 9, Arrays.copyOfRange(source, 0, 9)) ); } + + @ParameterizedTest + @MethodSource + public void testLongs(BufArg bufArg) { + var long1 = bufArg.b.getLong(0); + assertEquals(Longs.fromByteArray(bufArg.initialContent), long1); + var long2 = bufArg.b.getLong(Long.BYTES); + assertEquals(Longs.fromByteArray(Arrays.copyOfRange(bufArg.initialContent, Long.BYTES, Long.BYTES * 2)), long2); + + var expected1 = long1 + 1; + bufArg.b.setLong(0, expected1); + var expected2 = long2 + 1; + bufArg.b.setLong(Long.BYTES, expected2); + assertEquals(expected1, bufArg.b.getLong(0)); + assertEquals(expected2, bufArg.b.getLong(Long.BYTES)); + } + + public static Stream testLongs() { + return provideBufs().filter(ba -> ba.initialSize >= Long.BYTES * 2); + } + + @ParameterizedTest + @MethodSource + public void testInts(BufArg bufArg) { + var ib = ByteBuffer.wrap(bufArg.initialContent).asIntBuffer(); + var int1 = bufArg.b.getInt(0); + assertEquals(ib.get(0), int1); + var int2 = bufArg.b.getInt(Integer.BYTES); + assertEquals(ib.get(1), int2); + + var expected1 = int1 + 1; + bufArg.b.setInt(0, expected1); + var expected2 = int2 + 1; + bufArg.b.setInt(Integer.BYTES, expected2); + assertEquals(expected1, bufArg.b.getInt(0)); + assertEquals(expected2, bufArg.b.getInt(Integer.BYTES)); + } + + public static Stream testInts() { + return provideBufs().filter(ba -> ba.initialSize >= Integer.BYTES * 2); + } + + @ParameterizedTest + @MethodSource + public void testDoubles(BufArg bufArg) { + var ib = ByteBuffer.wrap(bufArg.initialContent).asDoubleBuffer(); + var double1 = bufArg.b.getDouble(0); + assertEquals(ib.get(0), double1); + var double2 = bufArg.b.getDouble(Double.BYTES); + assertEquals(ib.get(1), double2); + + var expected1 = double1 + 1; + bufArg.b.setDouble(0, expected1); + var expected2 = double2 + 1; + bufArg.b.setDouble(Double.BYTES, expected2); + assertEquals(expected1, bufArg.b.getDouble(0)); + assertEquals(expected2, bufArg.b.getDouble(Double.BYTES)); + } + + public static Stream testDoubles() { + return provideBufs().filter(ba -> ba.initialSize >= Double.BYTES * 2); + } + + @ParameterizedTest + @MethodSource + public void testFloats(BufArg bufArg) { + var ib = ByteBuffer.wrap(bufArg.initialContent).asFloatBuffer(); + var float1 = bufArg.b.getFloat(0); + assertEquals(ib.get(0), float1); + var float2 = bufArg.b.getFloat(Float.BYTES); + assertEquals(ib.get(1), float2); + + var expected1 = float1 + 1; + bufArg.b.setFloat(0, expected1); + var expected2 = float2 + 1; + bufArg.b.setFloat(Float.BYTES, expected2); + assertEquals(expected1, bufArg.b.getFloat(0)); + assertEquals(expected2, bufArg.b.getFloat(Float.BYTES)); + } + + public static Stream testFloats() { + return provideBufs().filter(ba -> ba.initialSize >= Float.BYTES * 2); + } + + @ParameterizedTest + @MethodSource + public void testBooleans(BufArg bufArg) { + var boolean1 = bufArg.b.getBoolean(0); + assertEquals(bufArg.initialContent[0] != 0, boolean1); + var boolean2 = bufArg.b.getBoolean(1); + assertEquals(bufArg.initialContent[1] != 0, boolean2); + + var expected1 = !boolean1; + bufArg.b.setBoolean(0, expected1); + var expected2 = !boolean2; + bufArg.b.setBoolean(1, expected2); + assertEquals(expected1, bufArg.b.getBoolean(0)); + assertEquals(expected2, bufArg.b.getBoolean(1)); + } + + public static Stream testBooleans() { + return provideBufs().filter(ba -> ba.initialSize >= 2); + } + + @ParameterizedTest + @MethodSource + public void testBytes(BufArg bufArg) { + var byte1 = bufArg.b.getByte(0); + assertEquals(bufArg.initialContent[0], byte1); + var byte2 = bufArg.b.getByte(1); + assertEquals(bufArg.initialContent[1], byte2); + var byte3 = bufArg.b.getByte(bufArg.initialSize - 1); + assertEquals(bufArg.initialContent[bufArg.initialSize - 1], byte3); + + var expected1 = (byte) (byte1 + 1); + bufArg.b.setByte(0, expected1); + var expected2 = (byte) (byte2 + 1); + bufArg.b.setByte(1, expected2); + var expected3 = (byte) (byte3 + 1); + bufArg.b.setByte(bufArg.initialSize - 1, expected3); + assertEquals(expected1, bufArg.b.getByte(0)); + assertEquals(expected2, bufArg.b.getByte(1)); + assertEquals(expected3, bufArg.b.getByte(bufArg.initialSize - 1)); + } + + public static Stream testBytes() { + return provideBufs().filter(ba -> ba.initialSize >= 2); + } + + @ParameterizedTest + @MethodSource("provideBufs") + public void testString(BufArg bufArg) { + var s = new String(bufArg.b.toByteArray(), StandardCharsets.UTF_8); + assertEquals(s, bufArg.b.toString(StandardCharsets.UTF_8)); + } + + @ParameterizedTest + @MethodSource("provideBufs") + public void testBufBinaryOutputStream(BufArg bufArg) { + testBinaryOutputStream(bufArg.b.binaryOutputStream()); + testBinaryOutputStream(bufArg.b.binaryOutputStream(0)); + testBinaryOutputStream(bufArg.b.binaryOutputStream(0, 0)); + if (bufArg.initialSize > 10) { + testBinaryOutputStream(bufArg.b.binaryOutputStream(0, 1)); + testBinaryOutputStream(bufArg.b.binaryOutputStream(5)); + testBinaryOutputStream(bufArg.b.binaryOutputStream(10)); + testBinaryOutputStream(bufArg.b.binaryOutputStream(11)); + testBinaryOutputStream(bufArg.b.binaryOutputStream(0, bufArg.initialSize)); + testBinaryOutputStream(bufArg.b.binaryOutputStream(bufArg.initialSize, bufArg.initialSize)); + } + } + + private void testBinaryOutputStream(SafeByteArrayOutputStream bos) { + + } + + @Test + public void testByteListBufConstructor() { + ByteListBuf blb1 = new ByteListBuf(); + blb1.add((byte) 0); + blb1.add((byte) 1); + blb1.add((byte) 2); + blb1.add((byte) 3); + + ByteListBuf blb2 = new ByteListBuf(List.of((byte) 0, (byte) 1, (byte) 2, (byte) 3)); + + ByteListBuf blb3 = new ByteListBuf(ByteCollections.unmodifiable(ByteList.of((byte) 0, (byte) 1, (byte) 2, (byte) 3))); + + ByteListBuf blb4 = new ByteListBuf(ByteList.of((byte) 0, (byte) 1, (byte) 2, (byte) 3)); + + ByteListBuf blb5 = new ByteListBuf(new byte[] {(byte) 0, (byte) 1, (byte) 2, (byte) 3}); + + ByteListBuf blb6 = new ByteListBuf(new byte[] {(byte) -1, (byte) 0, (byte) 1, (byte) 2, (byte) 3, (byte) 4, (byte) 5, (byte) 6}, 1, 4); + + ByteListBuf blb7 = new ByteListBuf(List.of((byte) 0, (byte) 1, (byte) 2, (byte) 3).iterator()); + + ByteListBuf blb8 = new ByteListBuf(ByteList.of((byte) 0, (byte) 1, (byte) 2, (byte) 3).iterator()); + + assertEquals(blb1, blb2); + assertEquals(blb1, blb3); + assertEquals(blb1, blb4); + assertEquals(blb1, blb5); + assertEquals(blb1, blb6); + assertEquals(blb1, blb7); + assertEquals(blb1, blb8); + + } }