242 lines
12 KiB
Java
242 lines
12 KiB
Java
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 java.util.Arrays;
|
|
import java.util.HexFormat;
|
|
import java.util.List;
|
|
import java.util.stream.Stream;
|
|
|
|
import static org.junit.jupiter.api.Assertions.*;
|
|
|
|
public class TestBuffer {
|
|
|
|
private record BufArg(String name, Buf b, int initialSize, byte[] initialContent) {
|
|
private static final HexFormat HEX = HexFormat.of();
|
|
|
|
@Override
|
|
public String toString() {
|
|
var bs = toStringArrayb(b.toByteArray());
|
|
var ic = toStringArrayb(initialContent);
|
|
return "BufArg{" +
|
|
"name='" + name + '\'' +
|
|
", b=" + bs +
|
|
", initialSize=" + initialSize +
|
|
", initialContent=" + ic +
|
|
'}';
|
|
}
|
|
|
|
private String toStringArraya(byte[] byteArray) {
|
|
var bs = Arrays.toString(Arrays.copyOf(byteArray, 24));
|
|
if (byteArray.length > 24) {
|
|
bs = bs.substring(0, bs.length() - 1) + ", ...]";
|
|
}
|
|
return bs;
|
|
}
|
|
|
|
private String toStringArrayb(byte[] byteArray) {
|
|
var out = HEX.formatHex(byteArray, 0, Math.min(byteArray.length, 24));
|
|
if (byteArray.length > 24) {
|
|
out += "...";
|
|
}
|
|
return out;
|
|
}
|
|
|
|
public BufArg subList(int from, int to) {
|
|
return new BufArg(name + ".subList(" + from + "," + to + ")", b.subList(from, to), to - from, Arrays.copyOfRange(initialContent, from, to));
|
|
}
|
|
|
|
public BufArg copyOfRange(int from, int to) {
|
|
return new BufArg(name + ".copyOfRange(" + from + "," + to + ")", b.copyOfRange(from, to), to - from, Arrays.copyOfRange(initialContent, from, to));
|
|
}
|
|
}
|
|
|
|
public static Stream<BufArg> provideBufs() {
|
|
List<BufArg> primaryBufs = createPrimaryBufs();
|
|
List<BufArg> subListBufs = createSubListBufs();
|
|
return Stream.concat(primaryBufs.stream(), subListBufs.stream());
|
|
}
|
|
|
|
public static List<BufArg> createPrimaryBufs() {
|
|
var emptyBuf = new BufArg("create()", Buf.create(), 0, new byte[0]);
|
|
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]);
|
|
var zeroedBuf = new BufArg("createZeroes(0)", Buf.createZeroes(0), 0, new byte[0]);
|
|
var zeroed10Buf = new BufArg("createZeroes(10)", Buf.createZeroes(10), 10, new byte[10]);
|
|
var zeroed10000Buf = new BufArg("createZeroes(10000)", Buf.createZeroes(10000), 10000, new byte[10000]);
|
|
var copyOfEmpty = new BufArg("copyOf(empty)", Buf.copyOf(new byte[0]), 0, new byte[0]);
|
|
var small = new byte[] {126, 19, 118, 33, -24, -65, 56, 17, 0, 90};
|
|
var copyOfSmall = new BufArg("copyOfSmall(small)", Buf.copyOf(small), small.length, small);
|
|
var big = new byte[10000];
|
|
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 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 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 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));
|
|
|
|
return List.of(emptyBuf, def0Buf, def10Buf, def10000Buf, zeroedBuf, zeroed10Buf, zeroed10000Buf, copyOfEmpty,
|
|
copyOfSmall, copyOfBig, wrapSmallArray, wrapBigArray, wrapSmallByteList, wrapBigByteList,
|
|
wrapSmallCapped, wrapBigCapped, wrapSmallCappedSame, wrapBigCappedSame, wrapSmallCappedMinusOne,
|
|
wrapBigCappedMinusOne, wrapSmallCappedRangeSame, wrapBigCappedRangeSame, wrapSmallCappedRangeOffset,
|
|
wrapBigCappedRangeOffset, wrapSmallCappedRangeOffsetAndLen, wrapBigCappedRangeOffsetAndLen,
|
|
wrapSmallCappedRangeLen, wrapBigCappedRangeLen);
|
|
}
|
|
|
|
public static List<BufArg> createSubListBufs() {
|
|
var sameSizeArgs = createPrimaryBufs().stream().filter(b -> b.initialSize > 0).map(bufArg -> new BufArg(bufArg.name + ".subList(0, same)", bufArg.b.subList(0, bufArg.initialSize), bufArg.initialSize, bufArg.initialContent)).toList();
|
|
var firstHalfArgs = createPrimaryBufs().stream().filter(b -> b.initialSize > 0).map(bufArg -> new BufArg(bufArg.name + ".subList(0, half)", bufArg.b.subList(0, bufArg.initialSize/2), bufArg.initialSize/2, Arrays.copyOfRange(bufArg.initialContent, 0, bufArg.initialSize/2))).toList();
|
|
var lastHalfArgs = createPrimaryBufs().stream().filter(b -> b.initialSize > 0).map(bufArg -> new BufArg(bufArg.name + ".subList(half, same)", bufArg.b.subList(bufArg.initialSize/2, bufArg.initialSize), bufArg.initialSize - bufArg.initialSize/2, Arrays.copyOfRange(bufArg.initialContent, bufArg.initialSize/2, bufArg.initialSize))).toList();
|
|
return Stream.concat(Stream.concat(sameSizeArgs.stream(), firstHalfArgs.stream()), lastHalfArgs.stream()).toList();
|
|
}
|
|
|
|
@Test
|
|
public void testCreate() {
|
|
var buf = Buf.create();
|
|
assertEquals(0, buf.size());
|
|
assertTrue(buf.isMutable());
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("provideBufs")
|
|
public void testInitialValidity(BufArg bufArg) {
|
|
assertEquals(bufArg.initialSize, bufArg.b.size());
|
|
assertEquals(bufArg.initialSize, bufArg.initialContent.length);
|
|
assertEquals(bufArg.initialSize == 0, bufArg.b.isEmpty());
|
|
assertTrue(bufArg.b.isMutable());
|
|
if (bufArg.b instanceof ByteListBuf.SubList subList) {
|
|
assertArrayEquals(bufArg.initialContent, subList.toByteArray());
|
|
} else if (bufArg.b instanceof ByteListBuf bytes) {
|
|
assertArrayEquals(bufArg.initialContent, bytes.toByteArray());
|
|
} else {
|
|
assertArrayEquals(bufArg.initialContent, bufArg.b.toByteArray());
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("provideBufs")
|
|
public void testGet(BufArg bufArg) {
|
|
assertThrows(Exception.class, () -> bufArg.b.getByte(-1));
|
|
assertThrows(Exception.class, () -> bufArg.b.getByte(bufArg.initialContent.length));
|
|
if (bufArg.initialSize > 0) {
|
|
// Test first
|
|
var expected = bufArg.initialContent[0];
|
|
var bi = bufArg.b.getByte(0);
|
|
assertEquals(expected, bi, "The first element does not match");
|
|
|
|
// Test last
|
|
var expectedLast = bufArg.initialContent[bufArg.initialSize - 1];
|
|
var biLast = bufArg.b.getByte(bufArg.initialSize - 1);
|
|
assertEquals(expectedLast, biLast, "The last element does not match");
|
|
}
|
|
|
|
// Test the other
|
|
for (int i = 1; i < bufArg.initialContent.length - 1; i++) {
|
|
var expected = bufArg.initialContent[i];
|
|
var bi = bufArg.b.getByte(i);
|
|
assertEquals(expected, bi, "The element index " + i + " does not match");
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("provideBufs")
|
|
public void testPut(BufArg bufArg) {
|
|
bufArg.b.copy().isMutable();
|
|
bufArg.b.size(10);
|
|
bufArg.b.size();
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("provideBufs")
|
|
public void testFreeze(BufArg bufArg) {
|
|
var buf = bufArg.b;
|
|
assertTrue(buf.isMutable());
|
|
Buf subList1 = null;
|
|
Buf subList2 = null;
|
|
if (bufArg.initialSize >= 3) {
|
|
subList1 = buf.subList(0, 2);
|
|
subList2 = subList1.subList(0, 1);
|
|
}
|
|
buf.freeze();
|
|
assertFalse(buf.isMutable());
|
|
if (subList1 != null) {
|
|
Buf subList3 = buf.subList(0, 2);
|
|
Buf subList4 = subList3.subList(0, 1);
|
|
assertFalse(subList1.isMutable());
|
|
assertFalse(subList2.isMutable());
|
|
assertFalse(subList3.isMutable());
|
|
assertFalse(subList4.isMutable());
|
|
}
|
|
buf.freeze();
|
|
assertFalse(buf.isMutable());
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("provideBufs")
|
|
public void testAsArray(BufArg bufArg) {
|
|
assertArrayEquals(bufArg.initialContent, bufArg.b.asArray());
|
|
assertArrayEquals(bufArg.initialContent, bufArg.b.toByteArray());
|
|
assertArrayEquals(bufArg.initialContent, Arrays.copyOf(bufArg.b.asUnboundedArray(), bufArg.initialSize));
|
|
var strictArray = bufArg.b.asArrayStrict();
|
|
if (strictArray != null) {
|
|
assertArrayEquals(bufArg.initialContent, strictArray);
|
|
}
|
|
var strictUnboundedArray = bufArg.b.asUnboundedArrayStrict();
|
|
if (strictUnboundedArray != null) {
|
|
assertArrayEquals(bufArg.initialContent, Arrays.copyOf(strictUnboundedArray, bufArg.initialSize));
|
|
}
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("generateWrapped")
|
|
public void testWrapSubList(BufArg bufArg) {
|
|
testInitialValidity(bufArg);
|
|
testAsArray(bufArg.subList(0, 5));
|
|
testAsArray(bufArg.subList(0, 2));
|
|
testAsArray(bufArg.subList(3, 5));
|
|
testAsArray(bufArg.subList(3, 4));
|
|
testAsArray(bufArg.subList(3, 3));
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("generateWrapped")
|
|
public void testWrapCopyOfRange(BufArg bufArg) {
|
|
testInitialValidity(bufArg);
|
|
testAsArray(bufArg.copyOfRange(0, 5));
|
|
testAsArray(bufArg.copyOfRange(0, 2));
|
|
testAsArray(bufArg.copyOfRange(3, 5));
|
|
testAsArray(bufArg.copyOfRange(3, 4));
|
|
testAsArray(bufArg.copyOfRange(3, 3));
|
|
}
|
|
|
|
public static Stream<BufArg> generateWrapped() {
|
|
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))
|
|
);
|
|
}
|
|
}
|