From df853ef46a9c12d319bf824ac106a411f5eddabd Mon Sep 17 00:00:00 2001 From: Matthias Andreas Benkard Date: Sun, 10 Dec 2023 20:29:35 +0100 Subject: Add property-based tests and fix the bugs discovered. Change-Id: I8deb1a7d75078c037714541d8f6f656052c2476c --- .../main/java/eu/mulk/jgvariant/core/Decoder.java | 18 +++-- .../mulk/jgvariant/core/DecoderPropertyTest.java | 89 ++++++++++++++++++++++ 2 files changed, 102 insertions(+), 5 deletions(-) create mode 100644 jgvariant-core/src/test/java/eu/mulk/jgvariant/core/DecoderPropertyTest.java (limited to 'jgvariant-core/src') diff --git a/jgvariant-core/src/main/java/eu/mulk/jgvariant/core/Decoder.java b/jgvariant-core/src/main/java/eu/mulk/jgvariant/core/Decoder.java index 9362487..fcbb639 100644 --- a/jgvariant-core/src/main/java/eu/mulk/jgvariant/core/Decoder.java +++ b/jgvariant-core/src/main/java/eu/mulk/jgvariant/core/Decoder.java @@ -342,14 +342,22 @@ public abstract class Decoder { } private static int getIntN(ByteBuffer byteSlice) { - var intBytes = new byte[4]; - byteSlice.get(intBytes, 0, Math.min(4, byteSlice.limit())); - return ByteBuffer.wrap(intBytes).order(LITTLE_ENDIAN).getInt(); + return switch (byteSlice.limit()) { + case 0 -> 0; + case 1 -> + Byte.toUnsignedInt(byteSlice.order(LITTLE_ENDIAN).get()); + case 2 -> + Short.toUnsignedInt(byteSlice.order(LITTLE_ENDIAN).getShort()); + case 4 -> + byteSlice.order(LITTLE_ENDIAN).getInt(); + default -> + throw new IllegalArgumentException("invalid byte count: %d".formatted(byteSlice.limit())); + }; } @SuppressWarnings("java:S3358") private static int byteCount(int n) { - return n < (1 << 8) ? 1 : n < (1 << 16) ? 2 : 4; + return n == 0 ? 0 : n < (1 << 8) ? 1 : n < (1 << 16) ? 2 : 4; } private static int computeFramingOffsetSize(int elementsRelativeEnd, List framingOffsets) { @@ -404,7 +412,7 @@ public abstract class Decoder { elements = List.of(); } else { // An array with aligned elements and a vector of framing offsets in the end. - int framingOffsetSize = byteCount(byteSlice.limit()); + int framingOffsetSize = max(1, byteCount(byteSlice.limit())); int lastFramingOffset = getIntN(byteSlice.slice(byteSlice.limit() - framingOffsetSize, framingOffsetSize)); int elementCount = (byteSlice.limit() - lastFramingOffset) / framingOffsetSize; diff --git a/jgvariant-core/src/test/java/eu/mulk/jgvariant/core/DecoderPropertyTest.java b/jgvariant-core/src/test/java/eu/mulk/jgvariant/core/DecoderPropertyTest.java new file mode 100644 index 0000000..5e07ea0 --- /dev/null +++ b/jgvariant-core/src/test/java/eu/mulk/jgvariant/core/DecoderPropertyTest.java @@ -0,0 +1,89 @@ +package eu.mulk.jgvariant.core; + +import java.text.ParseException; +import java.util.Optional; +import net.jqwik.api.*; + +@SuppressWarnings("java:S2187") +class DecoderPropertyTest { + + @Group + class VariantRoundtripLaw implements RoundtripLaw { + + @Override + public Decoder decoder() { + return Decoder.ofVariant(); + } + + @Override + public Arbitrary anyT() { + return anyVariant(); + } + } + + interface RoundtripLaw { + + @Property + default boolean roundtripsWell(@ForAll(value = "anyT") T entityLeft) { + var decoder = decoder(); + var bytes = decoder.encode(entityLeft); + var entityRight = decoder.decode(bytes); + return entityLeft.equals(entityRight); + } + + Decoder decoder(); + + @Provide + Arbitrary anyT(); + } + + @Provide + Arbitrary anyVariant() { + var anyString = Arbitraries.strings().map(s -> new Variant(parseSignature("s"), s)); + var anyInt = Arbitraries.integers().map(i -> new Variant(parseSignature("i"), i)); + var anyLong = Arbitraries.longs().map(l -> new Variant(parseSignature("x"), l)); + var anyDouble = Arbitraries.doubles().map(d -> new Variant(parseSignature("d"), d)); + var anyBoolean = + Arbitraries.of(Boolean.TRUE, Boolean.FALSE).map(b -> new Variant(parseSignature("b"), b)); + var anyByte = Arbitraries.bytes().map(b -> new Variant(parseSignature("y"), b)); + var anyShort = Arbitraries.shorts().map(s -> new Variant(parseSignature("n"), s)); + var anyByteArray = Arbitraries.bytes().list().map(b -> new Variant(parseSignature("ay"), b)); + var anySome = + Arbitraries.lazyOf( + () -> + anyVariant() + .map( + x -> + new Variant( + parseSignature("m" + x.signature().toString()), + Optional.of(x.value())))); + var anyNone = + Arbitraries.lazyOf( + () -> + anyVariant() + .map( + x -> + new Variant( + parseSignature("m" + x.signature().toString()), Optional.empty()))); + // FIXME missing: list, tuple, dictionary, variant + return Arbitraries.oneOf( + anyString, + anyInt, + anyLong, + anyDouble, + anyBoolean, + anyByte, + anyShort, + anyByteArray, + anySome, + anyNone); + } + + private Signature parseSignature(String s) { + try { + return Signature.parse(s); + } catch (ParseException e) { + throw new AssertionError(e); + } + } +} -- cgit v1.2.3