.github/workflows/codeql-analysis.yml

@@ -29,7 +29,7 @@ jobs:
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v3
+      uses: github/codeql-action/init@v2
       with:
         languages: ${{ matrix.language }}
         # If you wish to specify custom queries, you can do so here or in a config file.
@@ -40,4 +40,4 @@ jobs:
     - run: "mvn clean compile -Dmaven.test.skip=true -Dmaven.site.skip=true -Dmaven.javadoc.skip=true"
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v3
+      uses: github/codeql-action/analyze@v2

.github/workflows/deployment.yml

@@ -0,0 +1,82 @@
+# For more information see:
+#  * https://docs.github.com/en/actions/learn-github-actions
+#  * https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions
+#  * https://github.com/actions/setup-java/blob/v3.13.0/docs/advanced-usage.md#Publishing-using-Apache-Maven
+#
+
+name: Deployment workflow
+
+on:
+    release:
+      types: [published]
+  
+jobs:
+  # old-school build and jar method. No tests run or compiled.
+  publish-1_6: 
+    name: Publish Java 1.6 to GitHub Release
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup java
+        uses: actions/setup-java@v1
+        with:
+          java-version: 1.6
+      - name: Compile Java 1.6
+        run: |
+          mkdir -p target/classes
+          javac -version
+          javac -source 1.6 -target 1.6 -d target/classes/ src/main/java/org/json/*.java
+      - name: Create JAR 1.6
+        run: |
+          jar cvf "target/org.json-1.6-${{ github.ref_name }}.jar" -C target/classes .
+      - name: Add 1.6 Jar To Release
+        uses: softprops/action-gh-release@v1
+        with:
+          append_body: true
+          files: |
+            target/*.jar
+  publish:
+    name: Publish Java 8 to Maven Central and GitHub Release
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      packages: write
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Java for publishing to Maven Central Repository
+        uses: actions/setup-java@v3
+        with:
+          # Use lowest supported LTS Java version
+          java-version: '8'
+          distribution: 'temurin'
+          server-id: ossrh  # Value of the distributionManagement/repository/id field of the pom.xml
+          server-username: MAVEN_USERNAME # env variable for username in deploy
+          server-password: MAVEN_PASSWORD # env variable for token in deploy
+          gpg-private-key: ${{ secrets.MAVEN_GPG_PRIVATE_KEY }} # Value of the GPG private key to import
+          gpg-passphrase: MAVEN_GPG_PASSPHRASE # env variable for GPG private key passphrase
+  
+      - name: Publish to the Maven Central Repository
+        run: mvn --batch-mode deploy
+        env:
+          MAVEN_USERNAME: ${{ secrets.OSSRH_USERNAME }}
+          MAVEN_PASSWORD: ${{ secrets.OSSRH_TOKEN }}
+          MAVEN_GPG_PASSPHRASE: ${{ secrets.MAVEN_GPG_PASSPHRASE }}
+          
+      - name: Add Jar To Release
+        uses: softprops/action-gh-release@v1
+        with:
+          append_body: true
+          files: |
+            target/*.jar
+      # - name: Set up Java for publishing to GitHub Packages
+      #   uses: actions/setup-java@v3
+      #   with:
+      #     # Use lowest supported LTS Java version
+      #     java-version: '8'
+      #     distribution: 'temurin'
+      # - name: Publish to GitHub Packages
+      #   run: mvn --batch-mode deploy
+      #   env:
+      #     GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/pipeline.yml

@@ -30,19 +30,18 @@ jobs:
           jar cvf target/org.json.jar -C target/classes .
       - name: Upload JAR 1.6
         if: ${{ always() }}
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: Create java 1.6 JAR
           path: target/*.jar
-
+  build:
-  build-8:
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false
-      max-parallel: 1
+      max-parallel: 2
       matrix:
         # build against supported Java LTS versions:
-        java: [ 8 ]
+        java: [ 8, 11, 17, 21 ]
     name: Java ${{ matrix.java }}
     steps:
       - uses: actions/checkout@v3
@@ -64,13 +63,13 @@ jobs:
           mvn site -D generateReports=false -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }}
       - name: Upload Test Results ${{ matrix.java }}
         if: ${{ always() }}
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: Test Results ${{ matrix.java }}
           path: target/surefire-reports/
       - name: Upload Test Report ${{ matrix.java }}
         if: ${{ always() }}
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: Test Report ${{ matrix.java }}
           path: target/site/
@@ -78,151 +77,7 @@ jobs:
         run: mvn clean package -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }} -D maven.test.skip=true -D maven.site.skip=true
       - name: Upload Package Results ${{ matrix.java }}
         if: ${{ always() }}
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
-        with:
-          name: Package Jar ${{ matrix.java }}
-          path: target/*.jar
-
-  build-11:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      max-parallel: 1
-      matrix:
-        # build against supported Java LTS versions:
-        java: [ 11 ]
-    name: Java ${{ matrix.java }}
-    steps:
-      - uses: actions/checkout@v3
-      - name: Set up JDK ${{ matrix.java }}
-        uses: actions/setup-java@v3
-        with:
-          distribution: 'temurin'
-          java-version: ${{ matrix.java }}
-          cache: 'maven'
-      - name: Compile Java ${{ matrix.java }}
-        run: mvn clean compile -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }} -D maven.test.skip=true -D maven.site.skip=true -D maven.javadoc.skip=true
-      - name: Run Tests ${{ matrix.java }}
-        run: |
-          mvn test -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }}
-      - name: Build Test Report ${{ matrix.java }}
-        if: ${{ always() }}
-        run: |
-          mvn surefire-report:report-only -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }}
-          mvn site -D generateReports=false -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }}
-      - name: Upload Test Results ${{ matrix.java }}
-        if: ${{ always() }}
-        uses: actions/upload-artifact@v4
-        with:
-          name: Test Results ${{ matrix.java }}
-          path: target/surefire-reports/
-      - name: Upload Test Report ${{ matrix.java }}
-        if: ${{ always() }}
-        uses: actions/upload-artifact@v4
-        with:
-          name: Test Report ${{ matrix.java }}
-          path: target/site/
-      - name: Package Jar ${{ matrix.java }}
-        run: mvn clean package -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }} -D maven.test.skip=true -D maven.site.skip=true
-      - name: Upload Package Results ${{ matrix.java }}
-        if: ${{ always() }}
-        uses: actions/upload-artifact@v4
-        with:
-          name: Package Jar ${{ matrix.java }}
-          path: target/*.jar
-
-  build-17:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      max-parallel: 1
-      matrix:
-        # build against supported Java LTS versions:
-        java: [ 17 ]
-    name: Java ${{ matrix.java }}
-    steps:
-      - uses: actions/checkout@v3
-      - name: Set up JDK ${{ matrix.java }}
-        uses: actions/setup-java@v3
-        with:
-          distribution: 'temurin'
-          java-version: ${{ matrix.java }}
-          cache: 'maven'
-      - name: Compile Java ${{ matrix.java }}
-        run: mvn clean compile -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }} -D maven.test.skip=true -D maven.site.skip=true -D maven.javadoc.skip=true
-      - name: Run Tests ${{ matrix.java }}
-        run: |
-          mvn test -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }}
-      - name: Build Test Report ${{ matrix.java }}
-        if: ${{ always() }}
-        run: |
-          mvn surefire-report:report-only -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }}
-          mvn site -D generateReports=false -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }}
-      - name: Upload Test Results ${{ matrix.java }}
-        if: ${{ always() }}
-        uses: actions/upload-artifact@v4
-        with:
-          name: Test Results ${{ matrix.java }}
-          path: target/surefire-reports/
-      - name: Upload Test Report ${{ matrix.java }}
-        if: ${{ always() }}
-        uses: actions/upload-artifact@v4
-        with:
-          name: Test Report ${{ matrix.java }}
-          path: target/site/
-      - name: Package Jar ${{ matrix.java }}
-        run: mvn clean package -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }} -D maven.test.skip=true -D maven.site.skip=true
-      - name: Upload Package Results ${{ matrix.java }}
-        if: ${{ always() }}
-        uses: actions/upload-artifact@v4
-        with:
-          name: Package Jar ${{ matrix.java }}
-          path: target/*.jar
-
-  build-21:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      max-parallel: 1
-      matrix:
-        # build against supported Java LTS versions:
-        java: [ 21 ]
-    name: Java ${{ matrix.java }}
-    steps:
-      - uses: actions/checkout@v3
-      - name: Set up JDK ${{ matrix.java }}
-        uses: actions/setup-java@v3
-        with:
-          distribution: 'temurin'
-          java-version: ${{ matrix.java }}
-          cache: 'maven'
-      - name: Compile Java ${{ matrix.java }}
-        run: mvn clean compile -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }} -D maven.test.skip=true -D maven.site.skip=true -D maven.javadoc.skip=true
-      - name: Run Tests ${{ matrix.java }}
-        run: |
-          mvn test -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }}
-      - name: Build Test Report ${{ matrix.java }}
-        if: ${{ always() }}
-        run: |
-          mvn surefire-report:report-only -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }}
-          mvn site -D generateReports=false -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }}
-      - name: Upload Test Results ${{ matrix.java }}
-        if: ${{ always() }}
-        uses: actions/upload-artifact@v4
-        with:
-          name: Test Results ${{ matrix.java }}
-          path: target/surefire-reports/
-      - name: Upload Test Report ${{ matrix.java }}
-        if: ${{ always() }}
-        uses: actions/upload-artifact@v4
-        with:
-          name: Test Report ${{ matrix.java }}
-          path: target/site/
-      - name: Package Jar ${{ matrix.java }}
-        run: mvn clean package -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }} -D maven.test.skip=true -D maven.site.skip=true
-      - name: Upload Package Results ${{ matrix.java }}
-        if: ${{ always() }}
-        uses: actions/upload-artifact@v4
         with:
           name: Package Jar ${{ matrix.java }}
           path: target/*.jar

README.md

@@ -10,7 +10,7 @@ JSON in Java [package org.json]
 [![Java CI with Maven](https://github.com/stleary/JSON-java/actions/workflows/pipeline.yml/badge.svg)](https://github.com/stleary/JSON-java/actions/workflows/pipeline.yml)
 [![CodeQL](https://github.com/stleary/JSON-java/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/stleary/JSON-java/actions/workflows/codeql-analysis.yml)
 
-**[Click here if you just want the latest release jar file.](https://search.maven.org/remotecontent?filepath=org/json/json/20250517/json-20250517.jar)**
+**[Click here if you just want the latest release jar file.](https://search.maven.org/remotecontent?filepath=org/json/json/20240205/json-20240205.jar)**
 
 
 # Overview
@@ -97,18 +97,6 @@ Execute the test suite with Gradlew:
 gradlew clean build test
 ```
 
-*Optional* Execute the test suite in strict mode with Gradlew:
-
-```shell
-gradlew testWithStrictMode
-```
-
-*Optional* Execute the test suite in strict mode with Maven:
-
-```shell
-mvn test -P test-strict-mode 
-```
-
 # Notes
 
 For more information, please see [NOTES.md](https://github.com/stleary/JSON-java/blob/master/docs/NOTES.md)

build.gradle

@@ -3,10 +3,9 @@
  */
 apply plugin: 'java'
 apply plugin: 'eclipse'
-apply plugin: 'jacoco'
+// apply plugin: 'jacoco'
 apply plugin: 'maven-publish'
 
-// for now, publishing to maven is still a manual process
 //plugins {
     // id 'java'
     //id 'maven-publish'
@@ -20,20 +19,9 @@ repositories {
     }
 }
 
-// To view the report open build/reports/jacoco/test/html/index.html
-jacocoTestReport {
-    reports {
-        html.required = true
-    }
-}
-
-test {
-    finalizedBy jacocoTestReport
-}
-
 dependencies {
     testImplementation 'junit:junit:4.13.2'
-    testImplementation 'com.jayway.jsonpath:json-path:2.9.0'
+    testImplementation 'com.jayway.jsonpath:json-path:2.4.0'
     testImplementation 'org.mockito:mockito-core:4.2.0'
 }
 
@@ -42,7 +30,7 @@ subprojects {
 }
 
 group = 'org.json'
-version = 'v20250517-SNAPSHOT'
+version = 'v20230618-SNAPSHOT'
 description = 'JSON in Java'
 sourceCompatibility = '1.8'
 
