Add DataTypeTests integration coverage for null into non-nullable Array

Addresses review feedback on #2938: add integration tests in DataTypeTests
for the null-into-non-nullable-Array RowBinary writer fix.

These exercise the fix through the POJO insert path (client.insert ->
POJOSerDe -> RowBinaryFormatSerializer.writeValuePreamble), a different
entry point than the existing RowBinaryFormatWriterTest coverage:
- null into a non-nullable Array now throws IllegalArgumentException, pinned
  in both the plain RowBinary branch (no defaults) and the
  RowBinaryWithDefaults branch (a sibling column carries a default);
- valid empty/populated arrays still round-trip with the trailing column
  intact (no misframing);
- a null into a non-nullable Array that HAS a DDL default still coerces to
  the default instead of throwing.

Author: polyglotAI-bot

client-v2/src/test/java/com/clickhouse/client/datatypes/DataTypeTests.java

@@ -155,6 +155,110 @@ public static String tblCreateSQL(String table) {
         }
     }
 
+    // A non-nullable Array column cannot represent a null. Writing a Java null into one through the POJO
+    // insert path (POJOSerDe -> RowBinaryFormatSerializer.writeValuePreamble) must fail loudly like every
+    // other non-nullable type instead of emitting a stray marker byte, which the server read as a phantom
+    // extra row or a column shift. The fixed-width 'tail' column after the array would be corrupted by any
+    // stray byte, so it doubles as a misframing sentinel.
+    @Test(groups = {"integration"}, dataProvider = "nonNullableArrayNullColumns")
+    public void testInsertNullIntoNonNullableArrayThrows(String columns) throws Exception {
+        final String table = "test_non_nullable_array_null";
+        client.execute("DROP TABLE IF EXISTS " + table).get();
+        client.execute(tableDefinition(table, columns)).get();
+
+        client.register(DTOForNonNullableArrayTests.class, client.getTableSchema(table));
+
+        Exception thrown = null;
+        try {
+            client.insert(table, Collections.singletonList(new DTOForNonNullableArrayTests(1, null, 7)))
+                    .get(EXECUTE_CMD_TIMEOUT, TimeUnit.SECONDS);
+        } catch (Exception e) {
+            thrown = e;
+        }
+
+        Assert.assertNotNull(thrown, "Expected the insert to fail for a null in a non-nullable Array column using " + columns);
+        boolean clearMessage = false;
+        for (Throwable t = thrown; t != null; t = t.getCause()) {
+            if (t.getMessage() != null && t.getMessage().contains("An attempt to write null into not nullable column")) {
+                clearMessage = true;
+                break;
+            }
+        }
+        Assert.assertTrue(clearMessage, "Expected a clear non-nullable column error using " + columns + ", but got: " + thrown);
+    }
+
+    @DataProvider(name = "nonNullableArrayNullColumns")
+    public static Object[][] nonNullableArrayNullColumns() {
+        return new Object[][] {
+                // No defaults anywhere: the POJO insert uses plain RowBinary (non-defaults preamble branch).
+                {"rowId Int32, arr Array(Int32), tail Int32"},
+                // A sibling column has a default, so the POJO insert uses RowBinaryWithDefaults; the
+                // non-nullable arr itself has no default and so must still reject a null (defaults branch).
+                {"rowId Int32, arr Array(Int32), tail Int32 DEFAULT 99"},
+        };
+    }
+
+    // Contrast: valid non-nullable arrays (empty and populated) still round-trip through the POJO insert
+    // path, and the trailing 'tail' column keeps its value - proving the array length is still written as a
+    // single leading byte and that rejecting null did not perturb valid array writes.
+    @Test(groups = {"integration"}, dataProvider = "nonNullableArrayRoundTrip")
+    public void testInsertNonNullableArrayRoundTrips(List<Integer> arr, int expectedLength, String expectedConcat) throws Exception {
+        final String table = "test_non_nullable_array_round_trip";
+        client.execute("DROP TABLE IF EXISTS " + table).get();
+        client.execute(tableDefinition(table, "rowId Int32", "arr Array(Int32)", "tail Int32")).get();
+
+        client.register(DTOForNonNullableArrayTests.class, client.getTableSchema(table));
+        client.insert(table, Collections.singletonList(new DTOForNonNullableArrayTests(1, arr, 7)))
+                .get(EXECUTE_CMD_TIMEOUT, TimeUnit.SECONDS);
+
+        List<GenericRecord> records = client.queryAll(
+                "SELECT toInt32(length(arr)) AS alen, arrayStringConcat(arr, ',') AS acat, tail FROM " + table + " ORDER BY rowId");
+        Assert.assertEquals(records.size(), 1);
+        GenericRecord row = records.get(0);
+        Assert.assertEquals(row.getInteger("alen"), expectedLength);
+        Assert.assertEquals(row.getString("acat"), expectedConcat);
+        Assert.assertEquals(row.getInteger("tail"), 7);
+    }
+
+    @DataProvider(name = "nonNullableArrayRoundTrip")
+    public static Object[][] nonNullableArrayRoundTrip() {
+        return new Object[][] {
+                {new ArrayList<Integer>(), 0, ""},
+                {Arrays.asList(1, 2, 3), 3, "1,2,3"},
+        };
+    }
+
+    // Contrast: with a DDL DEFAULT the write uses RowBinaryWithDefaults, where a null into the non-nullable
+    // Array column falls back to the default instead of throwing - proving the fix only rejects null for a
+    // non-nullable array that has no default.
+    @Test(groups = {"integration"})
+    public void testInsertNullIntoDefaultedNonNullableArrayUsesDefault() throws Exception {
+        final String table = "test_non_nullable_array_null_default";
+        client.execute("DROP TABLE IF EXISTS " + table).get();
+        client.execute(tableDefinition(table, "rowId Int32", "arr Array(Int32) DEFAULT [1, 2]", "tail Int32")).get();
+
+        client.register(DTOForNonNullableArrayTests.class, client.getTableSchema(table));
+        client.insert(table, Collections.singletonList(new DTOForNonNullableArrayTests(1, null, 7)))
+                .get(EXECUTE_CMD_TIMEOUT, TimeUnit.SECONDS);
+
+        List<GenericRecord> records = client.queryAll(
+                "SELECT toInt32(length(arr)) AS alen, arrayStringConcat(arr, ',') AS acat, tail FROM " + table + " ORDER BY rowId");
+        Assert.assertEquals(records.size(), 1);
+        GenericRecord row = records.get(0);
+        Assert.assertEquals(row.getInteger("alen"), 2);
+        Assert.assertEquals(row.getString("acat"), "1,2");
+        Assert.assertEquals(row.getInteger("tail"), 7);
+    }
+
+    @Data
+    @AllArgsConstructor
+    @NoArgsConstructor
+    public static class DTOForNonNullableArrayTests {
+        private int rowId;
+        private List<Integer> arr;
+        private int tail;
+    }
+
     @Data
     @AllArgsConstructor
     @NoArgsConstructor