test: cover defensive exhaustive-switch arms (new-code coverage)

Post-0.12.0 the quality gate flagged branches my S1481 unnamed-
pattern cleanup surfaced into the new-code window — exhaustive-
switch arms for variants their caller never produces. Cover the
genuinely reachable ones with real tests: CodeGen rejects a
vector-of-unions schema (inline .fbs, real error path); FilterCommand's
columnPredicate compiles the null-test leaves and rejects the
composite/range leaves (package-private, documented, so the arms
the CLI grammar can't reach are exercised directly).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: dfa1

cli/src/main/java/io/github/dfa1/vortex/cli/FilterCommand.java

@@ -169,7 +169,10 @@ private static RowPredicate toRowPredicate(RowFilter filter) {
     /// Compiles a column-bound [Predicate] into a per-row test over the decoded chunk. Only the
     /// comparison and null-test leaves the filter grammar ([#parseFilter]) produces are supported;
     /// the composite and range predicate variants never arise from a parsed CLI expression.
-    private static RowPredicate columnPredicate(String col, Predicate predicate) {
+    ///
+    /// Package-private so the exhaustive switch's null-test and unsupported-composite arms — which
+    /// the CLI grammar never reaches — can be exercised directly.
+    static RowPredicate columnPredicate(String col, Predicate predicate) {
         return switch (predicate) {
             case Predicate.Gt(var val) -> (chunk, rowIdx) -> compareValue(chunk.column(col), rowIdx, val) > 0;
             case Predicate.Gte(var val) -> (chunk, rowIdx) -> compareValue(chunk.column(col), rowIdx, val) >= 0;

cli/src/test/java/io/github/dfa1/vortex/cli/FilterCommandTest.java

@@ -1,19 +1,24 @@
 package io.github.dfa1.vortex.cli;
 
+import io.github.dfa1.vortex.reader.compute.Predicate;
+import io.github.dfa1.vortex.csv.RowPredicate;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.junit.jupiter.params.provider.ValueSource;
 
 import java.io.IOException;
 import java.nio.file.Path;
+import java.util.stream.Stream;
 
 import static io.github.dfa1.vortex.cli.CliTestSupport.capture;
 import static io.github.dfa1.vortex.cli.CliTestSupport.writeSmallVortex;
 import static io.github.dfa1.vortex.cli.CliTestSupport.writeTypedVortex;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 class FilterCommandTest {
 
@@ -190,4 +195,35 @@ void operatorPrefixAttack_doesNotCauseBacktracking() {
         assertThat(elapsedMs).isLessThan(1000);
         assertThat(result.status()).isNotEqualTo(ExitStatus.USAGE_ERROR);
     }
+
+    @Test
+    void columnPredicate_nullTestLeaves_compileToARowPredicate() {
+        // Given the null-test predicate variants — the CLI grammar never produces them, but
+        // columnPredicate must handle them for switch exhaustiveness over Predicate
+        // When
+        RowPredicate isNull = FilterCommand.columnPredicate("c", new Predicate.IsNull());
+        RowPredicate isNotNull = FilterCommand.columnPredicate("c", new Predicate.IsNotNull());
+
+        // Then — each compiles to a usable per-row test
+        assertThat(isNull).isNotNull();
+        assertThat(isNotNull).isNotNull();
+    }
+
+    @ParameterizedTest
+    @MethodSource("unsupportedCompositePredicates")
+    void columnPredicate_compositeAndRangeLeaves_throw(Predicate predicate) {
+        // Given a composite or range predicate the CLI cannot express
+        // When / Then — columnPredicate rejects it rather than silently mishandling
+        assertThatThrownBy(() -> FilterCommand.columnPredicate("c", predicate))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageContaining("not supported on the command line");
+    }
+
+    private static Stream<Predicate> unsupportedCompositePredicates() {
+        Predicate leaf = new Predicate.Gt(1L);
+        return Stream.of(
+                new Predicate.Between(1L, 2L),
+                new Predicate.And(leaf, leaf),
+                new Predicate.Or(leaf, leaf));
+    }
 }

fbs-gen/src/test/java/io/github/dfa1/vortex/fbsgen/CodeGenTest.java

@@ -1,6 +1,7 @@
 package io.github.dfa1.vortex.fbsgen;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 import java.io.IOException;
 import java.nio.file.Files;
@@ -11,6 +12,26 @@
 
 class CodeGenTest {
 
+    @Test
+    void vectorOfUnions_throwsFbsParseException(@TempDir Path out) {
+        // Given a schema whose table field is a vector of a union type — the one array-element
+        // shape the FlatBuffers layout cannot express, so the generator must reject it.
+        String schema = """
+                namespace x;
+                table A { a: int; }
+                table B { b: int; }
+                union U { A, B }
+                table T { items: [U]; }
+                """;
+        Ast.SchemaFile file = new Parser(new Lexer(schema).tokenize()).parseFile();
+        CodeGen sut = new CodeGen(new TypeRegistry(List.of(file)));
+
+        // When / Then
+        assertThatThrownBy(() -> sut.emit(out))
+                .isInstanceOf(FbsParseException.class)
+                .hasMessageContaining("vectors of unions are not supported");
+    }
+
     @Test
     void emitsOneFilePerDeclarationForAllVortexSchemas(@TempDir Path out) throws IOException {
         // Given + When