test(integration): replace jqwik with seeded @ParameterizedTest + RandomArrays

jqwik team opposes AI-assisted development. Drop the dependency entirely.

- Add RandomArrays utility with seeded Random generators for long[], double[],
  float[], String[] (ascii, varBinView, u16Dict, unicode)
- Convert 7 @Property tests to @ParameterizedTest + @MethodSource
- Remove jqwik from integration/pom.xml and root pom.xml (property + managed dep)
- Remove .jqwik-database from .gitignore
- Update CLAUDE.md and README.md to reflect the new approach

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: dfa1

.gitignore

@@ -5,4 +5,3 @@ target/
 *.iml
 .DS_Store
 dependency-reduced-pom.xml
-.jqwik-database

CLAUDE.md

@@ -163,7 +163,7 @@ The decoder reads back via `ctx.metadata()`, not `ctx.buffer(n)`.
   `given` and `then` — not `willReturn`/`willThrow`.
 - Prefer `@ParameterizedTest` over copy-pasting tests. Use `@ValueSource` when possible; `@ArgumentsSource` when more
   structure needed (test case must have a name).
-- Use property-based tests (`@Property`) for encoding/decoding logic where input space is large — they find corner cases that example tests miss.
+- Use `@ParameterizedTest` with seeded random generators for encoding/decoding logic where input space is large — they find corner cases that example tests miss.
 - Acceptance tests run the built jar end-to-end with hosh scripts.
 - Use `@Nested` to group related tests by scenario or feature within a test class:
   ```java
@@ -175,10 +175,17 @@ The decoder reads back via `ctx.metadata()`, not `ctx.buffer(n)`.
   `@BeforeEach` inside a `@Nested` class applies only to that group. Private helpers go
   at the end of the class they serve, after all `@Test` methods.
 
-## Property-Based Testing (jqwik)
+## Random-data parameterized tests
 
-jqwik 1.9.3 works with JUnit Jupiter 5.11.x (JUnit Platform 1.x). Use `@Property` + `@ForAll` for parameters,
-`@Provide` for custom arbitraries, `Assume.that(...)` for preconditions.
+Use `@ParameterizedTest` + `@MethodSource` for random-input coverage. Put generators in `RandomArrays` (integration module)
+or a similar utility class. Static provider methods in the test class delegate to the generator:
 
-Keep `tries` low (10–20) for integration tests that involve file I/O or JNI; unit-level properties can use the
-default (100).
+```java
+static Stream<long[]> i64ArrayProvider() { return RandomArrays.i64Arrays(30); }
+
+@ParameterizedTest
+@MethodSource("i64ArrayProvider")
+void roundTrips(long[] data) { ... }
+```
+
+Keep counts low (10–30) for integration tests that involve file I/O or JNI.

README.md

@@ -237,7 +237,7 @@ another implementation cannot decode.
 
 The `integration` module addresses this by using the Rust JNI reader as a **test oracle**:
 Java writes a file, the Rust reader decodes it, and the values are compared exactly.
-[Property-based testing](https://jqwik.net/) (jqwik) generates large, diverse inputs automatically,
+Seeded random parameterized tests generate large, diverse inputs automatically,
 covering edge cases no hand-written test would anticipate.
 
 This combination caught two real bugs in ALP floating-point encoding:

integration/pom.xml

@@ -52,11 +52,6 @@
 			<artifactId>assertj-core</artifactId>
 			<scope>test</scope>
 		</dependency>
-		<dependency>
-			<groupId>net.jqwik</groupId>
-			<artifactId>jqwik</artifactId>
-			<scope>test</scope>
-		</dependency>
 		<dependency>
 			<groupId>org.slf4j</groupId>
 			<artifactId>slf4j-simple</artifactId>

integration/src/test/java/io/github/dfa1/vortex/integration/JavaWritesRustReadsIntegrationTest.java

@@ -28,11 +28,6 @@
 import io.github.dfa1.vortex.encoding.ZstdEncoding;
 import io.github.dfa1.vortex.writer.VortexWriter;
 import io.github.dfa1.vortex.writer.WriteOptions;
-import net.jqwik.api.Arbitraries;
-import net.jqwik.api.Arbitrary;
-import net.jqwik.api.ForAll;
-import net.jqwik.api.Property;
-import net.jqwik.api.Provide;
 import org.apache.arrow.memory.BufferAllocator;
 import org.apache.arrow.vector.BigIntVector;
 import org.apache.arrow.vector.BitVector;
@@ -46,6 +41,8 @@
 import org.junit.jupiter.api.Disabled;
 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.MethodSource;
 
 import java.io.IOException;
 import java.io.UncheckedIOException;
@@ -58,6 +55,7 @@
 import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Stream;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -452,9 +450,9 @@ void javaWriter_jniReader_varBinViewUtf8Column_mixed(@TempDir Path tmp) throws I
 	}
 
 	/// VarBinView utf8 with arbitrary strings — exercises both inlined and referenced views.
-	@Property(tries = 20)
-	void prop_varBinView_utf8_roundTripsViaRust(
-			@ForAll("varBinViewStringArrays") String[] data) throws IOException {
+	@ParameterizedTest
+	@MethodSource("varBinViewStringArrayProvider")
+	void prop_varBinView_utf8_roundTripsViaRust(String[] data) throws IOException {
 		Path tmp = Files.createTempDirectory("vortex-pbt-varbinview");
 		try {
 			Path file = tmp.resolve("pbt_varbinview_utf8.vtx");
@@ -551,13 +549,13 @@ void javaWriter_jniReader_cascading_ohlc_columnProjection(@TempDir Path tmp) thr
 		assertThat(volumes).containsExactlyInAnyOrder(expected);
 	}
 
-	// ── Property-based tests ──────────────────────────────────────────────────
+	// ── Parameterized random-data tests ─────────────────────────────────────
 
 	/// Dict utf8 with arbitrary strings (small dict → U8 codes).
 	/// Validates that random string data survives Java dict-encode → Rust JNI read.
-	@Property(tries = 20)
-	void prop_dictUtf8_ascii_roundTripsViaRust(
-			@ForAll("asciiStringArrays") String[] data) throws IOException {
+	@ParameterizedTest
+	@MethodSource("asciiStringArrayProvider")
+	void prop_dictUtf8_ascii_roundTripsViaRust(String[] data) throws IOException {
 		Path tmp = Files.createTempDirectory("vortex-pbt-ascii");
 		try {
 			Path file = tmp.resolve("pbt_dict_utf8_ascii.vtx");
@@ -573,9 +571,9 @@ void prop_dictUtf8_ascii_roundTripsViaRust(
 	}
 
 	/// Dict utf8 with 257+ unique strings → forces U16 codes (crosses U8→U16 boundary at 256).
-	@Property(tries = 10)
-	void prop_dictUtf8_u16Codes_roundTripsViaRust(
-			@ForAll("u16DictStringArrays") String[] data) throws IOException {
+	@ParameterizedTest
+	@MethodSource("u16DictStringArrayProvider")
+	void prop_dictUtf8_u16Codes_roundTripsViaRust(String[] data) throws IOException {
 		Path tmp = Files.createTempDirectory("vortex-pbt-u16");
 		try {
 			Path file = tmp.resolve("pbt_dict_utf8_u16.vtx");
@@ -590,10 +588,10 @@ void prop_dictUtf8_u16Codes_roundTripsViaRust(
 		}
 	}
 
-	/// Dict utf8 with unicode strings (multi-byte UTF-8, emoji, CJK).
-	@Property(tries = 20)
-	void prop_dictUtf8_unicode_roundTripsViaRust(
-			@ForAll("unicodeStringArrays") String[] data) throws IOException {
+	/// Dict utf8 with unicode strings (multi-byte UTF-8, CJK).
+	@ParameterizedTest
+	@MethodSource("unicodeStringArrayProvider")
+	void prop_dictUtf8_unicode_roundTripsViaRust(String[] data) throws IOException {
 		Path tmp = Files.createTempDirectory("vortex-pbt-unicode");
 		try {
 			Path file = tmp.resolve("pbt_dict_utf8_unicode.vtx");
@@ -609,8 +607,9 @@ void prop_dictUtf8_unicode_roundTripsViaRust(
 	}
 
 	/// I64 column: full Long range (MIN_VALUE, MAX_VALUE, negatives), empty and large arrays.
-	@Property(tries = 30)
-	void prop_i64_roundTripsViaRust(@ForAll("i64Arrays") long[] data) throws IOException {
+	@ParameterizedTest
+	@MethodSource("i64ArrayProvider")
+	void prop_i64_roundTripsViaRust(long[] data) throws IOException {
 		Path tmp = Files.createTempDirectory("vortex-pbt-i64");
 		try {
 			Path file = tmp.resolve("pbt_i64.vtx");
@@ -625,52 +624,11 @@ void prop_i64_roundTripsViaRust(@ForAll("i64Arrays") long[] data) throws IOExcep
 		}
 	}
 
-	@Provide
-	Arbitrary<String[]> varBinViewStringArrays() {
-		// Strings 0–30 chars: spans both inlined (≤12 bytes) and referenced (>12 bytes) paths
-		Arbitrary<String> strings = Arbitraries.strings()
-				.alpha()
-				.ofMinLength(0).ofMaxLength(30);
-		return strings.array(String[].class).ofMinSize(0).ofMaxSize(1_000);
-	}
-
-	@Provide
-	Arbitrary<String[]> asciiStringArrays() {
-		Arbitrary<String> strings = Arbitraries.strings()
-				.alpha()
-				.ofMinLength(0).ofMaxLength(100);
-		return strings.array(String[].class).ofMinSize(0).ofMaxSize(5_000);
-	}
-
-	@Provide
-	Arbitrary<String[]> u16DictStringArrays() {
-		// 257–5000 unique strings → U16 codes territory
-		Arbitrary<String> strings = Arbitraries.strings()
-				.alpha()
-				.ofMinLength(3).ofMaxLength(20);
-		return strings.list().ofMinSize(257).ofMaxSize(5_000)
-				.map(list -> list.stream().distinct().toArray(String[]::new))
-				.filter(arr -> arr.length >= 257);
-	}
-
-	@Provide
-	Arbitrary<String[]> unicodeStringArrays() {
-		Arbitrary<String> strings = Arbitraries.strings()
-				.withCharRange('\u4E00', '\uD7FF')
-				.ofMinLength(0).ofMaxLength(50);
-		return strings.array(String[].class).ofMinSize(0).ofMaxSize(1_000);
-	}
-
-	@Provide
-	Arbitrary<long[]> i64Arrays() {
-		return Arbitraries.longs()
-				.array(long[].class)
-				.ofMinSize(0).ofMaxSize(10_000);
-	}
 
 	/// F64 column: finite doubles (ALP encoding), empty and large arrays.
-	@Property(tries = 30)
-	void prop_f64_roundTripsViaRust(@ForAll("f64Arrays") double[] data) throws IOException {
+	@ParameterizedTest
+	@MethodSource("f64ArrayProvider")
+	void prop_f64_roundTripsViaRust(double[] data) throws IOException {
 		Path tmp = Files.createTempDirectory("vortex-pbt-f64");
 		try {
 			Path file = tmp.resolve("pbt_f64.vtx");
@@ -686,8 +644,9 @@ void prop_f64_roundTripsViaRust(@ForAll("f64Arrays") double[] data) throws IOExc
 	}
 
 	/// F32 column: finite floats, empty and large arrays.
-	@Property(tries = 30)
-	void prop_f32_roundTripsViaRust(@ForAll("f32Arrays") float[] data) throws IOException {
+	@ParameterizedTest
+	@MethodSource("f32ArrayProvider")
+	void prop_f32_roundTripsViaRust(float[] data) throws IOException {
 		Path tmp = Files.createTempDirectory("vortex-pbt-f32");
 		try {
 			Path file = tmp.resolve("pbt_f32.vtx");
@@ -702,20 +661,32 @@ void prop_f32_roundTripsViaRust(@ForAll("f32Arrays") float[] data) throws IOExce
 		}
 	}
 
-	@Provide
-	Arbitrary<double[]> f64Arrays() {
-		return Arbitraries.doubles()
-				.filter(Double::isFinite)
-				.array(double[].class)
-				.ofMinSize(0).ofMaxSize(5_000);
+	static Stream<String[]> varBinViewStringArrayProvider() {
+		return RandomArrays.varBinViewStringArrays(20);
+	}
+
+	static Stream<String[]> asciiStringArrayProvider() {
+		return RandomArrays.asciiStringArrays(20);
+	}
+
+	static Stream<String[]> u16DictStringArrayProvider() {
+		return RandomArrays.u16DictStringArrays(10);
+	}
+
+	static Stream<String[]> unicodeStringArrayProvider() {
+		return RandomArrays.unicodeStringArrays(20);
+	}
+
+	static Stream<long[]> i64ArrayProvider() {
+		return RandomArrays.i64Arrays(30);
+	}
+
+	static Stream<double[]> f64ArrayProvider() {
+		return RandomArrays.f64Arrays(30);
 	}
 
-	@Provide
-	Arbitrary<float[]> f32Arrays() {
-		return Arbitraries.floats()
-				.filter(Float::isFinite)
-				.array(float[].class)
-				.ofMinSize(0).ofMaxSize(5_000);
+	static Stream<float[]> f32ArrayProvider() {
+		return RandomArrays.f32Arrays(30);
 	}
 
 	/// F64: NaN and Inf go to ALP patches (raw bits). containsExactly fails for NaN — use bitwise comparison.

integration/src/test/java/io/github/dfa1/vortex/integration/RandomArrays.java

@@ -0,0 +1,125 @@
+package io.github.dfa1.vortex.integration;
+
+import java.util.LinkedHashSet;
+import java.util.Random;
+import java.util.Set;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+final class RandomArrays {
+
+    private static final long SEED = 0xCAFEBABEL;
+
+    static Stream<long[]> i64Arrays(int count) {
+        Random rng = new Random(SEED);
+        return IntStream.range(0, count).mapToObj(i -> {
+            int size = rng.nextInt(10_001);
+            long[] arr = new long[size];
+            for (int j = 0; j < size; j++) {
+                arr[j] = rng.nextLong();
+            }
+            return arr;
+        });
+    }
+
+    static Stream<double[]> f64Arrays(int count) {
+        Random rng = new Random(SEED);
+        return IntStream.range(0, count).mapToObj(i -> {
+            int size = rng.nextInt(5_001);
+            double[] arr = new double[size];
+            for (int j = 0; j < size; j++) {
+                double d;
+                do {
+                    d = Double.longBitsToDouble(rng.nextLong());
+                } while (!Double.isFinite(d));
+                arr[j] = d;
+            }
+            return arr;
+        });
+    }
+
+    static Stream<float[]> f32Arrays(int count) {
+        Random rng = new Random(SEED);
+        return IntStream.range(0, count).mapToObj(i -> {
+            int size = rng.nextInt(5_001);
+            float[] arr = new float[size];
+            for (int j = 0; j < size; j++) {
+                float f;
+                do {
+                    f = Float.intBitsToFloat(rng.nextInt());
+                } while (!Float.isFinite(f));
+                arr[j] = f;
+            }
+            return arr;
+        });
+    }
+
+    static Stream<String[]> asciiStringArrays(int count) {
+        Random rng = new Random(SEED);
+        return IntStream.range(0, count).mapToObj(i -> {
+            int size = rng.nextInt(5_001);
+            String[] arr = new String[size];
+            for (int j = 0; j < size; j++) {
+                arr[j] = randomAlphaString(rng, 0, 100);
+            }
+            return arr;
+        });
+    }
+
+    static Stream<String[]> varBinViewStringArrays(int count) {
+        Random rng = new Random(SEED);
+        return IntStream.range(0, count).mapToObj(i -> {
+            int size = rng.nextInt(1_001);
+            String[] arr = new String[size];
+            for (int j = 0; j < size; j++) {
+                arr[j] = randomAlphaString(rng, 0, 30);
+            }
+            return arr;
+        });
+    }
+
+    static Stream<String[]> u16DictStringArrays(int count) {
+        Random rng = new Random(SEED);
+        return IntStream.range(0, count).mapToObj(i -> {
+            int targetSize = 257 + rng.nextInt(5_000 - 257 + 1);
+            Set<String> unique = new LinkedHashSet<>();
+            while (unique.size() < targetSize) {
+                unique.add(randomAlphaString(rng, 3, 20));
+            }
+            return unique.toArray(String[]::new);
+        });
+    }
+
+    static Stream<String[]> unicodeStringArrays(int count) {
+        Random rng = new Random(SEED);
+        return IntStream.range(0, count).mapToObj(i -> {
+            int size = rng.nextInt(1_001);
+            StringBuilder sb = new StringBuilder();
+            String[] arr = new String[size];
+            for (int j = 0; j < size; j++) {
+                arr[j] = randomCjkString(rng, 0, 50, sb);
+            }
+            return arr;
+        });
+    }
+
+    private static String randomAlphaString(Random rng, int minLen, int maxLen) {
+        int len = minLen + (maxLen > minLen ? rng.nextInt(maxLen - minLen + 1) : 0);
+        char[] chars = new char[len];
+        for (int i = 0; i < len; i++) {
+            chars[i] = (char) ('a' + rng.nextInt(26));
+        }
+        return new String(chars);
+    }
+
+    private static String randomCjkString(Random rng, int minLen, int maxLen, StringBuilder sb) {
+        int len = minLen + (maxLen > minLen ? rng.nextInt(maxLen - minLen + 1) : 0);
+        sb.setLength(0);
+        for (int i = 0; i < len; i++) {
+            sb.appendCodePoint('一' + rng.nextInt('퟿' - '一' + 1));
+        }
+        return sb.toString();
+    }
+
+    private RandomArrays() {}
+}