test(compute): cover the kernel branches the oracles never reached

dfa1 · claude · dfa1 · commit 31fea8eb3977 · 2026-07-02T22:56:21.000+02:00
The Sonar quality gate fails on new-code coverage (75.25% &lt; 80%), and
the gap sits in exactly the branches the randomized oracles never
generate: FusedFilterSum's ShortArray/ByteArray and FloatArray filter
loops, the generic boxing path (composite and null-test predicates),
the empty-range boundary-constant guards of the range lowering, the
length-mismatch fail-fast, and Values' narrow-unsigned zero-extension
and non-numeric boxes.

FusedFilterSumTest's random filter/aggregate domains now include i16,
i8 (each randomly unsigned) and f32 columns, and the predicate sweep
adds And/Or composites and the null tests, driving the whole random
space through the generic path as well. Pinned tests cover the
mismatched-length throw and the Lt(min)/Gt(max) empty-range lowering.
The new ValuesTest pins the boxing accessor directly: u8/u16/u32
zero-extension (0xFF must box as 255, never -1), signed sign-extension,
the extension-dtype passthrough, Utf8/bool boxes, the no-scalar-
accessor fail-fast, and masked reads.

Co-Authored-By: Claude Fable 5 &lt;noreply@anthropic.com&gt;
diff --git a/reader/src/test/java/io/github/dfa1/vortex/reader/compute/FusedFilterSumTest.java b/reader/src/test/java/io/github/dfa1/vortex/reader/compute/FusedFilterSumTest.java
@@ -1,34 +1,42 @@
 package io.github.dfa1.vortex.reader.compute;
 
+import io.github.dfa1.vortex.core.error.VortexException;
 import io.github.dfa1.vortex.core.io.PTypeIO;
 import io.github.dfa1.vortex.core.model.DType;
 import io.github.dfa1.vortex.reader.array.Array;
 import io.github.dfa1.vortex.reader.array.MaskedArray;
+import io.github.dfa1.vortex.reader.array.MaterializedByteArray;
 import io.github.dfa1.vortex.reader.array.MaterializedDoubleArray;
+import io.github.dfa1.vortex.reader.array.MaterializedFloatArray;
 import io.github.dfa1.vortex.reader.array.MaterializedIntArray;
 import io.github.dfa1.vortex.reader.array.MaterializedLongArray;
+import io.github.dfa1.vortex.reader.array.MaterializedShortArray;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 
 import java.lang.foreign.Arena;
 import java.lang.foreign.MemorySegment;
+import java.lang.foreign.ValueLayout;
 import java.util.Random;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 
 /// Oracle test for the fused [Compute#filteredSum(Array, Predicate, Array)] kernel: the one-pass
 /// fused result must be bit-identical to an independent boxing reference — a plain per-element
 /// `if (predicate) acc += value` loop over the same columns. The fused hot lane shares no code with
 /// that boxing reference, so any divergence is a correctness bug.
 ///