@@ -65,75 +53,3 @@ publishing {
 tasks.withType(JavaCompile) {
     options.encoding = 'UTF-8'
 }
-// Add these imports at the top of your build.gradle file
-import java.nio.file.Files
-import java.nio.file.Path
-import java.nio.file.Paths
-import java.nio.file.StandardCopyOption
-
-// Your existing build configurations...
-
-// Add a new task to modify the file
-task modifyStrictMode {
-    doLast {
-        println "Modifying JSONParserConfiguration.java to enable strictMode..."
-
-        def filePath = project.file('src/main/java/org/json/JSONParserConfiguration.java')
-
-        if (!filePath.exists()) {
-            throw new GradleException("Could not find file: ${filePath.absolutePath}")
-        }
-
-        // Create a backup of the original file
-        def backupFile = new File(filePath.absolutePath + '.bak')
-        Files.copy(filePath.toPath(), backupFile.toPath(), StandardCopyOption.REPLACE_EXISTING)
-
-        // Read and modify the file content
-        def content = filePath.text
-        def modifiedContent = content.replace('// this.strictMode = true;', 'this.strictMode = true;')
-
-        // Write the modified content back to the file
-        filePath.text = modifiedContent
-
-        println "File modified successfully at: ${filePath.absolutePath}"
-    }
-}
-
-// Add a task to restore the original file
-task restoreStrictMode {
-    doLast {
-        println "Restoring original JSONParserConfiguration.java..."
-
-        def filePath = project.file('src/main/java/org/json/JSONParserConfiguration.java')
-        def backupFile = new File(filePath.absolutePath + '.bak')
-
-        if (backupFile.exists()) {
-            Files.copy(backupFile.toPath(), filePath.toPath(), StandardCopyOption.REPLACE_EXISTING)
-            backupFile.delete()
-            println "Original file restored successfully at: ${filePath.absolutePath}"
-        } else {
-            println "Backup file not found at: ${backupFile.absolutePath}. No restoration performed."
-        }
-    }
-}
-
-// Create a task to run the workflow
-task testWithStrictMode {
-    dependsOn modifyStrictMode
-    finalizedBy restoreStrictMode
-
-    doLast {
-        // This will trigger a clean build and run tests with strictMode enabled
-        if (org.gradle.internal.os.OperatingSystem.current().isWindows()) {
-            exec {
-                executable 'cmd'
-                args '/c', 'gradlew.bat', 'clean', 'build'
-            }
-        } else {
-            exec {
-                executable './gradlew'
-                args 'clean', 'build'
-            }
-        }
-    }
-}

docs/RELEASES.md

@@ -5,15 +5,6 @@ and artifactId "json". For example:
 [https://search.maven.org/search?q=g:org.json%20AND%20a:json&core=gav](https://search.maven.org/search?q=g:org.json%20AND%20a:json&core=gav)
 
 ~~~
-20250517    Strict mode hardening and recent commits
-
-20250107    Restore moditect in pom.xml
-
-20241224    Strict mode opt-in feature, and recent commits. This release does not contain module-info.class.
-It is not recommended if you need this feature.
-
-20240303    Revert optLong/getLong changes, and recent commits.
-
 20240205    Recent commits.
 
 20231013    First release with minimum Java version 1.8. Recent commits, including fixes for CVE-2023-5072.

pom.xml

@@ -3,7 +3,7 @@
 
     <groupId>org.json</groupId>
     <artifactId>json</artifactId>
-    <version>20250517</version>
+    <version>20240205</version>
     <packaging>bundle</packaging>
 
     <name>JSON in Java</name>
@@ -70,7 +70,7 @@
         <dependency>
             <groupId>com.jayway.jsonpath</groupId>
             <artifactId>json-path</artifactId>
-            <version>2.9.0</version>
+            <version>2.4.0</version>
             <scope>test</scope>
         </dependency>
         <dependency>
@@ -200,55 +200,4 @@
             </plugin>
         </plugins>
     </build>
-    <profiles>
-        <profile>
-            <id>test-strict-mode</id>
-            <build>
-                <plugins>
-                    <plugin>
-                        <groupId>com.google.code.maven-replacer-plugin</groupId>
-                        <artifactId>replacer</artifactId>
-                        <version>1.5.3</version>
-                        <executions>
-                            <!-- Enable strict mode -->
-                            <execution>
-                                <id>enable-strict-mode</id>
-                                <phase>process-sources</phase>
-                                <goals>
-                                    <goal>replace</goal>
-                                </goals>
-                                <configuration>
-                                    <file>src/main/java/org/json/JSONParserConfiguration.java</file>
-                                    <replacements>
-                                        <replacement>
-                                            <token>// this.strictMode = true;</token>
-                                            <value>this.strictMode = true;</value>
-                                        </replacement>
-                                    </replacements>
-                                </configuration>
-                            </execution>
-                            <!-- Restore original code after tests -->
-                            <execution>
-                                <id>restore-original</id>
-                                <phase>test</phase>
-                                <goals>
-                                    <goal>replace</goal>
-                                </goals>
-                                <configuration>
-                                    <file>src/main/java/org/json/JSONParserConfiguration.java</file>
-                                    <replacements>
-                                        <replacement>
-                                            <token>this.strictMode = true;</token>
-                                            <value>// this.strictMode = true;</value>
-                                        </replacement>
-                                    </replacements>
-                                </configuration>
-                            </execution>
-                        </executions>
-                    </plugin>
-                </plugins>
-            </build>
-        </profile>
-    </profiles>
-
 </project>

src/main/java/org/json/CDL.java

@@ -5,15 +5,15 @@ Public Domain.
  */
 
 /**
- * This provides static methods to convert comma (or otherwise) delimited text into a
+ * This provides static methods to convert comma delimited text into a
- * JSONArray, and to convert a JSONArray into comma (or otherwise) delimited text. Comma
+ * JSONArray, and to convert a JSONArray into comma delimited text. Comma
  * delimited text is a very popular format for data interchange. It is
  * understood by most database, spreadsheet, and organizer programs.
  * <p>
  * Each row of text represents a row in a table or a data record. Each row
  * ends with a NEWLINE character. Each row contains one or more values.
  * Values are separated by commas. A value can contain any character except
- * for comma, unless it is wrapped in single quotes or double quotes.
+ * for comma, unless is is wrapped in single quotes or double quotes.
  * <p>
  * The first row usually contains the names of the columns.
  * <p>
@@ -25,30 +25,25 @@ Public Domain.
  */
 public class CDL {
 
-    /**
-     * Constructs a new CDL object.
-     */
-    public CDL() {
-    }
-
     /**
      * Get the next value. The value can be wrapped in quotes. The value can
      * be empty.
      * @param x A JSONTokener of the source text.
-     * @param delimiter used in the file
      * @return The value string, or null if empty.
      * @throws JSONException if the quoted string is badly formed.
      */
-    private static String getValue(JSONTokener x, char delimiter) throws JSONException {
+    private static String getValue(JSONTokener x) throws JSONException {
         char c;
         char q;
         StringBuilder sb;
         do {
             c = x.next();
         } while (c == ' ' || c == '\t');
-        if (c == 0) {
+        switch (c) {
+        case 0:
             return null;
-        } else if (c == '"' || c == '\'') {
+        case '"':
+        case '\'':
             q = c;
             sb = new StringBuilder();
             for (;;) {
@@ -56,9 +51,9 @@ public class CDL {
                 if (c == q) {
                     //Handle escaped double-quote
                     char nextC = x.next();
-                    if (nextC != '\"') {
+                    if(nextC != '\"') {
                         // if our quote was the end of the file, don't step
-                        if (nextC > 0) {
+                        if(nextC > 0) {
                             x.back();
                         }
                         break;
@@ -70,12 +65,13 @@ public class CDL {
                 sb.append(c);
             }
             return sb.toString();
-        } else if (c == delimiter) {
+        case ',':
             x.back();
             return "";
-        }
+        default:
             x.back();
-        return x.nextTo(delimiter);
+            return x.nextTo(',');
+        }
     }
 
     /**
@@ -85,32 +81,17 @@ public class CDL {
      * @throws JSONException if a called function fails
      */
     public static JSONArray rowToJSONArray(JSONTokener x) throws JSONException {
-        return rowToJSONArray(x, ',');
-    }
-
-    /**
-     * Produce a JSONArray of strings from a row of comma delimited values.
-     * @param x A JSONTokener of the source text.
-     * @param delimiter custom delimiter char
-     * @return A JSONArray of strings.
-     * @throws JSONException if a called function fails
-     */
-    public static JSONArray rowToJSONArray(JSONTokener x, char delimiter) throws JSONException {
         JSONArray ja = new JSONArray();
         for (;;) {
-            String value = getValue(x,delimiter);
+            String value = getValue(x);
             char c = x.next();
-            if (value != null) {
+            if (value == null ||
-                ja.put(value);
+                    (ja.length() == 0 && value.length() == 0 && c != ',')) {
-            } else if (ja.length() == 0 && c != delimiter) {
                 return null;
-            } else {
-                // This line accounts for CSV ending with no newline
-                ja.put("");
             }
-
+            ja.put(value);
             for (;;) {
-                if (c == delimiter) {
+                if (c == ',') {
                     break;
                 }
                 if (c != ' ') {
@@ -135,23 +116,9 @@ public class CDL {
      * @return A JSONObject combining the names and values.
      * @throws JSONException if a called function fails
      */
-    public static JSONObject rowToJSONObject(JSONArray names, JSONTokener x) throws JSONException {
+    public static JSONObject rowToJSONObject(JSONArray names, JSONTokener x)
-        return rowToJSONObject(names, x, ',');
+            throws JSONException {
-    }
+        JSONArray ja = rowToJSONArray(x);
-
-    /**
-     * Produce a JSONObject from a row of comma delimited text, using a
-     * parallel JSONArray of strings to provides the names of the elements.
-     * @param names A JSONArray of names. This is commonly obtained from the
-     *  first row of a comma delimited text file using the rowToJSONArray
-     *  method.
-     * @param x A JSONTokener of the source text.
-     * @param delimiter custom delimiter char
-     * @return A JSONObject combining the names and values.
-     * @throws JSONException if a called function fails
-     */
-    public static JSONObject rowToJSONObject(JSONArray names, JSONTokener x, char delimiter) throws JSONException {
-        JSONArray ja = rowToJSONArray(x, delimiter);
         return ja != null ? ja.toJSONObject(names) :  null;
     }
 
@@ -163,27 +130,15 @@ public class CDL {
      * @return A string ending in NEWLINE.
      */
     public static String rowToString(JSONArray ja) {
-        return rowToString(ja, ',');
-    }
-
-    /**
-     * Produce a comma delimited text row from a JSONArray. Values containing
-     * the comma character will be quoted. Troublesome characters may be
-     * removed.
-     * @param ja A JSONArray of strings.
-     * @param delimiter custom delimiter char
-     * @return A string ending in NEWLINE.
-     */
-    public static String rowToString(JSONArray ja, char delimiter) {
         StringBuilder sb = new StringBuilder();
         for (int i = 0; i < ja.length(); i += 1) {
             if (i > 0) {
-                sb.append(delimiter);
+                sb.append(',');
             }
             Object object = ja.opt(i);
             if (object != null) {
                 String string = object.toString();
-                if (string.length() > 0 && (string.indexOf(delimiter) >= 0 ||
+                if (string.length() > 0 && (string.indexOf(',') >= 0 ||
                         string.indexOf('\n') >= 0 || string.indexOf('\r') >= 0 ||
                         string.indexOf(0) >= 0 || string.charAt(0) == '"')) {
                     sb.append('"');
@@ -212,19 +167,7 @@ public class CDL {
      * @throws JSONException if a called function fails
      */
     public static JSONArray toJSONArray(String string) throws JSONException {
-        return toJSONArray(string, ',');
+        return toJSONArray(new JSONTokener(string));
-    }
-
-    /**
-     * Produce a JSONArray of JSONObjects from a comma delimited text string,
-     * using the first row as a source of names.
-     * @param string The comma delimited text.
-     * @param delimiter custom delimiter char
-     * @return A JSONArray of JSONObjects.
-     * @throws JSONException if a called function fails
-     */
-    public static JSONArray toJSONArray(String string, char delimiter) throws JSONException {
-        return toJSONArray(new JSONTokener(string), delimiter);
     }
 
     /**
@@ -235,19 +178,7 @@ public class CDL {
      * @throws JSONException if a called function fails
      */
     public static JSONArray toJSONArray(JSONTokener x) throws JSONException {
-        return toJSONArray(x, ',');
+        return toJSONArray(rowToJSONArray(x), x);
-    }
-
-    /**
-     * Produce a JSONArray of JSONObjects from a comma delimited text string,
-     * using the first row as a source of names.
-     * @param x The JSONTokener containing the comma delimited text.
-     * @param delimiter custom delimiter char
-     * @return A JSONArray of JSONObjects.
-     * @throws JSONException if a called function fails
-     */
-    public static JSONArray toJSONArray(JSONTokener x, char delimiter) throws JSONException {
-        return toJSONArray(rowToJSONArray(x, delimiter), x, delimiter);
     }
 
     /**
@@ -258,21 +189,9 @@ public class CDL {
      * @return A JSONArray of JSONObjects.
      * @throws JSONException if a called function fails
      */
-    public static JSONArray toJSONArray(JSONArray names, String string) throws JSONException {
+    public static JSONArray toJSONArray(JSONArray names, String string)
-        return toJSONArray(names, string, ',');
+            throws JSONException {
-    }
+        return toJSONArray(names, new JSONTokener(string));
-
-    /**
-     * Produce a JSONArray of JSONObjects from a comma delimited text string
-     * using a supplied JSONArray as the source of element names.
-     * @param names A JSONArray of strings.
-     * @param string The comma delimited text.
-     * @param delimiter custom delimiter char
-     * @return A JSONArray of JSONObjects.
-     * @throws JSONException if a called function fails
-     */
-    public static JSONArray toJSONArray(JSONArray names, String string, char delimiter) throws JSONException {
-        return toJSONArray(names, new JSONTokener(string), delimiter);
     }
 
     /**
@@ -283,26 +202,14 @@ public class CDL {
      * @return A JSONArray of JSONObjects.
      * @throws JSONException if a called function fails
      */
-    public static JSONArray toJSONArray(JSONArray names, JSONTokener x) throws JSONException {
+    public static JSONArray toJSONArray(JSONArray names, JSONTokener x)
-        return toJSONArray(names, x, ',');
+            throws JSONException {
-    }
-
-    /**
-     * Produce a JSONArray of JSONObjects from a comma delimited text string
-     * using a supplied JSONArray as the source of element names.
-     * @param names A JSONArray of strings.
-     * @param x A JSONTokener of the source text.
-     * @param delimiter custom delimiter char
-     * @return A JSONArray of JSONObjects.
-     * @throws JSONException if a called function fails
-     */
-    public static JSONArray toJSONArray(JSONArray names, JSONTokener x, char delimiter) throws JSONException {
         if (names == null || names.length() == 0) {
             return null;
         }
         JSONArray ja = new JSONArray();
         for (;;) {
-            JSONObject jo = rowToJSONObject(names, x, delimiter);
+            JSONObject jo = rowToJSONObject(names, x);
             if (jo == null) {
                 break;
             }
@@ -311,17 +218,6 @@ public class CDL {
         if (ja.length() == 0) {
             return null;
         }
-
-        // The following block accounts for empty datasets (no keys or vals)
-        if (ja.length() == 1) {
-            JSONObject j = ja.getJSONObject(0);
-            if (j.length() == 1) {
-                String key = j.keys().next();
-                if ("".equals(key) && "".equals(j.get(key))) {
-                    return null;
-                }
-            }
-        }
         return ja;
     }
 
@@ -335,24 +231,11 @@ public class CDL {
      * @throws JSONException if a called function fails
      */
     public static String toString(JSONArray ja) throws JSONException {
-        return toString(ja, ',');
-    }
-
-    /**
-     * Produce a comma delimited text from a JSONArray of JSONObjects. The
-     * first row will be a list of names obtained by inspecting the first
-     * JSONObject.
-     * @param ja A JSONArray of JSONObjects.
-     * @param delimiter custom delimiter char
-     * @return A comma delimited text.
-     * @throws JSONException if a called function fails
-     */
-    public static String toString(JSONArray ja, char delimiter) throws JSONException {
         JSONObject jo = ja.optJSONObject(0);
         if (jo != null) {
             JSONArray names = jo.names();
             if (names != null) {
-                return rowToString(names, delimiter) + toString(names, ja, delimiter);
+                return rowToString(names) + toString(names, ja);
             }
         }
         return null;
@@ -367,21 +250,8 @@ public class CDL {
      * @return A comma delimited text.
      * @throws JSONException if a called function fails
      */
-    public static String toString(JSONArray names, JSONArray ja) throws JSONException {
+    public static String toString(JSONArray names, JSONArray ja)
-        return toString(names, ja, ',');
+            throws JSONException {
-    }
-
-    /**
-     * Produce a comma delimited text from a JSONArray of JSONObjects using
-     * a provided list of names. The list of names is not included in the
-     * output.
-     * @param names A JSONArray of strings.
-     * @param ja A JSONArray of JSONObjects.
-     * @param delimiter custom delimiter char
-     * @return A comma delimited text.
-     * @throws JSONException if a called function fails
-     */
-    public static String toString(JSONArray names, JSONArray ja, char delimiter) throws JSONException {
         if (names == null || names.length() == 0) {
             return null;
         }
@@ -389,7 +259,7 @@ public class CDL {
         for (int i = 0; i < ja.length(); i += 1) {
             JSONObject jo = ja.optJSONObject(i);
             if (jo != null) {
-                sb.append(rowToString(jo.toJSONArray(names), delimiter));
+                sb.append(rowToString(jo.toJSONArray(names)));
             }
         }
         return sb.toString();

src/main/java/org/json/Cookie.java

@@ -15,12 +15,6 @@ Public Domain.
  */
 public class Cookie {
 
-    /**
-     * Constructs a new Cookie object.
-     */
-    public Cookie() {
-    }
-
     /**
      * Produce a copy of a string in which the characters '+', '%', '=', ';'
      * and control characters are replaced with "%hh". This is a gentle form

src/main/java/org/json/CookieList.java

@@ -11,12 +11,6 @@ Public Domain.
  */
 public class CookieList {
 
-    /**
-     * Constructs a new CookieList object.
-     */
-    public CookieList() {
-    }
- 
     /**
      * Convert a cookie list into a JSONObject. A cookie list is a sequence
      * of name/value pairs. The names are separated from the values by '='.

src/main/java/org/json/HTTP.java

@@ -13,12 +13,6 @@ import java.util.Locale;
  */
 public class HTTP {
 
-    /**
-     * Constructs a new HTTP object.
-     */
-    public HTTP() {
-    }
-
     /** Carriage return/line feed. */
     public static final String CRLF = "\r\n";
 

src/main/java/org/json/JSONArray.java

@@ -5,6 +5,7 @@ Public Domain.
  */
 
 import java.io.IOException;
+import java.io.StringWriter;
 import java.io.Writer;
 import java.lang.reflect.Array;
 import java.math.BigDecimal;
@@ -83,20 +84,7 @@ public class JSONArray implements Iterable<Object> {
      *             If there is a syntax error.
      */
     public JSONArray(JSONTokener x) throws JSONException {
-        this(x, x.getJsonParserConfiguration());
-    }
-
-    /**
-     * Constructs a JSONArray from a JSONTokener and a JSONParserConfiguration.
-     *
-     * @param x                       A JSONTokener instance from which the JSONArray is constructed.
-     * @param jsonParserConfiguration A JSONParserConfiguration instance that controls the behavior of the parser.
-     * @throws JSONException If a syntax error occurs during the construction of the JSONArray.
-     */
-    public JSONArray(JSONTokener x, JSONParserConfiguration jsonParserConfiguration) throws JSONException {
         this();
-
-        boolean isInitial = x.getPrevious() == 0;
         if (x.nextClean() != '[') {
             throw x.syntaxError("A JSONArray text must start with '['");
         }
@@ -127,35 +115,16 @@ public class JSONArray implements Iterable<Object> {
                         throw x.syntaxError("Expected a ',' or ']'");
                     }
                     if (nextChar == ']') {
-                        // trailing commas are not allowed in strict mode
-                        if (jsonParserConfiguration.isStrictMode()) {
-                            throw x.syntaxError("Strict mode error: Expected another array element");
-                        }
-                        return;
-                    }
-                    if (nextChar == ',') {
-                        // consecutive commas are not allowed in strict mode
-                        if (jsonParserConfiguration.isStrictMode()) {
-                            throw x.syntaxError("Strict mode error: Expected a valid array element");
-                        }
                         return;
                     }
                     x.back();
                     break;
                 case ']':
-                    if (isInitial && jsonParserConfiguration.isStrictMode() &&
-                            x.nextClean() != 0) {
-                        throw x.syntaxError("Strict mode error: Unparsed characters found at end of input text");
-                    }
                     return;
                 default:
                     throw x.syntaxError("Expected a ',' or ']'");
                 }
             }
-        } else {
-            if (isInitial && jsonParserConfiguration.isStrictMode() && x.nextClean() != 0) {
-                throw x.syntaxError("Strict mode error: Unparsed characters found at end of input text");
-            }
         }
     }
 
@@ -170,22 +139,7 @@ public class JSONArray implements Iterable<Object> {
      *             If there is a syntax error.
      */
     public JSONArray(String source) throws JSONException {
-        this(source, new JSONParserConfiguration());
+        this(new JSONTokener(source));
-    }
-
-    /**
-     * Construct a JSONArray from a source JSON text.
-     *
-     * @param source
-     *            A string that begins with <code>[</code>&nbsp;<small>(left
-     *            bracket)</small> and ends with <code>]</code>
-     *            &nbsp;<small>(right bracket)</small>.
-     * @param jsonParserConfiguration the parser config object
-     * @throws JSONException
-     *             If there is a syntax error.
-     */
-    public JSONArray(String source, JSONParserConfiguration jsonParserConfiguration) throws JSONException {
-        this(new JSONTokener(source, jsonParserConfiguration), jsonParserConfiguration);
     }
 
     /**
@@ -334,11 +288,13 @@ public class JSONArray implements Iterable<Object> {
      */
     public boolean getBoolean(int index) throws JSONException {
         Object object = this.get(index);
-        if (Boolean.FALSE.equals(object)
+        if (object.equals(Boolean.FALSE)
-                || (object instanceof String && "false".equalsIgnoreCase((String) object))) {
+                || (object instanceof String && ((String) object)
+                        .equalsIgnoreCase("false"))) {
             return false;
-        } else if (Boolean.TRUE.equals(object)
+        } else if (object.equals(Boolean.TRUE)
-                || (object instanceof String && "true".equalsIgnoreCase((String) object))) {
+                || (object instanceof String && ((String) object)
+                        .equalsIgnoreCase("true"))) {
             return true;
         }
         throw wrongValueFormatException(index, "boolean", object, null);
@@ -404,7 +360,7 @@ public class JSONArray implements Iterable<Object> {
             if (object instanceof Number) {
                 return (Number)object;
             }
-            return JSONObject.stringToNumber(object.toString());
+            return NumberConversionUtil.stringToNumber(object.toString());
         } catch (Exception e) {
             throw wrongValueFormatException(index, "number", object, e);
         }
@@ -1151,7 +1107,7 @@ public class JSONArray implements Iterable<Object> {
         
         if (val instanceof String) {
             try {
-                return JSONObject.stringToNumber((String) val);
+                return NumberConversionUtil.stringToNumber((String) val);
             } catch (Exception e) {
                 return defaultValue;
             }
@@ -1739,10 +1695,7 @@ public class JSONArray implements Iterable<Object> {
      */
     @SuppressWarnings("resource")
     public String toString(int indentFactor) throws JSONException {
-        // each value requires a comma, so multiply the count by 2
+        StringWriter sw = new StringWriter();
-        // We don't want to oversize the initial capacity
-        int initialSize = myArrayList.size() * 2;
-        Writer sw = new StringBuilderWriter(Math.max(initialSize, 16));
         return this.write(sw, indentFactor, 0).toString();
     }
 
@@ -1984,7 +1937,7 @@ public class JSONArray implements Iterable<Object> {
             // JSONArray
             this.myArrayList.addAll(((JSONArray)array).myArrayList);
         } else if (array instanceof Collection) {
-            this.addAll((Collection<?>)array, wrap, recursionDepth, jsonParserConfiguration);
+            this.addAll((Collection<?>)array, wrap, recursionDepth);
         } else if (array instanceof Iterable) {
             this.addAll((Iterable<?>)array, wrap);
         } else {

src/main/java/org/json/JSONML.java

@@ -13,13 +13,6 @@ Public Domain.
  * @version 2016-01-30
  */
 public class JSONML {
-
-    /**
-     * Constructs a new JSONML object.
-     */
-    public JSONML() {
-    }
-
     /**
      * Parse XML values and store them in a JSONArray.
      * @param x       The XMLTokener containing the source string.
@@ -111,7 +104,7 @@ public class JSONML {
                             }
                         } else if (c == '[') {
                             token = x.nextToken();
-                            if ("CDATA".equals(token) && x.next() == '[') {
+                            if (token.equals("CDATA") && x.next() == '[') {
                                 if (ja != null) {
                                     ja.put(x.nextCDATA());
                                 }

src/main/java/org/json/JSONObject.java

@@ -6,6 +6,7 @@ Public Domain.
 
 import java.io.Closeable;
 import java.io.IOException;
+import java.io.StringWriter;
 import java.io.Writer;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Field;
@@ -14,10 +15,22 @@ import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.math.BigDecimal;
 import java.math.BigInteger;
-import java.util.*;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.IdentityHashMap;
+import java.util.Iterator;
+import java.util.Locale;
+import java.util.Map;
 import java.util.Map.Entry;
+import java.util.ResourceBundle;
+import java.util.Set;
 import java.util.regex.Pattern;
 
+import static org.json.NumberConversionUtil.potentialNumber;
+import static org.json.NumberConversionUtil.stringToNumber;
+
 /**
  * A JSONObject is an unordered collection of name/value pairs. Its external
  * form is a string wrapped in curly braces with colons between the names and
@@ -79,6 +92,17 @@ public class JSONObject {
      */
     private static final class Null {
 
+        /**
+         * There is only intended to be a single instance of the NULL object,
+         * so the clone method returns itself.
+         *
+         * @return NULL.
+         */
+        @Override
+        protected final Object clone() {
+            return this;
+        }
+
         /**
          * A Null object is equal to the null value and to itself.
          *
@@ -124,11 +148,6 @@ public class JSONObject {
      */
     private final Map<String, Object> map;
 
-    /**
-     * Retrieves the type of the underlying Map in this class.
-     *
-     * @return The class object representing the type of the underlying Map.
-     */
     public Class<? extends Map> getMapType() {
         return map.getClass();
     }
@@ -169,7 +188,7 @@ public class JSONObject {
         for (int i = 0; i < names.length; i += 1) {
             try {
                 this.putOnce(names[i], jo.opt(names[i]));
-            } catch (Exception ignore) { // exception thrown for missing key
+            } catch (Exception ignore) {
             }
         }
     }
@@ -184,150 +203,63 @@ public class JSONObject {
      *             duplicated key.
      */
     public JSONObject(JSONTokener x) throws JSONException {
-        this(x, x.getJsonParserConfiguration());
-    }
-
-    /**
-     * Construct a JSONObject from a JSONTokener with custom json parse configurations.
-     *
-     * @param x
-     *            A JSONTokener object containing the source string.
-     * @param jsonParserConfiguration
-     *            Variable to pass parser custom configuration for json parsing.
-     * @throws JSONException
-     *             If there is a syntax error in the source string or a
-     *             duplicated key.
-     */
-    public JSONObject(JSONTokener x, JSONParserConfiguration jsonParserConfiguration) throws JSONException {
         this();
-        boolean isInitial = x.getPrevious() == 0;
+        char c;
+        String key;
 
         if (x.nextClean() != '{') {
             throw x.syntaxError("A JSONObject text must begin with '{'");
         }
         for (;;) {
-            if (parseJSONObject(x, jsonParserConfiguration, isInitial)) {
+            c = x.nextClean();
-                return;
-            }
-        }
-    }
-
-    /**
-     * Parses entirety of JSON object
-     *
-     * @param jsonTokener Parses text as tokens
-     * @param jsonParserConfiguration Variable to pass parser custom configuration for json parsing.
-     * @param isInitial True if start of document, else false
-     * @return True if done building object, else false
-     */
-    private boolean parseJSONObject(JSONTokener jsonTokener, JSONParserConfiguration jsonParserConfiguration, boolean isInitial) {
-        Object obj;
-        String key;
-        boolean doneParsing = false;
-        char c = jsonTokener.nextClean();
-
             switch (c) {
             case 0:
-                throw jsonTokener.syntaxError("A JSONObject text must end with '}'");
+                throw x.syntaxError("A JSONObject text must end with '}'");
             case '}':
-                if (isInitial && jsonParserConfiguration.isStrictMode() && jsonTokener.nextClean() != 0) {
+                return;
-                    throw jsonTokener.syntaxError("Strict mode error: Unparsed characters found at end of input text");
-                }
-                return true;
             default:
-                obj = jsonTokener.nextSimpleValue(c);
+                key = x.nextSimpleValue(c).toString();
-                key = obj.toString();
             }
 
-        checkKeyForStrictMode(jsonTokener, jsonParserConfiguration, obj);
-
             // The key is followed by ':'.
-        c = jsonTokener.nextClean();
+
+            c = x.nextClean();
             if (c != ':') {
-            throw jsonTokener.syntaxError("Expected a ':' after a key");
+                throw x.syntaxError("Expected a ':' after a key");
             }
 
             // Use syntaxError(..) to include error location
+
             if (key != null) {
                 // Check if key exists
-            boolean keyExists = this.opt(key) != null;
+                if (this.opt(key) != null) {
-            if (keyExists && !jsonParserConfiguration.isOverwriteDuplicateKey()) {
+                    // key already exists
-                throw jsonTokener.syntaxError("Duplicate key \"" + key + "\"");
+                    throw x.syntaxError("Duplicate key \"" + key + "\"");
                 }
-
-            Object value = jsonTokener.nextValue();
                 // Only add value if non-null
-            if (value != null) {
+                Object value = x.nextValue();
+                if (value!=null) {
                     this.put(key, value);
                 }
             }
 
             // Pairs are separated by ','.
-        if (parseEndOfKeyValuePair(jsonTokener, jsonParserConfiguration, isInitial)) {
-            doneParsing = true;
-        }
 
-        return doneParsing;
+            switch (x.nextClean()) {
-    }
-
-    /**
-     * Checks for valid end of key:value pair
-     * @param jsonTokener Parses text as tokens
-     * @param jsonParserConfiguration Variable to pass parser custom configuration for json parsing.
-     * @param isInitial True if end of JSON object, else false
-     * @return
-     */
-    private static boolean parseEndOfKeyValuePair(JSONTokener jsonTokener, JSONParserConfiguration jsonParserConfiguration, boolean isInitial) {
-        switch (jsonTokener.nextClean()) {
             case ';':
-                // In strict mode semicolon is not a valid separator
-                if (jsonParserConfiguration.isStrictMode()) {
-                    throw jsonTokener.syntaxError("Strict mode error: Invalid character ';' found");
-                }
-                break;
             case ',':
-                if (jsonTokener.nextClean() == '}') {
+                if (x.nextClean() == '}') {
-                    // trailing commas are not allowed in strict mode
+                    return;
-                    if (jsonParserConfiguration.isStrictMode()) {
-                        throw jsonTokener.syntaxError("Strict mode error: Expected another object element");
                 }
-                    // End of JSON object
+                if (x.end()) {
-                    return true;
+                    throw x.syntaxError("A JSONObject text must end with '}'");
                 }
-                if (jsonTokener.end()) {
+                x.back();
-                    throw jsonTokener.syntaxError("A JSONObject text must end with '}'");
-                }
-                jsonTokener.back();
                 break;
             case '}':
-                if (isInitial && jsonParserConfiguration.isStrictMode() && jsonTokener.nextClean() != 0) {
+                return;
-                    throw jsonTokener.syntaxError("Strict mode error: Unparsed characters found at end of input text");
-                }
-                // End of JSON object
-                return true;
             default:
-                throw jsonTokener.syntaxError("Expected a ',' or '}'");
+                throw x.syntaxError("Expected a ',' or '}'");
-        }
-        // Not at end of JSON object
-        return false;
-    }
-
-    /**
-     * Throws error if key violates strictMode
-     * @param jsonTokener Parses text as tokens
-     * @param jsonParserConfiguration Variable to pass parser custom configuration for json parsing.
-     * @param obj Value to be checked
-     */
-    private static void checkKeyForStrictMode(JSONTokener jsonTokener, JSONParserConfiguration jsonParserConfiguration, Object obj) {
-        if (jsonParserConfiguration != null && jsonParserConfiguration.isStrictMode()) {
-            if(obj instanceof Boolean) {
-                throw jsonTokener.syntaxError(String.format("Strict mode error: key '%s' cannot be boolean", obj.toString()));
-            }
-            if(obj == JSONObject.NULL) {
-                throw jsonTokener.syntaxError(String.format("Strict mode error: key '%s' cannot be null", obj.toString()));
-            }
-            if(obj instanceof Number) {
-                throw jsonTokener.syntaxError(String.format("Strict mode error: key '%s' cannot be number", obj.toString()));
             }
         }
     }
@@ -362,6 +294,7 @@ public class JSONObject {
 
     /**
      * Construct a JSONObject from a map with recursion depth.
+     *
      */
     private JSONObject(Map<?, ?> m, int recursionDepth, JSONParserConfiguration jsonParserConfiguration) {
         if (recursionDepth > jsonParserConfiguration.getMaxNestingDepth()) {
@@ -376,7 +309,7 @@ public class JSONObject {
         	        throw new NullPointerException("Null key.");
         	    }
                 final Object value = e.getValue();
-                if (value != null || jsonParserConfiguration.isUseNativeNulls()) {
+                if (value != null) {
                     testValidity(value);
                     this.map.put(String.valueOf(e.getKey()), wrap(value, recursionDepth + 1, jsonParserConfiguration));
                 }
@@ -436,6 +369,7 @@ public class JSONObject {
      * &#64;JSONPropertyIgnore
      * public String getName() { return this.name; }
      * </pre>
+     * <p>
      *
      * @param bean
      *            An object that has getter methods that should be used to make
@@ -445,17 +379,12 @@ public class JSONObject {
      */
     public JSONObject(Object bean) {
         this();
-        this.populateMap(bean, new JSONParserConfiguration());
+        this.populateMap(bean);
-    }
-
-    public JSONObject(Object bean, JSONParserConfiguration jsonParserConfiguration) {
-        this();
-        this.populateMap(bean, jsonParserConfiguration);
     }
 
     private JSONObject(Object bean, Set<Object> objectsRecord) {
         this();
-        this.populateMap(bean, objectsRecord, new JSONParserConfiguration());
+        this.populateMap(bean, objectsRecord);
     }
 
     /**
@@ -497,25 +426,7 @@ public class JSONObject {
      *                duplicated key.
      */
     public JSONObject(String source) throws JSONException {
-        this(source, new JSONParserConfiguration());
+        this(new JSONTokener(source));
-    }
-
-    /**
-     * Construct a JSONObject from a source JSON text string with custom json parse configurations.
-     * This is the most commonly used JSONObject constructor.
-     *
-     * @param source
-     *            A string beginning with <code>{</code>&nbsp;<small>(left
-     *            brace)</small> and ending with <code>}</code>
-     *            &nbsp;<small>(right brace)</small>.
-     * @param jsonParserConfiguration
-     *            Variable to pass parser custom configuration for json parsing.
-     * @exception JSONException
-     *                If there is a syntax error in the source string or a
-     *                duplicated key.
-     */
-    public JSONObject(String source, JSONParserConfiguration jsonParserConfiguration) throws JSONException {
-        this(new JSONTokener(source, jsonParserConfiguration), jsonParserConfiguration);
     }
 
     /**
@@ -723,11 +634,13 @@ public class JSONObject {
      */
     public boolean getBoolean(String key) throws JSONException {
         Object object = this.get(key);
-        if (Boolean.FALSE.equals(object)
+        if (object.equals(Boolean.FALSE)
-                || (object instanceof String && "false".equalsIgnoreCase((String) object))) {
+                || (object instanceof String && ((String) object)
+                        .equalsIgnoreCase("false"))) {
             return false;
-        } else if (Boolean.TRUE.equals(object)
+        } else if (object.equals(Boolean.TRUE)
-                || (object instanceof String && "true".equalsIgnoreCase((String) object))) {
+                || (object instanceof String && ((String) object)
+                        .equalsIgnoreCase("true"))) {
             return true;
         }
         throw wrongValueFormatException(key, "Boolean", object, null);
@@ -1811,45 +1724,31 @@ public class JSONObject {
      * @throws JSONException
      *            If a getter returned a non-finite number.
      */
-    private void populateMap(Object bean, JSONParserConfiguration jsonParserConfiguration) {
+    private void populateMap(Object bean) {
-        populateMap(bean, Collections.newSetFromMap(new IdentityHashMap<Object, Boolean>()), jsonParserConfiguration);
+        populateMap(bean, Collections.newSetFromMap(new IdentityHashMap<Object, Boolean>()));
     }
 
-    /**
+    private void populateMap(Object bean, Set<Object> objectsRecord) {
-     * Convert a bean into a json object
-     * @param bean object tobe converted
-     * @param objectsRecord set of all objects for this method
-     * @param jsonParserConfiguration json parser settings
-     */
-    private void populateMap(Object bean, Set<Object> objectsRecord, JSONParserConfiguration jsonParserConfiguration) {
         Class<?> klass = bean.getClass();
 
         // If klass is a System class then set includeSuperClass to false.
 
-        Method[] methods = getMethods(klass);
+        boolean includeSuperClass = klass.getClassLoader() != null;
+
+        Method[] methods = includeSuperClass ? klass.getMethods() : klass.getDeclaredMethods();
         for (final Method method : methods) {
-            if (isValidMethod(method)) {
+            final int modifiers = method.getModifiers();
+            if (Modifier.isPublic(modifiers)
+                    && !Modifier.isStatic(modifiers)
+                    && method.getParameterTypes().length == 0
+                    && !method.isBridge()
+                    && method.getReturnType() != Void.TYPE
+                    && isValidMethodName(method.getName())) {
                 final String key = getKeyNameFromMethod(method);
                 if (key != null && !key.isEmpty()) {
-                    processMethod(bean, objectsRecord, jsonParserConfiguration, method, key);
-                }
-            }
-        }
-    }
-
-    /**
-     * Processes method into json object entry if appropriate
-     * @param bean object being processed (owns the method)
-     * @param objectsRecord set of all objects for this method
-     * @param jsonParserConfiguration json parser settings
-     * @param method method being processed
-     * @param key name of the method
-     */
-    private void processMethod(Object bean, Set<Object> objectsRecord, JSONParserConfiguration jsonParserConfiguration,
-                               Method method, String key) {
                     try {
                         final Object result = method.invoke(bean);
-            if (result != null || jsonParserConfiguration.isUseNativeNulls()) {
+                        if (result != null) {
                             // check cyclic dependency and throw error if needed
                             // the wrap and populateMap combination method is
                             // itself DFS recursive
@@ -1864,26 +1763,23 @@ public class JSONObject {
 
                             objectsRecord.remove(result);
 
-                closeClosable(result);
+                            // we don't use the result anywhere outside of wrap
+                            // if it's a resource we should be sure to close it
+                            // after calling toString
+                            if (result instanceof Closeable) {
+                                try {
+                                    ((Closeable) result).close();
+                                } catch (IOException ignore) {
+                                }
+                            }
                         }
                     } catch (IllegalAccessException ignore) {
-            // ignore exception
                     } catch (IllegalArgumentException ignore) {
-            // ignore exception
                     } catch (InvocationTargetException ignore) {
-            // ignore exception
                     }
                 }
-
+            }
-    /**
+        }
-     * This is a convenience method to simplify populate maps
-     * @param klass the name of the object being checked
-     * @return methods of klass
-     */
-    private static Method[] getMethods(Class<?> klass) {
-        boolean includeSuperClass = klass.getClassLoader() != null;
-
-        return includeSuperClass ? klass.getMethods() : klass.getDeclaredMethods();
     }
 
     private static boolean isValidMethodName(String name) {
@@ -1901,7 +1797,7 @@ public class JSONObject {
             }
         }
         JSONPropertyName annotation = getAnnotation(method, JSONPropertyName.class);
-        if (annotationValueNotEmpty(annotation)) {
+        if (annotation != null && annotation.value() != null && !annotation.value().isEmpty()) {
             return annotation.value();
         }
         String key;
@@ -1927,46 +1823,6 @@ public class JSONObject {
         return key;
     }
 
-    /**
-     * checks if the annotation is not null and the {@link JSONPropertyName#value()} is not null and is not empty.
-     * @param annotation the annotation to check
-     * @return true if the annotation and the value is not null and not empty, false otherwise.
-     */
-    private static boolean annotationValueNotEmpty(JSONPropertyName annotation) {
-        return annotation != null && annotation.value() != null && !annotation.value().isEmpty();
-    }
-
-    /**
-     * Checks if the method is valid for the {@link #populateMap(Object, Set, JSONParserConfiguration)} use case
-     * @param method the Method to check
-     * @return true, if valid, false otherwise.
-     */
-    private static boolean isValidMethod(Method method) {
-        final int modifiers = method.getModifiers();
-        return Modifier.isPublic(modifiers)
-                && !Modifier.isStatic(modifiers)
-                && method.getParameterTypes().length == 0
-                && !method.isBridge()
-                && method.getReturnType() != Void.TYPE
-                && isValidMethodName(method.getName());
-    }
-
-    /**
-     * calls {@link Closeable#close()} on the input, if it is an instance of Closable.
-     * @param input the input to close, if possible.
-     */
-    private static void closeClosable(Object input) {
-        // we don't use the result anywhere outside of wrap
-        // if it's a resource we should be sure to close it
-        // after calling toString
-        if (input instanceof Closeable) {
-            try {
-                ((Closeable) input).close();
-            } catch (IOException ignore) {
-            }
-        }
-    }
-
     /**
      * Searches the class hierarchy to see if the method or it's super
      * implementations and interfaces has the annotation.
@@ -2010,7 +1866,7 @@ public class JSONObject {
         }
 
         //If the superclass is Object, no annotations will be found any more
-        if (Object.class.equals(c.getSuperclass()))
+        if (c.getSuperclass().equals(Object.class))
             return null;
 
         try {
@@ -2068,7 +1924,7 @@ public class JSONObject {
         }
 
         //If the superclass is Object, no annotations will be found any more
-        if (Object.class.equals(c.getSuperclass()))
+        if (c.getSuperclass().equals(Object.class))
             return -1;
 
         try {
@@ -2367,10 +2223,7 @@ public class JSONObject {
      */
     @SuppressWarnings("resource")
     public static String quote(String string) {
-        if (string == null || string.isEmpty()) {
+        StringWriter sw = new StringWriter();
-            return "\"\"";
-        }
-        Writer sw = new StringBuilderWriter(string.length() + 2);
         try {
             return quote(string, sw).toString();
         } catch (IOException ignored) {
@@ -2379,14 +2232,6 @@ public class JSONObject {
         }
     }
 
-    /**
-     * Quotes a string and appends the result to a given Writer.
-     *
-     * @param string The input string to be quoted.
-     * @param w      The Writer to which the quoted string will be appended.
-     * @return The same Writer instance after appending the quoted string.
-     * @throws IOException If an I/O error occurs while writing to the Writer.
-     */
     public static Writer quote(String string, Writer w) throws IOException {
         if (string == null || string.isEmpty()) {
             w.write("\"\"");
@@ -2603,8 +2448,7 @@ public class JSONObject {
          * produced, then the value will just be a string.
          */
 
-        char initial = string.charAt(0);
+        if (potentialNumber(string)) {
-        if ((initial >= '0' && initial <= '9') || initial == '-') {
             try {
                 return stringToNumber(string);
             } catch (Exception ignore) {
@@ -2613,75 +2457,8 @@ public class JSONObject {
         return string;
     }
 
-    /**
-     * Converts a string to a number using the narrowest possible type. Possible
-     * returns for this function are BigDecimal, Double, BigInteger, Long, and Integer.
-     * When a Double is returned, it should always be a valid Double and not NaN or +-infinity.
-     *
-     * @param val value to convert
-     * @return Number representation of the value.
-     * @throws NumberFormatException thrown if the value is not a valid number. A public
-     *      caller should catch this and wrap it in a {@link JSONException} if applicable.
-     */
-    protected static Number stringToNumber(final String val) throws NumberFormatException {
-        char initial = val.charAt(0);
-        if ((initial >= '0' && initial <= '9') || initial == '-') {
-            // decimal representation
-            if (isDecimalNotation(val)) {
-                // Use a BigDecimal all the time so we keep the original
-                // representation. BigDecimal doesn't support -0.0, ensure we
-                // keep that by forcing a decimal.
-                try {
-                    BigDecimal bd = new BigDecimal(val);
-                    if(initial == '-' && BigDecimal.ZERO.compareTo(bd)==0) {
-                        return Double.valueOf(-0.0);
-                    }
-                    return bd;
-                } catch (NumberFormatException retryAsDouble) {
-                    // this is to support "Hex Floats" like this: 0x1.0P-1074
-                    try {
-                        Double d = Double.valueOf(val);
-                        if(d.isNaN() || d.isInfinite()) {
-                            throw new NumberFormatException("val ["+val+"] is not a valid number.");
-                        }
-                        return d;
-                    } catch (NumberFormatException ignore) {
-                        throw new NumberFormatException("val ["+val+"] is not a valid number.");
-                    }
-                }
-            }
-            // block items like 00 01 etc. Java number parsers treat these as Octal.
-            if(initial == '0' && val.length() > 1) {
-                char at1 = val.charAt(1);
-                if(at1 >= '0' && at1 <= '9') {
-                    throw new NumberFormatException("val ["+val+"] is not a valid number.");
-                }
-            } else if (initial == '-' && val.length() > 2) {
-                char at1 = val.charAt(1);
-                char at2 = val.charAt(2);
-                if(at1 == '0' && at2 >= '0' && at2 <= '9') {
-                    throw new NumberFormatException("val ["+val+"] is not a valid number.");
-                }
-            }
-            // integer representation.
-            // This will narrow any values to the smallest reasonable Object representation
-            // (Integer, Long, or BigInteger)
 
-            // BigInteger down conversion: We use a similar bitLength compare as
+
-            // BigInteger#intValueExact uses. Increases GC, but objects hold
-            // only what they need. i.e. Less runtime overhead if the value is
-            // long lived.
-            BigInteger bi = new BigInteger(val);
-            if(bi.bitLength() <= 31){
-                return Integer.valueOf(bi.intValue());
-            }
-            if(bi.bitLength() <= 63){
-                return Long.valueOf(bi.longValue());
-            }
-            return bi;
-        }
-        throw new NumberFormatException("val ["+val+"] is not a valid number.");
-    }
 
     /**
      * Throw an exception if the object is a NaN or infinite number.
@@ -2769,10 +2546,7 @@ public class JSONObject {
      */
     @SuppressWarnings("resource")
     public String toString(int indentFactor) throws JSONException {
-        // 6 characters are the minimum to serialise a key value pair e.g.: "k":1,
+        StringWriter w = new StringWriter();
-        // and we don't want to oversize the initial capacity
-        int initialSize = map.size() * 6;
-        Writer w = new StringBuilderWriter(Math.max(initialSize, 16));
         return this.write(w, indentFactor, 0).toString();
     }
 
@@ -2854,13 +2628,13 @@ public class JSONObject {
                 return NULL;
             }
             if (object instanceof JSONObject || object instanceof JSONArray
-                    || object instanceof JSONString || object instanceof String
+                    || NULL.equals(object) || object instanceof JSONString
                     || object instanceof Byte || object instanceof Character
                     || object instanceof Short || object instanceof Integer
                     || object instanceof Long || object instanceof Boolean
                     || object instanceof Float || object instanceof Double
-                    || object instanceof BigInteger || object instanceof BigDecimal
+                    || object instanceof String || object instanceof BigInteger
-                    || object instanceof Enum) {
+                    || object instanceof BigDecimal || object instanceof Enum) {
                 return object;
             }
 
@@ -2915,7 +2689,6 @@ public class JSONObject {
         if (value == null || value.equals(null)) {
             writer.write("null");
         } else if (value instanceof JSONString) {
-            // JSONString must be checked first, so it can overwrite behaviour of other types below
             Object o;
             try {
                 o = ((JSONString) value).toJSONString();
@@ -2923,10 +2696,6 @@ public class JSONObject {
                 throw new JSONException(e);
             }
             writer.write(o != null ? o.toString() : quote(value.toString()));
-        } else if (value instanceof String) {
-            // assuming most values are Strings, so testing it early
-            quote(value.toString(), writer);
-            return writer;
         } else if (value instanceof Number) {
             // not all Numbers may match actual JSON Numbers. i.e. fractions or Imaginary
             final String numberAsString = numberToString((Number) value);
@@ -3114,4 +2883,6 @@ public class JSONObject {
             "JavaBean object contains recursively defined member variable of key " + quote(key)
         );
     }
+
+
 }

src/main/java/org/json/JSONParserConfiguration.java

@@ -4,149 +4,23 @@ package org.json;
  * Configuration object for the JSON parser. The configuration is immutable.
  */
 public class JSONParserConfiguration extends ParserConfiguration {
-    /**
-     * Used to indicate whether to overwrite duplicate key or not.
-     */
-    private boolean overwriteDuplicateKey;
-    
-    /**
-     * Used to indicate whether to convert java null values to JSONObject.NULL or ignoring the entry when converting java maps.
-     */
-    private boolean useNativeNulls;
 
   /**
    * Configuration with the default values.
    */
   public JSONParserConfiguration() {
     super();
-        this.overwriteDuplicateKey = false;
-        // DO NOT DELETE THE FOLLOWING LINE -- it is used for strictMode testing
-        // this.strictMode = true;
   }
 
-    /**
-     * This flag, when set to true, instructs the parser to enforce strict mode when parsing JSON text.
-     * Garbage chars at the end of the doc, unquoted string, and single-quoted strings are all disallowed.
-     */
-    private boolean strictMode;
-
   @Override
   protected JSONParserConfiguration clone() {
-        JSONParserConfiguration clone = new JSONParserConfiguration();
+    return new JSONParserConfiguration();
-        clone.overwriteDuplicateKey = overwriteDuplicateKey;
-        clone.strictMode = strictMode;
-        clone.maxNestingDepth = maxNestingDepth;
-        clone.keepStrings = keepStrings;
-        clone.useNativeNulls = useNativeNulls;
-        return clone;
   }
 
-    /**
-     * Defines the maximum nesting depth that the parser will descend before throwing an exception
-     * when parsing a map into JSONObject or parsing a {@link java.util.Collection} instance into
-     * JSONArray. The default max nesting depth is 512, which means the parser will throw a JsonException
-     * if the maximum depth is reached.
-     *
-     * @param maxNestingDepth the maximum nesting depth allowed to the JSON parser
-     * @return The existing configuration will not be modified. A new configuration is returned.
-     */
   @SuppressWarnings("unchecked")
   @Override
   public JSONParserConfiguration withMaxNestingDepth(final int maxNestingDepth) {
-        JSONParserConfiguration clone = this.clone();
+    return super.withMaxNestingDepth(maxNestingDepth);
-        clone.maxNestingDepth = maxNestingDepth;
-
-        return clone;
   }
 
-    /**
-     * Controls the parser's behavior when meeting duplicate keys.
-     * If set to false, the parser will throw a JSONException when meeting a duplicate key.
-     * Or the duplicate key's value will be overwritten.
-     *
-     * @param overwriteDuplicateKey defines should the parser overwrite duplicate keys.
-     * @return The existing configuration will not be modified. A new configuration is returned.
-     */
-    public JSONParserConfiguration withOverwriteDuplicateKey(final boolean overwriteDuplicateKey) {
-        JSONParserConfiguration clone = this.clone();
-        clone.overwriteDuplicateKey = overwriteDuplicateKey;
-
-        return clone;
-    }
-    
-    /**
-     * Controls the parser's behavior when meeting Java null values while converting maps.
-     * If set to true, the parser will put a JSONObject.NULL into the resulting JSONObject.
-     * Or the map entry will be ignored.
-     *
-     * @param useNativeNulls defines if the parser should convert null values in Java maps
-     * @return The existing configuration will not be modified. A new configuration is returned.
-     */
-    public JSONParserConfiguration withUseNativeNulls(final boolean useNativeNulls) {
-        JSONParserConfiguration clone = this.clone();
-        clone.useNativeNulls = useNativeNulls;
-
-        return clone;
-    }
-
-    /**
-     * Sets the strict mode configuration for the JSON parser with default true value
-     * <p>
-     * When strict mode is enabled, the parser will throw a JSONException if it encounters an invalid character
-     * immediately following the final ']' character in the input. This is useful for ensuring strict adherence to the
-     * JSON syntax, as any characters after the final closing bracket of a JSON array are considered invalid.
-     * @return a new JSONParserConfiguration instance with the updated strict mode setting
-     */
-    public JSONParserConfiguration withStrictMode() {
-        return withStrictMode(true);
-    }
-
-    /**
-     * Sets the strict mode configuration for the JSON parser.
-     * <p>
-     * When strict mode is enabled, the parser will throw a JSONException if it encounters an invalid character
-     * immediately following the final ']' character in the input. This is useful for ensuring strict adherence to the
-     * JSON syntax, as any characters after the final closing bracket of a JSON array are considered invalid.
-     *
-     * @param mode a boolean value indicating whether strict mode should be enabled or not
-     * @return a new JSONParserConfiguration instance with the updated strict mode setting
-     */
-    public JSONParserConfiguration withStrictMode(final boolean mode) {
-        JSONParserConfiguration clone = this.clone();
-        clone.strictMode = mode;
-
-        return clone;
-    }
-
-    /**
-     * The parser's behavior when meeting duplicate keys, controls whether the parser should
-     * overwrite duplicate keys or not.
-     *
-     * @return The <code>overwriteDuplicateKey</code> configuration value.
-     */
-    public boolean isOverwriteDuplicateKey() {
-        return this.overwriteDuplicateKey;
-    }
-    
-    /**
-     * The parser's behavior when meeting a null value in a java map, controls whether the parser should 
-     * write a JSON entry with a null value (<code>isUseNativeNulls() == true</code>) 
-     * or ignore that map entry (<code>isUseNativeNulls() == false</code>).
-     *
-     * @return The <code>useNativeNulls</code> configuration value.
-     */
-    public boolean isUseNativeNulls() {
-        return this.useNativeNulls;
-    }
-    
-
-    /**
-     * The parser throws an Exception when strict mode is true and tries to parse invalid JSON characters.
-     * Otherwise, the parser is more relaxed and might tolerate some invalid characters.
-     *
-     * @return the current strict mode setting.
-     */
-    public boolean isStrictMode() {
-        return this.strictMode;
-    }
 }

src/main/java/org/json/JSONPointer.java

@@ -42,12 +42,6 @@ public class JSONPointer {
      */
     public static class Builder {
 
-        /**
-         * Constructs a new Builder object.
-         */
-        public Builder() {
-        }
-
         // Segments for the eventual JSONPointer string
         private final List<String> refTokens = new ArrayList<String>();
 
@@ -127,7 +121,7 @@ public class JSONPointer {
         if (pointer == null) {
             throw new NullPointerException("pointer cannot be null");
         }
-        if (pointer.isEmpty() || "#".equals(pointer)) {
+        if (pointer.isEmpty() || pointer.equals("#")) {
             this.refTokens = Collections.emptyList();
             return;
         }
@@ -169,12 +163,6 @@ public class JSONPointer {
         //}
     }
 
-    /**
-     * Constructs a new JSONPointer instance with the provided list of reference tokens.
-     *
-     * @param refTokens A list of strings representing the reference tokens for the JSON Pointer.
-     *                  Each token identifies a step in the path to the targeted value.
-     */
     public JSONPointer(List<String> refTokens) {
         this.refTokens = new ArrayList<String>(refTokens);
     }
@@ -246,7 +234,7 @@ public class JSONPointer {
      */
     @Override
     public String toString() {
-        StringBuilder rval = new StringBuilder();
+        StringBuilder rval = new StringBuilder("");
         for (String token: this.refTokens) {
             rval.append('/').append(escape(token));
         }

src/main/java/org/json/JSONPointerException.java

@@ -14,21 +14,10 @@ Public Domain.
 public class JSONPointerException extends JSONException {
     private static final long serialVersionUID = 8872944667561856751L;
 
-    /**
-     * Constructs a new JSONPointerException with the specified error message.
-     *
-     * @param message The detail message describing the reason for the exception.
-     */
     public JSONPointerException(String message) {
         super(message);
     }
 
-    /**
-     * Constructs a new JSONPointerException with the specified error message and cause.
-     *
-     * @param message The detail message describing the reason for the exception.
-     * @param cause   The cause of the exception.
-     */
     public JSONPointerException(String message, Throwable cause) {
         super(message, cause);
     }

src/main/java/org/json/JSONPropertyName.java

@@ -21,7 +21,6 @@ import java.lang.annotation.Target;
 @Target({METHOD})
 public @interface JSONPropertyName {
     /**
-     * The value of the JSON property.
      * @return The name of the property as to be used in the JSON Object.
      */
     String value();

src/main/java/org/json/JSONTokener.java

@@ -32,27 +32,13 @@ public class JSONTokener {
     /** the number of characters read in the previous line. */
     private long characterPreviousLine;
 
-    // access to this object is required for strict mode checking
-    private JSONParserConfiguration jsonParserConfiguration;
 
     /**
      * Construct a JSONTokener from a Reader. The caller must close the Reader.
      *
-     * @param reader the source.
+     * @param reader     A reader.
      */
     public JSONTokener(Reader reader) {
-        this(reader, new JSONParserConfiguration());
-    }
-
-    /**
-     * Construct a JSONTokener from a Reader with a given JSONParserConfiguration. The caller must close the Reader.
-     *
-     * @param reader the source.
-     * @param jsonParserConfiguration A JSONParserConfiguration instance that controls the behavior of the parser.
-     *
-     */
-    public JSONTokener(Reader reader, JSONParserConfiguration jsonParserConfiguration) {
-        this.jsonParserConfiguration = jsonParserConfiguration;
         this.reader = reader.markSupported()
                 ? reader
                         : new BufferedReader(reader);
@@ -65,60 +51,25 @@ public class JSONTokener {
         this.line = 1;
     }
 
+
     /**
      * Construct a JSONTokener from an InputStream. The caller must close the input stream.
      * @param inputStream The source.
      */
     public JSONTokener(InputStream inputStream) {
-        this(inputStream, new JSONParserConfiguration());
+        this(new InputStreamReader(inputStream, Charset.forName("UTF-8")));
-    }
-
-    /**
-     * Construct a JSONTokener from an InputStream. The caller must close the input stream.
-     * @param inputStream The source.
-     * @param jsonParserConfiguration A JSONParserConfiguration instance that controls the behavior of the parser.
-     */
-    public JSONTokener(InputStream inputStream, JSONParserConfiguration jsonParserConfiguration) {
-        this(new InputStreamReader(inputStream, Charset.forName("UTF-8")), jsonParserConfiguration);
     }
 
 
     /**
      * Construct a JSONTokener from a string.
      *
-     * @param source A source string.
+     * @param s     A source string.
      */
-    public JSONTokener(String source) {
+    public JSONTokener(String s) {
-        this(new StringReader(source));
+        this(new StringReader(s));
     }
 
-    /**
-     * Construct a JSONTokener from an InputStream. The caller must close the input stream.
-     * @param source The source.
-     * @param jsonParserConfiguration A JSONParserConfiguration instance that controls the behavior of the parser.
-     */
-    public JSONTokener(String source, JSONParserConfiguration jsonParserConfiguration) {
-        this(new StringReader(source), jsonParserConfiguration);
-    }
-
-    /**
-     * Getter
-     * @return jsonParserConfiguration
-     */
-    public JSONParserConfiguration getJsonParserConfiguration() {
-        return jsonParserConfiguration;
-    }
-
-    /**
-     * Setter
-     * @param jsonParserConfiguration new value for jsonParserConfiguration
-     *
-     * @deprecated method should not be used
-     */
-    @Deprecated
-    public void setJsonParserConfiguration(JSONParserConfiguration jsonParserConfiguration) {
-        this.jsonParserConfiguration = jsonParserConfiguration;
-    }
 
     /**
      * Back up one character. This provides a sort of lookahead capability,
@@ -348,8 +299,7 @@ public class JSONTokener {
             case 0:
             case '\n':
             case '\r':
-                throw this.syntaxError("Unterminated string. " +
+                throw this.syntaxError("Unterminated string");
-                        "Character with int code " + (int) c + " is not allowed within a quoted string.");
             case '\\':
                 c = this.next();
                 switch (c) {
@@ -369,12 +319,10 @@ public class JSONTokener {
                     sb.append('\r');
                     break;
                 case 'u':
-                    String next = this.next(4);
                     try {
-                        sb.append((char)Integer.parseInt(next, 16));
+                        sb.append((char)Integer.parseInt(this.next(4), 16));
                     } catch (NumberFormatException e) {
-                        throw this.syntaxError("Illegal escape. " +
+                        throw this.syntaxError("Illegal escape.", e);
-                                "\\u must be followed by a 4 digit hexadecimal number. \\" + next + " is not valid.", e);
                     }
                     break;
                 case '"':
@@ -384,7 +332,7 @@ public class JSONTokener {
                     sb.append(c);
                     break;
                 default:
-                    throw this.syntaxError("Illegal escape. Escape sequence  \\" + c + " is not valid.");
+                    throw this.syntaxError("Illegal escape.");
                 }
                 break;
             default:
@@ -458,14 +406,14 @@ public class JSONTokener {
         case '{':
             this.back();
             try {
-                return new JSONObject(this, jsonParserConfiguration);
+                return new JSONObject(this);
             } catch (StackOverflowError e) {
                 throw new JSONException("JSON Array or Object depth too large to process.", e);
             }
         case '[':
             this.back();
             try {
-                return new JSONArray(this, jsonParserConfiguration);
+                return new JSONArray(this);
             } catch (StackOverflowError e) {
                 throw new JSONException("JSON Array or Object depth too large to process.", e);
             }
@@ -476,12 +424,6 @@ public class JSONTokener {
     Object nextSimpleValue(char c) {
         String string;
 
-        // Strict mode only allows strings with explicit double quotes
-        if (jsonParserConfiguration != null &&
-                jsonParserConfiguration.isStrictMode() &&
-                c == '\'') {
-            throw this.syntaxError("Strict mode error: Single quoted strings are not allowed");
-        }
         switch (c) {
         case '"':
         case '\'':
@@ -510,24 +452,7 @@ public class JSONTokener {
         if ("".equals(string)) {
             throw this.syntaxError("Missing value");
         }
-        Object obj = JSONObject.stringToValue(string);
+        return JSONObject.stringToValue(string);
-        // if obj is a boolean, look at string
-        if (jsonParserConfiguration != null &&
-                jsonParserConfiguration.isStrictMode()) {
-            if (obj instanceof Boolean && !"true".equals(string) && !"false".equals(string)) {
-                // Strict mode only allows lowercase true or false
-                throw this.syntaxError(String.format("Strict mode error: Value '%s' is not lowercase boolean", obj));
-            }
-            else if (obj == JSONObject.NULL && !"null".equals(string)) {
-                // Strint mode only allows lowercase null
-                throw this.syntaxError(String.format("Strict mode error: Value '%s' is not lowercase null", obj));
-            }
-            else if (obj instanceof String) {
-                // Strict mode only allows strings with explicit double quotes
-                throw this.syntaxError(String.format("Strict mode error: Value '%s' is not surrounded by quotes", obj));
-            }
-        }
-        return obj;
     }
 
 
@@ -600,11 +525,6 @@ public class JSONTokener {
                 this.line + "]";
     }
 
-    /**
-     * Closes the underlying reader, releasing any resources associated with it.
-     *
-     * @throws IOException If an I/O error occurs while closing the reader.
-     */
     public void close() throws IOException {
         if(reader!=null){
             reader.close();

src/main/java/org/json/NumberConversionUtil.java

@@ -0,0 +1,152 @@
+package org.json;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+
+class NumberConversionUtil {
+
+    /**
+     * Converts a string to a number using the narrowest possible type. Possible
+     * returns for this function are BigDecimal, Double, BigInteger, Long, and Integer.
+     * When a Double is returned, it should always be a valid Double and not NaN or +-infinity.
+     *
+     * @param input value to convert
+     * @return Number representation of the value.
+     * @throws NumberFormatException thrown if the value is not a valid number. A public
+     *      caller should catch this and wrap it in a {@link JSONException} if applicable.
+     */
+    static Number stringToNumber(final String input) throws NumberFormatException {
+        String val = input;
+        if (val.startsWith(".")){
+            val = "0"+val;
+        }
+        if (val.startsWith("-.")){
+            val = "-0."+val.substring(2);
+        }
+        char initial = val.charAt(0);
+        if ( isNumericChar(initial) || initial == '-' ) {
+            // decimal representation
+            if (isDecimalNotation(val)) {
+                // Use a BigDecimal all the time so we keep the original
+                // representation. BigDecimal doesn't support -0.0, ensure we
+                // keep that by forcing a decimal.
+                try {
+                    BigDecimal bd = new BigDecimal(val);
+                    if(initial == '-' && BigDecimal.ZERO.compareTo(bd)==0) {
+                        return Double.valueOf(-0.0);
+                    }
+                    return bd;
+                } catch (NumberFormatException retryAsDouble) {
+                    // this is to support "Hex Floats" like this: 0x1.0P-1074
+                    try {
+                        Double d = Double.valueOf(val);
+                        if(d.isNaN() || d.isInfinite()) {
+                            throw new NumberFormatException("val ["+input+"] is not a valid number.");
+                        }
+                        return d;
+                    } catch (NumberFormatException ignore) {
+                        throw new NumberFormatException("val ["+input+"] is not a valid number.");
+                    }
+                }
+            }
+            val = removeLeadingZerosOfNumber(input);
+            initial = val.charAt(0);
+            if(initial == '0' && val.length() > 1) {
+                char at1 = val.charAt(1);
+                if(isNumericChar(at1)) {
+                    throw new NumberFormatException("val ["+input+"] is not a valid number.");
+                }
+            } else if (initial == '-' && val.length() > 2) {
+                char at1 = val.charAt(1);
+                char at2 = val.charAt(2);
+                if(at1 == '0' && isNumericChar(at2)) {
+                    throw new NumberFormatException("val ["+input+"] is not a valid number.");
+                }
+            }
+            // integer representation.
+            // This will narrow any values to the smallest reasonable Object representation
+            // (Integer, Long, or BigInteger)
+
+            // BigInteger down conversion: We use a similar bitLength compare as
+            // BigInteger#intValueExact uses. Increases GC, but objects hold
+            // only what they need. i.e. Less runtime overhead if the value is
+            // long lived.
+            BigInteger bi = new BigInteger(val);
+            if(bi.bitLength() <= 31){
+                return Integer.valueOf(bi.intValue());
+            }
+            if(bi.bitLength() <= 63){
+                return Long.valueOf(bi.longValue());
+            }
+            return bi;
+        }
+        throw new NumberFormatException("val ["+input+"] is not a valid number.");
+    }
+
+    /**
+     * Checks if the character is a numeric digit ('0' to '9').
+     *
+     * @param c The character to be checked.
+     * @return true if the character is a numeric digit, false otherwise.
+     */
+    private static boolean isNumericChar(char c) {
+        return (c <= '9' && c >= '0');
+    }
+
+    /**
+     * Checks if the value could be considered a number in decimal number system.
+     * @param value
+     * @return
+     */
+    static boolean potentialNumber(String value){
+        if (value == null || value.isEmpty()){
+            return false;
+        }
+        return potentialPositiveNumberStartingAtIndex(value, (value.charAt(0)=='-'?1:0));
+    }
+
+    /**
+     * Tests if the value should be tried as a decimal. It makes no test if there are actual digits.
+     *
+     * @param val value to test
+     * @return true if the string is "-0" or if it contains '.', 'e', or 'E', false otherwise.
+     */
+    private static boolean isDecimalNotation(final String val) {
+        return val.indexOf('.') > -1 || val.indexOf('e') > -1
+                || val.indexOf('E') > -1 || "-0".equals(val);
+    }
+
+    private static boolean potentialPositiveNumberStartingAtIndex(String value,int index){
+        if (index >= value.length()){
+            return false;
+        }
+        return digitAtIndex(value, (value.charAt(index)=='.'?index+1:index));
+    }
+
+    private static boolean digitAtIndex(String value, int index){
+        if (index >= value.length()){
+            return false;
+        }
+        return value.charAt(index) >= '0' && value.charAt(index) <= '9';
+    }
+
+    /**
+     * For a prospective number, remove the leading zeros
+     * @param value prospective number
+     * @return number without leading zeros
+     */
+    private static String removeLeadingZerosOfNumber(String value){
+        if (value.equals("-")){return value;}
+        boolean negativeFirstChar = (value.charAt(0) == '-');
+        int counter = negativeFirstChar ? 1:0;
+        while (counter < value.length()){
+            if (value.charAt(counter) != '0'){
+                if (negativeFirstChar) {return "-".concat(value.substring(counter));}
+                return value.substring(counter);
+            }
+            ++counter;
+        }
+        if (negativeFirstChar) {return "-0";}
+        return "0";
+    }
+}

src/main/java/org/json/ParserConfiguration.java

@@ -20,29 +20,20 @@ public class ParserConfiguration {
 
     /**
      * Specifies if values should be kept as strings (<code>true</code>), or if
-     * they should try to be guessed into JSON values (numeric, boolean, string).
+     * they should try to be guessed into JSON values (numeric, boolean, string)
      */
     protected boolean keepStrings;
 
     /**
-     * The maximum nesting depth when parsing an object.
+     * The maximum nesting depth when parsing a document.
      */
     protected int maxNestingDepth;
 
-    /**
-     * Constructs a new ParserConfiguration with default settings.
-     */
     public ParserConfiguration() {
         this.keepStrings = false;
         this.maxNestingDepth = DEFAULT_MAXIMUM_NESTING_DEPTH;
     }
 
-    /**
-     * Constructs a new ParserConfiguration with the specified settings.
-     *
-     * @param keepStrings     A boolean indicating whether to preserve strings during parsing.
-     * @param maxNestingDepth An integer representing the maximum allowed nesting depth.
-     */
     protected ParserConfiguration(final boolean keepStrings, final int maxNestingDepth) {
         this.keepStrings = keepStrings;
         this.maxNestingDepth = maxNestingDepth;
@@ -66,7 +57,7 @@ public class ParserConfiguration {
 
     /**
      * When parsing the XML into JSONML, specifies if values should be kept as strings (<code>true</code>), or if
-     * they should try to be guessed into JSON values (numeric, boolean, string).
+     * they should try to be guessed into JSON values (numeric, boolean, string)
      *
      * @return The <code>keepStrings</code> configuration value.
      */
@@ -78,21 +69,22 @@ public class ParserConfiguration {
      * When parsing the XML into JSONML, specifies if values should be kept as strings (<code>true</code>), or if
      * they should try to be guessed into JSON values (numeric, boolean, string)
      *
-     * @param newVal new value to use for the <code>keepStrings</code> configuration option.
+     * @param newVal
+     *      new value to use for the <code>keepStrings</code> configuration option.
      * @param <T> the type of the configuration object
+     * 
      * @return The existing configuration will not be modified. A new configuration is returned.
      */
     @SuppressWarnings("unchecked")
     public <T extends ParserConfiguration> T withKeepStrings(final boolean newVal) {
-        T newConfig = (T) this.clone();
+        T newConfig = (T)this.clone();
         newConfig.keepStrings = newVal;
         return newConfig;
     }
 
     /**
      * The maximum nesting depth that the parser will descend before throwing an exception
-     * when parsing an object (e.g. Map, Collection) into JSON-related objects.
+     * when parsing the XML into JSONML.
-     *
      * @return the maximum nesting depth set for this configuration
      */
     public int getMaxNestingDepth() {
@@ -101,19 +93,18 @@ public class ParserConfiguration {
 
     /**
      * Defines the maximum nesting depth that the parser will descend before throwing an exception
-     * when parsing an object (e.g. Map, Collection) into JSON-related objects.
+     * when parsing the XML into JSONML. The default max nesting depth is 512, which means the parser
-     * The default max nesting depth is 512, which means the parser will throw a JsonException if
+     * will throw a JsonException if the maximum depth is reached.
-     * the maximum depth is reached.
      * Using any negative value as a parameter is equivalent to setting no limit to the nesting depth,
      * which means the parses will go as deep as the maximum call stack size allows.
-     *
      * @param maxNestingDepth the maximum nesting depth allowed to the XML parser
      * @param <T> the type of the configuration object
+     * 
      * @return The existing configuration will not be modified. A new configuration is returned.
      */
     @SuppressWarnings("unchecked")
     public <T extends ParserConfiguration> T withMaxNestingDepth(int maxNestingDepth) {
-        T newConfig = (T) this.clone();
+        T newConfig = (T)this.clone();
 
         if (maxNestingDepth > UNDEFINED_MAXIMUM_NESTING_DEPTH) {
             newConfig.maxNestingDepth = maxNestingDepth;

src/main/java/org/json/Property.java

@@ -13,13 +13,6 @@ import java.util.Properties;
  * @version 2015-05-05
  */
 public class Property {
-
-    /**
-     * Constructs a new Property object.
-     */
-    public Property() {
-    }
-
     /**
      * Converts a property file object into a JSONObject. The property file object is a table of name value pairs.
      * @param properties java.util.Properties

src/main/java/org/json/StringBuilderWriter.java

@@ -1,92 +0,0 @@
-package org.json;
-
-import java.io.IOException;
-import java.io.Writer;
-
-/**
- * Performance optimised alternative for {@link java.io.StringWriter}
- * using internally a {@link StringBuilder} instead of a {@link StringBuffer}.
- */
-public class StringBuilderWriter extends Writer {
-    private final StringBuilder builder;
-
-    /**
-     * Create a new string builder writer using the default initial string-builder buffer size.
-     */
-    public StringBuilderWriter() {
-        builder = new StringBuilder();
-        lock = builder;
-    }
-
-    /**
-     * Create a new string builder writer using the specified initial string-builder buffer size.
-     *
-     * @param initialSize The number of {@code char} values that will fit into this buffer
-     *                    before it is automatically expanded
-     *
-     * @throws IllegalArgumentException If {@code initialSize} is negative
-     */
-    public StringBuilderWriter(int initialSize) {
-        builder = new StringBuilder(initialSize);
-        lock = builder;
-    }
-
-    @Override
-    public void write(int c) {
-        builder.append((char) c);
-    }
-
-    @Override
-    public void write(char[] cbuf, int offset, int length) {
-        if ((offset < 0) || (offset > cbuf.length) || (length < 0) ||
-                ((offset + length) > cbuf.length) || ((offset + length) < 0)) {
-            throw new IndexOutOfBoundsException();
-        } else if (length == 0) {
-            return;
-        }
-        builder.append(cbuf, offset, length);
-    }
-
-    @Override
-    public void write(String str) {
-        builder.append(str);
-    }
-
-    @Override
-    public void write(String str, int offset, int length) {
-        builder.append(str, offset, offset + length);
-    }
-
-    @Override
-    public StringBuilderWriter append(CharSequence csq) {
-        write(String.valueOf(csq));
-        return this;
-    }
-
-    @Override
-    public StringBuilderWriter append(CharSequence csq, int start, int end) {
-        if (csq == null) {
-            csq = "null";
-        }
-        return append(csq.subSequence(start, end));
-    }
-
-    @Override
-    public StringBuilderWriter append(char c) {
-        write(c);
-        return this;
-    }
-
-    @Override
-    public String toString() {
-        return builder.toString();
-    }
-
-    @Override
-    public void flush() {
-    }
-
-    @Override
-    public void close() throws IOException {
-    }
-}

src/main/java/org/json/XML.java

@@ -10,6 +10,10 @@ import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.util.Iterator;
 
+import static org.json.NumberConversionUtil.potentialNumber;
+import static org.json.NumberConversionUtil.stringToNumber;
+
+
 /**
  * This provides static methods to convert an XML text into a JSONObject, and to
  * covert a JSONObject into an XML text.
@@ -20,12 +24,6 @@ import java.util.Iterator;
 @SuppressWarnings("boxing")
 public class XML {
 
-    /**
-     * Constructs a new XML object.
-     */
-    public XML() {
-    }
-
     /** The Character '&'. */
     public static final Character AMP = '&';
 
@@ -58,9 +56,6 @@ public class XML {
      */
     public static final String NULL_ATTR = "xsi:nil";
 
-    /**
-     * Represents the XML attribute name for specifying type information.
-     */
     public static final String TYPE_ATTR = "xsi:type";
 
     /**
@@ -355,20 +350,10 @@ public class XML {
                                 && TYPE_ATTR.equals(string)) {
                             xmlXsiTypeConverter = config.getXsiTypeMap().get(token);
                         } else if (!nilAttributeFound) {
-                            Object obj = stringToValue((String) token);
-                            if (obj instanceof Boolean) {
                             jsonObject.accumulate(string,
-                                        config.isKeepBooleanAsString()
+                                    config.isKeepStrings()
                                             ? ((String) token)
-                                                : obj);
+                                            : stringToValue((String) token));
-                            } else if (obj instanceof Number) {
-                                jsonObject.accumulate(string,
-                                        config.isKeepNumberAsString()
-                                                ? ((String) token)
-                                                : obj);
-                            } else {
-                                jsonObject.accumulate(string, stringToValue((String) token));
-                            }
                         }
                         token = null;
                     } else {
@@ -417,23 +402,8 @@ public class XML {
                                     jsonObject.accumulate(config.getcDataTagName(),
                                             stringToValue(string, xmlXsiTypeConverter));
                                 } else {
-                                    Object obj = stringToValue((String) token);
-                                    if (obj instanceof Boolean) {
                                     jsonObject.accumulate(config.getcDataTagName(),
-                                                config.isKeepBooleanAsString()
+                                            config.isKeepStrings() ? string : stringToValue(string));
-                                                        ? ((String) token)
-                                                        : obj);
-                                    } else if (obj instanceof Number) {
-                                        jsonObject.accumulate(config.getcDataTagName(),
-                                                config.isKeepNumberAsString()
-                                                        ? ((String) token)
-                                                        : obj);
-                                    } else if (obj == JSONObject.NULL) {
-                                        jsonObject.accumulate(config.getcDataTagName(),
-                                                config.isKeepStrings() ? ((String) token) : obj);
-                                    } else {
-                                        jsonObject.accumulate(config.getcDataTagName(), stringToValue((String) token));
-                                    }
                                 }
                             }
 
@@ -520,76 +490,6 @@ public class XML {
         return true;
     }
 
-    /**
-     * direct copy of {@link JSONObject#stringToNumber(String)} to maintain Android support.
-     */
-    private static Number stringToNumber(final String val) throws NumberFormatException {
-        char initial = val.charAt(0);
-        if ((initial >= '0' && initial <= '9') || initial == '-') {
-            // decimal representation
-            if (isDecimalNotation(val)) {
-                // Use a BigDecimal all the time so we keep the original
-                // representation. BigDecimal doesn't support -0.0, ensure we
-                // keep that by forcing a decimal.
-                try {
-                    BigDecimal bd = new BigDecimal(val);
-                    if(initial == '-' && BigDecimal.ZERO.compareTo(bd)==0) {
-                        return Double.valueOf(-0.0);
-                    }
-                    return bd;
-                } catch (NumberFormatException retryAsDouble) {
-                    // this is to support "Hex Floats" like this: 0x1.0P-1074
-                    try {
-                        Double d = Double.valueOf(val);
-                        if(d.isNaN() || d.isInfinite()) {
-                            throw new NumberFormatException("val ["+val+"] is not a valid number.");
-                        }
-                        return d;
-                    } catch (NumberFormatException ignore) {
-                        throw new NumberFormatException("val ["+val+"] is not a valid number.");
-                    }
-                }
-            }
-            // block items like 00 01 etc. Java number parsers treat these as Octal.
-            if(initial == '0' && val.length() > 1) {
-                char at1 = val.charAt(1);
-                if(at1 >= '0' && at1 <= '9') {
-                    throw new NumberFormatException("val ["+val+"] is not a valid number.");
-                }
-            } else if (initial == '-' && val.length() > 2) {
-                char at1 = val.charAt(1);
-                char at2 = val.charAt(2);
-                if(at1 == '0' && at2 >= '0' && at2 <= '9') {
-                    throw new NumberFormatException("val ["+val+"] is not a valid number.");
-                }
-            }
-            // integer representation.
-            // This will narrow any values to the smallest reasonable Object representation
-            // (Integer, Long, or BigInteger)
-
-            // BigInteger down conversion: We use a similar bitLength compare as
-            // BigInteger#intValueExact uses. Increases GC, but objects hold
-            // only what they need. i.e. Less runtime overhead if the value is
-            // long lived.
-            BigInteger bi = new BigInteger(val);
-            if(bi.bitLength() <= 31){
-                return Integer.valueOf(bi.intValue());
-            }
-            if(bi.bitLength() <= 63){
-                return Long.valueOf(bi.longValue());
-            }
-            return bi;
-        }
-        throw new NumberFormatException("val ["+val+"] is not a valid number.");
-    }
-
-    /**
-     * direct copy of {@link JSONObject#isDecimalNotation(String)} to maintain Android support.
-     */
-    private static boolean isDecimalNotation(final String val) {
-        return val.indexOf('.') > -1 || val.indexOf('e') > -1
-                || val.indexOf('E') > -1 || "-0".equals(val);
-    }
 
     /**
      * This method tries to convert the given string value to the target object
@@ -634,8 +534,7 @@ public class XML {
          * produced, then the value will just be a string.
          */
 
-        char initial = string.charAt(0);
+        if (potentialNumber(string)) {
-        if ((initial >= '0' && initial <= '9') || initial == '-') {
             try {
                 return stringToNumber(string);
             } catch (Exception ignore) {
@@ -644,6 +543,11 @@ public class XML {
         return string;
     }
 
+
+
+
+
+
     /**
      * Convert a well-formed (but not necessarily valid) XML string into a
      * JSONObject. Some information may be lost in this transformation because
@@ -713,44 +617,6 @@ public class XML {
         return toJSONObject(reader, XMLParserConfiguration.ORIGINAL);
     }
 
-    /**
-     * Convert a well-formed (but not necessarily valid) XML into a
-     * JSONObject. Some information may be lost in this transformation because
-     * JSON is a data format and XML is a document format. XML uses elements,
-     * attributes, and content text, while JSON uses unordered collections of
-     * name/value pairs and arrays of values. JSON does not does not like to
-     * distinguish between elements and attributes. Sequences of similar
-     * elements are represented as JSONArrays. Content text may be placed in a
-     * "content" member. Comments, prologs, DTDs, and <pre>{@code
-     * &lt;[ [ ]]>}</pre>
-     * are ignored.
-     *
-     * All numbers are converted as strings, for 1, 01, 29.0 will not be coerced to
-     * numbers but will instead be the exact value as seen in the XML document depending
-     * on how flag is set.
-     * All booleans are converted as strings, for true, false will not be coerced to
-     * booleans but will instead be the exact value as seen in the XML document depending
-     * on how flag is set.
-     *
-     * @param reader The XML source reader.
-     * @param keepNumberAsString If true, then numeric values will not be coerced into
-     *  numeric values and will instead be left as strings
-     * @param keepBooleanAsString If true, then boolean values will not be coerced into
-     *      *  numeric values and will instead be left as strings
-     * @return A JSONObject containing the structured data from the XML string.
-     * @throws JSONException Thrown if there is an errors while parsing the string
-     */
-    public static JSONObject toJSONObject(Reader reader, boolean keepNumberAsString, boolean keepBooleanAsString) throws JSONException {
-        XMLParserConfiguration xmlParserConfiguration = new XMLParserConfiguration();
-        if(keepNumberAsString) {
-            xmlParserConfiguration = xmlParserConfiguration.withKeepNumberAsString(keepNumberAsString);
-        }
-        if(keepBooleanAsString) {
-            xmlParserConfiguration = xmlParserConfiguration.withKeepBooleanAsString(keepBooleanAsString);
-        }
-        return toJSONObject(reader, xmlParserConfiguration);
-    }
-
     /**
      * Convert a well-formed (but not necessarily valid) XML into a
      * JSONObject. Some information may be lost in this transformation because
@@ -809,38 +675,6 @@ public class XML {
         return toJSONObject(new StringReader(string), keepStrings);
     }
 
-    /**
-     * Convert a well-formed (but not necessarily valid) XML string into a
-     * JSONObject. Some information may be lost in this transformation because
-     * JSON is a data format and XML is a document format. XML uses elements,
-     * attributes, and content text, while JSON uses unordered collections of
-     * name/value pairs and arrays of values. JSON does not does not like to
-     * distinguish between elements and attributes. Sequences of similar
-     * elements are represented as JSONArrays. Content text may be placed in a
-     * "content" member. Comments, prologs, DTDs, and <pre>{@code
-     * &lt;[ [ ]]>}</pre>
-     * are ignored.
-     *
-     * All numbers are converted as strings, for 1, 01, 29.0 will not be coerced to
-     * numbers but will instead be the exact value as seen in the XML document depending
-     * on how flag is set.
-     * All booleans are converted as strings, for true, false will not be coerced to
-     * booleans but will instead be the exact value as seen in the XML document depending
-     * on how flag is set.
-     *
-     * @param string
-     *            The source string.
-     * @param keepNumberAsString If true, then numeric values will not be coerced into
-     *  numeric values and will instead be left as strings
-     * @param keepBooleanAsString If true, then boolean values will not be coerced into
-     *  numeric values and will instead be left as strings
-     * @return A JSONObject containing the structured data from the XML string.
-     * @throws JSONException Thrown if there is an errors while parsing the string
-     */
-    public static JSONObject toJSONObject(String string, boolean keepNumberAsString, boolean keepBooleanAsString) throws JSONException {
-        return toJSONObject(new StringReader(string), keepNumberAsString, keepBooleanAsString);
-    }
-
     /**
      * Convert a well-formed (but not necessarily valid) XML string into a
      * JSONObject. Some information may be lost in this transformation because
@@ -1132,4 +966,5 @@ public class XML {
         }
         return sb.toString();
     }
+
 }

src/main/java/org/json/XMLParserConfiguration.java

@@ -22,16 +22,6 @@ public class XMLParserConfiguration extends ParserConfiguration {
      */
 //    public static final int DEFAULT_MAXIMUM_NESTING_DEPTH = 512; // We could override
 
-    /**
-     * Allow user to control how numbers are parsed
-     */
-    private boolean keepNumberAsString;
-
-    /**
-     * Allow user to control how booleans are parsed
-     */
-    private boolean keepBooleanAsString;
-
     /** Original Configuration of the XML Parser. */
     public static final XMLParserConfiguration ORIGINAL
         = new XMLParserConfiguration();
@@ -152,9 +142,7 @@ public class XMLParserConfiguration extends ParserConfiguration {
      */
     @Deprecated
     public XMLParserConfiguration (final boolean keepStrings, final String cDataTagName, final boolean convertNilAttributeToNull) {
-        super(false, DEFAULT_MAXIMUM_NESTING_DEPTH);
+        super(keepStrings, DEFAULT_MAXIMUM_NESTING_DEPTH);
-        this.keepNumberAsString = keepStrings;
-        this.keepBooleanAsString = keepStrings;
         this.cDataTagName = cDataTagName;
         this.convertNilAttributeToNull = convertNilAttributeToNull;
     }
@@ -175,10 +163,8 @@ public class XMLParserConfiguration extends ParserConfiguration {
      */
     private XMLParserConfiguration (final boolean keepStrings, final String cDataTagName,
             final boolean convertNilAttributeToNull, final Map<String, XMLXsiTypeConverter<?>> xsiTypeMap, final Set<String> forceList,
-            final int maxNestingDepth, final boolean closeEmptyTag, final boolean keepNumberAsString, final boolean keepBooleanAsString) {
+            final int maxNestingDepth, final boolean closeEmptyTag) {
-        super(false, maxNestingDepth);
+        super(keepStrings, maxNestingDepth);
-        this.keepNumberAsString = keepNumberAsString;
-        this.keepBooleanAsString = keepBooleanAsString;
         this.cDataTagName = cDataTagName;
         this.convertNilAttributeToNull = convertNilAttributeToNull;
         this.xsiTypeMap = Collections.unmodifiableMap(xsiTypeMap);
@@ -203,9 +189,7 @@ public class XMLParserConfiguration extends ParserConfiguration {
                 this.xsiTypeMap,
                 this.forceList,
                 this.maxNestingDepth,
-                this.closeEmptyTag,
+                this.closeEmptyTag
-                this.keepNumberAsString,
-                this.keepBooleanAsString
         );
         config.shouldTrimWhiteSpace = this.shouldTrimWhiteSpace;
         return config;
@@ -223,43 +207,7 @@ public class XMLParserConfiguration extends ParserConfiguration {
     @SuppressWarnings("unchecked")
     @Override
     public XMLParserConfiguration withKeepStrings(final boolean newVal) {
-        XMLParserConfiguration newConfig = this.clone();
+        return super.withKeepStrings(newVal);
-        newConfig.keepStrings = newVal;
-        newConfig.keepNumberAsString = newVal;
-        newConfig.keepBooleanAsString = newVal;
-        return newConfig;
-    }
-
-    /**
-     * When parsing the XML into JSON, specifies if numbers should be kept as strings (<code>1</code>), or if
-     * they should try to be guessed into JSON values (numeric, boolean, string)
-     *
-     * @param newVal
-     *      new value to use for the <code>keepNumberAsString</code> configuration option.
-     *
-     * @return The existing configuration will not be modified. A new configuration is returned.
-     */
-    public XMLParserConfiguration withKeepNumberAsString(final boolean newVal) {
-        XMLParserConfiguration newConfig = this.clone();
-        newConfig.keepNumberAsString = newVal;
-        newConfig.keepStrings = newConfig.keepBooleanAsString && newConfig.keepNumberAsString;
-        return newConfig;
-    }
-
-    /**
-     * When parsing the XML into JSON, specifies if booleans should be kept as strings (<code>true</code>), or if
-     * they should try to be guessed into JSON values (numeric, boolean, string)
-     *
-     * @param newVal
-     *      new value to use for the <code>withKeepBooleanAsString</code> configuration option.
-     *
-     * @return The existing configuration will not be modified. A new configuration is returned.
-     */
-    public XMLParserConfiguration withKeepBooleanAsString(final boolean newVal) {
-        XMLParserConfiguration newConfig = this.clone();
-        newConfig.keepBooleanAsString = newVal;
-        newConfig.keepStrings = newConfig.keepBooleanAsString && newConfig.keepNumberAsString;
-        return newConfig;
     }
 
     /**
@@ -273,26 +221,6 @@ public class XMLParserConfiguration extends ParserConfiguration {
         return this.cDataTagName;
     }
 
-    /**
-     * When parsing the XML into JSONML, specifies if numbers should be kept as strings (<code>true</code>), or if
-     * they should try to be guessed into JSON values (numeric, boolean, string).
-     *
-     * @return The <code>keepStrings</code> configuration value.
-     */
-    public boolean isKeepNumberAsString() {
-        return this.keepNumberAsString;
-    }
-
-    /**
-     * When parsing the XML into JSONML, specifies if booleans should be kept as strings (<code>true</code>), or if
-     * they should try to be guessed into JSON values (numeric, boolean, string).
-     *
-     * @return The <code>keepStrings</code> configuration value.
-     */
-    public boolean isKeepBooleanAsString() {
-        return this.keepBooleanAsString;
-    }
-
     /**
      * The name of the key in a JSON Object that indicates a CDATA section. Historically this has
      * been the value "content" but can be changed. Use <code>null</code> to indicate no CDATA
@@ -424,20 +352,9 @@ public class XMLParserConfiguration extends ParserConfiguration {
         return clonedConfiguration;
     }
 
-    /**
-     * Checks if the parser should automatically close empty XML tags.
-     *
-     * @return {@code true} if empty XML tags should be automatically closed, {@code false} otherwise.
-     */
     public boolean isCloseEmptyTag() {
         return this.closeEmptyTag;
     }
-
-    /**
-     * Checks if the parser should trim white spaces from XML content.
-     *
-     * @return {@code true} if white spaces should be trimmed, {@code false} otherwise.
-     */
     public boolean shouldTrimWhiteSpace() {
         return this.shouldTrimWhiteSpace;
     }

src/main/java/org/json/XMLXsiTypeConverter.java

@@ -42,12 +42,5 @@ Public Domain.
  * @param <T> return type of convert method
  */
 public interface XMLXsiTypeConverter<T> {
-
-    /**
-     * Converts an XML xsi:type attribute value to the specified type {@code T}.
-     *
-     * @param value The string representation of the XML xsi:type attribute value to be converted.
-     * @return An object of type {@code T} representing the converted value.
-     */
     T convert(String value);
 }

src/test/java/org/json/NumberConversionUtilTest.java

@@ -0,0 +1,174 @@
+package org.json;
+
+import org.junit.Test;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+
+import static org.junit.Assert.*;
+
+public class NumberConversionUtilTest {
+
+    @Test
+    public void shouldParseDecimalFractionNumbersWithMultipleLeadingZeros(){
+        Number number = NumberConversionUtil.stringToNumber("00.10d");
+        assertEquals("Do not match",  0.10d, number.doubleValue(),0.0d);
+        assertEquals("Do not match",  0.10f, number.floatValue(),0.0f);
+        assertEquals("Do not match",  0, number.longValue(),0);
+        assertEquals("Do not match",  0, number.intValue(),0);
+    }
+
+    @Test
+    public void shouldParseDecimalFractionNumbersWithSingleLeadingZero(){
+        Number number = NumberConversionUtil.stringToNumber("0.10d");
+        assertEquals("Do not match",  0.10d, number.doubleValue(),0.0d);
+        assertEquals("Do not match",  0.10f, number.floatValue(),0.0f);
+        assertEquals("Do not match",  0, number.longValue(),0);
+        assertEquals("Do not match",  0, number.intValue(),0);
+    }
+
+
+    @Test
+    public void shouldParseDecimalFractionNumbersWithZerosAfterDecimalPoint(){
+        Number number = NumberConversionUtil.stringToNumber("0.010d");
+        assertEquals("Do not match",  0.010d, number.doubleValue(),0.0d);
+        assertEquals("Do not match",  0.010f, number.floatValue(),0.0f);
+        assertEquals("Do not match",  0, number.longValue(),0);
+        assertEquals("Do not match",  0, number.intValue(),0);
+    }
+
+    @Test
+    public void shouldParseMixedDecimalFractionNumbersWithMultipleLeadingZeros(){
+        Number number = NumberConversionUtil.stringToNumber("00200.10d");
+        assertEquals("Do not match",  200.10d, number.doubleValue(),0.0d);
+        assertEquals("Do not match",  200.10f, number.floatValue(),0.0f);
+        assertEquals("Do not match",  200, number.longValue(),0);
+        assertEquals("Do not match",  200, number.intValue(),0);
+    }
+
+    @Test
+    public void shouldParseMixedDecimalFractionNumbersWithoutLeadingZero(){
+        Number number = NumberConversionUtil.stringToNumber("200.10d");
+        assertEquals("Do not match",  200.10d, number.doubleValue(),0.0d);
+        assertEquals("Do not match",  200.10f, number.floatValue(),0.0f);
+        assertEquals("Do not match",  200, number.longValue(),0);
+        assertEquals("Do not match",  200, number.intValue(),0);
+    }
+
+
+    @Test
+    public void shouldParseMixedDecimalFractionNumbersWithZerosAfterDecimalPoint(){
+        Number number = NumberConversionUtil.stringToNumber("200.010d");
+        assertEquals("Do not match",  200.010d, number.doubleValue(),0.0d);
+        assertEquals("Do not match",  200.010f, number.floatValue(),0.0f);
+        assertEquals("Do not match",  200, number.longValue(),0);
+        assertEquals("Do not match",  200, number.intValue(),0);
+    }
+
+
+    @Test
+    public void shouldParseNegativeDecimalFractionNumbersWithMultipleLeadingZeros(){
+        Number number = NumberConversionUtil.stringToNumber("-00.10d");
+        assertEquals("Do not match",  -0.10d, number.doubleValue(),0.0d);
+        assertEquals("Do not match",  -0.10f, number.floatValue(),0.0f);
+        assertEquals("Do not match",  -0, number.longValue(),0);
+        assertEquals("Do not match",  -0, number.intValue(),0);
+    }
+
+    @Test
+    public void shouldParseNegativeDecimalFractionNumbersWithSingleLeadingZero(){
+        Number number = NumberConversionUtil.stringToNumber("-0.10d");
+        assertEquals("Do not match",  -0.10d, number.doubleValue(),0.0d);
+        assertEquals("Do not match",  -0.10f, number.floatValue(),0.0f);
+        assertEquals("Do not match",  -0, number.longValue(),0);
+        assertEquals("Do not match",  -0, number.intValue(),0);
+    }
+
+
+    @Test
+    public void shouldParseNegativeDecimalFractionNumbersWithZerosAfterDecimalPoint(){
+        Number number = NumberConversionUtil.stringToNumber("-0.010d");
+        assertEquals("Do not match",  -0.010d, number.doubleValue(),0.0d);
+        assertEquals("Do not match",  -0.010f, number.floatValue(),0.0f);
+        assertEquals("Do not match",  -0, number.longValue(),0);
+        assertEquals("Do not match",  -0, number.intValue(),0);
+    }
+
+    @Test
+    public void shouldParseNegativeMixedDecimalFractionNumbersWithMultipleLeadingZeros(){
+        Number number = NumberConversionUtil.stringToNumber("-00200.10d");
+        assertEquals("Do not match",  -200.10d, number.doubleValue(),0.0d);
+        assertEquals("Do not match",  -200.10f, number.floatValue(),0.0f);
+        assertEquals("Do not match",  -200, number.longValue(),0);
+        assertEquals("Do not match",  -200, number.intValue(),0);
+    }
+
+    @Test
+    public void shouldParseNegativeMixedDecimalFractionNumbersWithoutLeadingZero(){
+        Number number = NumberConversionUtil.stringToNumber("-200.10d");
+        assertEquals("Do not match",  -200.10d, number.doubleValue(),0.0d);
+        assertEquals("Do not match",  -200.10f, number.floatValue(),0.0f);
+        assertEquals("Do not match",  -200, number.longValue(),0);
+        assertEquals("Do not match",  -200, number.intValue(),0);
+    }
+
+
+    @Test
+    public void shouldParseNegativeMixedDecimalFractionNumbersWithZerosAfterDecimalPoint(){
+        Number number = NumberConversionUtil.stringToNumber("-200.010d");
+        assertEquals("Do not match",  -200.010d, number.doubleValue(),0.0d);
+        assertEquals("Do not match",  -200.010f, number.floatValue(),0.0f);
+        assertEquals("Do not match",  -200, number.longValue(),0);
+        assertEquals("Do not match",  -200, number.intValue(),0);
+    }
+
+    @Test
+    public void shouldParseNumbersWithExponents(){
+        Number number = NumberConversionUtil.stringToNumber("23.45e7");
+        assertEquals("Do not match",  23.45e7d, number.doubleValue(),0.0d);
+        assertEquals("Do not match",  23.45e7f, number.floatValue(),0.0f);
+        assertEquals("Do not match",  2.345E8, number.longValue(),0);
+        assertEquals("Do not match",  2.345E8, number.intValue(),0);
+    }
+
+
+    @Test
+    public void shouldParseNegativeNumbersWithExponents(){
+        Number number = NumberConversionUtil.stringToNumber("-23.45e7");
+        assertEquals("Do not match",  -23.45e7d, number.doubleValue(),0.0d);
+        assertEquals("Do not match",  -23.45e7f, number.floatValue(),0.0f);
+        assertEquals("Do not match",  -2.345E8, number.longValue(),0);
+        assertEquals("Do not match",  -2.345E8, number.intValue(),0);
+    }
+
+    @Test
+    public void shouldParseBigDecimal(){
+        Number number = NumberConversionUtil.stringToNumber("19007199254740993.35481234487103587486413587843213584");
+        assertTrue(number instanceof BigDecimal);
+    }
+
+    @Test
+    public void shouldParseBigInteger(){
+        Number number = NumberConversionUtil.stringToNumber("1900719925474099335481234487103587486413587843213584");
+        assertTrue(number instanceof BigInteger);
+    }
+
+    @Test
+    public void shouldIdentifyPotentialNumber(){
+        assertTrue("Does not identify as number", NumberConversionUtil.potentialNumber("112.123"));
+        assertTrue("Does not identify as number", NumberConversionUtil.potentialNumber("112e123"));
+        assertTrue("Does not identify as number", NumberConversionUtil.potentialNumber("-112.123"));
+        assertTrue("Does not identify as number", NumberConversionUtil.potentialNumber("-112e23"));
+        assertFalse("Does not identify as not number", NumberConversionUtil.potentialNumber("--112.123"));
+        assertFalse("Does not identify as not number", NumberConversionUtil.potentialNumber("-a112.123"));
+        assertFalse("Does not identify as not number", NumberConversionUtil.potentialNumber("a112.123"));
+        assertFalse("Does not identify as not number", NumberConversionUtil.potentialNumber("e112.123"));
+    }
+
+    @Test(expected = NumberFormatException.class)
+    public void shouldExpectExceptionWhenNumberIsNotFormatted(){
+        NumberConversionUtil.stringToNumber("112.aa123");
+    }
+
+
+}

src/test/java/org/json/junit/CDLTest.java

@@ -24,13 +24,14 @@ public class CDLTest {
      * String of lines where the column names are in the first row,
      * and all subsequent rows are values. All keys and values should be legal.
      */
-    private static final String LINES = "Col 1, Col 2,  \tCol 3, Col 4, Col 5, Col 6, Col 7\n" +
+    String lines = new String(
+            "Col 1, Col 2,  \tCol 3, Col 4, Col 5, Col 6, Col 7\n" +
             "val1, val2, val3, val4, val5, val6, val7\n" +
             "1, 2, 3, 4\t, 5, 6, 7\n" +
             "true, false, true, true, false, false, false\n" +
             "0.23, 57.42, 5e27, -234.879, 2.34e5, 0.0, 9e-3\n" +
-			"\"va\tl1\", \"v\bal2\", \"val3\", \"val\f4\", \"val5\", \"va'l6\", val7\n";
+            "\"va\tl1\", \"v\bal2\", \"val3\", \"val\f4\", \"val5\", va\'l6, val7\n"
-
+    );
 
     /**
      * CDL.toJSONArray() adds all values as strings, with no filtering or 
@@ -38,54 +39,12 @@ public class CDLTest {
      * values all must be quoted in the cases where the JSONObject parsing 
      * might normally convert the value into a non-string. 
      */
-    private static final String EXPECTED_LINES =
+    String expectedLines = new String(
-            "[  " +
+            "[{Col 1:val1, Col 2:val2, Col 3:val3, Col 4:val4, Col 5:val5, Col 6:val6, Col 7:val7}, "+
-                "{" +
+            "{Col 1:\"1\", Col 2:\"2\", Col 3:\"3\", Col 4:\"4\", Col 5:\"5\", Col 6:\"6\", Col 7:\"7\"}, "+
-                    "\"Col 1\":\"val1\", " +
+            "{Col 1:\"true\", Col 2:\"false\", Col 3:\"true\", Col 4:\"true\", Col 5:\"false\", Col 6:\"false\", Col 7:\"false\"}, "+
-                    "\"Col 2\":\"val2\", " +
+            "{Col 1:\"0.23\", Col 2:\"57.42\", Col 3:\"5e27\", Col 4:\"-234.879\", Col 5:\"2.34e5\", Col 6:\"0.0\", Col 7:\"9e-3\"}, "+
-                    "\"Col 3\":\"val3\", " +
+            "{Col 1:\"va\tl1\", Col 2:\"v\bal2\", Col 3:val3, Col 4:\"val\f4\", Col 5:val5, Col 6:va\'l6, Col 7:val7}]");
-                    "\"Col 4\":\"val4\", " +
-                    "\"Col 5\":\"val5\", " +
-                    "\"Col 6\":\"val6\", " +
-                    "\"Col 7\":\"val7\"" +
-                "}, " +
-			"   {" +
-                    "\"Col 1\":\"1\", " +
-                    "\"Col 2\":\"2\", " +
-                    "\"Col 3\":\"3\", " +
-                    "\"Col 4\":\"4\", " +
-                    "\"Col 5\":\"5\", " +
-                    "\"Col 6\":\"6\", " +
-                    "\"Col 7\":\"7\"" +
-                "}, " +
-			"   {" +
-                    "\"Col 1\":\"true\", " +
-                    "\"Col 2\":\"false\", " +
-                    "\"Col 3\":\"true\", " +
-                    "\"Col 4\":\"true\", " +
-                    "\"Col 5\":\"false\", " +
-                    "\"Col 6\":\"false\", " +
-                    "\"Col 7\":\"false\"" +
-                "}, " +
-			    "{" +
-                    "\"Col 1\":\"0.23\", " +
-                    "\"Col 2\":\"57.42\", " +
-                    "\"Col 3\":\"5e27\", " +
-                    "\"Col 4\":\"-234.879\", " +
-                    "\"Col 5\":\"2.34e5\", " +
-                    "\"Col 6\":\"0.0\", " +
-                    "\"Col 7\":\"9e-3\"" +
-                "}, " +
-			    "{" +
-                    "\"Col 1\":\"va\tl1\", " +
-                    "\"Col 2\":\"v\bal2\", " +
-                    "\"Col 3\":\"val3\", " +
-                    "\"Col 4\":\"val\f4\", " +
-                    "\"Col 5\":\"val5\", " +
-                    "\"Col 6\":\"va'l6\", " +
-                    "\"Col 7\":\"val7\"" +
-                "}" +
-            "]";
 
     /**
      * Attempts to create a JSONArray from a null string.
@@ -168,33 +127,6 @@ public class CDLTest {
            }
     }
 
-    /**
-     * Csv parsing skip last row if last field of this row is empty #943
-     */
-    @Test
-    public void csvParsingCatchesLastRow(){
-        String data = "Field 1,Field 2,Field 3\n" +
-                "value11,value12,\n" +
-                "value21,value22,";
-
-        JSONArray jsonArray = CDL.toJSONArray(data);
-
-        JSONArray expectedJsonArray = new JSONArray();
-        JSONObject jsonObject = new JSONObject();
-        jsonObject.put("Field 1", "value11");
-        jsonObject.put("Field 2", "value12");
-        jsonObject.put("Field 3", "");
-        expectedJsonArray.put(jsonObject);
-
-        jsonObject = new JSONObject();
-        jsonObject.put("Field 1", "value21");
-        jsonObject.put("Field 2", "value22");
-        jsonObject.put("Field 3", "");
-        expectedJsonArray.put(jsonObject);
-
-        Util.compareActualVsExpectedJsonArrays(jsonArray, expectedJsonArray);
-    }
-
     /**
      * Assert that there is no error for a single escaped quote within a properly embedded quote.
      */
@@ -262,7 +194,8 @@ public class CDLTest {
     public void emptyString() {
         String emptyStr = "";
         JSONArray jsonArray = CDL.toJSONArray(emptyStr);
-		assertNull("CDL should return null when the input string is empty", jsonArray);
+        assertTrue("CDL should return null when the input string is empty",
+                jsonArray == null);
     }
 
     /**
@@ -321,7 +254,7 @@ public class CDLTest {
         jsonObject.put("Col \r1", "V1");
         // \r will be filtered from value
         jsonObject.put("Col 2", "V2\r");
-		assertEquals("expected length should be 1", 1, jsonArray.length());
+        assertTrue("expected length should be 1",jsonArray.length() == 1);
         String cdlStr = CDL.toString(jsonArray);
         jsonObject = jsonArray.getJSONObject(0);
         assertTrue(cdlStr.contains("\"Col 1\""));
@@ -335,15 +268,8 @@ public class CDLTest {
      */
     @Test
     public void textToJSONArray() {
-        JSONArray jsonArray = CDL.toJSONArray(LINES);
+        JSONArray jsonArray = CDL.toJSONArray(this.lines);
-        JSONArray expectedJsonArray = new JSONArray(EXPECTED_LINES);
+        JSONArray expectedJsonArray = new JSONArray(this.expectedLines);
-        Util.compareActualVsExpectedJsonArrays(jsonArray, expectedJsonArray);
-    }
-    @Test
-    public void textToJSONArrayPipeDelimited() {
-        char delimiter = '|';
-        JSONArray jsonArray = CDL.toJSONArray(LINES.replaceAll(",", String.valueOf(delimiter)), delimiter);
-        JSONArray expectedJsonArray = new JSONArray(EXPECTED_LINES);
         Util.compareActualVsExpectedJsonArrays(jsonArray, expectedJsonArray);
     }
 
@@ -353,11 +279,11 @@ public class CDLTest {
      */
     @Test
     public void jsonArrayToJSONArray() {
-        String nameArrayStr = "[\"Col1\", \"Col2\"]";
+        String nameArrayStr = "[Col1, Col2]";
         String values = "V1, V2";
         JSONArray nameJSONArray = new JSONArray(nameArrayStr);
         JSONArray jsonArray = CDL.toJSONArray(nameJSONArray, values);
-        JSONArray expectedJsonArray = new JSONArray("[{\"Col1\":\"V1\",\"Col2\":\"V2\"}]");
+        JSONArray expectedJsonArray = new JSONArray("[{Col1:V1,Col2:V2}]");
         Util.compareActualVsExpectedJsonArrays(jsonArray, expectedJsonArray);
     }
 
@@ -367,24 +293,10 @@ public class CDLTest {
      */
     @Test
     public void textToJSONArrayAndBackToString() {
-        JSONArray jsonArray = CDL.toJSONArray(LINES);
+        JSONArray jsonArray = CDL.toJSONArray(this.lines);
         String jsonStr = CDL.toString(jsonArray);
         JSONArray finalJsonArray = CDL.toJSONArray(jsonStr);
-        JSONArray expectedJsonArray = new JSONArray(EXPECTED_LINES);
+        JSONArray expectedJsonArray = new JSONArray(this.expectedLines);
-        Util.compareActualVsExpectedJsonArrays(finalJsonArray, expectedJsonArray);
-    }
-
-    /**
-     * Create a JSONArray from a string of lines,
-     * then convert to string and then back to JSONArray
-     * with a custom delimiter
-     */
-    @Test
-    public void textToJSONArrayAndBackToStringCustomDelimiter() {
-        JSONArray jsonArray = CDL.toJSONArray(LINES, ',');
-        String jsonStr = CDL.toString(jsonArray, ';');
-        JSONArray finalJsonArray = CDL.toJSONArray(jsonStr, ';');
-        JSONArray expectedJsonArray = new JSONArray(EXPECTED_LINES);
         Util.compareActualVsExpectedJsonArrays(finalJsonArray, expectedJsonArray);
     }
     

src/test/java/org/json/junit/HTTPTokenerTest.java

@@ -1,107 +0,0 @@
-package org.json.junit;
-
-import org.json.HTTPTokener;
-import org.json.JSONException;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-/**
- * Tests for JSON-Java HTTPTokener.java
- */
-public class HTTPTokenerTest {
-
-    /**
-     * Test parsing a simple unquoted token.
-     */
-    @Test
-    public void parseSimpleToken() {
-        HTTPTokener tokener = new HTTPTokener("Content-Type");
-        String token = tokener.nextToken();
-        assertEquals("Content-Type", token);
-    }
-
-    /**
-     * Test parsing multiple tokens separated by whitespace.
-     */
-    @Test
-    public void parseMultipleTokens() {
-        HTTPTokener tokener = new HTTPTokener("Content-Type application/json");
-        String token1 = tokener.nextToken();
-        String token2 = tokener.nextToken();
-        assertEquals("Content-Type", token1);
-        assertEquals("application/json", token2);
-    }
-
-    /**
-     * Test parsing a double-quoted token.
-     */
-    @Test
-    public void parseDoubleQuotedToken() {
-        HTTPTokener tokener = new HTTPTokener("\"application/json\"");
-        String token = tokener.nextToken();
-        assertEquals("application/json", token);
-    }
-
-    /**
-     * Test parsing a single-quoted token.
-     */
-    @Test
-    public void parseSingleQuotedToken() {
-        HTTPTokener tokener = new HTTPTokener("'application/json'");
-        String token = tokener.nextToken();
-        assertEquals("application/json", token);
-    }
-
-    /**
-     * Test parsing a quoted token that includes spaces and semicolons.
-     */
-    @Test
-    public void parseQuotedTokenWithSpaces() {
-        HTTPTokener tokener = new HTTPTokener("\"text/html; charset=UTF-8\"");
-        String token = tokener.nextToken();
-        assertEquals("text/html; charset=UTF-8", token);
-    }
-
-    /**
-     * Test that unterminated quoted strings throw a JSONException.
-     */
-    @Test
-    public void throwExceptionOnUnterminatedString() {
-        HTTPTokener tokener = new HTTPTokener("\"incomplete");
-        JSONException exception = assertThrows(JSONException.class, tokener::nextToken);
-        assertTrue(exception.getMessage().contains("Unterminated string"));
-    }
-
-    /**
-     * Test behavior with empty input string.
-     */
-    @Test
-    public void parseEmptyInput() {
-        HTTPTokener tokener = new HTTPTokener("");
-        String token = tokener.nextToken();
-        assertEquals("", token);
-    }
-
-    /**
-     * Test behavior with input consisting only of whitespace.
-     */
-    @Test
-    public void parseWhitespaceOnly() {
-        HTTPTokener tokener = new HTTPTokener("   \t \n ");
-        String token = tokener.nextToken();
-        assertEquals("", token);
-    }
-
-    /**
-     * Test parsing tokens separated by multiple whitespace characters.
-     */
-    @Test
-    public void parseTokensWithMultipleWhitespace() {
-        HTTPTokener tokener = new HTTPTokener("GET     /index.html");
-        String method = tokener.nextToken();
-        String path = tokener.nextToken();
-        assertEquals("GET", method);
-        assertEquals("/index.html", path);
-    }
-
-}

src/test/java/org/json/junit/JSONArrayTest.java

@@ -8,7 +8,6 @@ import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
@@ -229,19 +228,6 @@ public class JSONArrayTest {
         Util.checkJSONArrayMaps(jaInt);
     }
 
-    @Test
-    public void jsonArrayByListWithNestedNullValue() {
-        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
-        Map<String, Object> sub = new HashMap<String, Object>();
-        sub.put("nullKey", null);	
-        list.add(sub);
-        JSONParserConfiguration parserConfiguration = new JSONParserConfiguration().withUseNativeNulls(true);
-        JSONArray jsonArray = new JSONArray(list, parserConfiguration);
-        JSONObject subObject = jsonArray.getJSONObject(0);
-        assertTrue(subObject.has("nullKey"));
-        assertEquals(JSONObject.NULL, subObject.get("nullKey"));
-    }
-
     /**
      * Tests consecutive calls to putAll with array and collection.
      */
@@ -273,11 +259,6 @@ public class JSONArrayTest {
                      jsonArray.length(),
                      len);
 
-	// collection as object
-        @SuppressWarnings("RedundantCast")
-        Object myListAsObject = (Object) myList;
-        jsonArray.putAll(myListAsObject);
-	    
         for (int i = 0; i < myList.size(); i++) {
             assertEquals("collection elements should be equal",
                          myList.get(i),
@@ -491,20 +472,10 @@ public class JSONArrayTest {
     @Test
     public void unquotedText() {
         String str = "[value1, something!, (parens), foo@bar.com, 23, 23+45]";
+        JSONArray jsonArray = new JSONArray(str);
         List<Object> expected = Arrays.asList("value1", "something!", "(parens)", "foo@bar.com", 23, "23+45");
-
-        // Test should fail if default strictMode is true, pass if false
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration();
-        if (jsonParserConfiguration.isStrictMode()) {
-            try {
-                JSONArray jsonArray = new JSONArray(str);
-                assertEquals("Expected to throw exception due to invalid string", true, false);
-            } catch (JSONException e) { }
-        } else {
-            JSONArray jsonArray = new JSONArray(str);
         assertEquals(expected, jsonArray.toList());
     }
-    }
 
     /**
      * Exercise JSONArray.join() by converting a JSONArray into a 
@@ -714,8 +685,8 @@ public class JSONArrayTest {
 
         String jsonArrayStr =
             "["+
-                "\"hello\","+
+                "hello,"+
-                "\"world\""+
+                "world"+
             "]";
         // 2
         jsonArray.put(new JSONArray(jsonArrayStr));
@@ -792,8 +763,8 @@ public class JSONArrayTest {
 
         String jsonArrayStr =
             "["+
-                "\"hello\","+
+                "hello,"+
-                "\"world\""+
+                "world"+
             "]";
         // 2
         jsonArray.put(2, new JSONArray(jsonArrayStr));
@@ -1528,14 +1499,6 @@ public class JSONArrayTest {
         new JSONArray(array);
     }
 
-    @Test
-    public void testStrictModeJSONTokener_expectException(){
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration().withStrictMode();
-        JSONTokener tokener = new JSONTokener("[\"value\"]invalidCharacters", jsonParserConfiguration);
-
-        assertThrows(JSONException.class, () -> { new JSONArray(tokener); });
-    }
-
     public static ArrayList<Object> buildNestedArray(int maxDepth) {
         if (maxDepth <= 0) {
             return new ArrayList<>();

src/test/java/org/json/junit/JSONMLTest.java

@@ -625,7 +625,7 @@ public class JSONMLTest {
                                 "\"subValue\","+
                                 "{\"svAttr\":\"svValue\"},"+
                                 "\"abc\""+
-                            "]"+
+                            "],"+
                         "],"+
                         "[\"value\",3],"+
                         "[\"value\",4.1],"+
@@ -709,7 +709,7 @@ public class JSONMLTest {
     @Test
     public void testToJSONArray_jsonOutput() {
         final String originalXml = "<root><id>01</id><id>1</id><id>00</id><id>0</id><item id=\"01\"/><title>True</title></root>";
-        final String expectedJsonString = "[\"root\",[\"id\",\"01\"],[\"id\",1],[\"id\",\"00\"],[\"id\",0],[\"item\",{\"id\":\"01\"}],[\"title\",true]]";
+        final String expectedJsonString = "[\"root\",[\"id\",1],[\"id\",1],[\"id\",0],[\"id\",0],[\"item\",{\"id\":1}],[\"title\",true]]";
         final JSONArray actualJsonOutput = JSONML.toJSONArray(originalXml, false);
         assertEquals(expectedJsonString, actualJsonOutput.toString());
     }

src/test/java/org/json/junit/JSONObjectDecimalTest.java

@@ -0,0 +1,100 @@
+package org.json.junit;
+
+import org.json.JSONObject;
+import org.junit.Test;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+
+import static org.junit.Assert.assertEquals;
+
+public class JSONObjectDecimalTest {
+
+    @Test
+    public void shouldParseDecimalNumberThatStartsWithDecimalPoint(){
+        JSONObject jsonObject = new JSONObject("{value:0.50}");
+        assertEquals("Float not recognized", 0.5f, jsonObject.getFloat("value"), 0.0f);
+        assertEquals("Float not recognized", 0.5f, jsonObject.optFloat("value"), 0.0f);
+        assertEquals("Float not recognized", 0.5f, jsonObject.optFloatObject("value"), 0.0f);
+        assertEquals("Double not recognized", 0.5d, jsonObject.optDouble("value"), 0.0f);
+        assertEquals("Double not recognized", 0.5d, jsonObject.optDoubleObject("value"), 0.0f);
+        assertEquals("Double not recognized", 0.5d, jsonObject.getDouble("value"), 0.0f);
+        assertEquals("Long not recognized", 0, jsonObject.optLong("value"), 0);
+        assertEquals("Long not recognized", 0, jsonObject.getLong("value"), 0);
+        assertEquals("Long not recognized", 0, jsonObject.optLongObject("value"), 0);
+        assertEquals("Integer not recognized", 0, jsonObject.optInt("value"), 0);
+        assertEquals("Integer not recognized", 0, jsonObject.getInt("value"), 0);
+        assertEquals("Integer not recognized", 0, jsonObject.optIntegerObject("value"), 0);
+        assertEquals("Number not recognized", 0, jsonObject.getNumber("value").intValue(), 0);
+        assertEquals("Number not recognized", 0, jsonObject.getNumber("value").longValue(), 0);
+        assertEquals("BigDecimal not recognized", 0, BigDecimal.valueOf(.5).compareTo(jsonObject.getBigDecimal("value")));
+        assertEquals("BigInteger not recognized",0, BigInteger.valueOf(0).compareTo(jsonObject.getBigInteger("value")));
+    }
+
+
+
+    @Test
+    public void shouldParseNegativeDecimalNumberThatStartsWithDecimalPoint(){
+        JSONObject jsonObject = new JSONObject("{value:-.50}");
+        assertEquals("Float not recognized", -0.5f, jsonObject.getFloat("value"), 0.0f);
+        assertEquals("Float not recognized", -0.5f, jsonObject.optFloat("value"), 0.0f);
+        assertEquals("Float not recognized", -0.5f, jsonObject.optFloatObject("value"), 0.0f);
+        assertEquals("Double not recognized", -0.5d, jsonObject.optDouble("value"), 0.0f);
+        assertEquals("Double not recognized", -0.5d, jsonObject.optDoubleObject("value"), 0.0f);
+        assertEquals("Double not recognized", -0.5d, jsonObject.getDouble("value"), 0.0f);
+        assertEquals("Long not recognized", 0, jsonObject.optLong("value"), 0);
+        assertEquals("Long not recognized", 0, jsonObject.getLong("value"), 0);
+        assertEquals("Long not recognized", 0, jsonObject.optLongObject("value"), 0);
+        assertEquals("Integer not recognized", 0, jsonObject.optInt("value"), 0);
+        assertEquals("Integer not recognized", 0, jsonObject.getInt("value"), 0);
+        assertEquals("Integer not recognized", 0, jsonObject.optIntegerObject("value"), 0);
+        assertEquals("Number not recognized", 0, jsonObject.getNumber("value").intValue(), 0);
+        assertEquals("Number not recognized", 0, jsonObject.getNumber("value").longValue(), 0);
+        assertEquals("BigDecimal not recognized", 0, BigDecimal.valueOf(-.5).compareTo(jsonObject.getBigDecimal("value")));
+        assertEquals("BigInteger not recognized",0, BigInteger.valueOf(0).compareTo(jsonObject.getBigInteger("value")));
+    }
+
+    @Test
+    public void shouldParseDecimalNumberThatHasZeroBeforeWithDecimalPoint(){
+        JSONObject jsonObject = new JSONObject("{value:00.050}");
+        assertEquals("Float not recognized", 0.05f, jsonObject.getFloat("value"), 0.0f);
+        assertEquals("Float not recognized", 0.05f, jsonObject.optFloat("value"), 0.0f);
+        assertEquals("Float not recognized", 0.05f, jsonObject.optFloatObject("value"), 0.0f);
+        assertEquals("Double not recognized", 0.05d, jsonObject.optDouble("value"), 0.0f);
+        assertEquals("Double not recognized", 0.05d, jsonObject.optDoubleObject("value"), 0.0f);
+        assertEquals("Double not recognized", 0.05d, jsonObject.getDouble("value"), 0.0f);
+        assertEquals("Long not recognized", 0, jsonObject.optLong("value"), 0);
+        assertEquals("Long not recognized", 0, jsonObject.getLong("value"), 0);
+        assertEquals("Long not recognized", 0, jsonObject.optLongObject("value"), 0);
+        assertEquals("Integer not recognized", 0, jsonObject.optInt("value"), 0);
+        assertEquals("Integer not recognized", 0, jsonObject.getInt("value"), 0);
+        assertEquals("Integer not recognized", 0, jsonObject.optIntegerObject("value"), 0);
+        assertEquals("Number not recognized", 0, jsonObject.getNumber("value").intValue(), 0);
+        assertEquals("Number not recognized", 0, jsonObject.getNumber("value").longValue(), 0);
+        assertEquals("BigDecimal not recognized", 0, BigDecimal.valueOf(.05).compareTo(jsonObject.getBigDecimal("value")));
+        assertEquals("BigInteger not recognized",0, BigInteger.valueOf(0).compareTo(jsonObject.getBigInteger("value")));
+    }
+
+    @Test
+    public void shouldParseNegativeDecimalNumberThatHasZeroBeforeWithDecimalPoint(){
+        JSONObject jsonObject = new JSONObject("{value:-00.050}");
+        assertEquals("Float not recognized", -0.05f, jsonObject.getFloat("value"), 0.0f);
+        assertEquals("Float not recognized", -0.05f, jsonObject.optFloat("value"), 0.0f);
+        assertEquals("Float not recognized", -0.05f, jsonObject.optFloatObject("value"), 0.0f);
+        assertEquals("Double not recognized", -0.05d, jsonObject.optDouble("value"), 0.0f);
+        assertEquals("Double not recognized", -0.05d, jsonObject.optDoubleObject("value"), 0.0f);
+        assertEquals("Double not recognized", -0.05d, jsonObject.getDouble("value"), 0.0f);
+        assertEquals("Long not recognized", 0, jsonObject.optLong("value"), 0);
+        assertEquals("Long not recognized", 0, jsonObject.getLong("value"), 0);
+        assertEquals("Long not recognized", 0, jsonObject.optLongObject("value"), 0);
+        assertEquals("Integer not recognized", 0, jsonObject.optInt("value"), 0);
+        assertEquals("Integer not recognized", 0, jsonObject.getInt("value"), 0);
+        assertEquals("Integer not recognized", 0, jsonObject.optIntegerObject("value"), 0);
+        assertEquals("Number not recognized", 0, jsonObject.getNumber("value").intValue(), 0);
+        assertEquals("Number not recognized", 0, jsonObject.getNumber("value").longValue(), 0);
+        assertEquals("BigDecimal not recognized", 0, BigDecimal.valueOf(-.05).compareTo(jsonObject.getBigDecimal("value")));
+        assertEquals("BigInteger not recognized",0, BigInteger.valueOf(0).compareTo(jsonObject.getBigInteger("value")));
+    }
+
+
+}

src/test/java/org/json/junit/JSONObjectNumberTest.java

@@ -23,18 +23,22 @@ public class JSONObjectNumberTest {
     @Parameters(name = "{index}: {0}")
     public static Collection<Object[]> data() {
         return Arrays.asList(new Object[][]{
-            {"{\"value\":50}", 1},
+            {"{value:0050}", 1},
-            {"{\"value\":50.0}", 1},
+            {"{value:0050.0000}", 1},
-            {"{\"value\":5e1}", 1},
+            {"{value:-0050}", -1},
-            {"{\"value\":5E1}", 1},
+            {"{value:-0050.0000}", -1},
-            {"{\"value\":5e1}", 1},
+            {"{value:50.0}", 1},
-            {"{\"value\":\"50\"}", 1},
+            {"{value:5e1}", 1},
-            {"{\"value\":-50}", -1},
+            {"{value:5E1}", 1},
-            {"{\"value\":-50.0}", -1},
+            {"{value:5e1}", 1},
-            {"{\"value\":-5e1}", -1},
+            {"{value:'50'}", 1},
-            {"{\"value\":-5E1}", -1},
+            {"{value:-50}", -1},
-            {"{\"value\":-5e1}", -1},
+            {"{value:-50.0}", -1},
-            {"{\"value\":\"-50\"}", -1}
+            {"{value:-5e1}", -1},
+            {"{value:-0005e1}", -1},
+            {"{value:-5E1}", -1},
+            {"{value:-5e1}", -1},
+            {"{value:'-50'}", -1}
             // JSON does not support octal or hex numbers;
             // see https://stackoverflow.com/a/52671839/6323312
             // "{value:062}", // octal 50

src/test/java/org/json/junit/JSONObjectTest.java

@@ -4,6 +4,7 @@ package org.json.junit;
 Public Domain.
 */
 
+import static java.lang.Double.NaN;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotEquals;
@@ -56,7 +57,6 @@ import org.json.junit.data.RecursiveBeanEquals;
 import org.json.junit.data.Singleton;
 import org.json.junit.data.SingletonEnum;
 import org.json.junit.data.WeirdList;
-import org.junit.After;
 import org.junit.Ignore;
 import org.junit.Test;
 
@@ -76,14 +76,6 @@ public class JSONObjectTest {
      */
     static final Pattern NUMBER_PATTERN = Pattern.compile("-?(?:0|[1-9]\\d*)(?:\\.\\d+)?(?:[eE][+-]?\\d+)?");
 
-    @After
-    public void tearDown() {
-        SingletonEnum.getInstance().setSomeInt(0);
-        SingletonEnum.getInstance().setSomeString(null);
-        Singleton.getInstance().setSomeInt(0);
-        Singleton.getInstance().setSomeString(null);
-    }
-
     /**
      * Tests that the similar method is working as expected.
      */
@@ -219,15 +211,6 @@ public class JSONObjectTest {
     @Test
     public void unquotedText() {
         String str = "{key1:value1, key2:42, 1.2 : 3.4, -7e5 : something!}";
-
-        // Test should fail if default strictMode is true, pass if false
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration();
-        if (jsonParserConfiguration.isStrictMode()) {
-            try {
-                JSONObject jsonObject = new JSONObject(str);
-                assertEquals("Expected to throw exception due to invalid string", true, false);
-            } catch (JSONException e) { }
-        } else {
         JSONObject jsonObject = new JSONObject(str);
         String textStr = jsonObject.toString();
         assertTrue("expected key1", textStr.contains("\"key1\""));
@@ -240,7 +223,6 @@ public class JSONObjectTest {
         assertTrue("expected something!", textStr.contains("\"something!\""));
         Util.checkJSONObjectMaps(jsonObject);
     }
-    }
     
     @Test
     public void testLongFromString(){
@@ -617,46 +599,6 @@ public class JSONObjectTest {
         Util.checkJSONObjectMaps(jsonObject);
     }
 
-    @Test
-    public void jsonObjectByMapWithNullValueAndParserConfiguration() {
-        Map<String, Object> map = new HashMap<String, Object>();
-        map.put("nullKey", null);
-        
-        // by default, null values are ignored
-        JSONObject obj1 = new JSONObject(map);
-        assertTrue("expected null value to be ignored by default", obj1.isEmpty());
-
-        // if configured, null values are written as such into the JSONObject.
-        JSONParserConfiguration parserConfiguration = new JSONParserConfiguration().withUseNativeNulls(true);
-        JSONObject obj2 = new JSONObject(map, parserConfiguration);
-        assertFalse("expected null value to accepted when configured", obj2.isEmpty());
-        assertTrue(obj2.has("nullKey"));
-        assertEquals(JSONObject.NULL, obj2.get("nullKey"));
-    }
-    
-    @Test
-    public void jsonObjectByMapWithNestedNullValueAndParserConfiguration() {
-        Map<String, Object> map = new HashMap<String, Object>();
-        Map<String, Object> nestedMap = new HashMap<String, Object>();
-        nestedMap.put("nullKey", null);
-        map.put("nestedMap", nestedMap);
-        List<Map<String, Object>> nestedList = new ArrayList<Map<String,Object>>();
-        nestedList.add(nestedMap);        
-        map.put("nestedList", nestedList);
-        
-        JSONParserConfiguration parserConfiguration = new JSONParserConfiguration().withUseNativeNulls(true);
-        JSONObject jsonObject = new JSONObject(map, parserConfiguration);
-
-        JSONObject nestedObject = jsonObject.getJSONObject("nestedMap");
-        assertTrue(nestedObject.has("nullKey"));
-        assertEquals(JSONObject.NULL, nestedObject.get("nullKey"));
-        
-        JSONArray nestedArray = jsonObject.getJSONArray("nestedList");
-        assertEquals(1, nestedArray.length());
-        assertTrue(nestedArray.getJSONObject(0).has("nullKey"));
-        assertEquals(JSONObject.NULL, nestedArray.getJSONObject(0).get("nullKey"));
-    }
-
     /**
      * JSONObject built from a bean. In this case all but one of the 
      * bean getters return valid JSON types
@@ -844,7 +786,7 @@ public class JSONObjectTest {
         jsonObject.accumulate("myArray", -23.45e7);
         // include an unsupported object for coverage
         try {
-            jsonObject.accumulate("myArray", Double.NaN);
+            jsonObject.accumulate("myArray", NaN);
             fail("Expected exception");
         } catch (JSONException ignored) {}
 
@@ -876,7 +818,7 @@ public class JSONObjectTest {
         jsonObject.append("myArray", -23.45e7);
         // include an unsupported object for coverage
         try {
-            jsonObject.append("myArray", Double.NaN);
+            jsonObject.append("myArray", NaN);
             fail("Expected exception");
         } catch (JSONException ignored) {}
 
@@ -901,7 +843,7 @@ public class JSONObjectTest {
     public void jsonObjectDoubleToString() {
         String [] expectedStrs = {"1", "1", "-23.4", "-2.345E68", "null", "null" };
         Double [] doubles = { 1.0, 00001.00000, -23.4, -23.45e67, 
-                Double.NaN, Double.NEGATIVE_INFINITY };
+                NaN, Double.NEGATIVE_INFINITY };
         for (int i = 0; i < expectedStrs.length; ++i) {
             String actualStr = JSONObject.doubleToString(doubles[i]);
             assertTrue("value expected ["+expectedStrs[i]+
@@ -956,11 +898,11 @@ public class JSONObjectTest {
         assertTrue("opt doubleKey should be double", 
                 jsonObject.optDouble("doubleKey") == -23.45e7);
         assertTrue("opt doubleKey with Default should be double", 
-                jsonObject.optDouble("doubleStrKey", Double.NaN) == 1);
+                jsonObject.optDouble("doubleStrKey", NaN) == 1);
         assertTrue("opt doubleKey should be Double",
                 Double.valueOf(-23.45e7).equals(jsonObject.optDoubleObject("doubleKey")));
         assertTrue("opt doubleKey with Default should be Double",
-                Double.valueOf(1).equals(jsonObject.optDoubleObject("doubleStrKey", Double.NaN)));
+                Double.valueOf(1).equals(jsonObject.optDoubleObject("doubleStrKey", NaN)));
         assertTrue("opt negZeroKey should be a Double", 
                 jsonObject.opt("negZeroKey") instanceof Double);
         assertTrue("get negZeroKey should be a Double", 
@@ -1121,57 +1063,110 @@ public class JSONObjectTest {
     public void jsonInvalidNumberValues() {
             // Number-notations supported by Java and invalid as JSON
         String str = 
-                "{" +
+            "{"+
-                        "\"hexNumber\":-0x123," +
+                "\"hexNumber\":-0x123,"+
-                        "\"tooManyZeros\":00," +
+                "\"tooManyZeros\":00,"+
-                        "\"negativeInfinite\":-Infinity," +
+                "\"negativeInfinite\":-Infinity,"+
-                        "\"negativeNaN\":-NaN," +
+                "\"negativeNaN\":-NaN,"+
-                        "\"negativeFraction\":-.01," +
+                "\"negativeNaNWithLeadingZeros\":-00NaN,"+
-                        "\"tooManyZerosFraction\":00.001," +
+                "\"negativeFraction\":-.01,"+
-                        "\"negativeHexFloat\":-0x1.fffp1," +
+                "\"tooManyZerosFraction\":00.001,"+
-                        "\"hexFloat\":0x1.0P-1074," +
+                "\"negativeHexFloat\":-0x1.fffp1,"+
-                        "\"floatIdentifier\":0.1f," +
+                "\"hexFloat\":0x1.0P-1074,"+
-                        "\"doubleIdentifier\":0.1d" +
+                "\"floatIdentifier\":0.1f,"+
+                "\"doubleIdentifier\":0.1d,"+
+                "\"doubleIdentifierWithMultipleLeadingZerosBeforeDecimal\":0000000.1d,"+
+                "\"negativeDoubleIdentifierWithMultipleLeadingZerosBeforeDecimal\":-0000000.1d,"+
+                "\"doubleIdentifierWithMultipleLeadingZerosAfterDecimal\":0000000.0001d,"+
+                "\"negativeDoubleIdentifierWithMultipleLeadingZerosAfterDecimal\":-0000000.0001d,"+
+                "\"integerWithLeadingZeros\":000900,"+
+                "\"integerWithAllZeros\":00000,"+
+                "\"compositeWithLeadingZeros\":00800.90d,"+
+                "\"decimalPositiveWithoutNumberBeforeDecimalPoint\":.90,"+
             "}";
-
-        // Test should fail if default strictMode is true, pass if false
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration();
-        if (jsonParserConfiguration.isStrictMode()) {
-            try {
-                JSONObject jsonObject = new JSONObject(str);
-                assertEquals("Expected to throw exception due to invalid string", true, false);
-            } catch (JSONException e) { }
-        } else {
         JSONObject jsonObject = new JSONObject(str);
         Object obj;
-            obj = jsonObject.get("hexNumber");
+        obj = jsonObject.get( "hexNumber" );
-            assertFalse("hexNumber must not be a number (should throw exception!?)",
+        assertFalse( "hexNumber must not be a number (should throw exception!?)",
-                    obj instanceof Number);
+                 obj instanceof Number );
         assertTrue("hexNumber currently evaluates to string",
                 obj.equals("-0x123"));
-            assertTrue("tooManyZeros currently evaluates to string",
+        assertTrue( "tooManyZeros currently evaluates to string",
-                    jsonObject.get("tooManyZeros").equals("00"));
+                jsonObject.get( "tooManyZeros" ).equals(0));
         obj = jsonObject.get("negativeInfinite");
-            assertTrue("negativeInfinite currently evaluates to string",
+        assertTrue( "negativeInfinite currently evaluates to string",
                 obj.equals("-Infinity"));
         obj = jsonObject.get("negativeNaN");
-            assertTrue("negativeNaN currently evaluates to string",
+        assertTrue( "negativeNaN currently evaluates to string",
                 obj.equals("-NaN"));
-            assertTrue("negativeFraction currently evaluates to double -0.01",
+        obj = jsonObject.get("negativeNaNWithLeadingZeros");
-                    jsonObject.get("negativeFraction").equals(BigDecimal.valueOf(-0.01)));
+        assertTrue( "negativeNaNWithLeadingZeros currently evaluates to string",
-            assertTrue("tooManyZerosFraction currently evaluates to double 0.001",
+                obj.equals("-00NaN"));
-                    jsonObject.optLong("tooManyZerosFraction") == 0);
+        assertTrue( "negativeFraction currently evaluates to double -0.01",
-            assertTrue("negativeHexFloat currently evaluates to double -3.99951171875",
+                jsonObject.get( "negativeFraction" ).equals(BigDecimal.valueOf(-0.01)));
-                    jsonObject.get("negativeHexFloat").equals(Double.valueOf(-3.99951171875)));
+        assertTrue( "tooManyZerosFraction currently evaluates to double 0.001",
+                jsonObject.get( "tooManyZerosFraction" ).equals(BigDecimal.valueOf(0.001)));
+        assertTrue( "tooManyZerosFraction currently evaluates to double 0.001",
+                jsonObject.getLong( "tooManyZerosFraction" )==0);
+        assertTrue( "tooManyZerosFraction currently evaluates to double 0.001",
+                jsonObject.optLong( "tooManyZerosFraction" )==0);
+        assertTrue( "negativeHexFloat currently evaluates to double -3.99951171875",
+                jsonObject.get( "negativeHexFloat" ).equals(Double.valueOf(-3.99951171875)));
         assertTrue("hexFloat currently evaluates to double 4.9E-324",
                 jsonObject.get("hexFloat").equals(Double.valueOf(4.9E-324)));
         assertTrue("floatIdentifier currently evaluates to double 0.1",
                 jsonObject.get("floatIdentifier").equals(Double.valueOf(0.1)));
         assertTrue("doubleIdentifier currently evaluates to double 0.1",
                 jsonObject.get("doubleIdentifier").equals(Double.valueOf(0.1)));
+        assertTrue("doubleIdentifierWithMultipleLeadingZerosBeforeDecimal currently evaluates to double 0.1",
+                jsonObject.get("doubleIdentifierWithMultipleLeadingZerosBeforeDecimal").equals(Double.valueOf(0.1)));
+        assertTrue("negativeDoubleIdentifierWithMultipleLeadingZerosBeforeDecimal currently evaluates to double -0.1",
+                jsonObject.get("negativeDoubleIdentifierWithMultipleLeadingZerosBeforeDecimal").equals(Double.valueOf(-0.1)));
+        assertTrue("doubleIdentifierWithMultipleLeadingZerosAfterDecimal currently evaluates to double 0.0001",
+                jsonObject.get("doubleIdentifierWithMultipleLeadingZerosAfterDecimal").equals(Double.valueOf(0.0001)));
+        assertTrue("doubleIdentifierWithMultipleLeadingZerosAfterDecimal currently evaluates to double 0.0001",
+                jsonObject.get("doubleIdentifierWithMultipleLeadingZerosAfterDecimal").equals(Double.valueOf(0.0001)));
+        assertTrue("negativeDoubleIdentifierWithMultipleLeadingZerosAfterDecimal currently evaluates to double -0.0001",
+                jsonObject.get("negativeDoubleIdentifierWithMultipleLeadingZerosAfterDecimal").equals(Double.valueOf(-0.0001)));
+        assertTrue("Integer does not evaluate to 900",
+                jsonObject.get("integerWithLeadingZeros").equals(900));
+        assertTrue("Integer does not evaluate to 900",
+                jsonObject.getInt("integerWithLeadingZeros")==900);
+        assertTrue("Integer does not evaluate to 900",
+                jsonObject.optInt("integerWithLeadingZeros")==900);
+        assertTrue("Integer does not evaluate to 0",
+                jsonObject.get("integerWithAllZeros").equals(0));
+        assertTrue("Integer does not evaluate to 0",
+                jsonObject.getInt("integerWithAllZeros")==0);
+        assertTrue("Integer does not evaluate to 0",
+                jsonObject.optInt("integerWithAllZeros")==0);
+        assertTrue("Double does not evaluate to 800.90",
+                jsonObject.get("compositeWithLeadingZeros").equals(800.90));
+        assertTrue("Double does not evaluate to 800.90",
+                jsonObject.getDouble("compositeWithLeadingZeros")==800.9d);
+        assertTrue("Integer does not evaluate to 800",
+                jsonObject.optInt("compositeWithLeadingZeros")==800);
+        assertTrue("Long does not evaluate to 800.90",
+                jsonObject.getLong("compositeWithLeadingZeros")==800);
+        assertTrue("Long does not evaluate to 800.90",
+                jsonObject.optLong("compositeWithLeadingZeros")==800);
+        assertEquals("Get long of decimalPositiveWithoutNumberBeforeDecimalPoint does not match",
+                0.9d,jsonObject.getDouble("decimalPositiveWithoutNumberBeforeDecimalPoint"),  0.0d);
+        assertEquals("Get long of decimalPositiveWithoutNumberBeforeDecimalPoint does not match",
+                0.9d,jsonObject.optDouble("decimalPositiveWithoutNumberBeforeDecimalPoint"),  0.0d);
+        assertEquals("Get long of decimalPositiveWithoutNumberBeforeDecimalPoint does not match",
+                0.0d,jsonObject.optLong("decimalPositiveWithoutNumberBeforeDecimalPoint"),  0.0d);
+
+        assertEquals("Get long of doubleIdentifierWithMultipleLeadingZerosAfterDecimal does not match",
+                0.0001d,jsonObject.getDouble("doubleIdentifierWithMultipleLeadingZerosAfterDecimal"),  0.0d);
+        assertEquals("Get long of doubleIdentifierWithMultipleLeadingZerosAfterDecimal does not match",
+                0.0001d,jsonObject.optDouble("doubleIdentifierWithMultipleLeadingZerosAfterDecimal"),  0.0d);
+        assertEquals("Get long of doubleIdentifierWithMultipleLeadingZerosAfterDecimal does not match",
+                0.0d, jsonObject.getLong("doubleIdentifierWithMultipleLeadingZerosAfterDecimal") , 0.0d);
+        assertEquals("Get long of doubleIdentifierWithMultipleLeadingZerosAfterDecimal does not match",
+                0.0d,jsonObject.optLong("doubleIdentifierWithMultipleLeadingZerosAfterDecimal"),  0.0d);
         Util.checkJSONObjectMaps(jsonObject);
     }
-    }
 
     /**
      * Tests how JSONObject get[type] handles incorrect types
@@ -1588,7 +1583,7 @@ public class JSONObjectTest {
             "{"+
                 "\"trueKey\":true,"+
                 "\"falseKey\":false,"+
-                "\"stringKey\":\"hello world!\""+
+                "\"stringKey\":\"hello world!\","+
             "}";
         JSONObject jsonObject2 = new JSONObject(str);
         names = JSONObject.getNames(jsonObject2);
@@ -1683,7 +1678,7 @@ public class JSONObjectTest {
             "{"+
                 "\"trueKey\":true,"+
                 "\"falseKey\":false,"+
-                "\"stringKey\":\"hello world!\""+
+                "\"stringKey\":\"hello world!\","+
             "}";
 
         JSONObject jsonObject = new JSONObject(str);
@@ -2262,181 +2257,95 @@ public class JSONObjectTest {
         }
     }
 
+    /**
+     * Explore how JSONObject handles parsing errors.
+     */
+    @SuppressWarnings({"boxing", "unused"})
     @Test
-    public void jsonObjectParseControlCharacterEOFAssertExceptionMessage(){
+    public void jsonObjectParsingErrors() {
-        char c = '\0';
-        final String source = "{\"key\":\"" + c + "\"}";
-        try {
-            JSONObject jo = new JSONObject(source);
-            fail("JSONException should be thrown");
-        } catch (JSONException ex) {
-            assertEquals("Unterminated string. " + "Character with int code 0" +
-                    " is not allowed within a quoted string. at 8 [character 9 line 1]", ex.getMessage());
-        }
-    }
-
-    @Test
-    public void jsonObjectParseControlCharacterNewLineAssertExceptionMessage(){
-        char[] chars = {'\n', '\r'};
-        for( char c : chars) {
-            final String source = "{\"key\":\"" + c + "\"}";
-            try {
-                JSONObject jo = new JSONObject(source);
-                fail("JSONException should be thrown");
-            } catch (JSONException ex) {
-                assertEquals("Unterminated string. " + "Character with int code " + (int) c +
-                        " is not allowed within a quoted string. at 9 [character 0 line 2]", ex.getMessage());
-            }
-        }
-    }
-
-    @Test
-    public void jsonObjectParseUTF8EncodingAssertExceptionMessage(){
-        String c = "\\u123x";
-        final String source = "{\"key\":\"" + c + "\"}";
-        try {
-            JSONObject jo = new JSONObject(source);
-            fail("JSONException should be thrown");
-        } catch (JSONException ex) {
-            assertEquals("Illegal escape. \\u must be followed by a 4 digit hexadecimal number. " +
-                    "\\123x is not valid. at 14 [character 15 line 1]", ex.getMessage());
-        }
-    }
-
-    @Test
-    public void jsonObjectParseIllegalEscapeAssertExceptionMessage(){
-        String c = "\\x";
-        final String source = "{\"key\":\"" + c + "\"}";
-        try {
-            JSONObject jo = new JSONObject(source);
-            fail("JSONException should be thrown");
-        } catch (JSONException ex) {
-            assertEquals("Illegal escape. Escape sequence  " + c + " is not valid." +
-                    " at 10 [character 11 line 1]", ex.getMessage());
-        }
-    }
-
-    @Test
-    public void parsingErrorTrailingCurlyBrace () {
-        try {
-            // does not end with '}'
-            String str = "{";
-            assertNull("Expected an exception", new JSONObject(str));
-        } catch (JSONException e) {
-            assertEquals("Expecting an exception message",
-                    "A JSONObject text must end with '}' at 1 [character 2 line 1]",
-                    e.getMessage());
-        }
-    }
-
-    @Test
-    public void parsingErrorInitialCurlyBrace() {
         try {
             // does not start with '{'
             String str = "abc";
-            assertNull("Expected an exception", new JSONObject(str));
+            assertNull("Expected an exception",new JSONObject(str));
         } catch (JSONException e) { 
             assertEquals("Expecting an exception message", 
                     "A JSONObject text must begin with '{' at 1 [character 2 line 1]",
                     e.getMessage());
         }
+        try {
+            // does not end with '}'
+            String str = "{";
+            assertNull("Expected an exception",new JSONObject(str));
+        } catch (JSONException e) { 
+            assertEquals("Expecting an exception message", 
+                    "A JSONObject text must end with '}' at 1 [character 2 line 1]",
+                    e.getMessage());
         }
-
-    @Test
-    public void parsingErrorNoColon() {
         try {
             // key with no ':'
             String str = "{\"myKey\" = true}";
-            assertNull("Expected an exception", new JSONObject(str));
+            assertNull("Expected an exception",new JSONObject(str));
         } catch (JSONException e) { 
             assertEquals("Expecting an exception message", 
                     "Expected a ':' after a key at 10 [character 11 line 1]",
                     e.getMessage());
         }
-    }
-
-    @Test
-    public void parsingErrorNoCommaSeparator() {
         try {
             // entries with no ',' separator
             String str = "{\"myKey\":true \"myOtherKey\":false}";
-            assertNull("Expected an exception", new JSONObject(str));
+            assertNull("Expected an exception",new JSONObject(str));
         } catch (JSONException e) { 
             assertEquals("Expecting an exception message", 
                     "Expected a ',' or '}' at 15 [character 16 line 1]",
                     e.getMessage());
         }
-    }
-
-    @Test
-    public void parsingErrorKeyIsNestedMap() {
         try {
             // key is a nested map
             String str = "{{\"foo\": \"bar\"}: \"baz\"}";
-            assertNull("Expected an exception", new JSONObject(str));
+            assertNull("Expected an exception",new JSONObject(str));
         } catch (JSONException e) {
             assertEquals("Expecting an exception message",
                 "Missing value at 1 [character 2 line 1]",
                 e.getMessage());
         }
-    }
-
-    @Test
-    public void parsingErrorKeyIsNestedArrayWithMap() {
         try {
             // key is a nested array containing a map
             String str = "{\"a\": 1, [{\"foo\": \"bar\"}]: \"baz\"}";
-            assertNull("Expected an exception", new JSONObject(str));
+            assertNull("Expected an exception",new JSONObject(str));
         } catch (JSONException e) {
             assertEquals("Expecting an exception message",
                 "Missing value at 9 [character 10 line 1]",
                 e.getMessage());
         }
-    }
-
-    @Test
-    public void parsingErrorKeyContainsCurlyBrace() {
         try {
             // key contains }
             String str = "{foo}: 2}";
-            assertNull("Expected an exception", new JSONObject(str));
+            assertNull("Expected an exception",new JSONObject(str));
         } catch (JSONException e) {
-//            assertEquals("Expecting an exception message",
+            assertEquals("Expecting an exception message",
-//                    "Expected a ':' after a key at 5 [character 6 line 1]",
+                "Expected a ':' after a key at 5 [character 6 line 1]",
-//                    e.getMessage());
+                e.getMessage());
         }
-    }
-
-    @Test
-    public void parsingErrorKeyContainsSquareBrace() {
         try {
             // key contains ]
             String str = "{foo]: 2}";
-            assertNull("Expected an exception", new JSONObject(str));
+            assertNull("Expected an exception",new JSONObject(str));
         } catch (JSONException e) {
-//            assertEquals("Expecting an exception message",
+            assertEquals("Expecting an exception message",
-//                    "Expected a ':' after a key at 5 [character 6 line 1]",
+                "Expected a ':' after a key at 5 [character 6 line 1]",
-//                    e.getMessage());
+                e.getMessage());
         }
-    }
-
-    @Test
-    public void parsingErrorKeyContainsBinaryZero() {
         try {
             // \0 after ,
             String str = "{\"myKey\":true, \0\"myOtherKey\":false}";
-            assertNull("Expected an exception", new JSONObject(str));
+            assertNull("Expected an exception",new JSONObject(str));
         } catch (JSONException e) {
             assertEquals("Expecting an exception message",
                     "A JSONObject text must end with '}' at 15 [character 16 line 1]",
                     e.getMessage());
         }
-    }
-
-    @Test
-    public void parsingErrorAppendToWrongValue() {
         try {
-            // append to wrong value
+            // append to wrong key
             String str = "{\"myKey\":true, \"myOtherKey\":false}";
             JSONObject jsonObject = new JSONObject(str);
             jsonObject.append("myKey", "hello");
@@ -2446,12 +2355,8 @@ public class JSONObjectTest {
                     "JSONObject[\"myKey\"] is not a JSONArray (null).",
                     e.getMessage());
         }
-    }
-
-    @Test
-    public void parsingErrorIncrementWrongValue() {
         try {
-            // increment wrong value
+            // increment wrong key
             String str = "{\"myKey\":true, \"myOtherKey\":false}";
             JSONObject jsonObject = new JSONObject(str);
             jsonObject.increment("myKey");
@@ -2461,9 +2366,6 @@ public class JSONObjectTest {
                     "Unable to increment [\"myKey\"].",
                     e.getMessage());
         }
-    }
-    @Test
-    public void parsingErrorInvalidKey() {
         try {
             // invalid key
             String str = "{\"myKey\":true, \"myOtherKey\":false}";
@@ -2475,23 +2377,16 @@ public class JSONObjectTest {
                     "Null key.",
                     e.getMessage());
         }
-    }
-
-    @Test
-    public void parsingErrorNumberToString() {
         try {
             // invalid numberToString()
-            JSONObject.numberToString((Number) null);
+            JSONObject.numberToString((Number)null);
             fail("Expected an exception");
         } catch (JSONException e) { 
             assertEquals("Expecting an exception message", 
                     "Null pointer",
                     e.getMessage());
         }
-    }
 
-    @Test
-    public void parsingErrorPutOnceDuplicateKey() {
         try {
             // multiple putOnce key 
             JSONObject jsonObject = new JSONObject("{}");
@@ -2501,21 +2396,13 @@ public class JSONObjectTest {
         } catch (JSONException e) { 
             assertTrue("", true);
         }
-    }
-
-    @Test
-    public void parsingErrorInvalidDouble() {
         try {
             // test validity of invalid double 
-            JSONObject.testValidity(Double.NaN);
+            JSONObject.testValidity(NaN);
             fail("Expected an exception");
         } catch (JSONException e) { 
             assertTrue("", true);
         }
-    }
-
-    @Test
-    public void parsingErrorInvalidFloat() {
         try {
             // test validity of invalid float 
             JSONObject.testValidity(Float.NEGATIVE_INFINITY);
@@ -2523,17 +2410,13 @@ public class JSONObjectTest {
         } catch (JSONException e) { 
             assertTrue("", true);
         }
-    }
-
-    @Test
-    public void parsingErrorDuplicateKeyException() {
         try {
             // test exception message when including a duplicate key (level 0)
             String str = "{\n"
-                    + "    \"attr01\":\"value-01\",\n"
+                        +"    \"attr01\":\"value-01\",\n"
-                    + "    \"attr02\":\"value-02\",\n"
+                        +"    \"attr02\":\"value-02\",\n"
-                    + "    \"attr03\":\"value-03\",\n"
+                        +"    \"attr03\":\"value-03\",\n"
-                    + "    \"attr03\":\"value-04\"\n"
+                        +"    \"attr03\":\"value-04\"\n"
                         + "}";
             new JSONObject(str);
             fail("Expected an exception");
@@ -2542,20 +2425,16 @@ public class JSONObjectTest {
                     "Duplicate key \"attr03\" at 90 [character 13 line 5]",
                     e.getMessage());
         }
-    }
-
-    @Test
-    public void parsingErrorNestedDuplicateKeyException() {
         try {
             // test exception message when including a duplicate key (level 0) holding an object
             String str = "{\n"
-                    + "    \"attr01\":\"value-01\",\n"
+                        +"    \"attr01\":\"value-01\",\n"
-                    + "    \"attr02\":\"value-02\",\n"
+                        +"    \"attr02\":\"value-02\",\n"
-                    + "    \"attr03\":\"value-03\",\n"
+                        +"    \"attr03\":\"value-03\",\n"
-                    + "    \"attr03\": {"
+                        +"    \"attr03\": {"
-                    + "        \"attr04-01\":\"value-04-01\",n"
+                        +"        \"attr04-01\":\"value-04-01\",n"
-                    + "        \"attr04-02\":\"value-04-02\",n"
+                        +"        \"attr04-02\":\"value-04-02\",n"
-                    + "        \"attr04-03\":\"value-04-03\"n"
+                        +"        \"attr04-03\":\"value-04-03\"n"
                         + "    }\n"
                         + "}";
             new JSONObject(str);
@@ -2565,22 +2444,18 @@ public class JSONObjectTest {
                     "Duplicate key \"attr03\" at 90 [character 13 line 5]",
                     e.getMessage());
         }
-    }
-
-    @Test
-    public void parsingErrorNestedDuplicateKeyWithArrayException() {
         try {
             // test exception message when including a duplicate key (level 0) holding an array
             String str = "{\n"
-                    + "    \"attr01\":\"value-01\",\n"
+                        +"    \"attr01\":\"value-01\",\n"
-                    + "    \"attr02\":\"value-02\",\n"
+                        +"    \"attr02\":\"value-02\",\n"
-                    + "    \"attr03\":\"value-03\",\n"
+                        +"    \"attr03\":\"value-03\",\n"
-                    + "    \"attr03\": [\n"
+                        +"    \"attr03\": [\n"
-                    + "        {"
+                        +"        {"
-                    + "            \"attr04-01\":\"value-04-01\",n"
+                        +"            \"attr04-01\":\"value-04-01\",n"
-                    + "            \"attr04-02\":\"value-04-02\",n"
+                        +"            \"attr04-02\":\"value-04-02\",n"
-                    + "            \"attr04-03\":\"value-04-03\"n"
+                        +"            \"attr04-03\":\"value-04-03\"n"
-                    + "        }\n"
+                        +"        }\n"
                         + "    ]\n"
                         + "}";
             new JSONObject(str);
@@ -2590,21 +2465,17 @@ public class JSONObjectTest {
                     "Duplicate key \"attr03\" at 90 [character 13 line 5]",
                     e.getMessage());
         }
-    }
-
-    @Test
-    public void parsingErrorDuplicateKeyWithinNestedDictExceptionMessage() {
         try {
             // test exception message when including a duplicate key (level 1)
             String str = "{\n"
-                    + "    \"attr01\":\"value-01\",\n"
+                        +"    \"attr01\":\"value-01\",\n"
-                    + "    \"attr02\":\"value-02\",\n"
+                        +"    \"attr02\":\"value-02\",\n"
-                    + "    \"attr03\":\"value-03\",\n"
+                        +"    \"attr03\":\"value-03\",\n"
-                    + "    \"attr04\": {\n"
+                        +"    \"attr04\": {\n"
-                    + "        \"attr04-01\":\"value04-01\",\n"
+                        +"        \"attr04-01\":\"value04-01\",\n"
-                    + "        \"attr04-02\":\"value04-02\",\n"
+                        +"        \"attr04-02\":\"value04-02\",\n"
-                    + "        \"attr04-03\":\"value04-03\",\n"
+                        +"        \"attr04-03\":\"value04-03\",\n"
-                    + "        \"attr04-03\":\"value04-04\"\n"
+                        +"        \"attr04-03\":\"value04-04\"\n"
                         + "    }\n"
                         + "}";
             new JSONObject(str);
@@ -2614,27 +2485,22 @@ public class JSONObjectTest {
                     "Duplicate key \"attr04-03\" at 215 [character 20 line 9]",
                     e.getMessage());
         }
-    }
-
-    @Test
-    public void parsingErrorDuplicateKeyDoubleNestedDictExceptionMessage() {
         try {
-            // test exception message when including a duplicate key (level 1) holding an
+            // test exception message when including a duplicate key (level 1) holding an object
-            // object
             String str = "{\n"
-                    + "    \"attr01\":\"value-01\",\n"
+                        +"    \"attr01\":\"value-01\",\n"
-                    + "    \"attr02\":\"value-02\",\n"
+                        +"    \"attr02\":\"value-02\",\n"
-                    + "    \"attr03\":\"value-03\",\n"
+                        +"    \"attr03\":\"value-03\",\n"
-                    + "    \"attr04\": {\n"
+                        +"    \"attr04\": {\n"
-                    + "        \"attr04-01\":\"value04-01\",\n"
+                        +"        \"attr04-01\":\"value04-01\",\n"
-                    + "        \"attr04-02\":\"value04-02\",\n"
+                        +"        \"attr04-02\":\"value04-02\",\n"
-                    + "        \"attr04-03\":\"value04-03\",\n"
+                        +"        \"attr04-03\":\"value04-03\",\n"
-                    + "        \"attr04-03\": {\n"
+                        +"        \"attr04-03\": {\n"
-                    + "            \"attr04-04-01\":\"value04-04-01\",\n"
+                        +"            \"attr04-04-01\":\"value04-04-01\",\n"
-                    + "            \"attr04-04-02\":\"value04-04-02\",\n"
+                        +"            \"attr04-04-02\":\"value04-04-02\",\n"
-                    + "            \"attr04-04-03\":\"value04-04-03\",\n"
+                        +"            \"attr04-04-03\":\"value04-04-03\",\n"
-                    + "        }\n"
+                        +"        }\n"
-                    + "    }\n"
+                        +"    }\n"
                         + "}";
             new JSONObject(str);
             fail("Expected an exception");
@@ -2643,29 +2509,24 @@ public class JSONObjectTest {
                     "Duplicate key \"attr04-03\" at 215 [character 20 line 9]",
                     e.getMessage());
         }
-    }
-
-    @Test
-    public void parsingErrorDuplicateKeyNestedWithArrayExceptionMessage() {
         try {
-            // test exception message when including a duplicate key (level 1) holding an
+            // test exception message when including a duplicate key (level 1) holding an array
-            // array
             String str = "{\n"
-                    + "    \"attr01\":\"value-01\",\n"
+                        +"    \"attr01\":\"value-01\",\n"
-                    + "    \"attr02\":\"value-02\",\n"
+                        +"    \"attr02\":\"value-02\",\n"
-                    + "    \"attr03\":\"value-03\",\n"
+                        +"    \"attr03\":\"value-03\",\n"
-                    + "    \"attr04\": {\n"
+                        +"    \"attr04\": {\n"
-                    + "        \"attr04-01\":\"value04-01\",\n"
+                        +"        \"attr04-01\":\"value04-01\",\n"
-                    + "        \"attr04-02\":\"value04-02\",\n"
+                        +"        \"attr04-02\":\"value04-02\",\n"
-                    + "        \"attr04-03\":\"value04-03\",\n"
+                        +"        \"attr04-03\":\"value04-03\",\n"
-                    + "        \"attr04-03\": [\n"
+                        +"        \"attr04-03\": [\n"
-                    + "            {\n"
+                        +"            {\n"
-                    + "                \"attr04-04-01\":\"value04-04-01\",\n"
+                        +"                \"attr04-04-01\":\"value04-04-01\",\n"
-                    + "                \"attr04-04-02\":\"value04-04-02\",\n"
+                        +"                \"attr04-04-02\":\"value04-04-02\",\n"
-                    + "                \"attr04-04-03\":\"value04-04-03\",\n"
+                        +"                \"attr04-04-03\":\"value04-04-03\",\n"
-                    + "            }\n"
+                        +"            }\n"
-                    + "        ]\n"
+                        +"        ]\n"
-                    + "    }\n"
+                        +"    }\n"
                         + "}";
             new JSONObject(str);
             fail("Expected an exception");
@@ -2674,22 +2535,17 @@ public class JSONObjectTest {
                     "Duplicate key \"attr04-03\" at 215 [character 20 line 9]",
                     e.getMessage());
         }
-    }
-
-    @Test
-    public void parsingErrorDuplicateKeyWithinArrayExceptionMessage() {
         try {
-            // test exception message when including a duplicate key in object (level 0)
+            // test exception message when including a duplicate key in object (level 0) within an array
-            // within an array
             String str = "[\n"
-                    + "    {\n"
+                        +"    {\n"
-                    + "        \"attr01\":\"value-01\",\n"
+                        +"        \"attr01\":\"value-01\",\n"
-                    + "        \"attr02\":\"value-02\"\n"
+                        +"        \"attr02\":\"value-02\"\n"
-                    + "    },\n"
+                        +"    },\n"
-                    + "    {\n"
+                        +"    {\n"
-                    + "        \"attr01\":\"value-01\",\n"
+                        +"        \"attr01\":\"value-01\",\n"
-                    + "        \"attr01\":\"value-02\"\n"
+                        +"        \"attr01\":\"value-02\"\n"
-                    + "    }\n"
+                        +"    }\n"
                         + "]";
             new JSONArray(str);
             fail("Expected an exception");
@@ -2698,28 +2554,23 @@ public class JSONObjectTest {
                     "Duplicate key \"attr01\" at 124 [character 17 line 8]",
                     e.getMessage());
         }
-    }
-
-    @Test
-    public void parsingErrorDuplicateKeyDoubleNestedWithinArrayExceptionMessage() {
         try {
-            // test exception message when including a duplicate key in object (level 1)
+            // test exception message when including a duplicate key in object (level 1) within an array
-            // within an array
             String str = "[\n"
-                    + "    {\n"
+                        +"    {\n"
-                    + "        \"attr01\":\"value-01\",\n"
+                        +"        \"attr01\":\"value-01\",\n"
-                    + "        \"attr02\": {\n"
+                        +"        \"attr02\": {\n"
-                    + "            \"attr02-01\":\"value-02-01\",\n"
+                        +"            \"attr02-01\":\"value-02-01\",\n"
-                    + "            \"attr02-02\":\"value-02-02\"\n"
+                        +"            \"attr02-02\":\"value-02-02\"\n"
-                    + "        }\n"
+                        +"        }\n"
-                    + "    },\n"
+                        +"    },\n"
-                    + "    {\n"
+                        +"    {\n"
-                    + "        \"attr01\":\"value-01\",\n"
+                        +"        \"attr01\":\"value-01\",\n"
-                    + "        \"attr02\": {\n"
+                        +"        \"attr02\": {\n"
-                    + "            \"attr02-01\":\"value-02-01\",\n"
+                        +"            \"attr02-01\":\"value-02-01\",\n"
-                    + "            \"attr02-01\":\"value-02-02\"\n"
+                        +"            \"attr02-01\":\"value-02-02\"\n"
-                    + "        }\n"
+                        +"        }\n"
-                    + "    }\n"
+                        +"    }\n"
                         + "]";
             new JSONArray(str);
             fail("Expected an exception");
@@ -3951,102 +3802,6 @@ public class JSONObjectTest {
         new JSONObject(map1);
     }
 
-    @Test
-    public void clarifyCurrentBehavior() {
-        // Behavior documented in #653 optLong vs getLong inconsistencies
-        // This problem still exists.
-        // Internally, both number_1 and number_2 are stored as strings. This is reasonable since they are parsed as strings.
-        // However, getLong and optLong should return similar results
-        JSONObject json = new JSONObject("{\"number_1\":\"01234\", \"number_2\": \"332211\"}");
-        assertEquals(json.getLong("number_1"), 1234L);
-        assertEquals(json.optLong("number_1"), 0); //THIS VALUE IS NOT RETURNED AS A NUMBER
-        assertEquals(json.getLong("number_2"), 332211L);
-        assertEquals(json.optLong("number_2"), 332211L);
-
-        // Behavior documented in #826 JSONObject parsing 0-led numeric strings as ints
-        // After reverting the code, personId is stored as a string, and the behavior is as expected
-        String personId = "\"0123\"";
-        JSONObject j1 = new JSONObject("{\"personId\": " + personId + "}");
-        assertEquals(j1.getString("personId"), "0123");
-
-        // Also #826. Here is input with missing quotes. Because of the leading zero, it should not be parsed as a number.
-        // This example was mentioned in the same ticket
-        // After reverting the code, personId is stored as a string, and the behavior is as expected
-        JSONObject j2 = new JSONObject("{\"personId\":\"0123\"}");
-        assertEquals(j2.getString("personId"), "0123");
-
-        // Behavior uncovered while working on the code
-        // All of the values are stored as strings except for hex4, which is stored as a number. This is probably incorrect
-        JSONObject j3 = new JSONObject("{ " +
-                "\"hex1\": \"010e4\", \"hex2\": \"00f0\", \"hex3\": \"0011\", " +
-                "\"hex4\": 00e0, \"hex5\": \"00f0\", \"hex6\": \"0011\" }");
-        assertEquals(j3.getString("hex1"), "010e4");
-        assertEquals(j3.getString("hex2"), "00f0");
-        assertEquals(j3.getString("hex3"), "0011");
-        assertEquals(j3.getLong("hex4"), 0, .1);
-        assertEquals(j3.getString("hex5"), "00f0");
-        assertEquals(j3.getString("hex6"), "0011");
-    }
-
-
-    @Test
-    public void testStrictModeJSONTokener_expectException(){
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration().withStrictMode();
-        JSONTokener tokener = new JSONTokener("{\"key\":\"value\"}invalidCharacters", jsonParserConfiguration);
-
-        assertThrows(JSONException.class, () -> { new JSONObject(tokener); });
-    }
-
-    @Test
-    public void test_strictModeWithMisCasedBooleanOrNullValue(){
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration().withStrictMode();
-        try{
-            new JSONObject("{\"a\":True}", jsonParserConfiguration);
-            fail("Expected an exception");
-        } catch (JSONException e) {
-            // No action, expected outcome
-        }
-        try{
-            new JSONObject("{\"a\":TRUE}", jsonParserConfiguration);
-            fail("Expected an exception");
-        } catch (JSONException e) {
-            // No action, expected outcome
-        }
-        try{
-            new JSONObject("{\"a\":nUlL}", jsonParserConfiguration);
-            fail("Expected an exception");
-        } catch (JSONException e) {
-            // No action, expected outcome
-        }
-    }
-
-    @Test
-    public void test_strictModeWithInappropriateKey(){
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration().withStrictMode();
-
-        // Parsing the following objects should fail
-        try{
-            new JSONObject("{true : 3}", jsonParserConfiguration);
-            fail("Expected an exception");
-        } catch (JSONException e) {
-            // No action, expected outcome
-        }
-        try{
-            new JSONObject("{TRUE : 3}", jsonParserConfiguration);
-            fail("Expected an exception");
-        } catch (JSONException e) {
-            // No action, expected outcome
-        }
-        try{
-            new JSONObject("{1 : 3}", jsonParserConfiguration);
-            fail("Expected an exception");
-        } catch (JSONException e) {
-            // No action, expected outcome
-        }
-
-    }
-
-
     /**
      * Method to build nested map of max maxDepth
      *
@@ -4062,36 +3817,4 @@ public class JSONObjectTest {
         return nestedMap;
     }
 
-
-    /**
-     * Tests the behavior of the {@link JSONObject} when parsing a bean with null fields
-     * using a custom {@link JSONParserConfiguration} that enables the use of native nulls.
-     * 
-     * <p>This test ensures that uninitialized fields in the bean are serialized correctly
-     * into the resulting JSON object, and their keys are present in the JSON string output.</p>
-     */
-    @Test
-    public void jsonObjectParseNullFieldsWithParserConfiguration() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration();
-        RecursiveBean bean = new RecursiveBean(null);
-        JSONObject jsonObject = new JSONObject(bean, jsonParserConfiguration.withUseNativeNulls(true));
-        assertTrue("name key should be present", jsonObject.has("name"));
-        assertTrue("ref key should be present", jsonObject.has("ref"));
-        assertTrue("ref2 key should be present", jsonObject.has("ref2"));
-    }
-
-    /**
-     * Tests the behavior of the {@link JSONObject} when parsing a bean with null fields
-     * without using a custom {@link JSONParserConfiguration}.
-     * 
-     * <p>This test ensures that uninitialized fields in the bean are not serialized
-     * into the resulting JSON object, and the object remains empty.</p>
-     */
-    @Test
-    public void jsonObjectParseNullFieldsWithoutParserConfiguration() {
-        RecursiveBean bean = new RecursiveBean(null);
-        JSONObject jsonObject = new JSONObject(bean);
-        assertTrue("JSONObject should be empty", jsonObject.isEmpty());
-    }
-
 }

src/test/java/org/json/junit/JSONParserConfigurationTest.java

@@ -1,624 +0,0 @@
-package org.json.junit;
-
-import org.json.JSONArray;
-import org.json.JSONException;
-import org.json.JSONObject;
-import org.json.JSONParserConfiguration;
-import org.json.JSONTokener;
-import org.junit.Test;
-
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Paths;
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThrows;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
-public class JSONParserConfigurationTest {
-    private static final String TEST_SOURCE = "{\"key\": \"value1\", \"key\": \"value2\"}";
-
-    @Test(expected = JSONException.class)
-    public void testThrowException() {
-        new JSONObject(TEST_SOURCE);
-    }
-
-    @Test
-    public void testOverwrite() {
-        JSONObject jsonObject = new JSONObject(TEST_SOURCE,
-                new JSONParserConfiguration().withOverwriteDuplicateKey(true));
-
-        assertEquals("duplicate key should be overwritten", "value2", jsonObject.getString("key"));
-    }
-
-    @Test
-    public void strictModeIsCloned(){
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(true)
-                .withMaxNestingDepth(12);
-
-        assertTrue(jsonParserConfiguration.isStrictMode());
-    }
-
-    @Test
-    public void maxNestingDepthIsCloned(){
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .<JSONParserConfiguration>withKeepStrings(true)
-                .withStrictMode(true);
-
-        assertTrue(jsonParserConfiguration.isKeepStrings());
-    }
-    
-    @Test
-    public void useNativeNullsIsCloned() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withUseNativeNulls(true)
-                .withStrictMode(true);
-        assertTrue(jsonParserConfiguration.isUseNativeNulls());
-    }
-
-    @Test
-    public void verifyDuplicateKeyThenMaxDepth() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withOverwriteDuplicateKey(true)
-                .withMaxNestingDepth(42);
-
-        assertEquals(42, jsonParserConfiguration.getMaxNestingDepth());
-        assertTrue(jsonParserConfiguration.isOverwriteDuplicateKey());
-    }
-
-    @Test
-    public void verifyMaxDepthThenDuplicateKey() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withMaxNestingDepth(42)
-                .withOverwriteDuplicateKey(true);
-
-        assertTrue(jsonParserConfiguration.isOverwriteDuplicateKey());
-        assertEquals(42, jsonParserConfiguration.getMaxNestingDepth());
-    }
-
-    @Test
-    public void givenInvalidInput_testStrictModeTrue_shouldThrowJsonException() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(true);
-        List<String> strictModeInputTestCases = getNonCompliantJSONArrayList();
-        // this is a lot easier to debug when things stop working
-        for (int i = 0; i < strictModeInputTestCases.size(); ++i) {
-            String testCase = strictModeInputTestCases.get(i);
-            try {
-                JSONArray jsonArray = new JSONArray(testCase, jsonParserConfiguration);
-                String s = jsonArray.toString();
-                String msg = "Expected an exception, but got: " + s + " Noncompliant Array index: " + i;
-                fail(msg);
-            } catch (Exception e) {
-                // its all good
-            }
-        }
-    }
-
-    @Test
-    public void givenInvalidInputObjects_testStrictModeTrue_shouldThrowJsonException() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(true);
-        List<String> strictModeInputTestCases = getNonCompliantJSONObjectList();
-        // this is a lot easier to debug when things stop working
-        for (int i = 0; i < strictModeInputTestCases.size(); ++i) {
-            String testCase = strictModeInputTestCases.get(i);
-            try {
-                JSONObject jsonObject = new JSONObject(testCase, jsonParserConfiguration);
-                String s = jsonObject.toString();
-                String msg = "Expected an exception, but got: " + s + " Noncompliant Array index: " + i;
-                fail(msg);
-            } catch (Exception e) {
-                // its all good
-            }
-        }
-    }
-
-    @Test
-    public void givenEmptyArray_testStrictModeTrue_shouldNotThrowJsonException() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(true);
-        String testCase = "[]";
-        JSONArray jsonArray = new JSONArray(testCase, jsonParserConfiguration);
-        assertEquals(testCase, jsonArray.toString());
-    }
-
-    @Test
-    public void givenEmptyObject_testStrictModeTrue_shouldNotThrowJsonException() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(true);
-        String testCase = "{}";
-        JSONObject jsonObject = new JSONObject(testCase, jsonParserConfiguration);
-        assertEquals(testCase, jsonObject.toString());
-    }
-
-    @Test
-    public void givenValidNestedArray_testStrictModeTrue_shouldNotThrowJsonException() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(true);
-
-        String testCase = "[[\"c\"], [10.2], [true, false, true]]";
-
-        JSONArray jsonArray = new JSONArray(testCase, jsonParserConfiguration);
-        JSONArray arrayShouldContainStringAt0 = jsonArray.getJSONArray(0);
-        JSONArray arrayShouldContainNumberAt0 = jsonArray.getJSONArray(1);
-        JSONArray arrayShouldContainBooleanAt0 = jsonArray.getJSONArray(2);
-
-        assertTrue(arrayShouldContainStringAt0.get(0) instanceof String);
-        assertTrue(arrayShouldContainNumberAt0.get(0) instanceof Number);
-        assertTrue(arrayShouldContainBooleanAt0.get(0) instanceof Boolean);
-    }
-
-    @Test
-    public void givenValidNestedObject_testStrictModeTrue_shouldNotThrowJsonException() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(true);
-
-        String testCase = "{\"a0\":[\"c\"], \"a1\":[10.2], \"a2\":[true, false, true]}";
-
-        JSONObject jsonObject = new JSONObject(testCase, jsonParserConfiguration);
-        JSONArray arrayShouldContainStringAt0 = jsonObject.getJSONArray("a0");
-        JSONArray arrayShouldContainNumberAt0 = jsonObject.getJSONArray("a1");
-        JSONArray arrayShouldContainBooleanAt0 = jsonObject.getJSONArray("a2");
-
-        assertTrue(arrayShouldContainStringAt0.get(0) instanceof String);
-        assertTrue(arrayShouldContainNumberAt0.get(0) instanceof Number);
-        assertTrue(arrayShouldContainBooleanAt0.get(0) instanceof Boolean);
-    }
-
-    @Test
-    public void givenValidEmptyArrayInsideArray_testStrictModeTrue_shouldNotThrowJsonException(){
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(true);
-        String testCase = "[[]]";
-        JSONArray jsonArray = new JSONArray(testCase, jsonParserConfiguration);
-        assertEquals(testCase, jsonArray.toString());
-    }
-
-    @Test
-    public void givenValidEmptyArrayInsideObject_testStrictModeTrue_shouldNotThrowJsonException(){
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(true);
-        String testCase = "{\"a0\":[]}";
-        JSONObject jsonObject = new JSONObject(testCase, jsonParserConfiguration);
-        assertEquals(testCase, jsonObject.toString());
-    }
-
-    @Test
-    public void givenValidEmptyArrayInsideArray_testStrictModeFalse_shouldNotThrowJsonException(){
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(false);
-        String testCase = "[[]]";
-        JSONArray jsonArray = new JSONArray(testCase, jsonParserConfiguration);
-        assertEquals(testCase, jsonArray.toString());
-    }
-
-    @Test
-    public void givenValidEmptyArrayInsideObject_testStrictModeFalse_shouldNotThrowJsonException(){
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(false);
-        String testCase = "{\"a0\":[]}";
-        JSONObject jsonObject = new JSONObject(testCase, jsonParserConfiguration);
-        assertEquals(testCase, jsonObject.toString());
-    }
-
-    @Test
-    public void givenInvalidStringArray_testStrictModeTrue_shouldThrowJsonException() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(true);
-        String testCase = "[badString]";
-        JSONException je = assertThrows(JSONException.class, () -> new JSONArray(testCase, jsonParserConfiguration));
-        assertEquals("Strict mode error: Value 'badString' is not surrounded by quotes at 10 [character 11 line 1]",
-                je.getMessage());
-    }
-
-    @Test
-    public void givenInvalidStringObject_testStrictModeTrue_shouldThrowJsonException() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(true);
-        String testCase = "{\"a0\":badString}";
-        JSONException je = assertThrows(JSONException.class, () -> new JSONObject(testCase, jsonParserConfiguration));
-        assertEquals("Strict mode error: Value 'badString' is not surrounded by quotes at 15 [character 16 line 1]",
-                je.getMessage());
-    }
-
-    @Test
-    public void allowNullArrayInStrictMode() {
-        String expected = "[null]";
-        JSONArray jsonArray = new JSONArray(expected, new JSONParserConfiguration().withStrictMode(true));
-        assertEquals(expected, jsonArray.toString());
-    }
-
-    @Test
-    public void allowNullObjectInStrictMode() {
-        String expected = "{\"a0\":null}";
-        JSONObject jsonObject = new JSONObject(expected, new JSONParserConfiguration().withStrictMode(true));
-        assertEquals(expected, jsonObject.toString());
-    }
-
-    @Test
-    public void shouldHandleNumericArray() {
-        String expected = "[10]";
-        JSONArray jsonArray = new JSONArray(expected, new JSONParserConfiguration().withStrictMode(true));
-        assertEquals(expected, jsonArray.toString());
-    }
-
-    @Test
-    public void shouldHandleNumericObject() {
-        String expected = "{\"a0\":10}";
-        JSONObject jsonObject = new JSONObject(expected, new JSONParserConfiguration().withStrictMode(true));
-        assertEquals(expected, jsonObject.toString());
-    }
-    @Test
-    public void givenCompliantJSONArrayFile_testStrictModeTrue_shouldNotThrowAnyException() throws IOException {
-        try (Stream<String> lines = Files.lines(Paths.get("src/test/resources/compliantJsonArray.json"))) {
-            String compliantJsonArrayAsString = lines.collect(Collectors.joining());
-            JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                    .withStrictMode(true);
-            new JSONArray(compliantJsonArrayAsString, jsonParserConfiguration);
-        }
-    }
-
-    @Test
-    public void givenCompliantJSONObjectFile_testStrictModeTrue_shouldNotThrowAnyException() throws IOException {
-        try (Stream<String> lines = Files.lines(Paths.get("src/test/resources/compliantJsonObject.json"))) {
-            String compliantJsonObjectAsString = lines.collect(Collectors.joining());
-            JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                    .withStrictMode(true);
-
-            new JSONObject(compliantJsonObjectAsString, jsonParserConfiguration);
-        }
-    }
-
-    @Test
-    public void givenInvalidInputArrays_testStrictModeFalse_shouldNotThrowAnyException() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(false);
-
-        List<String> strictModeInputTestCases = getNonCompliantJSONArrayList();
-
-        // this is a lot easier to debug when things stop working
-        for (int i = 0; i < strictModeInputTestCases.size(); ++i) {
-            String testCase = strictModeInputTestCases.get(i);
-            try {
-                JSONArray jsonArray = new JSONArray(testCase, jsonParserConfiguration);
-            } catch (Exception e) {
-                System.out.println("Unexpected exception: " + e.getMessage() + " Noncompliant Array index: " + i);
-                fail(String.format("Noncompliant array index: %d", i));
-            }
-        }
-    }
-
-    @Test
-    public void givenInvalidInputObjects_testStrictModeFalse_shouldNotThrowAnyException() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(false);
-
-        List<String> strictModeInputTestCases = getNonCompliantJSONObjectList();
-
-        // this is a lot easier to debug when things stop working
-        for (int i = 0; i < strictModeInputTestCases.size(); ++i) {
-            String testCase = strictModeInputTestCases.get(i);
-            try {
-                JSONObject jsonObject = new JSONObject(testCase, jsonParserConfiguration);
-            } catch (Exception e) {
-                System.out.println("Unexpected exception: " + e.getMessage() + " Noncompliant Array index: " + i);
-                fail(String.format("Noncompliant array index: %d", i));
-            }
-        }
-    }
-
-    @Test
-    public void givenInvalidInputArray_testStrictModeTrue_shouldThrowInvalidCharacterErrorMessage() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(true);
-        String testCase = "[1,2];[3,4]";
-        JSONException je = assertThrows("expected non-compliant array but got instead: " + testCase,
-                JSONException.class, () -> new JSONArray(testCase, jsonParserConfiguration));
-        assertEquals("Strict mode error: Unparsed characters found at end of input text at 6 [character 7 line 1]",
-                je.getMessage());
-    }
-
-    @Test
-    public void givenInvalidInputObject_testStrictModeTrue_shouldThrowInvalidCharacterErrorMessage() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(true);
-        String testCase = "{\"a0\":[1,2];\"a1\":[3,4]}";
-        JSONException je = assertThrows("expected non-compliant array but got instead: " + testCase,
-                JSONException.class, () -> new JSONObject(testCase, jsonParserConfiguration));
-        assertEquals("Strict mode error: Invalid character ';' found at 12 [character 13 line 1]", je.getMessage());
-    }
-
-    @Test
-    public void givenInvalidInputArrayWithNumericStrings_testStrictModeTrue_shouldThrowInvalidCharacterErrorMessage() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(true);
-        String testCase = "[\"1\",\"2\"];[3,4]";
-        JSONException je = assertThrows("expected non-compliant array but got instead: " + testCase,
-                JSONException.class, () -> new JSONArray(testCase, jsonParserConfiguration));
-        assertEquals("Strict mode error: Unparsed characters found at end of input text at 10 [character 11 line 1]",
-                je.getMessage());
-    }
-
-    @Test
-    public void givenInvalidInputObjectWithNumericStrings_testStrictModeTrue_shouldThrowInvalidCharacterErrorMessage() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(true);
-        String testCase = "{\"a0\":[\"1\",\"2\"];\"a1\":[3,4]}";
-        JSONException je = assertThrows("expected non-compliant array but got instead: " + testCase,
-                JSONException.class, () -> new JSONObject(testCase, jsonParserConfiguration));
-        assertEquals("Strict mode error: Invalid character ';' found at 16 [character 17 line 1]", je.getMessage());
-    }
-
-    @Test
-    public void givenInvalidInputArray_testStrictModeTrue_shouldThrowValueNotSurroundedByQuotesErrorMessage() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(true);
-        String testCase = "[{\"test\": implied}]";
-        JSONException je = assertThrows("expected non-compliant array but got instead: " + testCase,
-                JSONException.class, () -> new JSONArray(testCase, jsonParserConfiguration));
-        assertEquals("Strict mode error: Value 'implied' is not surrounded by quotes at 17 [character 18 line 1]",
-                je.getMessage());
-    }
-
-    @Test
-    public void givenInvalidInputObject_testStrictModeTrue_shouldThrowValueNotSurroundedByQuotesErrorMessage() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(true);
-        String testCase = "{\"a0\":{\"test\": implied}]}";
-        JSONException je = assertThrows("expected non-compliant array but got instead: " + testCase,
-                JSONException.class, () -> new JSONObject(testCase, jsonParserConfiguration));
-        assertEquals("Strict mode error: Value 'implied' is not surrounded by quotes at 22 [character 23 line 1]",
-                je.getMessage());
-    }
-
-    @Test
-    public void givenInvalidInputArray_testStrictModeFalse_shouldNotThrowAnyException() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(false);
-        String testCase = "[{\"test\": implied}]";
-        new JSONArray(testCase, jsonParserConfiguration);
-    }
-
-    @Test
-    public void givenInvalidInputObject_testStrictModeFalse_shouldNotThrowAnyException() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(false);
-        String testCase = "{\"a0\":{\"test\": implied}}";
-        new JSONObject(testCase, jsonParserConfiguration);
-    }
-
-    @Test
-    public void givenNonCompliantQuotesArray_testStrictModeTrue_shouldThrowJsonExceptionWithConcreteErrorDescription() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(true);
-
-        String testCaseOne = "[\"abc', \"test\"]";
-        String testCaseTwo = "['abc\", \"test\"]";
-        String testCaseThree = "['abc']";
-        String testCaseFour = "[{'testField': \"testValue\"}]";
-
-        JSONException jeOne = assertThrows(JSONException.class,
-                () -> new JSONArray(testCaseOne, jsonParserConfiguration));
-        JSONException jeTwo = assertThrows(JSONException.class,
-                () -> new JSONArray(testCaseTwo, jsonParserConfiguration));
-        JSONException jeThree = assertThrows(JSONException.class,
-                () -> new JSONArray(testCaseThree, jsonParserConfiguration));
-        JSONException jeFour = assertThrows(JSONException.class,
-                () -> new JSONArray(testCaseFour, jsonParserConfiguration));
-
-        assertEquals(
-                "Expected a ',' or ']' at 10 [character 11 line 1]",
-                jeOne.getMessage());
-        assertEquals(
-                "Strict mode error: Single quoted strings are not allowed at 2 [character 3 line 1]",
-                jeTwo.getMessage());
-        assertEquals(
-                "Strict mode error: Single quoted strings are not allowed at 2 [character 3 line 1]",
-                jeThree.getMessage());
-        assertEquals(
-                "Strict mode error: Single quoted strings are not allowed at 3 [character 4 line 1]",
-                jeFour.getMessage());
-    }
-
-    @Test
-    public void givenNonCompliantQuotesObject_testStrictModeTrue_shouldThrowJsonExceptionWithConcreteErrorDescription() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(true);
-
-        String testCaseOne = "{\"abc': \"test\"}";
-        String testCaseTwo = "{'abc\": \"test\"}";
-        String testCaseThree = "{\"a\":'abc'}";
-        String testCaseFour = "{'testField': \"testValue\"}";
-
-        JSONException jeOne = assertThrows(JSONException.class,
-                () -> new JSONObject(testCaseOne, jsonParserConfiguration));
-        JSONException jeTwo = assertThrows(JSONException.class,
-                () -> new JSONObject(testCaseTwo, jsonParserConfiguration));
-        JSONException jeThree = assertThrows(JSONException.class,
-                () -> new JSONObject(testCaseThree, jsonParserConfiguration));
-        JSONException jeFour = assertThrows(JSONException.class,
-                () -> new JSONObject(testCaseFour, jsonParserConfiguration));
-
-        assertEquals(
-                "Expected a ':' after a key at 10 [character 11 line 1]",
-                jeOne.getMessage());
-        assertEquals(
-                "Strict mode error: Single quoted strings are not allowed at 2 [character 3 line 1]",
-                jeTwo.getMessage());
-        assertEquals(
-                "Strict mode error: Single quoted strings are not allowed at 6 [character 7 line 1]",
-                jeThree.getMessage());
-        assertEquals(
-                "Strict mode error: Single quoted strings are not allowed at 2 [character 3 line 1]",
-                jeFour.getMessage());
-    }
-
-    @Test
-    public void givenUnbalancedQuotesArray_testStrictModeFalse_shouldThrowJsonException() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(false);
-
-        String testCaseOne = "[\"abc', \"test\"]";
-        String testCaseTwo = "['abc\", \"test\"]";
-
-        JSONException jeOne = assertThrows(JSONException.class,
-                () -> new JSONArray(testCaseOne, jsonParserConfiguration));
-        JSONException jeTwo = assertThrows(JSONException.class,
-                () -> new JSONArray(testCaseTwo, jsonParserConfiguration));
-
-        assertEquals("Expected a ',' or ']' at 10 [character 11 line 1]", jeOne.getMessage());
-        assertEquals("Unterminated string. Character with int code 0 is not allowed within a quoted string. at 15 [character 16 line 1]", jeTwo.getMessage());
-    }
-
-    @Test
-    public void givenUnbalancedQuotesObject_testStrictModeFalse_shouldThrowJsonException() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(false);
-
-        String testCaseOne = "{\"abc': \"test\"}";
-        String testCaseTwo = "{'abc\": \"test\"}";
-
-        JSONException jeOne = assertThrows(JSONException.class,
-                () -> new JSONObject(testCaseOne, jsonParserConfiguration));
-        JSONException jeTwo = assertThrows(JSONException.class,
-                () -> new JSONObject(testCaseTwo, jsonParserConfiguration));
-
-        assertEquals("Expected a ':' after a key at 10 [character 11 line 1]", jeOne.getMessage());
-        assertEquals("Unterminated string. Character with int code 0 is not allowed within a quoted string. at 15 [character 16 line 1]", jeTwo.getMessage());
-    }
-
-    @Test
-    public void givenInvalidInputArray_testStrictModeTrue_shouldThrowKeyNotSurroundedByQuotesErrorMessage() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(true);
-
-        String testCase = "[{test: implied}]";
-        JSONException je = assertThrows("expected non-compliant array but got instead: " + testCase,
-                JSONException.class, () -> new JSONArray(testCase, jsonParserConfiguration));
-
-        assertEquals("Strict mode error: Value 'test' is not surrounded by quotes at 6 [character 7 line 1]",
-                je.getMessage());
-    }
-
-    @Test
-    public void givenInvalidInputObject_testStrictModeTrue_shouldThrowKeyNotSurroundedByQuotesErrorMessage() {
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
-                .withStrictMode(true);
-
-        String testCase = "{test: implied}";
-        JSONException je = assertThrows("expected non-compliant json but got instead: " + testCase,
-                JSONException.class, () -> new JSONObject(testCase, jsonParserConfiguration));
-
-        assertEquals("Strict mode error: Value 'test' is not surrounded by quotes at 5 [character 6 line 1]",
-                je.getMessage());
-    }
-
-    @Test
-    public void givenInvalidInputObject_testStrictModeTrue_JSONObjectUsingJSONTokener_shouldThrowJSONException() {
-        JSONException exception = assertThrows(JSONException.class, () -> {
-            new JSONObject(new JSONTokener("{\"key\":\"value\"} invalid trailing text"), new JSONParserConfiguration().withStrictMode(true));
-        });
-
-        assertEquals("Strict mode error: Unparsed characters found at end of input text at 17 [character 18 line 1]", exception.getMessage());
-    }
-
-    @Test
-    public void givenInvalidInputObject_testStrictModeTrue_JSONObjectUsingString_shouldThrowJSONException() {
-        JSONException exception = assertThrows(JSONException.class, () -> {
-            new JSONObject("{\"key\":\"value\"} invalid trailing text", new JSONParserConfiguration().withStrictMode(true));
-        });
-        assertEquals("Strict mode error: Unparsed characters found at end of input text at 17 [character 18 line 1]", exception.getMessage());
-    }
-
-    @Test
-    public void givenInvalidInputObject_testStrictModeTrue_JSONArrayUsingJSONTokener_shouldThrowJSONException() {
-        JSONException exception = assertThrows(JSONException.class, () -> {
-            new JSONArray(new JSONTokener("[\"value\"] invalid trailing text"), new JSONParserConfiguration().withStrictMode(true));
-        });
-
-        assertEquals("Strict mode error: Unparsed characters found at end of input text at 11 [character 12 line 1]", exception.getMessage());
-    }
-
-    @Test
-    public void givenInvalidInputObject_testStrictModeTrue_JSONArrayUsingString_shouldThrowJSONException() {
-        JSONException exception = assertThrows(JSONException.class, () -> {
-            new JSONArray("[\"value\"] invalid trailing text", new JSONParserConfiguration().withStrictMode(true));
-        });
-        assertEquals("Strict mode error: Unparsed characters found at end of input text at 11 [character 12 line 1]", exception.getMessage());
-    }
-
-    /**
-     * This method contains short but focused use-case samples and is exclusively used to test strictMode unit tests in
-     * this class.
-     *
-     * @return List with JSON strings.
-     */
-    private List<String> getNonCompliantJSONArrayList() {
-        return Arrays.asList(
-                "[1],",
-                "[1,]",
-                "[,]",
-                "[,,]",
-                "[[1],\"sa\",[2]]a",
-                "[1],\"dsa\": \"test\"",
-                "[[a]]",
-                "[]asdf",
-                "[]]",
-                "[]}",
-                "[][",
-                "[]{",
-                "[],",
-                "[]:",
-                "[],[",
-                "[],{",
-                "[1,2];[3,4]",
-                "[test]",
-                "[{'testSingleQuote': 'testSingleQuote'}]",
-                "[1, 2,3]:[4,5]",
-                "[{test: implied}]",
-                "[{\"test\": implied}]",
-                "[{\"number\":\"7990154836330\",\"color\":'c'},{\"number\":8784148854580,\"color\":RosyBrown},{\"number\":\"5875770107113\",\"color\":\"DarkSeaGreen\"}]",
-                "[{test: \"implied\"}]");
-    }
-
-    /**
-     * This method contains short but focused use-case samples and is exclusively used to test strictMode unit tests in
-     * this class.
-     *
-     * @return List with JSON strings.
-     */
-    private List<String> getNonCompliantJSONObjectList() {
-        return Arrays.asList(
-                "{\"a\":1},",
-                "{\"a\":1,}",
-                "{\"a0\":[1],\"a1\":\"sa\",\"a2\":[2]}a",
-                "{\"a\":1},\"dsa\": \"test\"",
-                "{\"a\":[a]}",
-                "{}asdf",
-                "{}}",
-                "{}]",
-                "{}{",
-                "{}[",
-                "{},",
-                "{}:",
-                "{},{",
-                "{},[",
-                "{\"a0\":[1,2];\"a1\":[3,4]}",
-                "{\"a\":test}",
-                "{a:{'testSingleQuote': 'testSingleQuote'}}",
-                "{\"a0\":1, \"a1\":2,\"a2\":3}:{\"a3\":4,\"a4\":5}",
-                "{\"a\":{test: implied}}",
-                "{a:{\"test\": implied}}",
-                "{a:[{\"number\":\"7990154836330\",\"color\":'c'},{\"number\":8784148854580,\"color\":RosyBrown},{\"number\":\"5875770107113\",\"color\":\"DarkSeaGreen\"}]}",
-                "{a:{test: \"implied\"}}"
-        );
-    }
-
-}

src/test/java/org/json/junit/JSONPointerTest.java

@@ -384,7 +384,8 @@ public class JSONPointerTest {
     	String str = "{"+
                 "\"string\\\\\\\\Key\":\"hello world!\","+
 
-                "\"\\\\\":\"slash test\"" +
+                "\"\\\\\":\"slash test\"," + 
+                "}"+
                 "}";
             JSONObject jsonObject = new JSONObject(str);
             //Summary of issue: When a KEY in the jsonObject is "\\\\" --> it's held

src/test/java/org/json/junit/JSONStringTest.java

@@ -319,22 +319,6 @@ public class JSONStringTest {
         }
     }
 
-    @Test
-    public void testEnumJSONString() {
-        JSONObject jsonObject = new JSONObject();
-        jsonObject.put("key", MyEnum.MY_ENUM);
-        assertEquals("{\"key\":\"myJsonString\"}", jsonObject.toString());
-    }
-
-    private enum MyEnum implements JSONString {
-        MY_ENUM;
-
-        @Override
-        public String toJSONString() {
-            return "\"myJsonString\"";
-        }
-    }
-
     /**
      * A JSONString that returns a valid JSON string value.
      */

src/test/java/org/json/junit/JSONTokenerTest.java

@@ -16,7 +16,10 @@ import java.io.InputStreamReader;
 import java.io.Reader;
 import java.io.StringReader;
 
-import org.json.*;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.json.JSONTokener;
 import org.junit.Test;
 
 /**
@@ -95,17 +98,7 @@ public class JSONTokenerTest {
         checkValid(" []  ",JSONArray.class);
         checkValid("[1,2]",JSONArray.class);
         checkValid("\n\n[1,2]\n\n",JSONArray.class);
-
-        // Test should fail if default strictMode is true, pass if false
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration();
-        if (jsonParserConfiguration.isStrictMode()) {
-            try {
         checkValid("1 2", String.class);
-                assertEquals("Expected to throw exception due to invalid string", true, false);
-            } catch (JSONException e) { }
-        } else {
-            checkValid("1 2", String.class);
-        }
     }
     
     @Test
@@ -332,42 +325,4 @@ public class JSONTokenerTest {
            assertEquals("Stream closed", exception.getMessage());
        }
    }
-
-    @Test
-    public void testInvalidInput_JSONObject_withoutStrictModel_shouldParseInput() {
-        String input = "{\"invalidInput\": [],}";
-        JSONTokener tokener = new JSONTokener(input);
-
-        // Test should fail if default strictMode is true, pass if false
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration();
-        if (jsonParserConfiguration.isStrictMode()) {
-            try {
-                Object value = tokener.nextValue();
-                assertEquals(new JSONObject(input).toString(), value.toString());
-                assertEquals("Expected to throw exception due to invalid string", true, false);
-            } catch (JSONException e) { }
-        } else {
-            Object value = tokener.nextValue();
-            assertEquals(new JSONObject(input).toString(), value.toString());
-        }
-    }
-
-    @Test
-    public void testInvalidInput_JSONArray_withoutStrictModel_shouldParseInput() {
-        String input = "[\"invalidInput\",]";
-        JSONTokener tokener = new JSONTokener(input);
-
-        // Test should fail if default strictMode is true, pass if false
-        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration();
-        if (jsonParserConfiguration.isStrictMode()) {
-            try {
-                Object value = tokener.nextValue();
-                assertEquals(new JSONArray(input).toString(), value.toString());
-                assertEquals("Expected to throw exception due to invalid string", true, false);
-            } catch (JSONException e) { }
-        } else {
-            Object value = tokener.nextValue();
-            assertEquals(new JSONArray(input).toString(), value.toString());
-        }
-    }
 }

src/test/java/org/json/junit/JsonNumberZeroTest.java

@@ -0,0 +1,55 @@
+package org.json.junit;
+
+import org.json.JSONObject;
+import org.junit.Test;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+
+import static org.junit.Assert.assertEquals;
+
+public class JsonNumberZeroTest {
+
+    @Test
+    public void shouldParseNegativeZeroValueWithMultipleZeroDigit(){
+        JSONObject jsonObject = new JSONObject("{value:-0000}");
+        assertEquals("Float not recognized", -0f, jsonObject.getFloat("value"), 0.0f);
+        assertEquals("Float not recognized", -0f, jsonObject.optFloat("value"), 0.0f);
+        assertEquals("Float not recognized", -0f, jsonObject.optFloatObject("value"), 0.0f);
+        assertEquals("Double not recognized", -0d, jsonObject.optDouble("value"), 0.0f);
+        assertEquals("Double not recognized", -0.0d, jsonObject.optDoubleObject("value"), 0.0f);
+        assertEquals("Double not recognized", -0.0d, jsonObject.getDouble("value"), 0.0f);
+        assertEquals("Long not recognized", 0, jsonObject.optLong("value"), 0);
+        assertEquals("Long not recognized", 0, jsonObject.getLong("value"), 0);
+        assertEquals("Long not recognized", 0, jsonObject.optLongObject("value"), 0);
+        assertEquals("Integer not recognized", 0, jsonObject.optInt("value"), 0);
+        assertEquals("Integer not recognized", 0, jsonObject.getInt("value"), 0);
+        assertEquals("Integer not recognized", 0, jsonObject.optIntegerObject("value"), 0);
+        assertEquals("Number not recognized", 0, jsonObject.getNumber("value").intValue(), 0);
+        assertEquals("Number not recognized", 0, jsonObject.getNumber("value").longValue(), 0);
+        assertEquals("BigDecimal not recognized", 0, BigDecimal.valueOf(-0).compareTo(jsonObject.getBigDecimal("value")));
+        assertEquals("BigInteger not recognized",0, BigInteger.valueOf(0).compareTo(jsonObject.getBigInteger("value")));
+    }
+
+    @Test
+    public void shouldParseZeroValueWithMultipleZeroDigit(){
+        JSONObject jsonObject = new JSONObject("{value:0000}");
+        assertEquals("Float not recognized", 0f, jsonObject.getFloat("value"), 0.0f);
+        assertEquals("Float not recognized", 0f, jsonObject.optFloat("value"), 0.0f);
+        assertEquals("Float not recognized", 0f, jsonObject.optFloatObject("value"), 0.0f);
+        assertEquals("Double not recognized", 0d, jsonObject.optDouble("value"), 0.0f);
+        assertEquals("Double not recognized", 0.0d, jsonObject.optDoubleObject("value"), 0.0f);
+        assertEquals("Double not recognized", 0.0d, jsonObject.getDouble("value"), 0.0f);
+        assertEquals("Long not recognized", 0, jsonObject.optLong("value"), 0);
+        assertEquals("Long not recognized", 0, jsonObject.getLong("value"), 0);
+        assertEquals("Long not recognized", 0, jsonObject.optLongObject("value"), 0);
+        assertEquals("Integer not recognized", 0, jsonObject.optInt("value"), 0);
+        assertEquals("Integer not recognized", 0, jsonObject.getInt("value"), 0);
+        assertEquals("Integer not recognized", 0, jsonObject.optIntegerObject("value"), 0);
+        assertEquals("Number not recognized", 0, jsonObject.getNumber("value").intValue(), 0);
+        assertEquals("Number not recognized", 0, jsonObject.getNumber("value").longValue(), 0);
+        assertEquals("BigDecimal not recognized", 0, BigDecimal.valueOf(-0).compareTo(jsonObject.getBigDecimal("value")));
+        assertEquals("BigInteger not recognized",0, BigInteger.valueOf(0).compareTo(jsonObject.getBigInteger("value")));
+    }
+
+}

src/test/java/org/json/junit/StringBuilderWriterTest.java

@@ -1,60 +0,0 @@
-package org.json.junit;
-
-import static org.junit.Assert.assertEquals;
-
-import org.json.StringBuilderWriter;
-import org.junit.Before;
-import org.junit.Test;
-
-public class StringBuilderWriterTest {
-    private StringBuilderWriter writer;
-
-    @Before
-    public void setUp() {
-        writer = new StringBuilderWriter();
-    }
-
-    @Test
-    public void testWriteChar() {
-        writer.write('a');
-        assertEquals("a", writer.toString());
-    }
-
-    @Test
-    public void testWriteCharArray() {
-        char[] chars = {'a', 'b', 'c'};
-        writer.write(chars, 0, 3);
-        assertEquals("abc", writer.toString());
-    }
-
-    @Test
-    public void testWriteString() {
-        writer.write("hello");
-        assertEquals("hello", writer.toString());
-    }
-
-    @Test
-    public void testWriteStringWithOffsetAndLength() {
-        writer.write("hello world", 6, 5);
-        assertEquals("world", writer.toString());
-    }
-
-    @Test
-    public void testAppendCharSequence() {
-        writer.append("hello");
-        assertEquals("hello", writer.toString());
-    }
-
-    @Test
-    public void testAppendCharSequenceWithStartAndEnd() {
-        CharSequence csq = "hello world";
-        writer.append(csq, 6, 11);
-        assertEquals("world", writer.toString());
-    }
-
-    @Test
-    public void testAppendChar() {
-        writer.append('a');
-        assertEquals("a", writer.toString());
-    }
-}

src/test/java/org/json/junit/XMLConfigurationTest.java

@@ -270,9 +270,9 @@ public class XMLConfigurationTest {
 
         String expectedStr = 
             "{\"addresses\":{\"address\":{\"street\":\"[CDATA[Baker street 5]\","+
-            "\"name\":\"Joe Tester\",\"NothingHere\":\"\",\"TrueValue\":true,\n"+
+            "\"name\":\"Joe Tester\",\"NothingHere\":\"\",TrueValue:true,\n"+
             "\"FalseValue\":false,\"NullValue\":null,\"PositiveValue\":42,\n"+
-            "\"NegativeValue\":-23,\"DoubleValue\":-23.45,\"Nan\":\"-23x.45\",\n"+
+            "\"NegativeValue\":-23,\"DoubleValue\":-23.45,\"Nan\":-23x.45,\n"+
             "\"ArrayOfNum\":\"1, 2, 3, 4.1, 5.2\"\n"+
             "},\"xsi:noNamespaceSchemaLocation\":"+
             "\"test.xsd\",\"xmlns:xsi\":\"http://www.w3.org/2001/"+
@@ -574,18 +574,15 @@ public class XMLConfigurationTest {
         XMLParserConfiguration keepStringsAndCloseEmptyTag = keepStrings.withCloseEmptyTag(true);
         XMLParserConfiguration keepDigits = keepStringsAndCloseEmptyTag.withKeepStrings(false);
         XMLParserConfiguration keepDigitsAndNoCloseEmptyTag = keepDigits.withCloseEmptyTag(false);
-        assertTrue(keepStrings.isKeepNumberAsString());
+        assertTrue(keepStrings.isKeepStrings());
-        assertTrue(keepStrings.isKeepBooleanAsString());
         assertFalse(keepStrings.isCloseEmptyTag());
-        assertTrue(keepStringsAndCloseEmptyTag.isKeepNumberAsString());
+        assertTrue(keepStringsAndCloseEmptyTag.isKeepStrings());
-        assertTrue(keepStringsAndCloseEmptyTag.isKeepBooleanAsString());
         assertTrue(keepStringsAndCloseEmptyTag.isCloseEmptyTag());
-        assertFalse(keepDigits.isKeepNumberAsString());
+        assertFalse(keepDigits.isKeepStrings());
-        assertFalse(keepDigits.isKeepBooleanAsString());
         assertTrue(keepDigits.isCloseEmptyTag());
-        assertFalse(keepDigitsAndNoCloseEmptyTag.isKeepNumberAsString());
+        assertFalse(keepDigitsAndNoCloseEmptyTag.isKeepStrings());
-        assertFalse(keepDigitsAndNoCloseEmptyTag.isKeepBooleanAsString());
         assertFalse(keepDigitsAndNoCloseEmptyTag.isCloseEmptyTag());
+
     }
 
     /**
@@ -764,73 +761,12 @@ public class XMLConfigurationTest {
     @Test
     public void testToJSONArray_jsonOutput() {
         final String originalXml = "<root><id>01</id><id>1</id><id>00</id><id>0</id><item id=\"01\"/><title>True</title></root>";
-        final JSONObject expected = new JSONObject("{\"root\":{\"item\":{\"id\":\"01\"},\"id\":[\"01\",1,\"00\",0],\"title\":true}}");
+        final JSONObject expected = new JSONObject("{\"root\":{\"item\":{\"id\":1},\"id\":[1,1,0,0],\"title\":true}}");
         final JSONObject actualJsonOutput = XML.toJSONObject(originalXml, 
                 new XMLParserConfiguration().withKeepStrings(false));
         Util.compareActualVsExpectedJsonObjects(actualJsonOutput,expected);
     }
 
-    /**
-     * JSON string lost leading zero and converted "True" to true.
-     */
-    @Test
-    public void testToJSONArray_jsonOutput_withKeepNumberAsString() {
-        final String originalXml = "<root><id>01</id><id>1</id><id>00</id><id>0</id><id>null</id><item id=\"01\"/><title>True</title></root>";
-        final JSONObject expected = new JSONObject("{\"root\":{\"item\":{\"id\":\"01\"},\"id\":[\"01\",\"1\",\"00\",\"0\",null],\"title\":true}}");
-        final JSONObject actualJsonOutput = XML.toJSONObject(originalXml,
-                new XMLParserConfiguration().withKeepNumberAsString(true));
-        Util.compareActualVsExpectedJsonObjects(actualJsonOutput,expected);
-    }
-
-    /**
-     * JSON string lost leading zero and converted "True" to true.
-     */
-    @Test
-    public void testToJSONArray_jsonOutput_withKeepBooleanAsString() {
-        final String originalXml = "<root><id>01</id><id>1</id><id>00</id><id>0</id><id>null</id><item id=\"01\"/><title>True</title></root>";
-        final JSONObject expected = new JSONObject("{\"root\":{\"item\":{\"id\":\"01\"},\"id\":[\"01\",1,\"00\",0,null],\"title\":\"True\"}}");
-        final JSONObject actualJsonOutput = XML.toJSONObject(originalXml,
-                new XMLParserConfiguration().withKeepBooleanAsString(true));
-        Util.compareActualVsExpectedJsonObjects(actualJsonOutput,expected);
-    }
-
-    /**
-     * null is "null" when keepStrings == true
-     */
-    @Test
-    public void testToJSONArray_jsonOutput_null_withKeepString() {
-        final String originalXml = "<root><id>01</id><id>1</id><id>00</id><id>0</id><item id=\"01\"/><title>null</title></root>";
-        final JSONObject expected = new JSONObject("{\"root\":{\"item\":{\"id\":\"01\"},\"id\":[\"01\",\"1\",\"00\",\"0\"],\"title\":\"null\"}}");
-        final JSONObject actualJsonOutput = XML.toJSONObject(originalXml,
-                new XMLParserConfiguration().withKeepStrings(true));
-        Util.compareActualVsExpectedJsonObjects(actualJsonOutput,expected);
-    }
-
-    /**
-     * Test keepStrings behavior when setting keepBooleanAsString, keepNumberAsString
-     */
-    @Test
-    public void test_keepStringBehavior() {
-        XMLParserConfiguration xpc = new XMLParserConfiguration().withKeepStrings(true);
-        assertEquals(xpc.isKeepStrings(), true);
-
-        xpc = xpc.withKeepBooleanAsString(true);
-        xpc = xpc.withKeepNumberAsString(false);
-        assertEquals(xpc.isKeepStrings(), false);
-
-        xpc = xpc.withKeepBooleanAsString(false);
-        xpc = xpc.withKeepNumberAsString(true);
-        assertEquals(xpc.isKeepStrings(), false);
-
-        xpc = xpc.withKeepBooleanAsString(true);
-        xpc = xpc.withKeepNumberAsString(true);
-        assertEquals(xpc.isKeepStrings(), true);
-
-        xpc = xpc.withKeepBooleanAsString(false);
-        xpc = xpc.withKeepNumberAsString(false);
-        assertEquals(xpc.isKeepStrings(), false);
-    }
-
     /**
      * JSON string cannot be reverted to original xml.
      */

src/test/java/org/json/junit/XMLTest.java

@@ -267,9 +267,9 @@ public class XMLTest {
 
         String expectedStr = 
             "{\"addresses\":{\"address\":{\"street\":\"[CDATA[Baker street 5]\","+
-            "\"name\":\"Joe Tester\",\"NothingHere\":\"\",\"TrueValue\":true,\n"+
+            "\"name\":\"Joe Tester\",\"NothingHere\":\"\",TrueValue:true,\n"+
             "\"FalseValue\":false,\"NullValue\":null,\"PositiveValue\":42,\n"+
-            "\"NegativeValue\":-23,\"DoubleValue\":-23.45,\"Nan\":\"-23x.45\",\n"+
+            "\"NegativeValue\":-23,\"DoubleValue\":-23.45,\"Nan\":-23x.45,\n"+
             "\"ArrayOfNum\":\"1, 2, 3, 4.1, 5.2\"\n"+
             "},\"xsi:noNamespaceSchemaLocation\":"+
             "\"test.xsd\",\"xmlns:xsi\":\"http://www.w3.org/2001/"+
@@ -791,7 +791,7 @@ public class XMLTest {
     @Test
     public void testToJSONArray_jsonOutput() {
         final String originalXml = "<root><id>01</id><id>1</id><id>00</id><id>0</id><item id=\"01\"/><title>True</title></root>";
-        final JSONObject expectedJson = new JSONObject("{\"root\":{\"item\":{\"id\":\"01\"},\"id\":[\"01\",1,\"00\",0],\"title\":true}}");
+        final JSONObject expectedJson = new JSONObject("{\"root\":{\"item\":{\"id\":1},\"id\":[1,1,0,0],\"title\":true}}");
         final JSONObject actualJsonOutput = XML.toJSONObject(originalXml, false);
 
         Util.compareActualVsExpectedJsonObjects(actualJsonOutput,expectedJson);
@@ -1180,7 +1180,7 @@ public class XMLTest {
 
     @Test
     public void shouldCreateExplicitEndTagWithEmptyValueWhenConfigured(){
-        String jsonString = "{\"outer\":{\"innerOne\":\"\", \"innerTwo\":\"two\"}}";
+        String jsonString = "{outer:{innerOne:\"\", innerTwo:\"two\"}}";
         JSONObject jsonObject = new JSONObject(jsonString);
         String expectedXmlString = "<encloser><outer><innerOne></innerOne><innerTwo>two</innerTwo></outer></encloser>";
         String xmlForm = XML.toString(jsonObject,"encloser", new XMLParserConfiguration().withCloseEmptyTag(true));
@@ -1191,7 +1191,7 @@ public class XMLTest {
 
     @Test
     public void shouldNotCreateExplicitEndTagWithEmptyValueWhenNotConfigured(){
-        String jsonString = "{\"outer\":{\"innerOne\":\"\", \"innerTwo\":\"two\"}}";
+        String jsonString = "{outer:{innerOne:\"\", innerTwo:\"two\"}}";
         JSONObject jsonObject = new JSONObject(jsonString);
         String expectedXmlString = "<encloser><outer><innerOne/><innerTwo>two</innerTwo></outer></encloser>";
         String xmlForm = XML.toString(jsonObject,"encloser", new XMLParserConfiguration().withCloseEmptyTag(false));
@@ -1397,35 +1397,6 @@ public class XMLTest {
         Util.compareActualVsExpectedJsonObjects(actualJson,expectedJson);
     }
 
-    @Test
-    public void clarifyCurrentBehavior() {
-
-        // Behavior documented in #826
-        // After reverting the code, amount is stored as numeric, and phone is stored as string
-        String str1 =
-                "    <datatypes>\n" +
-                "        <telephone>0123456789</telephone>\n" +
-                "        <amount>0.1230</amount>\n" +
-                "        <boolean>true</boolean>\n" +
-                "    </datatypes>";
-        JSONObject jsonObject1 = XML.toJSONObject(str1,
-                new XMLParserConfiguration().withKeepStrings(false));
-        assertEquals(jsonObject1.getJSONObject("datatypes").getFloat("amount"), 0.123, .1);
-        assertEquals(jsonObject1.getJSONObject("datatypes").getString("telephone"), "0123456789");
-
-
-        // Behavior documented in #852
-        // After reverting the code, value is still stored as a number. This is due to how XML.isDecimalNotation() works
-        // and is probably a bug. JSONObject has a similar problem.
-        String str2 = "<color> <color_type>primary</color_type> <value>008E97</value> </color>";
-        JSONObject jsonObject2 = XML.toJSONObject(str2);
-        assertEquals(jsonObject2.getJSONObject("color").getLong("value"), 0e897, .1);
-
-        // Workaround for now is to use keepStrings
-        JSONObject jsonObject3 = XML.toJSONObject(str2, new XMLParserConfiguration().withKeepStrings(true));
-        assertEquals(jsonObject3.getJSONObject("color").getString("value"), "008E97");
-    }
-
 }
 
 

src/test/java/org/json/junit/XMLTokenerTest.java

@@ -1,81 +0,0 @@
-package org.json.junit;
-
-import org.json.XMLTokener;
-import org.junit.Test;
-
-import java.io.StringReader;
-
-import static org.junit.Assert.*;
-
-/**
- * Tests for JSON-Java XMLTokener.java
- */
-public class XMLTokenerTest {
-
-    /**
-     * Tests that nextCDATA() correctly extracts content from within a CDATA section.
-     */
-    @Test
-    public void testNextCDATA() {
-        String xml = "This is <![CDATA[ some <CDATA> content ]]> after";
-        XMLTokener tokener = new XMLTokener(new StringReader(xml));
-        tokener.skipPast("<![CDATA[");
-        String cdata = tokener.nextCDATA();
-        assertEquals(" some <CDATA> content ", cdata);
-    }
-
-    /**
-     * Tests that nextContent() returns plain text content before a tag.
-     */
-    @Test
-    public void testNextContentWithText() {
-        String xml = "Some content<nextTag>";
-        XMLTokener tokener = new XMLTokener(xml);
-        Object content = tokener.nextContent();
-        assertEquals("Some content", content);
-    }
-
-    /**
-     * Tests that nextContent() returns '<' character when starting with a tag.
-     */
-    @Test
-    public void testNextContentWithTag() {
-        String xml = "<tag>";
-        XMLTokener tokener = new XMLTokener(xml);
-        Object content = tokener.nextContent();
-        assertEquals('<', content);
-    }
-
-    /**
-     * Tests that nextEntity() resolves a known entity like &amp; correctly.
-     */
-    @Test
-    public void testNextEntityKnown() {
-        XMLTokener tokener = new XMLTokener("amp;");
-        Object result = tokener.nextEntity('&');
-        assertEquals("&", result);
-    }
-
-    /**
-     * Tests that nextEntity() preserves unknown entities by returning them unchanged.
-     */
-    @Test
-    public void testNextEntityUnknown() {
-        XMLTokener tokener = new XMLTokener("unknown;");
-        tokener.next(); // skip 'u'
-        Object result = tokener.nextEntity('&');
-        assertEquals("&nknown;", result);  // malformed start to simulate unknown
-    }
-
-    /**
-     * Tests skipPast() to ensure the cursor moves past the specified string.
-     */
-    @Test
-    public void testSkipPast() {
-        String xml = "Ignore this... endHere more text";
-        XMLTokener tokener = new XMLTokener(xml);
-        tokener.skipPast("endHere");
-        assertEquals(' ', tokener.next()); // should be the space after "endHere"
-    }
-
-}

src/test/resources/compliantJsonArray.json

@@ -1,317 +0,0 @@
-[
-  {
-    "_id": "6606c27d2ab4a0102d49420a",
-    "index": 0,
-    "guid": "441331fb-84d1-4873-a649-3814621a0370",
-    "isActive": true,
-    "balance": "$2,691.63",
-    "picture": "http://example.abc/32x32",
-    "age": 26,
-    "eyeColor": "blue",
-    "name": "abc",
-    "gender": "female",
-    "company": "example",
-    "email": "abc@def.com",
-    "phone": "+1 (123) 456-7890",
-    "address": "123 Main St",
-    "about": "Laborum magna tempor officia irure cillum nulla incididunt Lorem dolor veniam elit cupidatat amet. Veniam veniam exercitation nulla consectetur officia esse ex sunt nulla nisi ea cillum nisi reprehenderit. Qui aliquip reprehenderit aliqua aliquip aliquip anim sit magna nostrud dolore veniam velit elit aliquip.\r\n",
-    "registered": "2016-07-22T03:18:11 -01:00",
-    "latitude": -21.544934,
-    "longitude": 72.765495,
-    "tags": [
-      "consectetur",
-      "minim",
-      "sunt",
-      "in",
-      "ut",
-      "velit",
-      "anim"
-    ],
-    "friends": [
-      {
-        "id": 0,
-        "name": "abc def"
-      },
-      {
-        "id": 1,
-        "name": "ghi jkl"
-      },
-      {
-        "id": 2,
-        "name": "mno pqr"
-      }
-    ],
-    "greeting": "Hello, abc! You have 10 unread messages.",
-    "favoriteFruit": "banana"
-  },
-  {
-    "_id": "6606c27d0a45df5121fb765f",
-    "index": 1,
-    "guid": "fd774715-de85-44b9-b498-c214d8f68d9f",
-    "isActive": true,
-    "balance": "$2,713.96",
-    "picture": "http://placehold.it/32x32",
-    "age": 27,
-    "eyeColor": "green",
-    "name": "def",
-    "gender": "female",
-    "company": "sample",
-    "email": "def@abc.com",
-    "phone": "+1 (123) 456-78910",
-    "address": "1234 Main St",
-    "about": "Ea id cupidatat eiusmod culpa. Nulla consequat esse elit enim et pariatur eiusmod ipsum. Consequat eu non reprehenderit in.\r\n",
-    "registered": "2015-04-06T07:54:22 -01:00",
-    "latitude": 83.512347,
-    "longitude": -9.368739,
-    "tags": [
-      "excepteur",
-      "non",
-      "nostrud",
-      "laboris",
-      "laboris",
-      "qui",
-      "aute"
-    ],
-    "friends": [
-      {
-        "id": 0,
-        "name": "sample example"
-      },
-      {
-        "id": 1,
-        "name": "test name"
-      },
-      {
-        "id": 2,
-        "name": "aaa aaaa"
-      }
-    ],
-    "greeting": "Hello, test! You have 7 unread messages.",
-    "favoriteFruit": "apple"
-  },
-  {
-    "_id": "6606c27dfb3a0e4e7e7183d3",
-    "index": 2,
-    "guid": "688b0c36-98e0-4ee7-86b8-863638d79b5f",
-    "isActive": false,
-    "balance": "$3,514.35",
-    "picture": "http://placehold.it/32x32",
-    "age": 32,
-    "eyeColor": "green",
-    "name": "test",
-    "gender": "female",
-    "company": "test",
-    "email": "test@test.com",
-    "phone": "+1 (123) 456-7890",
-    "address": "123 Main St",
-    "about": "Mollit officia adipisicing ex nisi non Lorem sunt quis est. Irure exercitation duis ipsum qui ullamco eu ea commodo occaecat minim proident. Incididunt nostrud ex cupidatat eiusmod mollit anim irure culpa. Labore voluptate voluptate labore nisi sit eu. Dolor sit proident velit dolor deserunt labore sit ipsum incididunt eiusmod reprehenderit voluptate. Duis anim velit officia laboris consequat officia dolor sint dolor nisi ex.\r\n",
-    "registered": "2021-11-02T12:50:05 -00:00",
-    "latitude": -82.969939,
-    "longitude": 86.415645,
-    "tags": [
-      "aliquip",
-      "et",
-      "est",
-      "nulla",
-      "nulla",
-      "tempor",
-      "adipisicing"
-    ],
-    "friends": [
-      {
-        "id": 0,
-        "name": "test"
-      },
-      {
-        "id": 1,
-        "name": "sample"
-      },
-      {
-        "id": 2,
-        "name": "example"
-      }
-    ],
-    "greeting": "Hello, test! You have 1 unread messages.",
-    "favoriteFruit": "strawberry"
-  },
-  {
-    "_id": "6606c27d204bc2327fc9ba23",
-    "index": 3,
-    "guid": "be970cba-306e-4cbd-be08-c265a43a61fa",
-    "isActive": true,
-    "balance": "$3,691.63",
-    "picture": "http://placehold.it/32x32",
-    "age": 35,
-    "eyeColor": "brown",
-    "name": "another test",
-    "gender": "male",
-    "company": "TEST",
-    "email": "anothertest@anothertest.com",
-    "phone": "+1 (321) 987-6543",
-    "address": "123 Example Main St",
-    "about": "Do proident consectetur minim quis. In adipisicing culpa Lorem fugiat cillum exercitation velit velit. Non voluptate laboris deserunt veniam et sint consectetur irure aliqua quis eiusmod consectetur elit id. Ex sint do anim Lorem excepteur eu nulla.\r\n",
-    "registered": "2020-06-25T04:55:25 -01:00",
-    "latitude": 63.614955,
-    "longitude": -109.299405,
-    "tags": [
-      "irure",
-      "esse",
-      "non",
-      "mollit",
-      "laborum",
-      "adipisicing",
-      "ad"
-    ],
-    "friends": [
-      {
-        "id": 0,
-        "name": "test"
-      },
-      {
-        "id": 1,
-        "name": "sample"
-      },
-      {
-        "id": 2,
-        "name": "example"
-      }
-    ],
-    "greeting": "Hello, another test! You have 5 unread messages.",
-    "favoriteFruit": "apple"
-  },
-  {
-    "_id": "6606c27df63eb5f390cb9989",
-    "index": 4,
-    "guid": "2c3e5115-758d-468e-99c5-c9afa26e1f9f",
-    "isActive": true,
-    "balance": "$1,047.20",
-    "picture": "http://test.it/32x32",
-    "age": 30,
-    "eyeColor": "green",
-    "name": "Test Name",
-    "gender": "female",
-    "company": "test",
-    "email": "testname@testname.com",
-    "phone": "+1 (999) 999-9999",
-    "address": "999 Test Main St",
-    "about": "Voluptate exercitation tempor consectetur velit magna ea occaecat cupidatat consectetur anim aute. Aliquip est aute ipsum laboris non irure qui consectetur tempor quis do ea Lorem. Cupidatat exercitation ad culpa aliqua amet commodo mollit reprehenderit exercitation adipisicing amet et laborum pariatur.\r\n",
-    "registered": "2023-01-19T02:43:18 -00:00",
-    "latitude": 14.15208,
-    "longitude": 170.411535,
-    "tags": [
-      "dolor",
-      "qui",
-      "cupidatat",
-      "aliqua",
-      "laboris",
-      "reprehenderit",
-      "sint"
-    ],
-    "friends": [
-      {
-        "id": 0,
-        "name": "test"
-      },
-      {
-        "id": 1,
-        "name": "sample"
-      },
-      {
-        "id": 2,
-        "name": "example"
-      }
-    ],
-    "greeting": "Hello, test! You have 6 unread messages.",
-    "favoriteFruit": "apple"
-  },
-  {
-    "_id": "6606c27d01d19fa29853d59c",
-    "index": 5,
-    "guid": "816cda74-5d4b-498f-9724-20f340d5f5bf",
-    "isActive": false,
-    "balance": "$2,628.74",
-    "picture": "http://testing.it/32x32",
-    "age": 28,
-    "eyeColor": "green",
-    "name": "Testing",
-    "gender": "female",
-    "company": "test",
-    "email": "testing@testing.com",
-    "phone": "+1 (888) 888-8888",
-    "address": "123 Main St",
-    "about": "Cupidatat non ut nulla qui excepteur in minim non et nulla fugiat. Dolor quis laborum occaecat veniam dolor ullamco deserunt amet veniam dolor quis proident tempor laboris. In cillum duis ut quis. Aliqua cupidatat magna proident velit tempor veniam et consequat laborum ex dolore qui. Incididunt deserunt magna minim Lorem consectetur.\r\n",
-    "registered": "2017-10-14T11:14:08 -01:00",
-    "latitude": -5.345728,
-    "longitude": -9.706491,
-    "tags": [
-      "officia",
-      "velit",
-      "laboris",
-      "qui",
-      "cupidatat",
-      "cupidatat",
-      "ad"
-    ],
-    "friends": [
-      {
-        "id": 0,
-        "name": "test"
-      },
-      {
-        "id": 1,
-        "name": "sample"
-      },
-      {
-        "id": 2,
-        "name": "example"
-      }
-    ],
-    "greeting": "Hello, testing! You have 2 unread messages.",
-    "favoriteFruit": "strawberry"
-  },
-  {
-    "_id": "6606c27d803003cede1d6deb",
-    "index": 6,
-    "guid": "4ee550bc-0920-4104-b3ce-ebf9db6a803f",
-    "isActive": true,
-    "balance": "$1,709.31",
-    "picture": "http://sample.it/32x32",
-    "age": 31,
-    "eyeColor": "blue",
-    "name": "Sample Name",
-    "gender": "female",
-    "company": "Sample",
-    "email": "sample@sample.com",
-    "phone": "+1 (777) 777-7777",
-    "address": "123 Main St",
-    "about": "Lorem ex proident ipsum ullamco velit sit nisi eiusmod cillum. Id tempor irure culpa nisi sit non qui veniam non ut. Aliquip reprehenderit excepteur mollit quis excepteur ex sit. Quis do eu veniam do ullamco occaecat eu cupidatat nisi laborum tempor minim fugiat pariatur. Ex in nulla ex velit.\r\n",
-    "registered": "2019-04-08T03:54:36 -01:00",
-    "latitude": -70.660321,
-    "longitude": 71.547525,
-    "tags": [
-      "consequat",
-      "veniam",
-      "pariatur",
-      "aliqua",
-      "cillum",
-      "eu",
-      "officia"
-    ],
-    "friends": [
-      {
-        "id": 0,
-        "name": "Test"
-      },
-      {
-        "id": 1,
-        "name": "Sample"
-      },
-      {
-        "id": 2,
-        "name": "Example"
-      }
-    ],
-    "greeting": "Hello, Sample! You have 6 unread messages.",
-    "favoriteFruit": "apple"
-  }
-]