Issue #119 Add counterexamples and native mapping demo

Co-authored-by: simbo1905 <simbo1905@60hertz.com>

Author: cursoragent

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

@@ -4,9 +4,11 @@
 
 import java.math.BigDecimal;
 import java.math.BigInteger;
+import java.util.Map;
 import java.util.logging.Logger;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 public class DesignChoicesNumberExamplesTest {
     private static final Logger LOGGER = Logger.getLogger(DesignChoicesNumberExamplesTest.class.getName());
@@ -35,6 +37,24 @@ void convertingToDoubleIsPotentiallyLossy() {
         assertThat(lossy).isNotEqualByComparingTo(lossless);
     }
 
+    @Test
+    void convertingNonIntegralNumberToLongThrows() {
+        LOGGER.info("Executing convertingNonIntegralNumberToLongThrows");
+
+        var n = (JsonNumber) Json.parse("5.5");
+        assertThatThrownBy(n::toLong)
+                .isInstanceOf(JsonAssertionException.class);
+    }
+
+    @Test
+    void convertingOutOfRangeNumberToDoubleThrows() {
+        LOGGER.info("Executing convertingOutOfRangeNumberToDoubleThrows");
+
+        var n = (JsonNumber) Json.parse("1e309");
+        assertThatThrownBy(n::toDouble)
+                .isInstanceOf(JsonAssertionException.class);
+    }
+
     @Test
     void parseExponentFormToBigIntegerExactWorks() {
         LOGGER.info("Executing parseExponentFormToBigIntegerExactWorks");
@@ -75,5 +95,27 @@ void lexicalPreservationDiffersFromNumericNormalization() {
         // but numeric values compare equal when canonicalized explicitly
         assertThat(new BigDecimal(a.toString())).isEqualByComparingTo(new BigDecimal(b.toString()));
     }
+
+    @Test
+    void mappingToNativeTypesUsesPatternMatchingAndExplicitNumberPolicy() {
+        LOGGER.info("Executing mappingToNativeTypesUsesPatternMatchingAndExplicitNumberPolicy");
+
+        JsonValue json = Json.parse("""
+            {
+              "smallInt": 42,
+              "decimal": 5.5
+            }
+            """);
+
+        Object nativeValue = jdk.sandbox.java.util.json.examples.DesignChoicesExamples.toNative(json);
+        assertThat(nativeValue).isInstanceOf(Map.class);
+
+        @SuppressWarnings("unchecked")
+        var map = (Map<String, Object>) nativeValue;
+
+        assertThat(map.get("smallInt")).isEqualTo(42L);
+        assertThat(map.get("decimal")).isInstanceOf(BigDecimal.class);
+        assertThat((BigDecimal) map.get("decimal")).isEqualByComparingTo(new BigDecimal("5.5"));
+    }
 }
 

json-java21/src/test/java/jdk/sandbox/java/util/json/examples/DesignChoicesExamples.java

@@ -1,10 +1,19 @@
 package jdk.sandbox.java.util.json.examples;
 
 import jdk.sandbox.java.util.json.Json;
+import jdk.sandbox.java.util.json.JsonAssertionException;
+import jdk.sandbox.java.util.json.JsonArray;
+import jdk.sandbox.java.util.json.JsonBoolean;
 import jdk.sandbox.java.util.json.JsonNumber;
+import jdk.sandbox.java.util.json.JsonNull;
+import jdk.sandbox.java.util.json.JsonObject;
+import jdk.sandbox.java.util.json.JsonString;
+import jdk.sandbox.java.util.json.JsonValue;
 
 import java.math.BigDecimal;
 import java.math.BigInteger;
+import java.util.Map;
+import java.util.stream.Collectors;
 
 /**
  * Standalone examples demonstrating numeric design choices.
@@ -21,6 +30,8 @@ public static void main(String[] args) {
         parseToBigIntegerExact();
         bigDecimalToJsonNumberChooseTextPolicy();
         lexicalPreservationNotNormalization();
+        counterExamples();
+        mappingToNativeTypesWithPatternMatching();
 
         System.out.println("\n=== All examples completed successfully! ===");
     }
@@ -65,6 +76,78 @@ public static boolean lexicalPreservationNotNormalization() {
         return a.toString().equals(b.toString());
     }
 
+    public static void counterExamples() {
+        System.out.println("Counter-examples");
+        System.out.println("----------------");
+
+        // 1) Converting a non-integral JSON number to long throws.
+        try {
+            var nonIntegral = (JsonNumber) Json.parse("5.5");
+            System.out.println("nonIntegral.toString(): " + nonIntegral);
+            System.out.println("nonIntegral.toLong(): " + nonIntegral.toLong());
+        } catch (JsonAssertionException e) {
+            System.out.println("Expected toLong() failure: " + e.getMessage());
+        }
+
+        // 2) Converting an out-of-range JSON number to double throws.
+        try {
+            var tooBig = (JsonNumber) Json.parse("1e309");
+            System.out.println("tooBig.toString(): " + tooBig);
+            System.out.println("tooBig.toDouble(): " + tooBig.toDouble());
+        } catch (JsonAssertionException e) {
+            System.out.println("Expected toDouble() failure: " + e.getMessage());
+        }
+
+        // 3) Converting to double can be lossy even when it does not throw.
+        var highPrecision = (JsonNumber) Json.parse("3.141592653589793238462643383279");
+        var lossless = new BigDecimal(highPrecision.toString());
+        var lossy = new BigDecimal(Double.toString(highPrecision.toDouble()));
+        System.out.println("lossless (BigDecimal): " + lossless.toPlainString());
+        System.out.println("lossy    (double->BD): " + lossy.toPlainString());
+        System.out.println("lossless equals lossy? " + (lossless.compareTo(lossy) == 0));
+        System.out.println();
+    }
+
+    public static Object toNative(JsonValue v) {
+        return switch (v) {
+            case JsonNull ignored -> null;
+            case JsonBoolean b -> b.bool();
+            case JsonString s -> s.string();
+            case JsonNumber n -> {
+                try {
+                    yield n.toLong();
+                } catch (JsonAssertionException ignored) {
+                    yield new BigDecimal(n.toString());
+                }
+            }
+            case JsonArray a -> a.elements().stream().map(DesignChoicesExamples::toNative).toList();
+            case JsonObject o -> o.members().entrySet().stream()
+                    .collect(Collectors.toMap(Map.Entry::getKey, e -> toNative(e.getValue())));
+        };
+    }
+
+    public static Object mappingToNativeTypesWithPatternMatching() {
+        System.out.println("Mapping to native types (pattern matching)");
+        System.out.println("------------------------------------------");
+
+        JsonValue json = Json.parse("""
+            {
+              "smallInt": 42,
+              "decimal": 5.5,
+              "huge": 3.141592653589793238462643383279,
+              "flag": true,
+              "name": "Ada",
+              "items": [1, 2, 3]
+            }
+            """);
+
+        Object nativeValue = toNative(json);
+        System.out.println("native class: " + nativeValue.getClass().getName());
+        System.out.println("native value: " + nativeValue);
+        System.out.println();
+        return nativeValue;
+    }
+
     private DesignChoicesExamples() {}
 }