Complete JSON text support with core Unicode module (no literal-registered methods)

src/main/cod/demo/src/main/test/json/JsonStandardLibraryComprehensive.cod

@@ -0,0 +1,120 @@
+unit test.json
+
+use {json}
+
+share JsonStandardLibraryComprehensive {
+    share check(label: text, actual: text, expected: text) {
+        if actual == expected {
+            out("PASS " + label)
+            return
+        }
+        out("FAIL " + label)
+        out("  actual:   " + actual)
+        out("  expected: " + expected)
+    }
+
+    share checkBool(label: text, actual: bool, expected: bool) {
+        if actual == expected {
+            out("PASS " + label)
+            return
+        }
+        out("FAIL " + label)
+        out("  actual:   " + actual)
+        out("  expected: " + expected)
+    }
+
+    share main() {
+        out("== json standard library comprehensive ==")
+
+        nullValue := Json.parse("null")
+        JsonStandardLibraryComprehensive.checkBool("parse null", nullValue.isNull(), true)
+
+        trueValue := Json.parse("true")
+        JsonStandardLibraryComprehensive.checkBool("parse true", trueValue.isBool(), true)
+        JsonStandardLibraryComprehensive.checkBool("true value", trueValue.asBool(), true)
+
+        falseValue := Json.parse("false")
+        JsonStandardLibraryComprehensive.checkBool("parse false", falseValue.isBool(), true)
+        JsonStandardLibraryComprehensive.checkBool("false value", falseValue.asBool(), false)
+
+        numberValue := Json.parse("-12.5e+2")
+        JsonStandardLibraryComprehensive.checkBool("parse number kind", numberValue.isNumber(), true)
+        JsonStandardLibraryComprehensive.check("parse number text", numberValue.asNumberText(), "-12.5e+2")
+
+        textValue := Json.parse("\"hello \\\"coderive\\\"\\nline\"")
+        JsonStandardLibraryComprehensive.checkBool("parse text kind", textValue.isText(), true)
+        JsonStandardLibraryComprehensive.check("parse text data", textValue.asText(), "hello \"coderive\"\nline")
+        JsonStandardLibraryComprehensive.check("serialize text", Json.serialize(textValue), "\"hello \\\"coderive\\\"\\nline\"")
+
+        mixedArray := Json.parse("[1, true, null, \"x\", [2,3]]")
+        JsonStandardLibraryComprehensive.checkBool("array kind", mixedArray.isArray(), true)
+        JsonStandardLibraryComprehensive.check("array size", "" + mixedArray.size(), "5")
+        JsonStandardLibraryComprehensive.checkBool("array nested kind", mixedArray.get(4).isArray(), true)
+        JsonStandardLibraryComprehensive.check("array nested value", mixedArray.get(4).get(1).asNumberText(), "3")
+
+        objectValue := Json.parse("{\"name\":\"Coderive\",\"ok\":true,\"n\":10,\"tags\":[\"lang\",\"json\"],\"meta\":{\"major\":0}}")
+        JsonStandardLibraryComprehensive.checkBool("object kind", objectValue.isObject(), true)
+        JsonStandardLibraryComprehensive.checkBool("object has name", objectValue.has("name"), true)
+        JsonStandardLibraryComprehensive.check("object name", objectValue.getKey("name").asText(), "Coderive")
+        JsonStandardLibraryComprehensive.checkBool("object ok", objectValue.getKey("ok").asBool(), true)
+        JsonStandardLibraryComprehensive.check("object nested array value", objectValue.getKey("tags").get(1).asText(), "json")
+        JsonStandardLibraryComprehensive.check("object nested object value", objectValue.getKey("meta").getKey("major").asNumberText(), "0")
+
+        compact := Json.serialize(objectValue)
+        JsonStandardLibraryComprehensive.check("compact serialize", compact, "{\"name\":\"Coderive\",\"ok\":true,\"n\":10,\"tags\":[\"lang\",\"json\"],\"meta\":{\"major\":0}}")
+
+        pretty := Json.serializePretty(objectValue)
+        JsonStandardLibraryComprehensive.checkBool("pretty has new lines", pretty.has("\n"), true)
+        JsonStandardLibraryComprehensive.checkBool("pretty has indentation", pretty.has("  \"name\""), true)
+
+        created := Json.object()
+        created.set("language", Json.text("Coderive"))
+        created.set("stable", Json.bool(false))
+        versions := Json.array()
+        versions.add(Json.numberText("0.9"))
+        versions.add(Json.numberText("1.0"))
+        created.set("versions", versions)
+        JsonStandardLibraryComprehensive.check("constructed serialize", Json.serialize(created), "{\"language\":\"Coderive\",\"stable\":false,\"versions\":[0.9,1.0]}")
+
+        updateObject := Json.object()
+        updateObject.set("x", Json.numberText("1"))
+        updateObject.set("x", Json.numberText("2"))
+        JsonStandardLibraryComprehensive.check("object key update", Json.serialize(updateObject), "{\"x\":2}")
+
+        roundTripSource := " { \"a\" : [ 1 , 2 , {\"b\":false} ] , \"c\" : null } "
+        roundTrip := Json.parse(roundTripSource)
+        JsonStandardLibraryComprehensive.checkBool("round trip parse ok", roundTrip.isError(), false)
+        JsonStandardLibraryComprehensive.check("round trip compact", Json.serialize(roundTrip), "{\"a\":[1,2,{\"b\":false}],\"c\":null}")
+
+        invalid1 := Json.parse("{\"a\":1,}")
+        JsonStandardLibraryComprehensive.checkBool("invalid trailing comma object", invalid1.isError(), true)
+
+        invalid2 := Json.parse("[1,2,]")
+        JsonStandardLibraryComprehensive.checkBool("invalid trailing comma array", invalid2.isError(), true)
+
+        invalid3 := Json.parse("{\"a\" 1}")
+        JsonStandardLibraryComprehensive.checkBool("invalid missing colon", invalid3.isError(), true)
+
+        invalid4 := Json.parse("\"unterminated")
+        JsonStandardLibraryComprehensive.checkBool("invalid unterminated text", invalid4.isError(), true)
+
+        invalid5 := Json.parse("true false")
+        JsonStandardLibraryComprehensive.checkBool("invalid trailing content", invalid5.isError(), true)
+
+        unicodeEscaped := Json.parse("\"\\u0041\"")
+        JsonStandardLibraryComprehensive.check("unicode escape preserved", unicodeEscaped.asText(), "\\u0041")
+        JsonStandardLibraryComprehensive.check("unicode serialize", Json.serialize(unicodeEscaped), "\"\\u0041\"")
+
+        unicodePair := Json.parse("\"\\uD83D\\uDE00\"")
+        JsonStandardLibraryComprehensive.check("unicode surrogate pair preserved", unicodePair.asText(), "\\uD83D\\uDE00")
+        JsonStandardLibraryComprehensive.check("unicode surrogate pair serialize", Json.serialize(unicodePair), "\"\\uD83D\\uDE00\"")
+
+        invalid6 := Json.parse("\"\\uD83Dx\"")
+        JsonStandardLibraryComprehensive.checkBool("invalid missing low surrogate pair", invalid6.isError(), true)
+
+        invalid7 := Json.parse("\"\\uDE00\"")
+        JsonStandardLibraryComprehensive.checkBool("invalid unexpected low surrogate", invalid7.isError(), true)
+
+        out("== done ==")
+    }
+}

