Issue #118 fix upstream bug in JsonNumber.of(double) hardcoding offsets

Applied local workaround for upstream jdk-sandbox bug where JsonNumber.of(double)
hardcodes decimalOffset=0 and exponentOffset=0, causing toLong() to fail for
integral doubles like 123.0.

Fix: delegate of(double) to of(String) which correctly computes offsets via Json.parse().

Added test TestJsonNumberOfDouble to verify the fix.

To verify: mvn test -pl json-java21 -Dtest=TestJsonNumberOfDouble
All 4 tests pass (toString, toDouble, toLong for integral, toLong throws for non-integral).

Author: simbo1905

README.md

@@ -295,6 +295,12 @@ This is a simplified backport with the following changes from the original:
 - Removed `@PreviewFeature` annotations.
 - Compatible with JDK 21.
 
+### Upstream Bug Fixes
+
+The following fixes have been applied to address bugs in the upstream OpenJDK jdk-sandbox code. These are upstream issues that should be reported to the [core-libs-dev@openjdk.org](mailto:core-libs-dev@openjdk.org) mailing list per OpenJDK process:
+
+- **`JsonNumber.of(double)` offset bug** ([#118](https://github.com/simbo1905/java.util.json.Java21/issues/118)): The upstream implementation hardcodes `decimalOffset=0` and `exponentOffset=0`, causing `toLong()` to fail for integral doubles like `123.0`. Our fix delegates to `JsonNumber.of(String)` which correctly computes offsets via `Json.parse()`.
+
 ## Security Considerations
 
 **⚠️ This unstable API historically contained a undocumented security vulnerabilities.** The compatibility test suite (documented below) includes crafted attack vectors that expose these issues:

json-java21/src/main/java/jdk/sandbox/java/util/json/JsonNumber.java

@@ -113,8 +113,11 @@ static JsonNumber of(double num) {
         if (!Double.isFinite(num)) {
             throw new IllegalArgumentException("Not a valid JSON number");
         }
-        var str = Double.toString(num);
-        return new JsonNumberImpl(str.toCharArray(), 0, str.length(), 0, 0);
+        // LOCAL FIX for upstream bug: The original code hardcoded decimalOffset=0
+        // and exponentOffset=0, which breaks toLong() for integral doubles like 123.0.
+        // Delegating to of(String) ensures correct offset computation via Json.parse().
+        // See: https://github.com/simbo1905/java.util.json.Java21/issues/118
+        return JsonNumber.of(Double.toString(num));
     }
 
     /**

json-java21/src/test/java/jdk/sandbox/java/util/json/TestJsonNumberOfDouble.java

@@ -0,0 +1,34 @@
+package jdk.sandbox.java.util.json;
+
+import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.*;
+
+public class TestJsonNumberOfDouble {
+    
+    @Test
+    void ofDoubleToStringPreservesValue() {
+        var jn = JsonNumber.of(123.45);
+        assertThat(jn.toString()).isEqualTo("123.45");
+    }
+    
+    @Test
+    void ofDoubleToDoubleWorks() {
+        var jn = JsonNumber.of(123.45);
+        assertThat(jn.toDouble()).isEqualTo(123.45);
+    }
+    
+    @Test
+    void ofDoubleThenToLongForIntegralDouble() {
+        // 123.0 should be convertible to long 123
+        var jn = JsonNumber.of(123.0);
+        System.out.println("toString: " + jn.toString());
+        assertThat(jn.toLong()).isEqualTo(123L);
+    }
+    
+    @Test
+    void ofDoubleThenToLongForNonIntegralShouldThrow() {
+        var jn = JsonNumber.of(123.45);
+        assertThatThrownBy(() -> jn.toLong())
+            .isInstanceOf(jdk.sandbox.java.util.json.JsonAssertionException.class);
+    }
+}