test: add jqwik property-based integration tests for dict utf8 + i64

Add jqwik 1.9.3 and four @Property tests in JavaWritesRustReadsIntegrationTest
that validate Java-writer → Rust-JNI-reader round-trips across randomly generated
inputs:

- prop_dictUtf8_ascii_roundTripsViaRust    (20 tries, U8 codes range)
- prop_dictUtf8_u16Codes_roundTripsViaRust (10 tries, 257+ unique → U16 codes)
- prop_dictUtf8_unicode_roundTripsViaRust  (20 tries, multi-byte UTF-8)
- prop_i64_roundTripsViaRust               (20 tries, arbitrary long[])

Unit tests only cover Java→Java roundtrips; these properties catch wire-format
divergence between the Java writer and the Rust JNI reader that unit tests miss.

Fix stale CLAUDE.md note claiming jqwik doesn't work with JUnit Platform 1.x.

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

Author: dfa1

CLAUDE.md

@@ -147,9 +147,8 @@ methods in the Rust source to get the exact protobuf schema, then implement from
 
 ## Property-Based Testing (jqwik)
 
-**Known issue:** jqwik 1.9.3 targets JUnit Platform 1.x; project uses JUnit 6 (Platform 6.x). `@Property` tests compile
-and are structurally correct but the jqwik engine does not execute them at runtime.
-Track https://github.com/jqwik-team/jqwik/issues for jqwik 2.x.
+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.
 
-Write property tests: `@Property` + `@ForAll` for parameters, `@Provide` for custom arbitraries, `Assume.that(...)` for
-preconditions.
+Keep `tries` low (10–20) for integration tests that involve file I/O or JNI; unit-level properties can use the
+default (100).

integration/pom.xml

@@ -54,6 +54,10 @@
 			<groupId>org.assertj</groupId>
 			<artifactId>assertj-core</artifactId>
 		</dependency>
+		<dependency>
+			<groupId>net.jqwik</groupId>
+			<artifactId>jqwik</artifactId>
+		</dependency>
 	</dependencies>
 
 	<build>

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

@@ -20,15 +20,23 @@
 import org.apache.arrow.vector.VarCharVector;
 import org.apache.arrow.vector.VectorSchemaRoot;
 import org.apache.arrow.vector.ipc.ArrowReader;
+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 net.jqwik.api.constraints.Size;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
 
 import java.io.IOException;
 import java.nio.channels.FileChannel;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.StandardOpenOption;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
 
@@ -352,4 +360,113 @@ void javaWriter_jniReader_cascading_ohlc_columnProjection(@TempDir Path tmp) thr
 		long[] expected = batches.stream().flatMapToLong(b -> Arrays.stream(b.volume())).toArray();
 		assertThat(volumes).containsExactlyInAnyOrder(expected);
 	}
