[ADDED] Test for sample JSON files

Author: hossain-khan

lib/src/test/kotlin/io/github/json5/kotlin/JSON5ParserTextExampleFiles.kt

@@ -0,0 +1,144 @@
+package io.github.json5.kotlin
+
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+import java.nio.file.Files
+import java.nio.file.Paths
+
+class JSON5ParserTextExampleFiles {
+    @Test
+    fun testParseSimpleObjectJson5() {
+        val path = Paths.get("src/test/resources/simple-object.json5")
+        val json5Text = Files.readString(path)
+        val result = JSON5Parser.parse(json5Text)
+
+        val expected = mapOf(
+            "name" to "John Doe",
+            "age" to 30.0,
+            "isEmployed" to true,
+            "salary" to 75000.50,
+            "address" to mapOf(
+                "street" to "123 Main St",
+                "city" to "New York",
+                "zipCode" to 10001.0
+            )
+        )
+
+        assertEquals(expected, result)
+    }
+
+    @Test
+    fun testParseArrayExampleJson5() {
+        val path = Paths.get("src/test/resources/array-example.json5")
+        val json5Text = Files.readString(path)
+        val result = JSON5Parser.parse(json5Text)
+
+        val expected = listOf(
+            42.0,
+            "Hello World",
+            true,
+            null,
+            mapOf(
+                "name" to "Nested object",
+                "active" to true
+            ),
+            listOf(1.0, 2.0, 3.0),
+            Double.POSITIVE_INFINITY,
+            Double.NEGATIVE_INFINITY,
+            Double.NaN
+        )
+
+        assertEquals(expected.size, (result as List<*>).size)
+        for (i in expected.indices) {
+            val exp = expected[i]
+            val act = result[i]
+            if (exp is Double && exp.isNaN()) {
+                assert((act as Double).isNaN())
+            } else {
+                assertEquals(exp, act)
+            }
+        }
+    }
+
+    @Test
+    fun testParseEmptyJson5() {
+        val path = Paths.get("src/test/resources/empty-json.json5")
+        val json5Text = Files.readString(path)
+        val result = JSON5Parser.parse(json5Text)
+        val expected = emptyMap<String, Any?>()
+        assertEquals(expected, result)
+    }
+
+    @Test
+    fun testParseNumericFormatsJson5() {
+        val path = Paths.get("src/test/resources/numeric-formats.json5")
+        val json5Text = Files.readString(path)
+        val result = JSON5Parser.parse(json5Text)
+        val expected = mapOf(
+            "integer" to 42.0,
+            "negative" to -17.0,
+            "float" to 3.14159,
+            "leadingDecimal" to 0.25,
+            "trailingDecimal" to 5.0,
+            "positiveSign" to 42.0,
+            "hex" to 12648430.0,
+            "smallHex" to 255.0,
+            "negativeHex" to -123.0,
+            "scientific" to 6.02e23,
+            "negativeExp" to 1e-10,
+            "positiveExp" to 1.5e4,
+            "infinite" to Double.POSITIVE_INFINITY,
+            "negativeInfinite" to Double.NEGATIVE_INFINITY,
+            "notANumber" to Double.NaN
+        )
+        assertEquals(expected.size, (result as Map<*, *>).size)
+        for ((k, v) in expected) {
+            val actual = result[k]
+            if (v is Double && v.isNaN()) {
+                assert((actual as Double).isNaN())
+            } else {
+                assertEquals(v, actual)
+            }
+        }
+    }
+
+    @Test
+    fun testParseStringAndIdentifiersJson5() {
+        val path = Paths.get("src/test/resources/string-and-identifiers.json5")
+        val json5Text = Files.readString(path)
+        val result = JSON5Parser.parse(json5Text)
+        val expected = mapOf(
+            "escapes" to """Escaped characters: \b \f \n \r \t \u000B \u0000 \u000F \u00A9""",
+            "quotes" to "He said, \"Hello!\"",
+            "singleQuotes" to "It's working",
+            "multiline" to "This string spans multiple lines",
+            "lineSeparators" to "Line\u2028and\u2029paragraph separators",
+            "\$special_key" to "Dollar sign prefix",
+            "_under_score" to "Underscore prefix",
+            "ùñîçødë" to "Unicode property name",
+            "abc" to "abc via Unicode escapes",
+            "emptyObject" to emptyMap<String, Any?>(),
+            "emptyArray" to emptyList<Any?>(),
+            "indentedProperty" to 42.0
+        )
+        val resultMap = result as Map<*, *>
+        assertEquals(expected.size, resultMap.size)
+        for ((k, v) in expected) {
+            val actual = resultMap[k]
+            if (v is Double && v.isNaN()) {
+                assert((actual as Double).isNaN())
+            } else {
+                assertEquals(v, actual)
+            }
+        }
+    }
+
+    @Test
+    fun testParseRootStringJson5() {
+        val path = Paths.get("src/test/resources/root-string.json5")
+        val json5Text = Files.readString(path)
+        val result = JSON5Parser.parse(json5Text)
+        val expected = "This is a valid root-level string in JSON5"
+        assertEquals(expected, result)
+    }
+}

