test(client-v2): exhaustively cover all 65,536 BFloat16 values

Address review feedback: instead of a handful of hand-picked values, round-trip
every one of the 2^16 BFloat16 bit patterns.

- SerializerUtilsPrimitiveSerializationTests: replace the 7-row bFloat16Values
  DataProvider with a single test that serializes and reads back all 65,536
  patterns in-memory. Non-NaN patterns (incl. +/-0, subnormals, +/-Infinity)
  must round-trip bit-for-bit; NaN inputs collapse to one canonical NaN on write
  (Float#floatToIntBits normalizes the payload) so they only need to read back
  as NaN.
- DataTypeTests#testBFloat16: exhaustively insert all 65,536 values through the
  full client write -> server -> client read POJO round-trip (incl.
  Nullable(BFloat16)); widen the DTO rowId column to Int32 to key 65,536 rows.

Author: polyglotAI-bot

client-v2/src/test/java/com/clickhouse/client/api/data_formats/internal/SerializerUtilsPrimitiveSerializationTests.java

@@ -111,38 +111,53 @@ public void testSerializeFloatColumnRejectsUnsupportedValue() {
                 () -> serializeSingleValue("Float64", new Object()));
     }
 
-    @DataProvider(name = "bFloat16Values")
-    public static Object[][] bFloat16Values() {
-        // input float, expected float after a BFloat16 round-trip. BFloat16 keeps the high
-        // 16 bits of the float32 representation, so writing truncates the low mantissa bits
-        // (matching the ClickHouse server) and reading widens the value back losslessly.
-        return new Object[][] {
-                {0.0f, 0.0f},                    // zero
-                {1.5f, 1.5f},                    // exactly representable
-                {-2.5f, -2.5f},                  // exactly representable, sign preserved
-                {100.0f, 100.0f},                // exactly representable
-                {256.0f, 256.0f},                // exactly representable
-                {3.14f, 3.125f},                 // 0x4048F5C3 -> 0x40480000 (low bits dropped)
-                {0.1f, 0.099609375f},            // 0x3DCCCCCD -> 0x3DCC0000 (low bits dropped)
-        };
-    }
-
-    @Test(dataProvider = "bFloat16Values")
-    public void testSerializeBFloat16RoundTrip(float input, float expected) throws IOException {
-        RowBinaryWithNamesAndTypesFormatReader reader = serializeSingleValue("BFloat16", input);
+    @Test
+    public void testSerializeBFloat16RoundTripAllValues() throws IOException {
+        // Exhaustively round-trip every one of the 2^16 BFloat16 bit patterns. For pattern b the
+        // canonical float32 is intBitsToFloat(b << 16); the client writes its high 16 bits and reads
+        // them back widened. Every non-NaN pattern - including +/-0, subnormals and +/-Infinity -
+        // must round-trip bit-for-bit. NaN inputs collapse to a single NaN because Float#floatToIntBits
+        // normalizes the payload on write, so they are only required to read back as a NaN.
+        final int count = 1 << 16;
+        Object[] inputs = new Object[count];
+        for (int b = 0; b < count; b++) {
+            inputs[b] = Float.intBitsToFloat(b << 16);
+        }
 
-        reader.next();
+        RowBinaryWithNamesAndTypesFormatReader reader = serializeColumn("BFloat16", inputs);
+
+        for (int b = 0; b < count; b++) {
+            Assert.assertNotNull(reader.next(), "missing row for BFloat16 pattern " + hex(b));
+            float actual = reader.getFloat("value");
+            if (Float.isNaN((Float) inputs[b])) {
+                Assert.assertTrue(Float.isNaN(actual), "BFloat16 pattern " + hex(b) + " must read back as NaN");
+            } else {
+                Assert.assertEquals(Float.floatToRawIntBits(actual), b << 16,
+                        "BFloat16 pattern " + hex(b) + " did not round-trip");
+            }
+        }
+        Assert.assertNull(reader.next(), "unexpected extra row after all 65,536 BFloat16 patterns");
+    }
 
-        Assert.assertEquals(reader.getFloat("value"), expected, 0.0f);
+    private static String hex(int bFloat16Bits) {
+        return String.format("0x%04X", bFloat16Bits);
     }
 
     private RowBinaryWithNamesAndTypesFormatReader serializeSingleValue(String type, Object value)
             throws IOException {
+        return serializeColumn(type, new Object[]{value});
+    }
+
+    private RowBinaryWithNamesAndTypesFormatReader serializeColumn(String type, Object[] values)
+            throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         BinaryStreamUtils.writeVarInt(out, 1);
         BinaryStreamUtils.writeString(out, "value");
         BinaryStreamUtils.writeString(out, type);
-        SerializerUtils.serializeData(out, value, ClickHouseColumn.of("value", type));
+        ClickHouseColumn column = ClickHouseColumn.of("value", type);
+        for (Object value : values) {
+            SerializerUtils.serializeData(out, value, column);
+        }
 
         return new RowBinaryWithNamesAndTypesFormatReader(
                 new ByteArrayInputStream(out.toByteArray()),

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

@@ -163,7 +163,7 @@ public static class DTOForBFloat16Tests {
         private Float bFloat16Nullable;
 
         public static String tblCreateSQL(String table) {
-            return tableDefinition(table, "rowId Int16", "bFloat16 BFloat16",
+            return tableDefinition(table, "rowId Int32", "bFloat16 BFloat16",
                     "bFloat16Nullable Nullable(BFloat16)");
         }
     }
@@ -177,24 +177,46 @@ public void testBFloat16() throws Exception {
             return;
         }
 
+        // Exhaustively cover every one of the 2^16 BFloat16 bit patterns through a full client
+        // write -> server -> client read round-trip (POJO path, incl. Nullable(BFloat16)). For
+        // pattern b the value is Float.intBitsToFloat(b << 16): non-NaN values (incl. +/-0,
+        // subnormals, +/-Infinity) must return bit-for-bit, while NaN inputs collapse to a single
+        // canonical NaN on write and are only required to read back as NaN. Truncation of
+        // non-representable float inputs is covered by testBFloat16TruncationMatchesServer.
         final String table = "test_bfloat16";
-        // Only exactly-representable BFloat16 values are used here so a client-side write
-        // followed by a read returns the same value. Truncation of non-representable values
-        // is covered by testBFloat16TruncationMatchesServer.
+        final int count = 1 << 16;
+        List<DTOForBFloat16Tests> data = new ArrayList<>(count);
+        for (int b = 0; b < count; b++) {
+            float value = Float.intBitsToFloat(b << 16);
+            // Row 0 exercises the null path; every other row round-trips a non-null Nullable(BFloat16).
+            data.add(new DTOForBFloat16Tests(b, value, b == 0 ? null : value));
+        }
+
         writeReadVerify(table,
                 DTOForBFloat16Tests.tblCreateSQL(table),
                 DTOForBFloat16Tests.class,
-                Arrays.asList(
-                        new DTOForBFloat16Tests(0, 1.5f, -2.5f),
-                        new DTOForBFloat16Tests(1, 0.0f, null),
-                        new DTOForBFloat16Tests(2, 256.0f, 100.0f)),
-                (data, dto) -> {
-                    DTOForBFloat16Tests expected = data.get(dto.getRowId());
-                    Assert.assertEquals(dto.getBFloat16(), expected.getBFloat16(), 0.0f);
-                    Assert.assertEquals(dto.getBFloat16Nullable(), expected.getBFloat16Nullable());
+                data,
+                (all, dto) -> {
+                    DTOForBFloat16Tests expected = all.get(dto.getRowId());
+                    assertBFloat16Equals(dto.getBFloat16(), expected.getBFloat16());
+                    assertBFloat16Equals(dto.getBFloat16Nullable(), expected.getBFloat16Nullable());
                 });
     }
 
+    // BFloat16 keeps the high 16 bits of a float32, so every non-NaN value round-trips bit-for-bit;
+    // NaN inputs collapse to a single canonical NaN on write and are only required to read back as NaN.
+    private static void assertBFloat16Equals(Float actual, Float expected) {
+        if (expected == null) {
+            Assert.assertNull(actual);
+        } else if (Float.isNaN(expected)) {
+            Assert.assertNotNull(actual);
+            Assert.assertTrue(Float.isNaN(actual), "expected a NaN but got " + actual);
+        } else {
+            Assert.assertNotNull(actual);
+            Assert.assertEquals(Float.floatToRawIntBits(actual), Float.floatToRawIntBits(expected));
+        }
+    }
+
     @Test(groups = {"integration"})
     public void testBFloat16TruncationMatchesServer() throws Exception {
         if (isVersionMatch(BFLOAT16_UNSUPPORTED_VERSIONS)) {