src/main/cod/demo/src/main/test/unicode/UnicodeStandardLibraryComprehensive.cod

@@ -0,0 +1,42 @@
+unit test.unicode
+
+use {unicode}
+
+share UnicodeStandardLibraryComprehensive {
+    share check(label: text, actual: text, expected: text) {
+        if actual == expected {
+            out("PASS " + label)
+            return
+        }
+        out("FAIL " + label)
+        out("  actual:   " + actual)
+        out("  expected: " + expected)
+    }
+
+    share checkBool(label: text, actual: bool, expected: bool) {
+        if actual == expected {
+            out("PASS " + label)
+            return
+        }
+        out("FAIL " + label)
+        out("  actual:   " + actual)
+        out("  expected: " + expected)
+    }
+
+    share main() {
+        out("== unicode standard library comprehensive ==")
+
+        UnicodeStandardLibraryComprehensive.check("normalize simple", Unicode.normalizeEscaped("\\u0041"), "\\u0041")
+        UnicodeStandardLibraryComprehensive.check("normalize lowercase", Unicode.normalizeEscaped("\\u03c9"), "\\u03C9")
+        UnicodeStandardLibraryComprehensive.check("normalize surrogate pair", Unicode.normalizeEscaped("\\ud83d\\ude00"), "\\uD83D\\uDE00")
+
+        UnicodeStandardLibraryComprehensive.checkBool("valid empty", Unicode.isValidEscaped(""), true)
+        UnicodeStandardLibraryComprehensive.checkBool("valid basic", Unicode.isValidEscaped("\\u0041"), true)
+        UnicodeStandardLibraryComprehensive.checkBool("valid surrogate", Unicode.isValidEscaped("\\uD83D\\uDE00"), true)
+        UnicodeStandardLibraryComprehensive.checkBool("invalid bad hex", Unicode.isValidEscaped("\\u00G1"), false)
+        UnicodeStandardLibraryComprehensive.checkBool("invalid lone high", Unicode.isValidEscaped("\\uD83D"), false)
+        UnicodeStandardLibraryComprehensive.checkBool("invalid lone low", Unicode.isValidEscaped("\\uDE00"), false)
+
+        out("== done ==")
+    }
+}