lib/src/test/resources/array-example.json5

@@ -0,0 +1,17 @@
+[
+  // This is an array with different data types
+  42,
+  "Hello World",
+  true,
+  null,
+  {
+    name: 'Nested object',
+    active: true,
+  },
+  [1, 2, 3], // Nested array
+  Infinity,  // Special numeric values
+  -Infinity,
+  NaN,
+  // Trailing comma is valid in JSON5
+]
+

lib/src/test/resources/empty-json.json5

@@ -0,0 +1 @@
+{}

lib/src/test/resources/numeric-formats.json5

@@ -0,0 +1,31 @@
+{
+  /* Multi-line comment example
+     showing various numeric formats
+     supported by JSON5 */
+
+  // Regular numbers
+  integer: 42,
+  negative: -17,
+  float: 3.14159,
+
+  // Numbers with different formats
+  leadingDecimal: .25,       // Leading decimal point
+  trailingDecimal: 5.,       // Trailing decimal point
+  positiveSign: +42,         // Explicit positive sign
+
+  // Hexadecimal numbers
+  hex: 0xC0FFEE,            // Uppercase hex
+  smallHex: 0xff,           // Lowercase hex
+  negativeHex: -0x7B,       // Negative hex
+
+  // Scientific notation
+  scientific: 6.02e23,      // Regular scientific notation
+  negativeExp: 1e-10,       // Negative exponent
+  positiveExp: 1.5e+4,      // Explicit positive exponent
+
+  // Special numeric values
+  infinite: Infinity,
+  negativeInfinite: -Infinity,
+  notANumber: NaN,
+}
+

lib/src/test/resources/root-string.json5

@@ -0,0 +1,3 @@
+// Root-level values can be strings, numbers, booleans, or null in JSON5
+"This is a valid root-level string in JSON5"
+

lib/src/test/resources/simple-object.json5

@@ -0,0 +1,13 @@
+{
+  // This is a simple object with various types of values
+  name: "John Doe", // Unquoted property name
+  age: 30,
+  isEmployed: true,
+  salary: 75000.50,
+  address: {
+    street: '123 Main St', // Single-quoted string
+    city: "New York",
+    zipCode: 10001
+  }
+}
+

lib/src/test/resources/string-and-identifiers.json5

@@ -0,0 +1,27 @@
+{
+  // String escape sequences
+  escapes: 'Escaped characters: \b \f \n \r \t \v \0 \x0F \u00A9',
+  quotes: "He said, \"Hello!\"",
+  singleQuotes: 'It\'s working',
+  multiline: 'This string \
+spans multiple \
+lines',
+  lineSeparators: 'Line\u2028and\u2029paragraph separators',
+
+  // Special identifiers as keys
+  $special_key: "Dollar sign prefix",
+  _under_score: "Underscore prefix",
+  ùñîçødë: "Unicode property name",
+
+  // Escaped property names
+  \u0061\u0062\u0063: "abc via Unicode escapes",
+
+  // Empty object and arrays
+  emptyObject: {},
+  emptyArray: [],
+
+  // Indentation and whitespace
+		indentedProperty:     42,
+
+  // Root value example shown in another file
+}