-/// The randomized cases pair a random primitive filter column (`i64` / `i32` / `f64`, with and
-/// without nulls) against a random primitive aggregate column, under each comparison predicate, so
-/// every filter/aggregate domain crossing (long/double, hot lane and the narrow-int generic
-/// fall-back) is exercised. The explicit cases pin the corners — empty, an all-null filter, an
-/// all-null aggregate, zero matches, and a full match.
+/// The randomized cases pair a random primitive filter column (`i64` / `i32` / `i16` / `i8` — each
+/// narrow width randomly unsigned — plus `f32` / `f64`, with and without nulls) against a random
+/// primitive aggregate column, under each comparison predicate and under composite / null-test
+/// predicates (the generic boxing path), so every filter/aggregate domain crossing (long/double,
+/// signed/unsigned, hot lane and the narrow-int generic fall-back) is exercised. The explicit cases
+/// pin the corners — empty, an all-null filter, an all-null aggregate, zero matches, a full match,
+/// mismatched column lengths, and the empty-range boundary constants of the range lowering.
 class FusedFilterSumTest {
 
     private static final Arena ARENA = Arena.ofAuto();
@@ -137,6 +145,37 @@ void doubleFilterLongAggregateCrossesDomains() {
         assertFusedMatchesTwoPass(filter, new Predicate.Gt(1.0), agg);
     }
 
+    @Test
+    void mismatchedColumnLengthsFailFast() {
+        // Given columns of different lengths — the kernel must reject them before any scan
+        Array filter = longColumn(new long[]{1, 2, 3}, null);
+        Array agg = longColumn(new long[]{1, 2}, null);
+
+        // When the fused kernel is asked to fold misaligned columns
+        // Then it fails fast instead of reading out of bounds
+        assertThatExceptionOfType(VortexException.class)
+                .isThrownBy(() -> Compute.filteredSum(filter, new Predicate.Gt(0L), agg))
+                .withMessageContaining("filter length");
+    }
+
+    @Test
+    void boundaryConstantsLowerToEmptyRanges() {
+        // Given the two range-lowering guards: Lt(min long) and Gt(max long) can match no value,
+        // so both must lower to the canonical empty range instead of under/overflowing the bound
+        Array filter = longColumn(new long[]{Long.MIN_VALUE, -1, 0, 1, Long.MAX_VALUE}, null);
+        Array agg = longColumn(new long[]{1, 2, 4, 8, 16}, null);
+
+        // When the fused kernel filters with each boundary constant
+        Number ltMin = Compute.filteredSum(filter, new Predicate.Lt(Long.MIN_VALUE), agg);
+        Number gtMax = Compute.filteredSum(filter, new Predicate.Gt(Long.MAX_VALUE), agg);
+
+        // Then nothing is selected either way, matching the boxing reference
+        assertThat(ltMin).isEqualTo(0L);
+        assertThat(gtMax).isEqualTo(0L);
+        assertFusedMatchesTwoPass(filter, new Predicate.Lt(Long.MIN_VALUE), agg);
+        assertFusedMatchesTwoPass(filter, new Predicate.Gt(Long.MAX_VALUE), agg);
+    }
+
     private static void assertFusedMatchesTwoPass(Array filter, Predicate predicate, Array agg) {
         Number reference = referenceFilteredSum(filter, predicate, agg);
         Number fused = Compute.filteredSum(filter, predicate, agg);
@@ -182,7 +221,13 @@ private static Predicate[] everyComparison(Random random, Array filter) {
                 new Predicate.Gt(a),
                 new Predicate.Lte(a),
                 new Predicate.Gte(a),
-                new Predicate.Between(lo, hi)
+                new Predicate.Between(lo, hi),
+                // Composite and null-test predicates have no fast lane, so these drive the whole
+                // sweep through the generic boxing path (PredicateEvaluator + Values + Compare).
+                new Predicate.And(new Predicate.Gte(lo), new Predicate.Lte(hi)),
+                new Predicate.Or(new Predicate.Lt(lo), new Predicate.Gt(hi)),
+                new Predicate.IsNull(),
+                new Predicate.IsNotNull()
         };
     }
 
@@ -204,9 +249,12 @@ private static Array randomColumn(Random random, boolean nullable) {
 
     private static Array randomColumn(Random random, boolean nullable, int n) {
         boolean[] valid = nullable ? randomValidity(random, n) : null;
-        return switch (random.nextInt(3)) {
+        return switch (random.nextInt(6)) {
             case 0 -> longColumn(randomLongs(random, n), valid);
             case 1 -> intColumn(randomLongs(random, n), valid);
+            case 2 -> shortColumn(randomLongs(random, n), valid, random.nextBoolean());
+            case 3 -> byteColumn(randomLongs(random, n), valid, random.nextBoolean());
+            case 4 -> floatColumn(randomDoubles(random, n), valid);
             default -> doubleColumn(randomDoubles(random, n), valid);
         };
     }
@@ -251,6 +299,30 @@ private static Array intColumn(long[] values, boolean[] valid) {
         return wrap(new MaterializedIntArray(DType.I32, values.length, seg), valid);
     }
 
+    private static Array shortColumn(long[] values, boolean[] valid, boolean unsigned) {
+        MemorySegment seg = ARENA.allocate(Math.max(2L, values.length * 2L), 2);
+        for (int i = 0; i < values.length; i++) {
+            seg.setAtIndex(PTypeIO.LE_SHORT, i, (short) values[i]);
+        }
+        return wrap(new MaterializedShortArray(unsigned ? DType.U16 : DType.I16, values.length, seg), valid);
+    }
+
+    private static Array byteColumn(long[] values, boolean[] valid, boolean unsigned) {
+        MemorySegment seg = ARENA.allocate(Math.max(1L, values.length));
+        for (int i = 0; i < values.length; i++) {
+            seg.set(ValueLayout.JAVA_BYTE, i, (byte) values[i]);
+        }
+        return wrap(new MaterializedByteArray(unsigned ? DType.U8 : DType.I8, values.length, seg), valid);
+    }
+
+    private static Array floatColumn(double[] values, boolean[] valid) {
+        MemorySegment seg = ARENA.allocate(Math.max(4L, values.length * 4L), 4);
+        for (int i = 0; i < values.length; i++) {
+            seg.setAtIndex(PTypeIO.LE_FLOAT, i, (float) values[i]);
+        }
+        return wrap(new MaterializedFloatArray(DType.F32, values.length, seg), valid);
+    }
+
     private static Array doubleColumn(double[] values, boolean[] valid) {
         MemorySegment seg = ARENA.allocate(Math.max(8L, values.length * 8L), 8);
         for (int i = 0; i < values.length; i++) {
diff --git a/reader/src/test/java/io/github/dfa1/vortex/reader/compute/ValuesTest.java b/reader/src/test/java/io/github/dfa1/vortex/reader/compute/ValuesTest.java
@@ -0,0 +1,145 @@
+package io.github.dfa1.vortex.reader.compute;
+
+import io.github.dfa1.vortex.core.error.VortexException;
+import io.github.dfa1.vortex.core.io.PTypeIO;
+import io.github.dfa1.vortex.core.model.DType;
+import io.github.dfa1.vortex.reader.array.Array;
+import io.github.dfa1.vortex.reader.array.GenericArray;
+import io.github.dfa1.vortex.reader.array.MaskedArray;
+import io.github.dfa1.vortex.reader.array.MaterializedByteArray;
+import io.github.dfa1.vortex.reader.array.MaterializedIntArray;
+import io.github.dfa1.vortex.reader.array.MaterializedShortArray;
+import org.junit.jupiter.api.Test;
+
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.ValueLayout;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+
+/// Unit test for the boxing value accessor [Values] — the correctness baseline every generic
+/// compute path reads through. Pins the branches the kernel oracles reach only incidentally: the
+/// zero-extension of narrow unsigned columns (a `u8` `0xFF` must box as `255`, never `-1`), the
+/// non-numeric boxes (Utf8 → [String], bool → [Boolean]), the extension-dtype passthrough of the
+/// integer widening, and the fail-fast on an array type with no scalar accessor.
+class ValuesTest {
+
+    private static final Arena ARENA = Arena.ofAuto();
+
+    @Test
+    void unsignedNarrowColumnsZeroExtend() {
+        // Given the all-ones bit pattern in u8 / u16 / u32 columns — sign-extended by the raw
+        // accessors, so boxing must zero-extend or the value reads back negative
+        Array u8 = byteArray(DType.U8, (byte) 0xFF);
+        Array u16 = shortArray(DType.U16, (short) 0xFFFF);
+        Array u32 = intArray(DType.U32, 0xFFFFFFFF);
+
+        // When each value is boxed
+        Object result8 = Values.valueAt(u8, 0);
+        Object result16 = Values.valueAt(u16, 0);
+        Object result32 = Values.valueAt(u32, 0);
+
+        // Then the boxes carry the unsigned magnitude
+        assertThat(result8).isEqualTo(255L);
+        assertThat(result16).isEqualTo(65535L);
+        assertThat(result32).isEqualTo(4294967295L);
+    }
+
+    @Test
+    void signedNarrowColumnsSignExtend() {
+        // Given the same all-ones bit pattern in the signed narrow columns
+        Array i8 = byteArray(DType.I8, (byte) 0xFF);
+        Array i16 = shortArray(DType.I16, (short) 0xFFFF);
+
+        // When each value is boxed
+        Object result8 = Values.valueAt(i8, 0);
+        Object result16 = Values.valueAt(i16, 0);
+
+        // Then the boxes keep the signed value
+        assertThat(result8).isEqualTo(-1L);
+        assertThat(result16).isEqualTo(-1L);
+    }
+
+    @Test
+    void extensionDtypePassesIntegerThrough() {
+        // Given an integer column whose dtype is an Extension (not a Primitive) — the unsigned
+        // widening must pass the raw value through rather than assume a primitive ptype
+        DType extension = new DType.Extension("test.ext", DType.I32, null, false);
+        MemorySegment seg = ARENA.allocate(4, 4);
+        seg.setAtIndex(PTypeIO.LE_INT, 0, -7);
+        Array column = new MaterializedIntArray(extension, 1, seg);
+
+        // When the value is boxed
+        Object result = Values.valueAt(column, 0);
+
+        // Then it carries the raw signed value unchanged
+        assertThat(result).isEqualTo(-7L);
+    }
+
+    @Test
+    void utf8AndBoolBoxNaturally() {
+        // Given a Utf8 column and a bool column
+        Array utf8 = ComputeArrays.utf8Array(ARENA, "alpha", "beta");
+        Array bool = ComputeArrays.boolArray(ARENA, true, false);
+
+        // When the values are boxed
+        Object result = Values.valueAt(utf8, 1);
+        Object resultBool = Values.valueAt(bool, 1);
+
+        // Then Utf8 boxes as String and bool as Boolean
+        assertThat(result).isEqualTo("beta");
+        assertThat(resultBool).isEqualTo(false);
+    }
+
+    @Test
+    void arrayWithoutScalarAccessorFailsFast() {
+        // Given a GenericArray — the fallback array type with no scalar accessor for compute
+        Array generic = new GenericArray(DType.I64, 1, ARENA.allocate(8, 8));
+
+        // When a value read is attempted
+        // Then the accessor fails fast instead of returning garbage
+        assertThatExceptionOfType(VortexException.class)
+                .isThrownBy(() -> Values.valueAt(generic, 0))
+                .withMessageContaining("no scalar accessor");
+    }
+
+    @Test
+    void maskedArrayReadsThroughItsPayload() {
+        // Given a masked narrow column with one null position
+        Array masked = new MaskedArray(byteArray(DType.U8, (byte) 42, (byte) 7),
+                ComputeArrays.boolArray(ARENA, true, false));
+
+        // When the valid position is boxed and both positions are null-tested
+        Object result = Values.valueAt(masked, 0);
+
+        // Then the payload boxes through the mask and the validity drives the null test
+        assertThat(result).isEqualTo(42L);
+        assertThat(Values.isNullAt(masked, 0)).isFalse();
+        assertThat(Values.isNullAt(masked, 1)).isTrue();
+    }
+
+    private static Array byteArray(DType dtype, byte... values) {
+        MemorySegment seg = ARENA.allocate(Math.max(1L, values.length));
+        for (int i = 0; i < values.length; i++) {
+            seg.set(ValueLayout.JAVA_BYTE, i, values[i]);
+        }
+        return new MaterializedByteArray(dtype, values.length, seg);
+    }
+
+    private static Array shortArray(DType dtype, short... values) {
+        MemorySegment seg = ARENA.allocate(Math.max(2L, values.length * 2L), 2);
+        for (int i = 0; i < values.length; i++) {
+            seg.setAtIndex(PTypeIO.LE_SHORT, i, values[i]);
+        }
+        return new MaterializedShortArray(dtype, values.length, seg);
+    }
+
+    private static Array intArray(DType dtype, int... values) {
+        MemorySegment seg = ARENA.allocate(Math.max(4L, values.length * 4L), 4);
+        for (int i = 0; i < values.length; i++) {
+            seg.setAtIndex(PTypeIO.LE_INT, i, values[i]);
+        }
+        return new MaterializedIntArray(dtype, values.length, seg);
+    }
+}