+
+	// ── Property-based 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 {
+		Path tmp = Files.createTempDirectory("vortex-pbt-ascii");
+		try {
+			Path file = tmp.resolve("pbt_dict_utf8_ascii.vtx");
+			try (var ch = FileChannel.open(file, StandardOpenOption.CREATE, StandardOpenOption.WRITE);
+			     var sut = VortexWriter.create(ch, STRING_SCHEMA, WriteOptions.defaults())) {
+				sut.writeChunk(Map.of("s", data));
+			}
+			String[] decoded = readStringColumn(file, "s");
+			assertThat(decoded).containsExactly(data);
+		} finally {
+			deleteDir(tmp);
+		}
+	}
+
+	/// 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 {
+		Path tmp = Files.createTempDirectory("vortex-pbt-u16");
+		try {
+			Path file = tmp.resolve("pbt_dict_utf8_u16.vtx");
+			try (var ch = FileChannel.open(file, StandardOpenOption.CREATE, StandardOpenOption.WRITE);
+			     var sut = VortexWriter.create(ch, STRING_SCHEMA, WriteOptions.defaults())) {
+				sut.writeChunk(Map.of("s", data));
+			}
+			String[] decoded = readStringColumn(file, "s");
+			assertThat(decoded).containsExactly(data);
+		} finally {
+			deleteDir(tmp);
+		}
+	}
+
+	/// 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 {
+		Path tmp = Files.createTempDirectory("vortex-pbt-unicode");
+		try {
+			Path file = tmp.resolve("pbt_dict_utf8_unicode.vtx");
+			try (var ch = FileChannel.open(file, StandardOpenOption.CREATE, StandardOpenOption.WRITE);
+			     var sut = VortexWriter.create(ch, STRING_SCHEMA, WriteOptions.defaults())) {
+				sut.writeChunk(Map.of("s", data));
+			}
+			String[] decoded = readStringColumn(file, "s");
+			assertThat(decoded).containsExactly(data);
+		} finally {
+			deleteDir(tmp);
+		}
+	}
+
+	/// I64 column: arbitrary longs survive Java write → Rust JNI read.
+	@Property(tries = 20)
+	void prop_i64_roundTripsViaRust(
+			@ForAll @Size(min = 1, max = 500) List<Long> values) throws IOException {
+		Path tmp = Files.createTempDirectory("vortex-pbt-i64");
+		try {
+			long[] data = values.stream().mapToLong(Long::longValue).toArray();
+			Path file = tmp.resolve("pbt_i64.vtx");
+			try (var ch = FileChannel.open(file, StandardOpenOption.CREATE, StandardOpenOption.WRITE);
+			     var sut = VortexWriter.create(ch, TS_SCHEMA, WriteOptions.defaults())) {
+				sut.writeChunk(Map.of("ts", data));
+			}
+			long[] decoded = readLongColumn(file, "ts");
+			assertThat(decoded).containsExactly(data);
+		} finally {
+			deleteDir(tmp);
+		}
+	}
+
+	@Provide
+	Arbitrary<String[]> asciiStringArrays() {
+		Arbitrary<String> strings = Arbitraries.strings()
+				.alpha()
+				.ofMinLength(0).ofMaxLength(20);
+		return strings.array(String[].class).ofMinSize(1).ofMaxSize(200);
+	}
+
+	@Provide
+	Arbitrary<String[]> u16DictStringArrays() {
+		// 257 unique strings guaranteed by @UniqueElements on a list, then a suffix of repeats
+		Arbitrary<String> strings = Arbitraries.strings()
+				.alpha()
+				.ofMinLength(3).ofMaxLength(12);
+		return strings.list().ofMinSize(257).ofMaxSize(300)
+				.map(list -> list.stream().distinct().limit(300).toArray(String[]::new))
+				.filter(arr -> arr.length >= 257);
+	}
+
+	@Provide
+	Arbitrary<String[]> unicodeStringArrays() {
+		Arbitrary<String> strings = Arbitraries.strings()
+				.withCharRange('€', '퟿')
+				.ofMinLength(1).ofMaxLength(10);
+		return strings.array(String[].class).ofMinSize(1).ofMaxSize(100);
+	}
+
+	private static void deleteDir(Path dir) throws IOException {
+		try (var walk = Files.walk(dir)) {
+			walk.sorted(Comparator.reverseOrder()).forEach(p -> p.toFile().delete());
+		}
+	}
 }

pom.xml

@@ -25,6 +25,7 @@
 		<junit.version>5.11.4</junit.version>
 		<assertj.version>3.26.3</assertj.version>
 		<mockito.version>5.14.2</mockito.version>
+		<jqwik.version>1.9.3</jqwik.version>
 	</properties>
 
 	<dependencyManagement>
@@ -72,6 +73,12 @@
 				<version>${mockito.version}</version>
 				<scope>test</scope>
 			</dependency>
+			<dependency>
+				<groupId>net.jqwik</groupId>
+				<artifactId>jqwik</artifactId>
+				<version>${jqwik.version}</version>
+				<scope>test</scope>
+			</dependency>
 		</dependencies>
 	</dependencyManagement>