Issue #145 port upstream tests, verify #118 closed, bump frontier docs

- Port all nine upstream jtreg/junit test files from jdk-sandbox json
  branch at frontier 43325738c into json-java21 (TestAccess, TestGenerate,
  TestJsonArray, TestJsonLiteral, TestJsonNumber, TestJsonObject,
  TestJsonString, TestOtherImpl, TestParse): mechanical jtreg header
  removal, package rename, FieldSource to MethodSource (JUnit 5.10),
  boxed type patterns for the Java 21 backport of factoryTest.
- Add JsonTestLoggingConfig base class (JUL per repo test rules) and
  JsonNumberOfDoubleMatrixTest proving issue #118 is closed by upstream:
  of(double) now computes decimal/exponent offsets via indexOf and the
  reworked JsonNumberImpl handles integral doubles, fractions, negatives,
  zero variants and out-of-range conversions identically to the historic
  of(String) delegation fix.
- Add junit-jupiter-params test dependency to json-java21.
- README: bump synced frontier anchor c1a4f80 to 43325738c (2026-08-27),
  mark the incubator migration DONE (issue #145), refresh stale accessor
  lists (asString/asLong/asInt/asBoolean/asList/asMap, tryGet/tryValue),
  fix JsonParseException getErrorLine/getErrorPosition example, record
  the #118 closed-by-upstream disposition in Upstream Bug Fixes.
- ci.yml: exp_tests 1355 -> 1665 (full clean verify, all modules green).

Author: simbo1905

.github/workflows/ci.yml

@@ -39,7 +39,7 @@ jobs:
                       for k in totals: totals[k]+=int(r.get(k,'0'))
                   except Exception:
                       pass
-          exp_tests=1355
+          exp_tests=1665
           exp_skipped=0
           if totals['tests']!=exp_tests or totals['skipped']!=exp_skipped:
               print(f"Unexpected test totals: {totals} != expected tests={exp_tests}, skipped={exp_skipped}")

README.md

@@ -123,14 +123,16 @@ double ageDouble = obj.get("age").asDouble(); // Returns 30.0
 ```
 
 The accessor methods on `JsonValue`:
-- `string()` - Returns the String value (for JsonString)
-- `toLong()` - Returns the long value (for JsonNumber, if representable)
-- `toDouble()` - Returns the double value (for JsonNumber, if representable)
-- `bool()` - Returns the boolean value (for JsonBoolean)
-- `elements()` - Returns List<JsonValue> (for JsonArray)
-- `members()` - Returns Map<String, JsonValue> (for JsonObject)
+- `asString()` - Returns the String value (for JsonString)
+- `asLong()` - Returns the long value (for JsonNumber, if representable)
+- `asDouble()` - Returns the double value (for JsonNumber, if representable)
+- `asBoolean()` - Returns the boolean value (for JsonBoolean)
+- `asList()` - Returns List<JsonValue> (for JsonArray)
+- `asMap()` - Returns Map<String, JsonValue> (for JsonObject)
 - `get(String name)` - Access JsonObject member by name
-- `element(int index)` - Access JsonArray element by index
+- `get(int index)` - Access JsonArray element by index
+- `tryGet(String name)` - Returns Optional<JsonValue> for a JsonObject member
+- `tryValue()` - Returns Optional<JsonValue>, empty for JsonNull
 
 ### Realistic Record Mapping
 
@@ -222,9 +224,9 @@ try {
     JsonValue value = Json.parse(userInput);
     // Process valid JSON
 } catch (JsonParseException e) {
-    // Handle malformed JSON with line/column information
-    System.err.println("Invalid JSON at line " + e.getLine() + 
-                       ", column " + e.getColumn() + ": " + e.getMessage());
+    // Handle malformed JSON with line/position information
+    System.err.println("Invalid JSON at line " + e.getErrorLine() + 
+                       ", position " + e.getErrorPosition() + ": " + e.getMessage());
 }
 ```
 
@@ -289,17 +291,17 @@ The test data is bundled as ZIP files and extracted automatically at runtime:
 
 **Final `java.util.json` sandbox-era release** (2026-05-19).
 
-This code is derived from the OpenJDK jdk-sandbox repository "json" branch at commit `c1a4f80` (2026-02-05), which was the last commit before the API was moved to `jdk.incubator.json`.
+This code is derived from the OpenJDK jdk-sandbox repository "json" branch at commit `43325738c` (2026-08-27), which is the current frontier of the incubator-era `jdk.incubator.json` API. The incubator promotion itself happened at commit `b956ae0` (2026-02-05); this branch completed the migration from the sandbox-era `java.util.json` naming to the incubator packages — see the notice below and issue #145.
 
 ### API Summary
-- `JsonValue` conversion methods: `asBoolean()`, `toInt()`, `toLong()`, `toDouble()`, `asString()`
-- `JsonValue` navigation methods: `get(String)`, `get(int)`, `getOrAbsent(String)`, `valueOrNull()`
-- `JsonArray`: `elements()`, `of(List)`
-- `JsonObject`: `members()`, `of(Map)`
+- `JsonValue` conversion methods: `asBoolean()`, `asString()`, `asInt()`, `asLong()`, `asDouble()`
+- `JsonValue` navigation methods: `get(String)`, `get(int)`, `tryGet(String)`, `tryValue()`
+- `JsonArray`: `asList()`, `of(List)`
+- `JsonObject`: `asMap()`, `of(Map)`
 - `Json`: `parse(String)`, `parse(char[])`, `toDisplayString(JsonValue, String indent)`
 
 ### Upstream Migration Notice
-The upstream `java.util.json` API has been promoted to `jdk.incubator.json` (commit `b956ae0`, 2026-02-05). The incubator version introduces significant API changes including method renames (`bool()`→`asBoolean()`, `string()`→`asString()`, etc.) and new methods (`asInt()`). A separate branch tracks the incubator upgrade — see issue #145.
+The upstream `java.util.json` API has been promoted to `jdk.incubator.json` (commit `b956ae0`, 2026-02-05). The incubator version introduces significant API changes including method renames (`bool()`→`asBoolean()`, `string()`→`asString()`, `toInt()`→`asInt()`, etc.), `tryGet()`/`tryValue()` navigation, and identity (non-value) `equals`/`hashCode`. **That migration is now DONE in this branch** (issue #145): the public API lives in `jdk.incubator.java.util.json` and the implementation in `jdk.incubator.internal.util.json`, matching upstream frontier `43325738c`.
 
 The original proposal and design rationale can be found in the included PDF: [Towards a JSON API for the JDK.pdf](Towards%20a%20JSON%20API%20for%20the%20JDK.pdf)
 
@@ -327,9 +329,9 @@ This is a simplified backport with the following changes from the original:
 
 ### 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:
+Historically this backport carried local fixes against the upstream OpenJDK jdk-sandbox code. With the uplift to upstream frontier `43325738c` their disposition is:
 
-- **`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()`.
+- **`JsonNumber.of(double)` offset bug** ([#118](https://github.com/simbo1905/java.util.json.Java21/issues/118)): **CLOSED BY UPSTREAM — no longer carried.** Upstream reworked the numeric logic: `of(double)` now computes the decimal/exponent offsets from `Double.toString` output via `indexOf`, and `JsonNumberImpl` was rewritten with `LazyConstant`-cached conversions, trailing-zero stripping and sign/scale handling. Verified equivalent to our historic `of(String)` delegation fix by `JsonNumberOfDoubleMatrixTest` (integral doubles such as `123.0` and `1.0E2`, fractions, negatives, zero variants, out-of-range `asInt`/`asLong` throwing `JsonValueException`, and very large/small magnitudes) plus the ported upstream `TestJsonNumber`. The historic delegation hack has been removed with the uplifted upstream source.
 
 ## Security Considerations
 

json-java21/pom.xml

@@ -34,6 +34,11 @@
             <artifactId>junit-jupiter-engine</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-params</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.assertj</groupId>
             <artifactId>assertj-core</artifactId>

json-java21/src/test/java/jdk/incubator/java/util/json/JsonNumberOfDoubleMatrixTest.java

@@ -0,0 +1,116 @@
+package jdk.incubator.java.util.json;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+/// Evidence matrix for issue #118 (`JsonNumber.of(double)` decimal/exponent
+/// offsets). The historic local fix delegated `of(double)` to `of(String)`;
+/// upstream has since reworked the numeric logic to compute the offsets via
+/// `indexOf`. These tests prove the uplifted upstream implementation handles
+/// the full matrix that motivated #118, making the carried fix unnecessary.
+public class JsonNumberOfDoubleMatrixTest extends JsonTestLoggingConfig {
+
+    private static void assertIntegralDouble(double d, long expected) {
+        var jn = JsonNumber.of(d);
+        // of(double) must be equivalent to the historic of(String) delegation
+        var viaString = JsonNumber.of(Double.toString(d));
+        assertEquals(viaString.toString(), jn.toString(), "toString for " + d);
+        assertEquals(expected, jn.asLong(), "asLong for " + d);
+        assertEquals((int) expected, jn.asInt(), "asInt for " + d);
+        assertEquals(d, jn.asDouble(), "asDouble for " + d);
+    }
+
+    @Test
+    void integralDoublesConvertExactly() {
+        assertIntegralDouble(123.0, 123L);
+        assertIntegralDouble(1.0E2, 100L);
+        assertIntegralDouble(42.0, 42L);
+        assertIntegralDouble(420e-1, 42L);
+        assertIntegralDouble(42e6, 42_000_000L);
+        assertIntegralDouble(0.0, 0L);
+        assertIntegralDouble(1.0, 1L);
+        assertIntegralDouble(5.000, 5L);
+    }
+
+    @Test
+    void negativeIntegralDoublesConvertExactly() {
+        assertIntegralDouble(-123.0, -123L);
+        assertIntegralDouble(-42e6, -42_000_000L);
+        assertIntegralDouble(-1.0, -1L);
+    }
+
+    @Test
+    void negativeZeroBehaves() {
+        var jn = JsonNumber.of(-0.0);
+        assertEquals("-0.0", jn.toString());
+        assertEquals(0L, jn.asLong());
+        assertEquals(0, jn.asInt());
+        assertEquals(-0.0, jn.asDouble());
+        assertEquals(0.0, jn.asDouble() + 0.0);
+    }
+
+    @Test
+    void fractionalDoublesAreNotIntegral() {
+        assertNotIntegral(123.45);
+        assertNotIntegral(0.1);
+        assertNotIntegral(0.002);
+        assertNotIntegral(-123.45);
+    }
+
+    private static void assertNotIntegral(double d) {
+        var jn = JsonNumber.of(d);
+        assertThrows(JsonValueException.class, jn::asLong, "asLong for " + d);
+        assertThrows(JsonValueException.class, jn::asInt, "asInt for " + d);
+        assertEquals(d, jn.asDouble(), "asDouble for " + d);
+        // of(double) must match the of(String) representation exactly
+        assertEquals(JsonNumber.of(Double.toString(d)).toString(), jn.toString());
+    }
+
+    @Test
+    void outOfRangeIntegralThrowsJsonValueException() {
+        assertNotConvertibleToLong(1e300);
+        assertNotConvertibleToLong(-1e300);
+        assertNotConvertibleToLong(Double.MAX_VALUE);
+        assertNotConvertibleToLong(9.3e18);
+    }
+
+    private static void assertNotConvertibleToLong(double d) {
+        var jn = JsonNumber.of(d);
+        assertThrows(JsonValueException.class, jn::asLong, "asLong for " + d);
+        assertThrows(JsonValueException.class, jn::asInt, "asInt for " + d);
+        assertEquals(d, jn.asDouble(), "asDouble for " + d);
+    }
+
+    @Test
+    void tinyMagnitudesRoundTripAsDouble() {
+        var tiny = JsonNumber.of(4.9E-324);
+        assertEquals(4.9E-324, tiny.asDouble());
+        assertThrows(JsonValueException.class, tiny::asLong);
+        var small = JsonNumber.of(5e-100);
+        assertEquals(5e-100, small.asDouble());
+        assertThrows(JsonValueException.class, small::asLong);
+    }
+
+    @Test
+    void ofDoubleMatchesParsedEquivalent() {
+        // of(double) goes through Double.toString; parsing that same text must
+        // produce the same conversions (the equivalence #118 was about)
+        for (double d : new double[]{123.0, 1.0E2, 42e6, 0.0, -0.0, 123.45, 1e300, 4.9E-324}) {
+            var factory = JsonNumber.of(d);
+            var parsed = Json.parse(Double.toString(d));
+            assertNotEquals(parsed, factory); // identity semantics; compare behaviour
+            assertEquals(factory.toString(), parsed.toString(), "toString for " + d);
+            assertEquals(factory.asDouble(), ((JsonNumber) parsed).asDouble(), "asDouble for " + d);
+        }
+    }
+
+    @Test
+    void nonFiniteDoublesRejected() {
+        assertThrows(IllegalArgumentException.class, () -> JsonNumber.of(Double.NaN));
+        assertThrows(IllegalArgumentException.class, () -> JsonNumber.of(Double.POSITIVE_INFINITY));
+        assertThrows(IllegalArgumentException.class, () -> JsonNumber.of(Double.NEGATIVE_INFINITY));
+    }
+}

json-java21/src/test/java/jdk/incubator/java/util/json/JsonTestLoggingConfig.java

@@ -0,0 +1,57 @@
+package jdk.incubator.java.util.json;
+
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.TestInfo;
+
+import java.util.Locale;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/// Base class for the ported upstream JSON tests. Configures JUL logging from
+/// the `java.util.logging.ConsoleHandler.level` system property so that
+/// `-Djava.util.logging.ConsoleHandler.level=FINE` (etc.) works uniformly, and
+/// announces each test method execution at INFO level.
+public class JsonTestLoggingConfig {
+
+    static final Logger LOG = Logger.getLogger(JsonTestLoggingConfig.class.getName());
+
+    @BeforeAll
+    static void enableJulDebug() {
+        Logger root = Logger.getLogger("");
+        String levelProp = System.getProperty("java.util.logging.ConsoleHandler.level");
+        Level targetLevel = resolveLevel(levelProp);
+        // Ensure the root logger honors the most verbose configured level
+        if (root.getLevel() == null || root.getLevel().intValue() > targetLevel.intValue()) {
+            root.setLevel(targetLevel);
+        }
+        for (var handler : root.getHandlers()) {
+            Level handlerLevel = handler.getLevel();
+            if (handlerLevel == null || handlerLevel.intValue() > targetLevel.intValue()) {
+                handler.setLevel(targetLevel);
+            }
+        }
+        LOG.config(() -> "JUL level configured for JSON tests: " + targetLevel);
+    }
+
+    private static Level resolveLevel(String levelProp) {
+        Level targetLevel = Level.INFO;
+        if (levelProp != null) {
+            try {
+                targetLevel = Level.parse(levelProp.trim());
+            } catch (IllegalArgumentException ex) {
+                try {
+                    targetLevel = Level.parse(levelProp.trim().toUpperCase(Locale.ROOT));
+                } catch (IllegalArgumentException ignored) {
+                    LOG.warning(() -> "Unrecognized logging level from 'java.util.logging.ConsoleHandler.level': " + levelProp);
+                }
+            }
+        }
+        return targetLevel;
+    }
+
+    @BeforeEach
+    void announceTest(TestInfo testInfo) {
+        LOG.info(() -> "Running test: " + testInfo.getDisplayName());
+    }
+}