test(varbin): add VarBinArray unit tests

Covers Regular and Dict modes: getBytes, getByteLength,
forEachByteLength, empty array, and error cases.

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

Author: dfa1

core/src/test/java/io/github/dfa1/vortex/core/array/VarBinArrayTest.java

@@ -0,0 +1,210 @@
+package io.github.dfa1.vortex.core.array;
+
+import io.github.dfa1.vortex.core.ArrayStats;
+import io.github.dfa1.vortex.core.DType;
+import io.github.dfa1.vortex.core.PType;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.lang.foreign.MemorySegment;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class VarBinArrayTest {
+
+	private static final DType UTF8 = new DType.Utf8(false);
+
+	@Nested
+	class Regular {
+
+		@Test
+		void length_returnsElementCount() {
+			// Given
+			VarBinArray sut = of("a", "bb", "ccc");
+
+			// When / Then
+			assertThat(sut.length()).isEqualTo(3L);
+		}
+
+		@Test
+		void dtype_returnsConstructedDtype() {
+			// Given
+			VarBinArray sut = of("x");
+
+			// When / Then
+			assertThat(sut.dtype()).isEqualTo(UTF8);
+		}
+
+		@Test
+		void getBytes_returnsCorrectBytes() {
+			// Given
+			VarBinArray sut = of("hello", "world");
+
+			// When / Then
+			assertThat(new String(sut.getBytes(0), StandardCharsets.UTF_8)).isEqualTo("hello");
+			assertThat(new String(sut.getBytes(1), StandardCharsets.UTF_8)).isEqualTo("world");
+		}
+
+		@Test
+		void getByteLength_returnsCorrectLengths() {
+			// Given
+			VarBinArray sut = of("hi", "there", "!");
+
+			// When / Then
+			assertThat(sut.getByteLength(0)).isEqualTo(2);
+			assertThat(sut.getByteLength(1)).isEqualTo(5);
+			assertThat(sut.getByteLength(2)).isEqualTo(1);
+		}
+
+		@Test
+		void forEachByteLength_visitsAllLengths() {
+			// Given
+			VarBinArray sut = of("ab", "c", "def");
+			List<Integer> lengths = new ArrayList<>();
+
+			// When
+			sut.forEachByteLength(lengths::add);
+
+			// Then
+			assertThat(lengths).containsExactly(2, 1, 3);
+		}
+
+		@Test
+		void getBytes_emptyString_returnsEmptyArray() {
+			// Given
+			VarBinArray sut = of("", "x", "");
+
+			// When / Then
+			assertThat(sut.getBytes(0)).isEmpty();
+			assertThat(sut.getByteLength(0)).isZero();
+			assertThat(sut.getByteLength(2)).isZero();
+		}
+
+		@Test
+		void empty_zeroElements() {
+			// Given
+			VarBinArray sut = of();
+
+			// When / Then
+			assertThat(sut.length()).isZero();
+		}
+
+		@Test
+		void buffer_invalidIndex_throws() {
+			// Given
+			VarBinArray sut = of("a");
+
+			// When / Then
+			assertThatThrownBy(() -> sut.buffer(1))
+					.isInstanceOf(IndexOutOfBoundsException.class);
+		}
+
+		@Test
+		void child_invalidIndex_throws() {
+			// Given
+			VarBinArray sut = of("a");
+
+			// When / Then
+			assertThatThrownBy(() -> sut.child(1))
+					.isInstanceOf(IndexOutOfBoundsException.class);
+		}
+	}
+
+	@Nested
+	class Dict {
+
+		@Test
+		void getBytes_resolvesViaDict() {
+			// Given — dict=["foo","bar"], codes=[1,0,1]
+			VarBinArray sut = ofDict(new String[]{"foo", "bar"}, new int[]{1, 0, 1});
+
+			// When / Then
+			assertThat(new String(sut.getBytes(0), StandardCharsets.UTF_8)).isEqualTo("bar");
+			assertThat(new String(sut.getBytes(1), StandardCharsets.UTF_8)).isEqualTo("foo");
+			assertThat(new String(sut.getBytes(2), StandardCharsets.UTF_8)).isEqualTo("bar");
+		}
+
+		@Test
+		void getByteLength_resolvesViaDict() {
+			// Given — dict=["hi","there"], codes=[0,1,0]
+			VarBinArray sut = ofDict(new String[]{"hi", "there"}, new int[]{0, 1, 0});
+
+			// When / Then
+			assertThat(sut.getByteLength(0)).isEqualTo(2);
+			assertThat(sut.getByteLength(1)).isEqualTo(5);
+			assertThat(sut.getByteLength(2)).isEqualTo(2);
+		}
+
+		@Test
+		void forEachByteLength_resolvesViaDict() {
+			// Given
+			VarBinArray sut = ofDict(new String[]{"a", "bbb"}, new int[]{1, 0, 1});
+			List<Integer> lengths = new ArrayList<>();
+
+			// When
+			sut.forEachByteLength(lengths::add);
+
+			// Then
+			assertThat(lengths).containsExactly(3, 1, 3);
+		}
+
+		@Test
+		void child_inDictMode_throws() {
+			// Given
+			VarBinArray sut = ofDict(new String[]{"x"}, new int[]{0});
+
+			// When / Then
+			assertThatThrownBy(() -> sut.child(0))
+					.isInstanceOf(IllegalStateException.class);
+		}
+
+		private static VarBinArray ofDict(String[] dictValues, int[] codes) {
+			byte[] allBytes = String.join("", dictValues).getBytes(StandardCharsets.UTF_8);
+			MemorySegment dictValBytes = MemorySegment.ofArray(allBytes);
+
+			int[] offs = new int[dictValues.length + 1];
+			for (int i = 0; i < dictValues.length; i++) {
+				offs[i + 1] = offs[i] + dictValues[i].getBytes(StandardCharsets.UTF_8).length;
+			}
+			MemorySegment dictValOffsets = leInts(offs);
+
+			MemorySegment dictCodes = leInts(codes);
+
+			return VarBinArray.ofDict(UTF8, codes.length,
+					dictValBytes, dictValOffsets, PType.I32,
+					dictCodes, PType.I32, ArrayStats.empty());
+		}
+
+		private static MemorySegment leInts(int[] values) {
+			ByteBuffer bb = ByteBuffer.allocate(values.length * 4).order(ByteOrder.LITTLE_ENDIAN);
+			for (int v : values) {
+				bb.putInt(v);
+			}
+			return MemorySegment.ofArray(bb.array());
+		}
+	}
+
+	private static VarBinArray of(String... values) {
+		byte[] allBytes = String.join("", values).getBytes(StandardCharsets.UTF_8);
+		MemorySegment bytes = MemorySegment.ofArray(allBytes);
+
+		int[] offs = new int[values.length + 1];
+		for (int i = 0; i < values.length; i++) {
+			offs[i + 1] = offs[i] + values[i].getBytes(StandardCharsets.UTF_8).length;
+		}
+		ByteBuffer bb = ByteBuffer.allocate(offs.length * 4).order(ByteOrder.LITTLE_ENDIAN);
+		for (int o : offs) {
+			bb.putInt(o);
+		}
+		MemorySegment offsetsSeg = MemorySegment.ofArray(bb.array());
+		DType i32 = new DType.Primitive(PType.I32, false);
+		IntArray offsetsArr = new IntArray(i32, offs.length, offsetsSeg, ArrayStats.empty());
+		return new VarBinArray(UTF8, values.length, bytes, offsetsArr, PType.I32, ArrayStats.empty());
+	}
+}