fix: DH-21298: Factor out test utility classes

src/test/java/io/deephaven/csv/testutil/Blackhole.java

@@ -0,0 +1,30 @@
+package io.deephaven.csv.testutil;
+
+import io.deephaven.csv.sinks.Sink;
+import io.deephaven.csv.sinks.Source;
+
+public class Blackhole<TARRAY> implements Sink<TARRAY>, Source<TARRAY> {
+    private final int colNum;
+
+    public Blackhole(int colNum) {
+        this.colNum = colNum;
+    }
+
+    @Override
+    public void write(TARRAY src, boolean[] isNull, long destBegin, long destEnd, boolean appending) {
+        // Do nothing.
+    }
+
+    /**
+     * For the sake of one of our unit tests, we return the colNum as our underlying.
+     */
+    @Override
+    public Object getUnderlying() {
+        return colNum;
+    }
+
+    @Override
+    public void read(TARRAY dest, boolean[] isNull, long srcBegin, long srcEnd) {
+        // Do nothing.
+    }
+}

src/test/java/io/deephaven/csv/testutil/Column.java

@@ -0,0 +1,83 @@
+package io.deephaven.csv.testutil;
+
+import io.deephaven.csv.CsvReaderTest;
+
+import java.lang.reflect.Array;
+
+public final class Column<TARRAY> {
+    private final String name;
+    private final TARRAY values;
+    private final int size;
+    private final Class<?> reinterpretedType;
+
+    public static Column<byte[]> ofValues(final String name, final byte... values) {
+        return ofArray(name, values, values.length);
+    }
+
+    public static Column<short[]> ofValues(final String name, final short... values) {
+        return ofArray(name, values, values.length);
+    }
+
+    public static Column<int[]> ofValues(final String name, final int... values) {
+        return ofArray(name, values, values.length);
+    }
+
+    public static Column<long[]> ofValues(final String name, final long... values) {
+        return ofArray(name, values, values.length);
+    }
+
+    public static Column<float[]> ofValues(final String name, final float... values) {
+        return ofArray(name, values, values.length);
+    }
+
+    public static Column<double[]> ofValues(final String name, final double... values) {
+        return ofArray(name, values, values.length);
+    }
+
+    public static Column<char[]> ofValues(final String name, final char... values) {
+        return ofArray(name, values, values.length);
+    }
+
+    public static <T> Column<T[]> ofRefs(final String name, final T... values) {
+        return ofArray(name, values, values.length);
+    }
+
+    public static <TARRAY> Column<TARRAY> ofArray(final String name, final TARRAY values, int size) {
+        return new Column<>(name, values, size);
+    }
+
+    private Column(final String name, final TARRAY values, int size) {
+        this(name, values, size, values.getClass().getComponentType());
+    }
+
+    private Column(final String name, final TARRAY values, int size, Class<?> reinterpretedType) {
+        this.name = name;
+        this.values = values;
+        this.size = size;
+        this.reinterpretedType = reinterpretedType;
+    }
+
+    public Column<TARRAY> reinterpret(Class<?> reinterpretedType) {
+        return new Column<>(name, values, size, reinterpretedType);
+    }
+
+    public int size() {
+        return size;
+    }
+
+    public String name() {
+        return name;
+    }
+
+    public Class<?> elementType() {
+        return values.getClass().getComponentType();
+    }
+
+    public Class<?> reinterpretedType() {
+        return reinterpretedType;
+    }
+
+    public Object getItem(int index) {
+        return Array.get(values, index);
+    }
+}

src/test/java/io/deephaven/csv/testutil/ColumnSet.java

@@ -0,0 +1,73 @@
+package io.deephaven.csv.testutil;
+
+import io.deephaven.csv.CsvReaderTest;
+import io.deephaven.csv.util.Renderer;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.BiFunction;
+
+public final class ColumnSet {
+    public static final ColumnSet NONE = new ColumnSet(new Column[0], 0);
+
+    private final Column<?>[] columns;
+    private final int columnSize;
+
+    public static ColumnSet of(Column<?>... columns) {
+        if (columns.length == 0) {
+            throw new RuntimeException("Empty column set is not permitted");
+        }
+        final int c0Size = columns[0].size();
+        for (int ii = 1; ii < columns.length; ++ii) { // Deliberately starting at 1.
+            final int ciiSize = columns[ii].size();
+            if (ciiSize != c0Size) {
+                throw new RuntimeException(
+                        String.format(
+                                "Column %d (size %d) has a different size than column 0 (size %d)",
+                                ii, ciiSize, c0Size));
+            }
+        }
+        return new ColumnSet(columns, c0Size);
+    }
+
+    private ColumnSet(Column<?>[] columns, int columnSize) {
+        this.columns = columns;
+        this.columnSize = columnSize;
+    }
+
+    public Column<?>[] getColumns() {
+        return columns;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        final List<Column<?>> colList = Arrays.asList(columns);
+
+        final BiFunction<Class<?>, Class<?>, String> renderType =
+                (etype, rtype) -> {
+                    if (etype == rtype) {
+                        return etype.getCanonicalName();
+                    }
+                    return etype.getCanonicalName() + "->" + rtype.getCanonicalName();
+                };
+
+        Renderer.renderList(
+                sb,
+                colList,
+                ",",
+                col -> String.format(
+                        "%s(%s)",
+                        col.name(), renderType.apply(col.elementType(), col.reinterpretedType())));
+        for (int jj = 0; jj < columnSize; ++jj) {
+            final int jjFinal = jj;
+            sb.append('\n');
+            Renderer.renderList(sb, colList, ",", col -> safeToString(col.getItem(jjFinal)));
+        }
+        return sb.toString();
+    }
+
+    private static String safeToString(Object o) {
+        return o == null ? "(null)" : o.toString();
+    }
+}