Merge branch '2.x' into 3.1

Author: cowtowncoder

release-notes/CREDITS-2.x

@@ -288,7 +288,7 @@ Henning Langhorst (@HenningLanghorst)
   when preceding column is quoted
  (2.18.7)
 
-Shanchao Li (@tonguaroot)
+Shanchao Li (@tonghuaroot)
 
 * Fixed #679: (toml) Validate integer length for hex/octal/binary radix literals
  (2.18.8)
@@ -313,3 +313,15 @@ Dmitry Bufistov (@dmitry-workato)
 * Requested #601: (csv) Reader should allow separating plain `nullValue`
   and quoted value `"nullValue"`
  (2.22.0)
+
+EverNife (@EverNife)
+
+* Reported #696: (toml) Write non-finite floating-point values as TOML tokens
+  (`nan`/`inf`/`-inf`) instead of Java tokens (`NaN`/`Infinity`)
+ (2.23.0)
+
+seonwoojung (@seonwooj0810)
+
+* Fixed #696: (toml) Write non-finite floating-point values as TOML tokens
+  (`nan`/`inf`/`-inf`) instead of Java tokens (`NaN`/`Infinity`)
+ (2.23.0)

release-notes/VERSION-2.x

@@ -14,13 +14,20 @@ Active Maintainers:
 === Releases ===
 ------------------------------------------------------------------------
 
-2.22.0 (not yet released)
+2.23.0 (not yet released)
+
+#696: (toml) Write non-finite floating-point values as TOML tokens
+  (`nan`/`inf`/`-inf`) instead of Java tokens (`NaN`/`Infinity`)
+ (reported by @EverNife)
+ (fix by @seonwooj0810)
+
+2.22.0 (31-May-2026)
 
 #601: (csv) Reader should allow separating plain `nullValue` and quoted
   value `"nullValue"`
  (requested by Dmitry B)
 
-2.21.4 (not yet released)
+2.21.4 (28-May-2026)
 
 #679: (toml) Validate integer length for hex/octal/binary radix literals
  (fix by @tonghuaroot)
@@ -93,7 +100,7 @@ No changes since 2.19.0
 #554: (csv) Enforce, document thread-safety of `CsvSchema`
  (requested by Gili T)
 
-2.18.8 (not yet released)
+2.18.8 (28-May-2026)
 
 #679: (toml) Validate integer length for hex/octal/binary radix literals
  (fix by @tonghuaroot)

toml/src/main/java/tools/jackson/dataformat/toml/TomlGenerator.java

@@ -603,17 +603,37 @@ public JsonGenerator writeNumber(BigInteger v) throws JacksonException {
     @Override
     public JsonGenerator writeNumber(double d) throws JacksonException {
         _verifyValueWrite("write number");
-        _writeRaw(String.valueOf(d));
+        _writeRaw(_nonFiniteTomlToken(d, String.valueOf(d)));
         return writeValueEnd();
     }
 
     @Override
     public JsonGenerator writeNumber(float f) throws JacksonException {
         _verifyValueWrite("write number");
-        _writeRaw(String.valueOf(f));
+        _writeRaw(_nonFiniteTomlToken(f, String.valueOf(f)));
         return writeValueEnd();
     }
 
+    /**
+     * Maps a non-finite floating-point value to the TOML float token
+     * ({@code nan}, {@code inf} or {@code -inf}); finite values are written
+     * using the supplied Java text form. {@code String.valueOf(...)} would
+     * otherwise emit {@code NaN} / {@code Infinity} / {@code -Infinity}, which
+     * are not valid TOML and cannot be read back by the parser.
+     */
+    private static String _nonFiniteTomlToken(double d, String finiteForm) {
+        if (Double.isNaN(d)) {
+            return "nan";
+        }
+        if (d == Double.POSITIVE_INFINITY) {
+            return "inf";
+        }
+        if (d == Double.NEGATIVE_INFINITY) {
+            return "-inf";
+        }
+        return finiteForm;
+    }
+
     @Override
     public JsonGenerator writeNumber(BigDecimal dec) throws JacksonException {
         if (dec == null) {

toml/src/test/java/tools/jackson/dataformat/toml/TomlGeneratorTest.java

@@ -7,8 +7,10 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import tools.jackson.core.JsonGenerator;
+import tools.jackson.databind.JsonNode;
 import tools.jackson.databind.ObjectMapper;
 
 public class TomlGeneratorTest extends TomlMapperTestBase {
@@ -48,6 +50,61 @@ public void floats() {
         assertEquals("abc = 1.23\n", w.toString());
     }
 
+    // [dataformats-text#696]: non-finite floats must be written as the TOML
+    // tokens `nan` / `inf` / `-inf` (not Java's `NaN` / `Infinity`) so the
+    // writer's own output can be parsed back.
+    @Test
+    public void nonFiniteDoubles() throws IOException {
+        assertEquals("abc = nan\n", _writeDouble(Double.NaN));
+        assertEquals("abc = inf\n", _writeDouble(Double.POSITIVE_INFINITY));
+        assertEquals("abc = -inf\n", _writeDouble(Double.NEGATIVE_INFINITY));
+    }
+
+    @Test
+    public void nonFiniteFloats() throws IOException {
+        assertEquals("abc = nan\n", _writeFloat(Float.NaN));
+        assertEquals("abc = inf\n", _writeFloat(Float.POSITIVE_INFINITY));
+        assertEquals("abc = -inf\n", _writeFloat(Float.NEGATIVE_INFINITY));
+    }
+
+    // Written non-finite values must round-trip through the same mapper.
+    @Test
+    public void nonFiniteRoundTrip() throws IOException {
+        TomlMapper mapper = newTomlMapper();
+        for (double d : new double[] {
+                Double.NaN, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY }) {
+            String toml = mapper.writeValueAsString(java.util.Collections.singletonMap("x", d));
+            JsonNode node = mapper.readTree(toml).get("x");
+            if (Double.isNaN(d)) {
+                assertTrue(Double.isNaN(node.doubleValue()), "expected NaN from: " + toml);
+            } else {
+                assertEquals(d, node.doubleValue(), 0.0, "round-trip failed for: " + toml);
+            }
+        }
+    }
+
+    private String _writeDouble(double d) throws IOException {
+        StringWriter w = new StringWriter();
+        try (JsonGenerator generator = newTomlMapper().createGenerator(w)) {
+            generator.writeStartObject();
+            generator.writeName("abc");
+            generator.writeNumber(d);
+            generator.writeEndObject();
+        }
+        return w.toString();
+    }
+
+    private String _writeFloat(float f) throws IOException {
+        StringWriter w = new StringWriter();
+        try (JsonGenerator generator = newTomlMapper().createGenerator(w)) {
+            generator.writeStartObject();
+            generator.writeName("abc");
+            generator.writeNumber(f);
+            generator.writeEndObject();
+        }
+        return w.toString();
+    }
+
     @Test
     public void stringNormal() {
         StringWriter w = new StringWriter();