test(reader,writer): make the zstd binding guard testable

The optional-binding guards added in 0.12.0 had branches no in-
process test could reach — the binding is always on the test
classpath. Factor the probe into bindingPresent(className) and the
throw into requireBinding(present), both package-private, so both
branches are covered by a plain unit test passing an absent class
name / present=false. Behavior unchanged; greens 6 of the new-code
coverage gaps the post-0.12.0 quality gate flagged.

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

Author: dfa1

reader/src/main/java/io/github/dfa1/vortex/reader/decode/ZstdEncodingDecoder.java

@@ -32,30 +32,44 @@ public final class ZstdEncodingDecoder implements EncodingDecoder {
     // The io.github.dfa1.zstd binding is an OPTIONAL dependency: probe once so a reader
     // touching vortex.zstd without it gets an actionable message instead of a raw
     // NoClassDefFoundError surfacing from the first binding call.
-    private static final boolean ZSTD_BINDING_PRESENT = zstdBindingPresent();
+    private static final boolean ZSTD_BINDING_PRESENT =
+            bindingPresent("io.github.dfa1.zstd.ZstdDecompressContext");
 
-    private static boolean zstdBindingPresent() {
+    /// Reports whether the named binding class is loadable — package-private and
+    /// class-name-parameterized so both branches are unit-testable without the binding
+    /// having to actually be absent from the classpath.
+    ///
+    /// @param className fully qualified class name to probe
+    /// @return `true` if the class resolves, `false` if it is absent
+    static boolean bindingPresent(String className) {
         try {
-            Class.forName("io.github.dfa1.zstd.ZstdDecompressContext", false,
-                    ZstdEncodingDecoder.class.getClassLoader());
+            Class.forName(className, false, ZstdEncodingDecoder.class.getClassLoader());
             return true;
         } catch (ClassNotFoundException e) {
             return false;
         }
     }
 
+    /// Fails with an actionable [VortexException] when the optional zstd binding is absent.
+    ///
+    /// @param present whether the binding is on the classpath
+    /// @throws VortexException naming the two artifacts to add, if `present` is `false`
+    static void requireBinding(boolean present) {
+        if (!present) {
+            throw new VortexException(EncodingId.VORTEX_ZSTD, "this file uses vortex.zstd, but the "
+                    + "optional zstd binding is not on the classpath — add io.github.dfa1.zstd:zstd "
+                    + "and io.github.dfa1.zstd:zstd-platform (versions pinned by the vortex BOM)");
+        }
+    }
+
     @Override
     public EncodingId encodingId() {
         return EncodingId.VORTEX_ZSTD;
     }
 
     @Override
     public Array decode(DecodeContext ctx) {
-        if (!ZSTD_BINDING_PRESENT) {
-            throw new VortexException(EncodingId.VORTEX_ZSTD, "this file uses vortex.zstd, but the "
-                    + "optional zstd binding is not on the classpath — add io.github.dfa1.zstd:zstd "
-                    + "and io.github.dfa1.zstd:zstd-platform (versions pinned by the vortex BOM)");
-        }
+        requireBinding(ZSTD_BINDING_PRESENT);
         MemorySegment rawMeta = ctx.metadata();
         if (rawMeta == null) {
             throw new VortexException(EncodingId.VORTEX_ZSTD, "missing metadata");

reader/src/test/java/io/github/dfa1/vortex/reader/decode/ZstdBindingGuardTest.java

@@ -0,0 +1,51 @@
+package io.github.dfa1.vortex.reader.decode;
+
+import io.github.dfa1.vortex.core.error.VortexException;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatCode;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+/// Covers the optional-zstd-binding guard on the decode side. The binding is always on the test
+/// classpath, so the "absent" branches are unreachable through a real decode; the guard logic is
+/// factored into class-name- and boolean-parameterized helpers precisely so both branches are
+/// exercised here without the jar having to be missing.
+class ZstdBindingGuardTest {
+
+    @Test
+    void bindingPresent_resolvableClass_returnsTrue() {
+        // Given the real binding class name
+        // When
+        boolean result = ZstdEncodingDecoder.bindingPresent("io.github.dfa1.zstd.ZstdDecompressContext");
+
+        // Then
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    void bindingPresent_absentClass_returnsFalse() {
+        // Given a class name no classpath provides — exercises the ClassNotFoundException branch
+        // without the binding actually being absent
+        // When
+        boolean result = ZstdEncodingDecoder.bindingPresent("io.github.dfa1.zstd.NoSuchBindingClass");
+
+        // Then
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    void requireBinding_absent_throwsActionableVortexException() {
+        // Given / When / Then — the message names the two artifacts a consumer must add
+        assertThatThrownBy(() -> ZstdEncodingDecoder.requireBinding(false))
+                .isInstanceOf(VortexException.class)
+                .hasMessageContaining("io.github.dfa1.zstd:zstd")
+                .hasMessageContaining("zstd-platform");
+    }
+
+    @Test
+    void requireBinding_present_doesNotThrow() {
+        // Given / When / Then
+        assertThatCode(() -> ZstdEncodingDecoder.requireBinding(true)).doesNotThrowAnyException();
+    }
+}

writer/src/main/java/io/github/dfa1/vortex/writer/encode/ZstdEncodingEncoder.java

@@ -29,18 +29,36 @@ public final class ZstdEncodingEncoder implements EncodingEncoder {
     // The io.github.dfa1.zstd binding is an OPTIONAL dependency: probe once so a writer
     // touching vortex.zstd without it gets an actionable message instead of a raw
     // NoClassDefFoundError surfacing from the first binding call.
-    private static final boolean ZSTD_BINDING_PRESENT = zstdBindingPresent();
+    private static final boolean ZSTD_BINDING_PRESENT =
+            bindingPresent("io.github.dfa1.zstd.ZstdCompressContext");
 
-    private static boolean zstdBindingPresent() {
+    /// Reports whether the named binding class is loadable — package-private and
+    /// class-name-parameterized so both branches are unit-testable without the binding
+    /// having to actually be absent from the classpath.
+    ///
+    /// @param className fully qualified class name to probe
+    /// @return `true` if the class resolves, `false` if it is absent
+    static boolean bindingPresent(String className) {
         try {
-            Class.forName("io.github.dfa1.zstd.ZstdCompressContext", false,
-                    ZstdEncodingEncoder.class.getClassLoader());
+            Class.forName(className, false, ZstdEncodingEncoder.class.getClassLoader());
             return true;
         } catch (ClassNotFoundException e) {
             return false;
         }
     }
 
+    /// Fails with an actionable [VortexException] when the optional zstd binding is absent.
+    ///
+    /// @param present whether the binding is on the classpath
+    /// @throws VortexException naming the two artifacts to add, if `present` is `false`
+    static void requireBinding(boolean present) {
+        if (!present) {
+            throw new VortexException(EncodingId.VORTEX_ZSTD, "vortex.zstd encoding requires the "
+                    + "optional zstd binding — add io.github.dfa1.zstd:zstd and "
+                    + "io.github.dfa1.zstd:zstd-platform (versions pinned by the vortex BOM)");
+        }
+    }
+
     /// Values per zstd frame; `0` (or any non-positive value) means a single frame for the whole array.
     private final long valuesPerFrame;
 
@@ -77,11 +95,7 @@ public boolean acceptsNullable(DType dtype) {
 
     @Override
     public EncodeResult encode(DType dtype, Object data, EncodeContext ctx) {
-        if (!ZSTD_BINDING_PRESENT) {
-            throw new VortexException(EncodingId.VORTEX_ZSTD, "vortex.zstd encoding requires the "
-                    + "optional zstd binding — add io.github.dfa1.zstd:zstd and "
-                    + "io.github.dfa1.zstd:zstd-platform (versions pinned by the vortex BOM)");
-        }
+        requireBinding(ZSTD_BINDING_PRESENT);
         if (data instanceof NullableData nd) {
             if (dtype instanceof DType.Primitive dt) {
                 return encodeNullablePrimitive(dt, nd, ctx);

writer/src/test/java/io/github/dfa1/vortex/writer/encode/ZstdBindingGuardTest.java

@@ -0,0 +1,50 @@
+package io.github.dfa1.vortex.writer.encode;
+
+import io.github.dfa1.vortex.core.error.VortexException;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatCode;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+/// Covers the optional-zstd-binding guard on the encode side. The binding is always on the test
+/// classpath, so the "absent" branches are unreachable through a real encode; the guard logic is
+/// factored into class-name- and boolean-parameterized helpers precisely so both branches are
+/// exercised here without the jar having to be missing.
+class ZstdBindingGuardTest {
+
+    @Test
+    void bindingPresent_resolvableClass_returnsTrue() {
+        // Given the real binding class name
+        // When
+        boolean result = ZstdEncodingEncoder.bindingPresent("io.github.dfa1.zstd.ZstdCompressContext");
+
+        // Then
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    void bindingPresent_absentClass_returnsFalse() {
+        // Given a class name no classpath provides — exercises the ClassNotFoundException branch
+        // When
+        boolean result = ZstdEncodingEncoder.bindingPresent("io.github.dfa1.zstd.NoSuchBindingClass");
+
+        // Then
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    void requireBinding_absent_throwsActionableVortexException() {
+        // Given / When / Then — the message names the two artifacts a consumer must add
+        assertThatThrownBy(() -> ZstdEncodingEncoder.requireBinding(false))
+                .isInstanceOf(VortexException.class)
+                .hasMessageContaining("io.github.dfa1.zstd:zstd")
+                .hasMessageContaining("zstd-platform");
+    }
+
+    @Test
+    void requireBinding_present_doesNotThrow() {
+        // Given / When / Then
+        assertThatCode(() -> ZstdEncodingEncoder.requireBinding(true)).doesNotThrowAnyException();
+    }
+}