Merge pull request #1027 from Simulant87/1023-set-default-locale

Save/restore default locale in test

.github/workflows/codeql-analysis.yml

@@ -25,11 +25,11 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
+      uses: github/codeql-action/init@v3
       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@v1
+      uses: github/codeql-action/analyze@v3

.github/workflows/pipeline.yml

@@ -1,5 +1,5 @@
 # This workflow will build a Java project with Maven
-# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-maven
+# For more information see: https://docs.github.com/en/actions/learn-github-actions or https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions
 
 name: Java CI with Maven
 
@@ -12,63 +12,266 @@ on:
 jobs:
   # old-school build and jar method. No tests run or compiled.
   build-1_6: 
+    name: Java 1.6
     runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        # build for java 1.6, however don't run any tests
-        java: [ 1.6 ]
-    name: Java ${{ matrix.java }}
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v5
       - name: Setup java
         uses: actions/setup-java@v1
         with:
-          java-version: ${{ matrix.java }}
-      - name: Compile Java ${{ matrix.java }}
+          java-version: 1.6
+      - name: Compile Java 1.6
         run: |
           mkdir -p target/classes
-          javac -d target/classes/ src/main/java/org/json/*.java
-      - name: Create java ${{ matrix.java }} JAR
+          javac -version
+          javac -source 1.6 -target 1.6 -d target/classes/ src/main/java/org/json/*.java
+      - name: Create java 1.6 JAR
         run: |
           jar cvf target/org.json.jar -C target/classes .
-      - name: Upload Java ${{ matrix.java }} JAR
-        uses: actions/upload-artifact@v1
+      - name: Upload JAR 1.6
+        if: ${{ always() }}
+        uses: actions/upload-artifact@v5
         with:
-          name: Java ${{ matrix.java }} JAR
-          path: target/org.json.jar
-      
-  build:
+          name: Create java 1.6 JAR
+          path: target/*.jar
+
+  build-8:
     runs-on: ubuntu-latest
     strategy:
+      fail-fast: false
+      max-parallel: 1
       matrix:
         # build against supported Java LTS versions:
-        java: [ 8, 11 ]
+        java: [ 8 ]
     name: Java ${{ matrix.java }}
     steps:
-      - uses: actions/checkout@v2
-      - name: Setup java
-        uses: actions/setup-java@v1
+      - uses: actions/checkout@v5
+      - name: Set up JDK ${{ matrix.java }}
+        uses: actions/setup-java@v5
         with:
+          distribution: 'temurin'
           java-version: ${{ matrix.java }}
+          cache: 'maven'
       - name: Compile Java ${{ matrix.java }}
-        run: mvn clean compile -Dmaven.compiler.source=${{ matrix.java }} -Dmaven.compiler.target=${{ matrix.java }} -Dmaven.test.skip=true -Dmaven.site.skip=true -Dmaven.javadoc.skip=true
+        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 -Dmaven.compiler.source=${{ matrix.java }} -Dmaven.compiler.target=${{ matrix.java }}
+          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 -Dmaven.compiler.source=${{ matrix.java }} -Dmaven.compiler.target=${{ matrix.java }}
-          mvn site -DgenerateReports=false -Dmaven.compiler.source=${{ matrix.java }} -Dmaven.compiler.target=${{ matrix.java }}
+          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@v1
+        uses: actions/upload-artifact@v5
         with:
           name: Test Results ${{ matrix.java }}
           path: target/surefire-reports/
       - name: Upload Test Report ${{ matrix.java }}
         if: ${{ always() }}
-        uses: actions/upload-artifact@v1
+        uses: actions/upload-artifact@v5
         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@v5
+        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@v5
+      - name: Set up JDK ${{ matrix.java }}
+        uses: actions/setup-java@v5
+        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@v5
+        with:
+          name: Test Results ${{ matrix.java }}
+          path: target/surefire-reports/
+      - name: Upload Test Report ${{ matrix.java }}
+        if: ${{ always() }}
+        uses: actions/upload-artifact@v5
+        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@v5
+        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@v5
+      - name: Set up JDK ${{ matrix.java }}
+        uses: actions/setup-java@v5
+        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@v5
+        with:
+          name: Test Results ${{ matrix.java }}
+          path: target/surefire-reports/
+      - name: Upload Test Report ${{ matrix.java }}
+        if: ${{ always() }}
+        uses: actions/upload-artifact@v5
+        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@v5
+        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@v5
+      - name: Set up JDK ${{ matrix.java }}
+        uses: actions/setup-java@v5
+        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@v5
+        with:
+          name: Test Results ${{ matrix.java }}
+          path: target/surefire-reports/
+      - name: Upload Test Report ${{ matrix.java }}
+        if: ${{ always() }}
+        uses: actions/upload-artifact@v5
+        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@v5
+        with:
+          name: Package Jar ${{ matrix.java }}
+          path: target/*.jar
+
+  build-25:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      max-parallel: 1
+      matrix:
+        # build against supported Java LTS versions:
+        java: [ 25 ]
+    name: Java ${{ matrix.java }}
+    steps:
+      - uses: actions/checkout@v5
+      - name: Set up JDK ${{ matrix.java }}
+        uses: actions/setup-java@v5
+        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@v5
+        with:
+          name: Test Results ${{ matrix.java }}
+          path: target/surefire-reports/
+      - name: Upload Test Report ${{ matrix.java }}
+        if: ${{ always() }}
+        uses: actions/upload-artifact@v5
+        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@v5
+        with:
+          name: Package Jar ${{ matrix.java }}
+          path: target/*.jar
+

.gitignore

@@ -1,6 +1,8 @@
 # ignore eclipse project files
 .project
 .classpath
+# ignore vscode files
+.vscode
 # ignore Intellij Idea project files
 .idea
 *.iml

CONTRIBUTING.md

@@ -1,8 +1,8 @@
 # Contribution Guidelines
 
-Feel free to work on any issue with a #hacktoberfest label.
+Feel free to work on any open issue, you don't need to ask permission first. This year, the hacktoberfest label will be added to any PR and associated issue during the month of October.
 
-If you discover an issue you would like to work on, you can add a new issue to the list. If it meets our criteria, a hacktoberfest label will be added.
+If you discover an issue you would like to work on, you can add a new issue to the list. If it meets our criteria, it will be available to work on (if not, it will be closed after review).
 
 # Who is allowed to submit pull requests for this project?
 

Examples.md

@@ -1,7 +1,7 @@
 <h1>Examples</h1>
 <p>Imports used in the examples: </p>
 
-```
+```java
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Properties;
@@ -14,208 +14,208 @@ import java.util.Properties;
 
 <h3>Using JSONArray</h3>
 
-```
-	private static void JSONExampleArray1() {
-		//We create a JSONObject from a String containing an array using JSONArray
-		//Firstly, we declare an Array in a String
+```java
+private static void JSONExampleArray1() {
+	//We create a JSONObject from a String containing an array using JSONArray
+	//Firstly, we declare an Array in a String
 
-		 String arrayStr = 
-		            "["+"true,"+"false,"+ "\"true\","+ "\"false\","+"\"hello\","+"23.45e-4,"+
-		                "\"23.45\","+"42,"+"\"43\","+"["+"\"world\""+"],"+
-		            		"{"+
-		                    "\"key1\":\"value1\","+
-		                    "\"key2\":\"value2\","+
-		                    "\"key3\":\"value3\","+
-		                    "\"key4\":\"value4\""+
-		                "},"+
-		                "0,"+"\"-1\""+
-		            "]";
+	String arrayStr = 
+		    "["+"true,"+"false,"+ "\"true\","+ "\"false\","+"\"hello\","+"23.45e-4,"+
+			"\"23.45\","+"42,"+"\"43\","+"["+"\"world\""+"],"+
+				"{"+
+			    "\"key1\":\"value1\","+
+			    "\"key2\":\"value2\","+
+			    "\"key3\":\"value3\","+
+			    "\"key4\":\"value4\""+
+			"},"+
+			"0,"+"\"-1\""+
+		    "]";
 
-		 //Then, we initializate the JSONArray thanks to its constructor
+	//Then, we initializate the JSONArray thanks to its constructor
 
-		  JSONArray array = new JSONArray(arrayStr);
-		  System.out.println("Values array: "+ array);
+	JSONArray array = new JSONArray(arrayStr);
+	System.out.println("Values array: "+ array);
 
-		  //We convert that array into a JSONObject, but first, we need the labels, so we need another JSONArray with the labels.
-		  //Here we will use an auxiliary function to get one for the example.
+	//We convert that array into a JSONObject, but first, we need the labels, so we need another JSONArray with the labels.
+	//Here we will use an auxiliary function to get one for the example.
 
-		  JSONArray list = listNumberArray(array.length());
-		  System.out.println("Label Array: "+ list.toString());
-		  //Now, we construct the JSONObject using both the  value array and the label array.
-		  JSONObject object = array.toJSONObject(list);
-		  System.out.println("Final JSONOBject: " + object);
-	}
-
-	//This method creates an JSONArray of labels in which those are generated by their positions
-
-	private static JSONArray listNumberArray(int max){
-		 JSONArray res = new JSONArray();
-		for (int i=0; i<max;i++) {
-			//The value of the labels must be an String in order to make it work
-			res.put(String.valueOf(i));
-		}
-		return res;
+	JSONArray list = listNumberArray(array.length());
+	System.out.println("Label Array: "+ list.toString());
+	//Now, we construct the JSONObject using both the  value array and the label array.
+	JSONObject object = array.toJSONObject(list);
+	System.out.println("Final JSONOBject: " + object);
+}
+
+//This method creates an JSONArray of labels in which those are generated by their positions
+
+private static JSONArray listNumberArray(int max){
+	JSONArray res = new JSONArray();
+	for (int i=0; i<max;i++) {
+		//The value of the labels must be an String in order to make it work
+		res.put(String.valueOf(i));
 	}
+	return res;
+}
 ```
-```
-	private static void JSONExampleArray2() {
+```java
+private static void JSONExampleArray2() {
 
-		//We can also create an Array without a String by creating an empty array and adding elements to it
+	//We can also create an Array without a String by creating an empty array and adding elements to it
 
-		  JSONArray array = new JSONArray();
+	JSONArray array = new JSONArray();
 
-		//Adding elements with .put()
+	//Adding elements with .put()
 
-		array.put("value");
-		array.put(5);
-		array.put(-23.45e67);
-		array.put(true);
-		
-		//We convert it to JSONObject providing a label arrray like last time
+	array.put("value");
+	array.put(5);
+	array.put(-23.45e67);
+	array.put(true);
 
-		 JSONArray list = listNumberArray(array.length());
-		 JSONObject object = array.toJSONObject(list);
-		 System.out.println("Final JSONOBject: " + object);
-	}
+	//We convert it to JSONObject providing a label arrray like last time
+
+	JSONArray list = listNumberArray(array.length());
+	JSONObject object = array.toJSONObject(list);
+	System.out.println("Final JSONOBject: " + object);
+}
 ```
 
 <h3>Using JSONStringer</h3>
 
-```
-	private static void JSONExampleStringer() {
+```java
+private static void JSONExampleStringer() {
 
-		//We initializate the JSONStringer
+	//We initializate the JSONStringer
 
-		JSONStringer jsonStringer = new JSONStringer();
+	JSONStringer jsonStringer = new JSONStringer();
 
-		//Now we start the process of adding elements with .object()
+	//Now we start the process of adding elements with .object()
 
-        jsonStringer.object();
+	jsonStringer.object();
 
-        //We can now add elements as keys and values with .values () and .key()
+	//We can now add elements as keys and values with .values () and .key()
 
-        jsonStringer.key("trueValue").value(true);
-        jsonStringer.key("falseValue").value(false);
-        jsonStringer.key("nullValue").value(null);
-        jsonStringer.key("stringValue").value("hello world!");
-        jsonStringer.key("complexStringValue").value("h\be\tllo w\u1234orld!");
-        jsonStringer.key("intValue").value(42);
-        jsonStringer.key("doubleValue").value(-23.45e67);
+	jsonStringer.key("trueValue").value(true);
+	jsonStringer.key("falseValue").value(false);
+	jsonStringer.key("nullValue").value(null);
+	jsonStringer.key("stringValue").value("hello world!");
+	jsonStringer.key("complexStringValue").value("h\be\tllo w\u1234orld!");
+	jsonStringer.key("intValue").value(42);
+	jsonStringer.key("doubleValue").value(-23.45e67);
 
-        //We end this prcedure with .ednObject
+	//We end this prcedure with .ednObject
 
-        jsonStringer.endObject();
+	jsonStringer.endObject();
 
-       //Once we have a JSONStringer, we convert it to JSONObject generating a String and using JSONObject's contructor.
+	//Once we have a JSONStringer, we convert it to JSONObject generating a String and using JSONObject's contructor.
 
-        String str = jsonStringer.toString();
-        JSONObject jsonObject = new JSONObject(str);
-        
-       System.out.println("Final JSONOBject: " + jsonObject);
-	}
+	String str = jsonStringer.toString();
+	JSONObject jsonObject = new JSONObject(str);
+
+	System.out.println("Final JSONOBject: " + jsonObject);
+}
 ```
 <h3>Using JSONObject</h3>
 
+```java
+private static void JSONExampleObject1() {
+
+	//We can create a JSONObject from a String with the class builder
+
+	String string = "{\"0\":\"value\",\"1\":5,\"2\":-2.345E68,\"3\":true}";
+	JSONObject example = new JSONObject(string);
+	System.out.println("Final JSONObject: " + example);
+
+}
 ```
-	private static void JSONExampleObject1() {
+```java
+private static void JSONExampleObject2() {
 
-		//We can create a JSONObject from a String with the class builder
+	//We can also create a JSONObject directly without messing around with any of the other functions.
 
-		String string = "{\"0\":\"value\",\"1\":5,\"2\":-2.345E68,\"3\":true}";
-		JSONObject example = new JSONObject(string);
-		System.out.println("Final JSONObject: " + example);
-		
-	}
+	JSONObject example = new JSONObject();
+
+
+	//Now we add the keys and values in a similar way as the Stringer method
+	example.put("key", "value");
+
+	//As you can see, the first entry is the key and the second would be its associeted value.
+
+	example.put("key2", 5);
+	example.put("key3", -23.45e67);
+	example.put("trueValue", true);
+
+	//We can't add null values thougth
+
+	//example.put("nullValue", null); //This is not possible
+
+	 System.out.println("Final JSONOBject: " + example);
+}
 ```
-```
-	private static void JSONExampleObject2() {
+```java
+private static void JSONExampleObject3() {
 
-		//We can also create a JSONObject directly without messing around with any of the other functions.
+	//We can also create a JSONObject with a Java Map
+	//YoU will need a Map whose keys are Strings. The values can be whatever you want
 
-		JSONObject example = new JSONObject();
+	Map<String,Double> map = new HashMap<String, Double>();
 
+	map.put("key1", 1.0);
+	map.put("key2", -23.45e67);
 
-		//Now we add the keys and values in a similar way as the Stringer method
-		example.put("key", "value");
+	//We create the JSONObject with the map with its class builder
 
-		//As you can see, the first entry is the key and the second would be its associeted value.
-
-		example.put("key2", 5);
-		example.put("key3", -23.45e67);
-		example.put("trueValue", true);
-
-		//We can't add null values thougth
-
-		//example.put("nullValue", null); //This is not possible
-		
-		 System.out.println("Final JSONOBject: " + example);
-	}
-```
-```
-	private static void JSONExampleObject3() {
-
-		//We can also create a JSONObject with a Java Map
-		//YoU will need a Map whose keys are Strings. The values can be whatever you want
-
-		Map<String,Double> map = new HashMap<String, Double>();
-		
-		map.put("key1", 1.0);
-		map.put("key2", -23.45e67);
-		
-		//We create the JSONObject with the map with its class builder
-
-		JSONObject example = new JSONObject(map);
-		 System.out.println("Final JSONOBject: " + example);
-	}
+	JSONObject example = new JSONObject(map);
+	 System.out.println("Final JSONOBject: " + example);
+}
 ```
 <h3>Using JSONWriter</h3>
 
-```	
-	private static void JSONExamplWriter() {
+```java
+private static void JSONExamplWriter() {
 
-		//This method works in a very similar way to Object  and Stringer in the construction of the JSON.
-		//The difference is that it needs a Java object called "Appendable" like StringBuilder
+	//This method works in a very similar way to Object  and Stringer in the construction of the JSON.
+	//The difference is that it needs a Java object called "Appendable" like StringBuilder
 
-		StringBuilder write = new StringBuilder();
-		JSONWriter jsonWriter = new JSONWriter(write);
+	StringBuilder write = new StringBuilder();
+	JSONWriter jsonWriter = new JSONWriter(write);
 
-		//We behave now the same way as Stringer
+	//We behave now the same way as Stringer
 
-		jsonWriter.object();
-		
-		jsonWriter.key("trueValue").value(true);
-		jsonWriter.key("falseValue").value(false);
-		jsonWriter.key("nullValue").value(null);
-		jsonWriter.key("stringValue").value("hello world!");
-		jsonWriter.key("complexStringValue").value("h\be\tllo w\u1234orld!");
-		jsonWriter.key("intValue").value(42);
-		jsonWriter.key("doubleValue").value(-23.45e67);
-		
-		jsonWriter.endObject();
-		
-		//The resoult should be in the "write" object
-		
-		System.out.println("JSON: " + write.toString());
-		
-		//The difference is that we don't get a JSONObject in this one.
-		
-		
-	}
+	jsonWriter.object();
+
+	jsonWriter.key("trueValue").value(true);
+	jsonWriter.key("falseValue").value(false);
+	jsonWriter.key("nullValue").value(null);
+	jsonWriter.key("stringValue").value("hello world!");
+	jsonWriter.key("complexStringValue").value("h\be\tllo w\u1234orld!");
+	jsonWriter.key("intValue").value(42);
+	jsonWriter.key("doubleValue").value(-23.45e67);
+
+	jsonWriter.endObject();
+
+	//The resoult should be in the "write" object
+
+	System.out.println("JSON: " + write.toString());
+
+	//The difference is that we don't get a JSONObject in this one.
+
+
+}
 ```
-```	
-	private static void JSONExampleTokener() {
+```java
+private static void JSONExampleTokener() {
 
-		//A partir de una String podemos crear un JSONTokener, que lo podemos usar alternativamente para JSONArray,JSONObject
+	//A partir de una String podemos crear un JSONTokener, que lo podemos usar alternativamente para JSONArray,JSONObject
 
-		String string = "this is not a valid JSON string";
-		JSONTokener token = new JSONTokener(string);
-		
-		//Now you can use the token in JSONObject and Array the same way as a String
+	String string = "this is not a valid JSON string";
+	JSONTokener token = new JSONTokener(string);
 
-		JSONObject object = new JSONObject(token);
-		JSONArray array = new JSONArray(token);
-		
-	}
+	//Now you can use the token in JSONObject and Array the same way as a String
+
+	JSONObject object = new JSONObject(token);
+	JSONArray array = new JSONArray(token);
+
+}
 ```	
 <h2>Part 2: Conversion methods</h2>
 <p>We don't need to have a JSON document to work. This project also admits conversions from other type of files.</p>
@@ -223,144 +223,144 @@ import java.util.Properties;
 	
 <h3>Extra: Conversion to JSONArray</h3>
 
-```
-	private static void JSONObjectToArray() {
-		//We start with a JSONObject
+```java
+private static void JSONObjectToArray() {
+	//We start with a JSONObject
 
-		String string = "{\"0\":\"value\",\"1\":5,\"2\":-2.345E68,\"3\":true}";
+	String string = "{\"0\":\"value\",\"1\":5,\"2\":-2.345E68,\"3\":true}";
 
-		JSONObject example = new JSONObject(string);
-		
-		//We need a list of key strings like the reverse operation
-		
-		JSONArray keyStrings = listNumberArray(example.length());
-		
-		//Then we convert to the Array using both elelements
-		
-		JSONArray array = example.toJSONArray(keyStrings);
-		
-		System.out.println("Final JSONArray: " + array);
-	}
+	JSONObject example = new JSONObject(string);
+
+	//We need a list of key strings like the reverse operation
+
+	JSONArray keyStrings = listNumberArray(example.length());
+
+	//Then we convert to the Array using both elelements
+
+	JSONArray array = example.toJSONArray(keyStrings);
+
+	System.out.println("Final JSONArray: " + array);
+}
 ```
 <h3>XML Conversions</h3>
 
-```		
-	private static void XMLToExampleConversion() {
+```java
+private static void XMLToExampleConversion() {
 
-		//We start with a JSONObject
-		
-		String string = "{\"0\":\"value\",\"1\":5,\"2\":-2.345E68,\"3\":true}";
-		JSONObject example = new JSONObject(string);
+	//We start with a JSONObject
 
-		//We obtain a String with XML format with toString()
+	String string = "{\"0\":\"value\",\"1\":5,\"2\":-2.345E68,\"3\":true}";
+	JSONObject example = new JSONObject(string);
 
-		String output = XML.toString(example);
-		System.out.println("Final XML: " + output);
-	}
+	//We obtain a String with XML format with toString()
+
+	String output = XML.toString(example);
+	System.out.println("Final XML: " + output);
+}
 ```
-```	
-	private static void XMLFromExampleConversion() {
+```java
+private static void XMLFromExampleConversion() {
 
-		//We start with a string with  the XML format
+	//We start with a string with  the XML format
 
-		String string = "<0>value</0><1>5</1><2>-2.345E+68</2><3>true</3>";
+	String string = "<0>value</0><1>5</1><2>-2.345E+68</2><3>true</3>";
 
-		//We obtain a JSONObject with toJSONOBject()
+	//We obtain a JSONObject with toJSONOBject()
 
-		JSONObject output = XML.toJSONObject(string);
-		
-		System.out.println("Final JSONObject: " + output);
-	}
+	JSONObject output = XML.toJSONObject(string);
+
+	System.out.println("Final JSONObject: " + output);
+}
 ```
 <h3>Cookie Conversions</h3>
 
+```java
+private static void CookieToExampleConversion() {
+
+	//We start with a JSONObject
+	//The JSONOBject needs to entries that gives the cookie a name and gives the field "name" a name too.
+	//The Cokkie format doesn't support booleans
+
+	String string = "{\"name\":\"Cookie-Name\",\"value\":\"name\",\"1\":5,\"2\":-2.345E68,\"3\":'true'}";
+	JSONObject example = new JSONObject(string);
+
+	//We obtain a String with Cookie format with toString()
+
+	String output = Cookie.toString(example);
+	System.out.println("Final Cookie: " + output);
+}
 ```
-	private static void CookieToExampleConversion() {
+```java
+private static void CookieFromExampleConversion() {
 
-		//We start with a JSONObject
-		//The JSONOBject needs to entries that gives the cookie a name and gives the field "name" a name too.
-		//The Cokkie format doesn't support booleans
+	//We start with a string with  the Cookie format
 
-		String string = "{\"name\":\"Cookie-Name\",\"value\":\"name\",\"1\":5,\"2\":-2.345E68,\"3\":'true'}";
-		JSONObject example = new JSONObject(string);
-		
-		//We obtain a String with Cookie format with toString()
+	String string = "Cookie-Name=name;1=5;2=-2.345E%2b68;3=true";
 
-		String output = Cookie.toString(example);
-		System.out.println("Final Cookie: " + output);
-	}
-```
-```
-	private static void CookieFromExampleConversion() {
+	//We obtain a JSONObject with toJSONOBject()
 
-		//We start with a string with  the Cookie format
-
-		String string = "Cookie-Name=name;1=5;2=-2.345E%2b68;3=true";
-
-		//We obtain a JSONObject with toJSONOBject()
-
-		JSONObject output = Cookie.toJSONObject(string);
-		System.out.println("Final JSONObject: " + output);
-	}
+	JSONObject output = Cookie.toJSONObject(string);
+	System.out.println("Final JSONObject: " + output);
+}
 ```
 
 <h3>HTTP Conversions</h3>
 
+```java
+private static void HTTPToExampleConversion() {
+
+	//We start with a JSONObject
+	//The JSONObject must have the minimun header for a HTTP request or header
+
+	String string = "{\"Method\":\"POST\",\"Request-URI\":'/',\"HTTP-Version\":'HTTP/1.1',\"Value1\":true,\"Value2\":2,\"Value3\":-2.345E68}";
+
+	JSONObject example = new JSONObject(string);
+
+	//We obtain a String with HTTP format with toString()
+
+	String output = HTTP.toString(example);
+	System.out.println("Final HTTP: " + output);
+}
 ```
-	private static void HTTPToExampleConversion() {
+```java
+private static void HTTPFromExampleConversion() {
 
-		//We start with a JSONObject
-		//The JSONObject must have the minimun header for a HTTP request or header
+	//We start with a string with  the HTTP format
 
-		String string = "{\"Method\":\"POST\",\"Request-URI\":'/',\"HTTP-Version\":'HTTP/1.1',\"Value1\":true,\"Value2\":2,\"Value3\":-2.345E68}";
+	String string = "Final HTTP: POST '/' HTTP/1.1 Value3: -2.345E+68 Value1: true Value2: 2";
 
-		JSONObject example = new JSONObject(string);
+	//We obtain a JSONObject with toJSONOBject()
 
-		//We obtain a String with HTTP format with toString()
-
-		String output = HTTP.toString(example);
-		System.out.println("Final HTTP: " + output);
-	}
-```
-```	
-	private static void HTTPFromExampleConversion() {
-
-		//We start with a string with  the HTTP format
-
-		String string = "Final HTTP: POST '/' HTTP/1.1 Value3: -2.345E+68 Value1: true Value2: 2";
-
-		//We obtain a JSONObject with toJSONOBject()
-
-		JSONObject output = HTTP.toJSONObject(string);
-		System.out.println("Final JSONObject: " + output);
-	}
+	JSONObject output = HTTP.toJSONObject(string);
+	System.out.println("Final JSONObject: " + output);
+}
 ```
 <h3>CDL Conversions</h3>
 
-```	
+```java
 private static void CDLToExampleConversion() {
 
-		//We start with some JSONObjects with the same values in the keys but different values in the "values"
+	//We start with some JSONObjects with the same values in the keys but different values in the "values"
 
-		String string = "{\"0\":\"value\",\"1\":5,\"2\":-2.345E68,\"3\":true}";
-		JSONObject example = new JSONObject(string);
-		
-		String string2 = "{\"0\":\"value2\",\"1\":6,\"2\":-8.345E68,\"3\":false}";
-		JSONObject example2 = new JSONObject(string2);
-		
-		//We need now a JSONArray with those JSONObjects
+	String string = "{\"0\":\"value\",\"1\":5,\"2\":-2.345E68,\"3\":true}";
+	JSONObject example = new JSONObject(string);
 
-		JSONArray array = new JSONArray();
-		array.put(example);
-		array.put(example2);
+	String string2 = "{\"0\":\"value2\",\"1\":6,\"2\":-8.345E68,\"3\":false}";
+	JSONObject example2 = new JSONObject(string2);
 
-		//We obtain a String with XML format with toString()
+	//We need now a JSONArray with those JSONObjects
 
-		String output = CDL.toString(array);
-		System.out.println("Final CDL: \r\n" + output);
-	}
-```	
+	JSONArray array = new JSONArray();
+	array.put(example);
+	array.put(example2);
+
+	//We obtain a String with XML format with toString()
+
+	String output = CDL.toString(array);
+	System.out.println("Final CDL: \r\n" + output);
+}
 ```	
+```java
 private static void CDLFromExampleConversion() {
 
 	//We start wtih a String with the CDL format
@@ -368,7 +368,7 @@ private static void CDLFromExampleConversion() {
 	String string = "0,1,2,3\n"
 			+ "value,5,-2.345E+68,true\n"
 			+ "value2,6,-8.345E+68,false";
-	
+
 	//We obtain a JSONArray with toJSONOBject()
 
 	JSONArray output = CDL.toJSONArray(string);
@@ -377,8 +377,8 @@ private static void CDLFromExampleConversion() {
 ```
 <h3>Properties Conversions</h3>
 
-```
-	private static Properties PropertyToExampleConversion() {
+```java
+private static Properties PropertyToExampleConversion() {
 
 	//We start with a JSONObject
 
@@ -391,43 +391,43 @@ private static void CDLFromExampleConversion() {
 	System.out.println("Final Properties: " + output);
 
 	return output;
-	}
+}
 ```
-```	
-	private static void PropertyFromExampleConversion() {
+```java
+private static void PropertyFromExampleConversion() {
 
-		//We start with a Properties object
+	//We start with a Properties object
 
-		Properties input = PropertyToExampleConversion();
+	Properties input = PropertyToExampleConversion();
 
-		//We obtain a JSONObject with toJSONOBject()
+	//We obtain a JSONObject with toJSONOBject()
 
-		JSONObject output = Property.toJSONObject(input);
-		System.out.println("Final JSONObject: " + output);
-	}
+	JSONObject output = Property.toJSONObject(input);
+	System.out.println("Final JSONObject: " + output);
+}
 ```
-<h2>List of all examples methods</h2>
+ <h2>List of all examples methods</h2>
 
-```
-	public static void main(String[] args) {
-		//JSONObjectToArray();
-		//JSONExampleArray1();
-		//JSONExampleArray2();
-		//JSONExampleStringer();
-		//JSONExampleObject1();
-		//JSONExampleObject2();
-		//JSONExampleObject3();
-		//JSONExamplWriter();
-		//XMLToExampleConversion();
-		//XMLFromExampleConversion();
-		//CookieToExampleConversion();
-		//CookieFromExampleConversion(); 
-		//HTTPToExampleConversion();
-		//HTTPFromExampleConversion();
-		//CDLToExampleConversion();
-		//CDLFromExampleConversion();
-		//PropertyToExampleConversion();
-		//PropertyFromExampleConversion();
-	}
+```java
+public static void main(String[] args) {
+	//JSONObjectToArray();
+	//JSONExampleArray1();
+	//JSONExampleArray2();
+	//JSONExampleStringer();
+	//JSONExampleObject1();
+	//JSONExampleObject2();
+	//JSONExampleObject3();
+	//JSONExamplWriter();
+	//XMLToExampleConversion();
+	//XMLFromExampleConversion();
+	//CookieToExampleConversion();
+	//CookieFromExampleConversion(); 
+	//HTTPToExampleConversion();
+	//HTTPFromExampleConversion();
+	//CDLToExampleConversion();
+	//CDLFromExampleConversion();
+	//PropertyToExampleConversion();
+	//PropertyFromExampleConversion();
+}
 ```
 

README.md

@@ -7,8 +7,11 @@ JSON in Java [package org.json]
 ===============================
 
 [![Maven Central](https://img.shields.io/maven-central/v/org.json/json.svg)](https://mvnrepository.com/artifact/org.json/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)
+[![javadoc](https://javadoc.io/badge2/org.json/json/javadoc.svg)](https://javadoc.io/doc/org.json/json)
 
-**[Click here if you just want the latest release jar file.](https://search.maven.org/remotecontent?filepath=org/json/json/20220924/json-20220924.jar)**
+**[Click here if you just want the latest release jar file.](https://search.maven.org/remotecontent?filepath=org/json/json/20251224/json-20251224.jar)**
 
 
 # Overview
@@ -24,7 +27,8 @@ Project goals include:
 * No external dependencies
 * Fast execution and low memory footprint
 * Maintain backward compatibility
-* Designed and tested to use on Java versions 1.6 - 1.11
+* Designed and tested to use on Java versions 1.6 - 25
+
 
 The files in this package implement JSON encoders and decoders. The package can also convert between JSON and XML, HTTP headers, Cookies, and CDL.
 
@@ -41,59 +45,71 @@ The org.json package can be built from the command line, Maven, and Gradle. The
 **Building from the command line**
 
 *Build the class files from the package root directory src/main/java*
-````
+```shell
 javac org/json/*.java
-````
+```
 
 *Create the jar file in the current directory*
-````
+```shell
 jar cf json-java.jar org/json/*.class
-````
+```
 
 *Compile a program that uses the jar (see example code below)*
-````
+```shell
 javac -cp .;json-java.jar Test.java (Windows)
 javac -cp .:json-java.jar Test.java (Unix Systems)
-````
+```
 
 *Test file contents*
 
-````
+```java
 import org.json.JSONObject;
 public class Test {
     public static void main(String args[]){
        JSONObject jo = new JSONObject("{ \"abc\" : \"def\" }");
-       System.out.println(jo.toString());
+       System.out.println(jo);
     }
 }
-````
+```
 
 *Execute the Test file*
-```` 
+```shell 
 java -cp .;json-java.jar Test (Windows)
 java -cp .:json-java.jar Test (Unix Systems)
-````
+```
 
 *Expected output*
 
-````
+```json
 {"abc":"def"}
-````
+```
 
  
 **Tools to build the package and execute the unit tests**
 
 Execute the test suite with Maven:
-```
+```shell
 mvn clean test
 ```
 
 Execute the test suite with Gradlew:
 
-```
+```shell
 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,9 +3,10 @@
  */
 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'
@@ -19,10 +20,21 @@ 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.1'
-    testImplementation 'com.jayway.jsonpath:json-path:2.1.0'
-    testImplementation 'org.mockito:mockito-core:1.9.5'
+    testImplementation 'junit:junit:4.13.2'
+    testImplementation 'com.jayway.jsonpath:json-path:2.9.0'
+    testImplementation 'org.mockito:mockito-core:4.2.0'
 }
 
 subprojects {
@@ -30,9 +42,9 @@ subprojects {
 }
 
 group = 'org.json'
-version = 'v20211205-SNAPSHOT'
+version = 'v20251224-SNAPSHOT'
 description = 'JSON in Java'
-sourceCompatibility = '1.7'
+sourceCompatibility = '1.8'
 
 configurations.all {
 }
@@ -53,3 +65,75 @@ 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,6 +5,25 @@ 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)
 
 ~~~
+20251224    Records, fromJson(), and recent commits
+
+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.
+
+20230618    Final release with Java 1.6 compatibility. Future releases will require Java 1.8 or greater.
+
+20230227    Fix for CVE-2022-45688 and recent commits
+
 20220924    New License - public domain, and some minor updates
 
 20220320    Wrap StackOverflow with JSONException
@@ -20,6 +39,7 @@ and artifactId "json". For example:
 20190722    Recent commits
 
 20180813    POM change to include Automatic-Module-Name (#431)
+            JSONObject(Map) now throws an exception if any of a map keys are null (#405)
 
 20180130    Recent commits
 

pom.xml

@@ -3,7 +3,7 @@
 
     <groupId>org.json</groupId>
     <artifactId>json</artifactId>
-    <version>20220924</version>
+    <version>20251224</version>
     <packaging>bundle</packaging>
 
     <name>JSON in Java</name>
@@ -15,18 +15,12 @@
         It also includes the capability to convert between JSON and XML, HTTP
         headers, Cookies, and CDL.
 
-        This is a reference implementation. There is a large number of JSON packages
+        This is a reference implementation. There are a large number of JSON packages
         in Java. Perhaps someday the Java community will standardize on one. Until
         then, choose carefully.
     </description>
     <url>https://github.com/douglascrockford/JSON-java</url>
 
-    <parent>
-        <groupId>org.sonatype.oss</groupId>
-        <artifactId>oss-parent</artifactId>
-        <version>9</version>
-    </parent>
-
     <scm>
         <url>https://github.com/douglascrockford/JSON-java.git</url>
         <connection>scm:git:git://github.com/douglascrockford/JSON-java.git</connection>
@@ -53,23 +47,36 @@
     </properties>
 
 
+    <distributionManagement>
+        <repository>
+            <id>ossrh</id>
+            <name>Central Repository OSSRH</name>
+            <url>https://oss.sonatype.org/service/local/staging/deploy/maven2/</url>
+        </repository>
+        <snapshotRepository>
+            <id>ossrh</id>
+            <url>https://oss.sonatype.org/content/repositories/snapshots</url>
+        </snapshotRepository>
+    </distributionManagement>
+
+
     <dependencies>
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
-            <version>4.13.1</version>
+            <version>4.13.2</version>
             <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>com.jayway.jsonpath</groupId>
             <artifactId>json-path</artifactId>
-            <version>2.1.0</version>
+            <version>2.9.0</version>
             <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>org.mockito</groupId>
             <artifactId>mockito-core</artifactId>
-            <version>1.9.5</version>
+            <version>4.2.0</version>
             <scope>test</scope>
         </dependency>
     </dependencies>
@@ -79,7 +86,7 @@
             <plugin>
                 <groupId>org.apache.felix</groupId>
                 <artifactId>maven-bundle-plugin</artifactId>
-                <version>3.0.1</version>
+                <version>5.1.9</version>
                 <extensions>true</extensions>
                 <configuration>
                     <instructions>
@@ -93,16 +100,19 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
-                <version>2.3.2</version>
+                <version>3.11.0</version>
                 <configuration>
-                    <source>1.6</source>
-                    <target>1.6</target>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                    <compilerArgs>
+                        <arg>-Xlint:unchecked</arg>
+                    </compilerArgs>
                 </configuration>
             </plugin>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-source-plugin</artifactId>
-                <version>2.1.2</version>
+                <version>3.3.0</version>
                 <executions>
                     <execution>
                         <id>attach-sources</id>
@@ -115,7 +125,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-javadoc-plugin</artifactId>
-                <version>2.7</version>
+                <version>3.5.0</version>
                 <executions>
                     <execution>
                         <id>attach-javadocs</id>
@@ -131,7 +141,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-gpg-plugin</artifactId>
-                <version>1.5</version>
+                <version>1.6</version>
                 <executions>
                     <execution>
                         <id>sign-artifacts</id>
@@ -139,6 +149,12 @@
                         <goals>
                             <goal>sign</goal>
                         </goals>
+                        <configuration>
+                            <gpgArguments>
+                                <arg>--pinentry-mode</arg>
+                                <arg>loopback</arg>
+                            </gpgArguments>
+                        </configuration>
                     </execution>
                 </executions>
             </plugin>
@@ -153,18 +169,86 @@
                     <autoReleaseAfterClose>false</autoReleaseAfterClose>
                 </configuration>
             </plugin>
+            <plugin>
+                <groupId>org.moditect</groupId>
+                <artifactId>moditect-maven-plugin</artifactId>
+                <version>1.0.0.Final</version>
+                <executions>
+                    <execution>
+                        <id>add-module-infos</id>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>add-module-info</goal>
+                        </goals>
+                        <configuration>
+                            <jvmVersion>9</jvmVersion>
+                            <module>
+                                <moduleInfoSource>
+                                    module org.json {
+                                        exports org.json;
+                                    }
+                                </moduleInfoSource>
+                            </module>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-jar-plugin</artifactId>
-                <version>3.2.0</version>
-                <configuration>
-                    <archive>
-                        <manifestEntries>
-                            <Automatic-Module-Name>org.json</Automatic-Module-Name>
-                        </manifestEntries>
-                    </archive>
-                </configuration>
+                <version>3.3.0</version>
             </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 delimited text into a
- * JSONArray, and to convert a JSONArray into comma delimited text. Comma
+ * This provides static methods to convert comma (or otherwise) delimited text into a
+ * JSONArray, and to convert a JSONArray into comma (or otherwise) 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 is is wrapped in single quotes or double quotes.
+ * for comma, unless it is wrapped in single quotes or double quotes.
  * <p>
  * The first row usually contains the names of the columns.
  * <p>
@@ -25,25 +25,32 @@ Public Domain.
  */
 public class CDL {
 
+    /**
+     * Constructs a new CDL object.
+     * @deprecated (Utility class cannot be instantiated)
+     */
+    @Deprecated
+    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) throws JSONException {
+    private static String getValue(JSONTokener x, char delimiter) throws JSONException {
         char c;
         char q;
         StringBuilder sb;
         do {
             c = x.next();
         } while (c == ' ' || c == '\t');
-        switch (c) {
-        case 0:
+        if (c == 0) {
             return null;
-        case '"':
-        case '\'':
+        } else if (c == '"' || c == '\'') {
             q = c;
             sb = new StringBuilder();
             for (;;) {
@@ -51,9 +58,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;
@@ -65,13 +72,12 @@ public class CDL {
                 sb.append(c);
             }
             return sb.toString();
-        case ',':
+        } else if (c == delimiter) {
             x.back();
             return "";
-        default:
-            x.back();
-            return x.nextTo(',');
         }
+        x.back();
+        return x.nextTo(delimiter);
     }
 
     /**
@@ -81,17 +87,32 @@ 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);
+            String value = getValue(x,delimiter);
             char c = x.next();
-            if (value == null ||
-                    (ja.length() == 0 && value.length() == 0 && c != ',')) {
+            if (value != null) {
+                ja.put(value);
+            } 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 == ',') {
+                if (c == delimiter) {
                     break;
                 }
                 if (c != ' ') {
@@ -116,9 +137,23 @@ 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 {
-        JSONArray ja = rowToJSONArray(x);
+    public static JSONObject rowToJSONObject(JSONArray names, JSONTokener x) throws JSONException {
+        return rowToJSONObject(names, 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;
     }
 
@@ -130,15 +165,27 @@ 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(',');
+                sb.append(delimiter);
             }
             Object object = ja.opt(i);
             if (object != null) {
                 String string = object.toString();
-                if (string.length() > 0 && (string.indexOf(',') >= 0 ||
+                if (!string.isEmpty() && (string.indexOf(delimiter) >= 0 ||
                         string.indexOf('\n') >= 0 || string.indexOf('\r') >= 0 ||
                         string.indexOf(0) >= 0 || string.charAt(0) == '"')) {
                     sb.append('"');
@@ -167,7 +214,19 @@ public class CDL {
      * @throws JSONException if a called function fails
      */
     public static JSONArray toJSONArray(String string) throws JSONException {
-        return toJSONArray(new JSONTokener(string));
+        return toJSONArray(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);
     }
 
     /**
@@ -178,7 +237,19 @@ public class CDL {
      * @throws JSONException if a called function fails
      */
     public static JSONArray toJSONArray(JSONTokener x) throws JSONException {
-        return toJSONArray(rowToJSONArray(x), x);
+        return toJSONArray(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);
     }
 
     /**
@@ -189,9 +260,21 @@ 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 {
-        return toJSONArray(names, new JSONTokener(string));
+    public static JSONArray toJSONArray(JSONArray names, String string) throws JSONException {
+        return toJSONArray(names, 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);
     }
 
     /**
@@ -202,14 +285,26 @@ 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) throws JSONException {
+        return toJSONArray(names, x, ',');
+    }
+
+    /**
+     * 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);
+            JSONObject jo = rowToJSONObject(names, x, delimiter);
             if (jo == null) {
                 break;
             }
@@ -218,6 +313,17 @@ 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;
     }
 
@@ -231,11 +337,24 @@ 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) + toString(names, ja);
+                return rowToString(names, delimiter) + toString(names, ja, delimiter);
             }
         }
         return null;
@@ -250,8 +369,21 @@ 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) throws JSONException {
+        return toString(names, ja, ',');
+    }
+
+    /**
+     * 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;
         }
@@ -259,7 +391,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)));
+                sb.append(rowToString(jo.toJSONArray(names), delimiter));
             }
         }
         return sb.toString();

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

@@ -15,6 +15,14 @@ Public Domain.
  */
 public class Cookie {
 
+    /**
+     * Constructs a new Cookie object.
+     * @deprecated (Utility class cannot be instantiated)
+     */
+    @Deprecated()
+    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,6 +11,14 @@ Public Domain.
  */
 public class CookieList {
 
+    /**
+     * Constructs a new CookieList object.
+     * @deprecated (Utility class cannot be instantiated)
+     */
+    @Deprecated
+    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 '='.
@@ -46,19 +54,19 @@ public class CookieList {
      * @throws JSONException if a called function fails
      */
     public static String toString(JSONObject jo) throws JSONException {
-        boolean             b = false;
+        boolean             isEndOfPair = false;
         final StringBuilder sb = new StringBuilder();
         // Don't use the new entrySet API to maintain Android support
         for (final String key : jo.keySet()) {
             final Object value = jo.opt(key);
             if (!JSONObject.NULL.equals(value)) {
-                if (b) {
+                if (isEndOfPair) {
                     sb.append(';');
                 }
                 sb.append(Cookie.escape(key));
                 sb.append("=");
                 sb.append(Cookie.escape(value.toString()));
-                b = true;
+                isEndOfPair = true;
             }
         }
         return sb.toString();

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

@@ -13,6 +13,12 @@ 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,7 +5,6 @@ Public Domain.
  */
 
 import java.io.IOException;
-import java.io.StringWriter;
 import java.io.Writer;
 import java.lang.reflect.Array;
 import java.math.BigDecimal;
@@ -84,15 +83,30 @@ 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 '['");
         }
-        
+
         char nextChar = x.nextClean();
         if (nextChar == 0) {
             // array is unclosed. No ']' found, instead EOF
             throw x.syntaxError("Expected a ',' or ']'");
+        } else if (nextChar==',' && jsonParserConfiguration.isStrictMode()) {
+        	 throw x.syntaxError("Array content starts with a ','");
         }
         if (nextChar != ']') {
             x.back();
@@ -104,30 +118,61 @@ public class JSONArray implements Iterable<Object> {
                     x.back();
                     this.myArrayList.add(x.nextValue());
                 }
-                switch (x.nextClean()) {
-                case 0:
-                    // array is unclosed. No ']' found, instead EOF
-                    throw x.syntaxError("Expected a ',' or ']'");
-                case ',':
-                    nextChar = x.nextClean();
-                    if (nextChar == 0) {
-                        // array is unclosed. No ']' found, instead EOF
-                        throw x.syntaxError("Expected a ',' or ']'");
-                    }
-                    if (nextChar == ']') {
-                        return;
-                    }
-                    x.back();
-                    break;
-                case ']':
-                    return;
-                default:
-                    throw x.syntaxError("Expected a ',' or ']'");
-                }
+                if (checkForSyntaxError(x, jsonParserConfiguration, isInitial)) return;
+            }
+        } else {
+            if (isInitial && jsonParserConfiguration.isStrictMode() && x.nextClean() != 0) {
+                throw x.syntaxError("Strict mode error: Unparsed characters found at end of input text");
             }
         }
     }
 
+    /** Convenience function. Checks for JSON syntax error.
+     * @param x                       A JSONTokener instance from which the JSONArray is constructed.
+     * @param jsonParserConfiguration A JSONParserConfiguration instance that controls the behavior of the parser.
+     * @param isInitial               Boolean indicating position of char
+     * @return
+     */
+    private static boolean checkForSyntaxError(JSONTokener x, JSONParserConfiguration jsonParserConfiguration, boolean isInitial) {
+        char nextChar;
+        switch (x.nextClean()) {
+        case 0:
+            // array is unclosed. No ']' found, instead EOF
+            throw x.syntaxError("Expected a ',' or ']'");
+        case ',':
+            nextChar = x.nextClean();
+            if (nextChar == 0) {
+                // array is unclosed. No ']' found, instead EOF
+                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 true;
+            }
+            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 true;
+            }
+            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 true;
+        default:
+            throw x.syntaxError("Expected a ',' or ']'");
+        }
+        return false;
+    }
+
     /**
      * Construct a JSONArray from a source JSON text.
      *
@@ -139,7 +184,22 @@ public class JSONArray implements Iterable<Object> {
      *             If there is a syntax error.
      */
     public JSONArray(String source) throws JSONException {
-        this(new JSONTokener(source));
+        this(source, new JSONParserConfiguration());
+    }
+
+    /**
+     * 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);
     }
 
     /**
@@ -149,11 +209,40 @@ public class JSONArray implements Iterable<Object> {
      *            A Collection.
      */
     public JSONArray(Collection<?> collection) {
+      this(collection, 0, new JSONParserConfiguration());
+    }
+
+    /**
+     * Construct a JSONArray from a Collection.
+     *
+     * @param collection
+     *            A Collection.
+     * @param jsonParserConfiguration
+     *            Configuration object for the JSON parser
+     */
+    public JSONArray(Collection<?> collection, JSONParserConfiguration jsonParserConfiguration) {
+        this(collection, 0, jsonParserConfiguration);
+    }
+
+    /**
+     * Construct a JSONArray from a collection with recursion depth.
+     *
+     * @param collection
+     *             A Collection.
+     * @param recursionDepth
+     *             Variable for tracking the count of nested object creations.
+     * @param jsonParserConfiguration
+     *             Configuration object for the JSON parser
+     */
+    JSONArray(Collection<?> collection, int recursionDepth, JSONParserConfiguration jsonParserConfiguration) {
+        if (recursionDepth > jsonParserConfiguration.getMaxNestingDepth()) {
+          throw new JSONException("JSONArray has reached recursion depth limit of " + jsonParserConfiguration.getMaxNestingDepth());
+        }
         if (collection == null) {
             this.myArrayList = new ArrayList<Object>();
         } else {
             this.myArrayList = new ArrayList<Object>(collection.size());
-            this.addAll(collection, true);
+            this.addAll(collection, true, recursionDepth, jsonParserConfiguration);
         }
     }
 
@@ -205,7 +294,7 @@ public class JSONArray implements Iterable<Object> {
             throw new JSONException(
                     "JSONArray initial value should be a string or collection or array.");
         }
-        this.addAll(array, true);
+        this.addAll(array, true, 0);
     }
 
     /**
@@ -259,13 +348,11 @@ public class JSONArray implements Iterable<Object> {
      */
     public boolean getBoolean(int index) throws JSONException {
         Object object = this.get(index);
-        if (object.equals(Boolean.FALSE)
-                || (object instanceof String && ((String) object)
-                        .equalsIgnoreCase("false"))) {
+        if (Boolean.FALSE.equals(object)
+                || (object instanceof String && "false".equalsIgnoreCase((String) object))) {
             return false;
-        } else if (object.equals(Boolean.TRUE)
-                || (object instanceof String && ((String) object)
-                        .equalsIgnoreCase("true"))) {
+        } else if (Boolean.TRUE.equals(object)
+                || (object instanceof String && "true".equalsIgnoreCase((String) object))) {
             return true;
         }
         throw wrongValueFormatException(index, "boolean", object, null);
@@ -599,6 +686,38 @@ public class JSONArray implements Iterable<Object> {
         }
     }
 
+    /**
+     * Get the optional Boolean object associated with an index. It returns false
+     * if there is no value at that index, or if the value is not Boolean.TRUE
+     * or the String "true".
+     *
+     * @param index
+     *            The index must be between 0 and length() - 1.
+     * @return The truth.
+     */
+    public Boolean optBooleanObject(int index) {
+        return this.optBooleanObject(index, false);
+    }
+
+    /**
+     * Get the optional Boolean object associated with an index. It returns the
+     * defaultValue if there is no value at that index or if it is not a Boolean
+     * or the String "true" or "false" (case insensitive).
+     *
+     * @param index
+     *            The index must be between 0 and length() - 1.
+     * @param defaultValue
+     *            A boolean default.
+     * @return The truth.
+     */
+    public Boolean optBooleanObject(int index, Boolean defaultValue) {
+        try {
+            return this.getBoolean(index);
+        } catch (Exception e) {
+            return defaultValue;
+        }
+    }
+
     /**
      * Get the optional double value associated with an index. NaN is returned
      * if there is no value for the index, or if the value is not a number and
@@ -628,11 +747,39 @@ public class JSONArray implements Iterable<Object> {
         if (val == null) {
             return defaultValue;
         }
-        final double doubleValue = val.doubleValue();
-        // if (Double.isNaN(doubleValue) || Double.isInfinite(doubleValue)) {
-        // return defaultValue;
-        // }
-        return doubleValue;
+        return val.doubleValue();
+    }
+
+    /**
+     * Get the optional Double object associated with an index. NaN is returned
+     * if there is no value for the index, or if the value is not a number and
+     * cannot be converted to a number.
+     *
+     * @param index
+     *            The index must be between 0 and length() - 1.
+     * @return The object.
+     */
+    public Double optDoubleObject(int index) {
+        return this.optDoubleObject(index, Double.NaN);
+    }
+
+    /**
+     * Get the optional double value associated with an index. The defaultValue
+     * is returned if there is no value for the index, or if the value is not a
+     * number and cannot be converted to a number.
+     *
+     * @param index
+     *            subscript
+     * @param defaultValue
+     *            The default object.
+     * @return The object.
+     */
+    public Double optDoubleObject(int index, Double defaultValue) {
+        final Number val = this.optNumber(index, null);
+        if (val == null) {
+            return defaultValue;
+        }
+        return val.doubleValue();
     }
 
     /**
@@ -664,11 +811,39 @@ public class JSONArray implements Iterable<Object> {
         if (val == null) {
             return defaultValue;
         }
-        final float floatValue = val.floatValue();
-        // if (Float.isNaN(floatValue) || Float.isInfinite(floatValue)) {
-        // return floatValue;
-        // }
-        return floatValue;
+        return val.floatValue();
+    }
+
+    /**
+     * Get the optional Float object associated with an index. NaN is returned
+     * if there is no value for the index, or if the value is not a number and
+     * cannot be converted to a number.
+     *
+     * @param index
+     *            The index must be between 0 and length() - 1.
+     * @return The object.
+     */
+    public Float optFloatObject(int index) {
+        return this.optFloatObject(index, Float.NaN);
+    }
+
+    /**
+     * Get the optional Float object associated with an index. The defaultValue
+     * is returned if there is no value for the index, or if the value is not a
+     * number and cannot be converted to a number.
+     *
+     * @param index
+     *            subscript
+     * @param defaultValue
+     *            The default object.
+     * @return The object.
+     */
+    public Float optFloatObject(int index, Float defaultValue) {
+        final Number val = this.optNumber(index, null);
+        if (val == null) {
+            return defaultValue;
+        }
+        return val.floatValue();
     }
 
     /**
@@ -703,6 +878,38 @@ public class JSONArray implements Iterable<Object> {
         return val.intValue();
     }
 
+    /**
+     * Get the optional Integer object associated with an index. Zero is returned if
+     * there is no value for the index, or if the value is not a number and
+     * cannot be converted to a number.
+     *
+     * @param index
+     *            The index must be between 0 and length() - 1.
+     * @return The object.
+     */
+    public Integer optIntegerObject(int index) {
+        return this.optIntegerObject(index, 0);
+    }
+
+    /**
+     * Get the optional Integer object associated with an index. The defaultValue is
+     * returned if there is no value for the index, or if the value is not a
+     * number and cannot be converted to a number.
+     *
+     * @param index
+     *            The index must be between 0 and length() - 1.
+     * @param defaultValue
+     *            The default object.
+     * @return The object.
+     */
+    public Integer optIntegerObject(int index, Integer defaultValue) {
+        final Number val = this.optNumber(index, null);
+        if (val == null) {
+            return defaultValue;
+        }
+        return val.intValue();
+    }
+
     /**
      * Get the enum value associated with a key.
      * 
@@ -788,30 +995,57 @@ public class JSONArray implements Iterable<Object> {
     }
 
     /**
-     * Get the optional JSONArray associated with an index.
+     * Get the optional JSONArray associated with an index. Null is returned if
+     * there is no value at that index or if the value is not a JSONArray.
      *
      * @param index
-     *            subscript
-     * @return A JSONArray value, or null if the index has no value, or if the
-     *         value is not a JSONArray.
+     *            The index must be between 0 and length() - 1.
+     * @return A JSONArray value.
      */
     public JSONArray optJSONArray(int index) {
-        Object o = this.opt(index);
-        return o instanceof JSONArray ? (JSONArray) o : null;
+        return this.optJSONArray(index, null);
+    }
+
+    /**
+     * Get the optional JSONArray associated with an index. The defaultValue is returned if
+     * there is no value at that index or if the value is not a JSONArray.
+     *
+     * @param index
+     *            The index must be between 0 and length() - 1.
+     * @param defaultValue
+     *            The default.
+     * @return A JSONArray value.
+     */
+    public JSONArray optJSONArray(int index, JSONArray defaultValue) {
+        Object object = this.opt(index);
+        return object instanceof JSONArray ? (JSONArray) object : defaultValue;
     }
 
     /**
      * Get the optional JSONObject associated with an index. Null is returned if
-     * the key is not found, or null if the index has no value, or if the value
-     * is not a JSONObject.
+     * there is no value at that index or if the value is not a JSONObject.
      *
      * @param index
      *            The index must be between 0 and length() - 1.
      * @return A JSONObject value.
      */
     public JSONObject optJSONObject(int index) {
-        Object o = this.opt(index);
-        return o instanceof JSONObject ? (JSONObject) o : null;
+        return this.optJSONObject(index, null);
+    }
+
+    /**
+     * Get the optional JSONObject associated with an index. The defaultValue is returned if
+     * there is no value at that index or if the value is not a JSONObject.
+     *
+     * @param index
+     *            The index must be between 0 and length() - 1.
+     * @param defaultValue
+     *            The default.
+     * @return A JSONObject value.
+     */
+    public JSONObject optJSONObject(int index, JSONObject defaultValue) {
+        Object object = this.opt(index);
+        return object instanceof JSONObject ? (JSONObject) object : defaultValue;
     }
 
     /**
@@ -846,6 +1080,38 @@ public class JSONArray implements Iterable<Object> {
         return val.longValue();
     }
 
+    /**
+     * Get the optional Long object associated with an index. Zero is returned if
+     * there is no value for the index, or if the value is not a number and
+     * cannot be converted to a number.
+     *
+     * @param index
+     *            The index must be between 0 and length() - 1.
+     * @return The object.
+     */
+    public Long optLongObject(int index) {
+        return this.optLongObject(index, 0L);
+    }
+
+    /**
+     * Get the optional Long object associated with an index. The defaultValue is
+     * returned if there is no value for the index, or if the value is not a
+     * number and cannot be converted to a number.
+     *
+     * @param index
+     *            The index must be between 0 and length() - 1.
+     * @param defaultValue
+     *            The default object.
+     * @return The object.
+     */
+    public Long optLongObject(int index, Long defaultValue) {
+        final Number val = this.optNumber(index, null);
+        if (val == null) {
+            return defaultValue;
+        }
+        return val.longValue();
+    }
+
     /**
      * Get an optional {@link Number} value associated with a key, or <code>null</code>
      * if there is no such key or if the value is not a number. If the value is a string,
@@ -1135,7 +1401,8 @@ public class JSONArray implements Iterable<Object> {
      *            The subscript.
      * @param value
      *            The Map value.
-     * @return this.
+     * @return
+     *             reference to self
      * @throws JSONException
      *             If the index is negative or if the value is an invalid
      *             number.
@@ -1143,7 +1410,27 @@ public class JSONArray implements Iterable<Object> {
      *             If a key in the map is <code>null</code>
      */
     public JSONArray put(int index, Map<?, ?> value) throws JSONException {
-        this.put(index, new JSONObject(value));
+        this.put(index, new JSONObject(value, new JSONParserConfiguration()));
+        return this;
+    }
+
+    /**
+     * Put a value in the JSONArray, where the value will be a JSONObject that
+     * is produced from a Map.
+     *
+     * @param index
+     *          The subscript
+     * @param value
+     *          The Map value.
+     * @param jsonParserConfiguration
+     *          Configuration object for the JSON parser
+     * @return reference to self
+     * @throws JSONException
+     *          If the index is negative or if the value is an invalid
+     *          number.
+     */
+    public JSONArray put(int index, Map<?, ?> value, JSONParserConfiguration jsonParserConfiguration) throws JSONException {
+        this.put(index, new JSONObject(value, jsonParserConfiguration));
         return this;
     }
 
@@ -1354,29 +1641,44 @@ public class JSONArray implements Iterable<Object> {
             if(valueThis == null) {
             	return false;
             }
-            if (valueThis instanceof JSONObject) {
-                if (!((JSONObject)valueThis).similar(valueOther)) {
-                    return false;
-                }
-            } else if (valueThis instanceof JSONArray) {
-                if (!((JSONArray)valueThis).similar(valueOther)) {
-                    return false;
-                }
-            } else if (valueThis instanceof Number && valueOther instanceof Number) {
-                if (!JSONObject.isNumberSimilar((Number)valueThis, (Number)valueOther)) {
-                	return false;
-                }
-            } else if (valueThis instanceof JSONString && valueOther instanceof JSONString) {
-                if (!((JSONString) valueThis).toJSONString().equals(((JSONString) valueOther).toJSONString())) {
-                    return false;
-                }
-            } else if (!valueThis.equals(valueOther)) {
+            if (!isSimilar(valueThis, valueOther)) {
                 return false;
             }
         }
         return true;
     }
 
+    /**
+     * Convenience function; checks for object similarity
+     * @param valueThis
+     *      Initial object to compare
+     * @param valueOther
+     *      Comparison object
+     * @return  boolean
+     */
+    private boolean isSimilar(Object valueThis, Object valueOther) {
+        if (valueThis instanceof JSONObject) {
+            if (!((JSONObject)valueThis).similar(valueOther)) {
+                return false;
+            }
+        } else if (valueThis instanceof JSONArray) {
+            if (!((JSONArray)valueThis).similar(valueOther)) {
+                return false;
+            }
+        } else if (valueThis instanceof Number && valueOther instanceof Number) {
+            if (!JSONObject.isNumberSimilar((Number)valueThis, (Number)valueOther)) {
+                return false;
+            }
+        } else if (valueThis instanceof JSONString && valueOther instanceof JSONString) {
+            if (!((JSONString) valueThis).toJSONString().equals(((JSONString) valueOther).toJSONString())) {
+                return false;
+            }
+        } else if (!valueThis.equals(valueOther)) {
+            return false;
+        }
+        return true;
+    }
+
     /**
      * Produce a JSONObject by combining a JSONArray of names with the values of
      * this JSONArray.
@@ -1450,10 +1752,11 @@ public class JSONArray implements Iterable<Object> {
      */
     @SuppressWarnings("resource")
     public String toString(int indentFactor) throws JSONException {
-        StringWriter sw = new StringWriter();
-        synchronized (sw.getBuffer()) {
-            return this.write(sw, indentFactor, 0).toString();
-        }
+        // each value requires a comma, so multiply the count by 2
+        // 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();
     }
 
     /**
@@ -1507,12 +1810,7 @@ public class JSONArray implements Iterable<Object> {
             writer.write('[');
 
             if (length == 1) {
-                try {
-                    JSONObject.writeValue(writer, this.myArrayList.get(0),
-                            indentFactor, indent);
-                } catch (Exception e) {
-                    throw new JSONException("Unable to write JSONArray value at index: 0", e);
-                }
+                writeArrayAttempt(writer, indentFactor, indent, 0);
             } else if (length != 0) {
                 final int newIndent = indent + indentFactor;
 
@@ -1524,12 +1822,7 @@ public class JSONArray implements Iterable<Object> {
                         writer.write('\n');
                     }
                     JSONObject.indent(writer, newIndent);
-                    try {
-                        JSONObject.writeValue(writer, this.myArrayList.get(i),
-                                indentFactor, newIndent);
-                    } catch (Exception e) {
-                        throw new JSONException("Unable to write JSONArray value at index: " + i, e);
-                    }
+                    writeArrayAttempt(writer, indentFactor, newIndent, i);
                     needsComma = true;
                 }
                 if (indentFactor > 0) {
@@ -1544,6 +1837,26 @@ public class JSONArray implements Iterable<Object> {
         }
     }
 
+    /**
+     * Convenience function. Attempts to write
+     * @param writer
+     *            Writes the serialized JSON
+     * @param indentFactor
+     *            The number of spaces to add to each level of indentation.
+     * @param indent
+     *            The indentation of the top level.
+     * @param i
+     *            Index in array to be added
+     */
+    private void writeArrayAttempt(Writer writer, int indentFactor, int indent, int i) {
+        try {
+            JSONObject.writeValue(writer, this.myArrayList.get(i),
+                    indentFactor, indent);
+        } catch (Exception e) {
+            throw new JSONException("Unable to write JSONArray value at index: " + i, e);
+        }
+    }
+
     /**
      * Returns a java.util.List containing all of the elements in this array.
      * If an element in the array is a JSONArray or JSONObject it will also
@@ -1586,13 +1899,14 @@ public class JSONArray implements Iterable<Object> {
      * @param wrap
      *            {@code true} to call {@link JSONObject#wrap(Object)} for each item,
      *            {@code false} to add the items directly
-     *            
+     * @param recursionDepth
+     *            Variable for tracking the count of nested object creations.
      */
-    private void addAll(Collection<?> collection, boolean wrap) {
+    private void addAll(Collection<?> collection, boolean wrap, int recursionDepth, JSONParserConfiguration jsonParserConfiguration) {
         this.myArrayList.ensureCapacity(this.myArrayList.size() + collection.size());
         if (wrap) {
             for (Object o: collection){
-                this.put(JSONObject.wrap(o));
+                this.put(JSONObject.wrap(o, recursionDepth + 1, jsonParserConfiguration));
             }
         } else {
             for (Object o: collection){
@@ -1621,7 +1935,24 @@ public class JSONArray implements Iterable<Object> {
             }
         }
     }
-    
+
+    /**
+     * Add an array's elements to the JSONArray.
+     *
+     * @param array
+     *          Array. If the parameter passed is null, or not an array,
+     *          JSONArray, Collection, or Iterable, an exception will be
+     *          thrown.
+     * @param wrap
+     *          {@code true} to call {@link JSONObject#wrap(Object)} for each item,
+     *          {@code false} to add the items directly
+     * @throws JSONException
+     *          If not an array or if an array value is non-finite number.
+     */
+    private void addAll(Object array, boolean wrap) throws JSONException {
+      this.addAll(array, wrap, 0);
+    }
+
     /**
      * Add an array's elements to the JSONArray.
      *
@@ -1630,21 +1961,40 @@ public class JSONArray implements Iterable<Object> {
      *            JSONArray, Collection, or Iterable, an exception will be
      *            thrown.
      * @param wrap
+     *          {@code true} to call {@link JSONObject#wrap(Object)} for each item,
+     *          {@code false} to add the items directly
+     * @param recursionDepth
+     *          Variable for tracking the count of nested object creations.
+     */
+    private void addAll(Object array, boolean wrap, int recursionDepth) {
+        addAll(array, wrap, recursionDepth, new JSONParserConfiguration());
+    }
+    /**
+     * Add an array's elements to the JSONArray.
+     *`
+     * @param array
+     *            Array. If the parameter passed is null, or not an array,
+     *            JSONArray, Collection, or Iterable, an exception will be
+     *            thrown.
+     * @param wrap
      *            {@code true} to call {@link JSONObject#wrap(Object)} for each item,
      *            {@code false} to add the items directly
-     *
+     * @param recursionDepth
+     *            Variable for tracking the count of nested object creations.
+     * @param jsonParserConfiguration
+     *            Variable to pass parser custom configuration for json parsing.
      * @throws JSONException
      *            If not an array or if an array value is non-finite number.
      * @throws NullPointerException
      *            Thrown if the array parameter is null.
      */
-    private void addAll(Object array, boolean wrap) throws JSONException {
+    private void addAll(Object array, boolean wrap, int recursionDepth, JSONParserConfiguration jsonParserConfiguration) throws JSONException {
         if (array.getClass().isArray()) {
             int length = Array.getLength(array);
             this.myArrayList.ensureCapacity(this.myArrayList.size() + length);
             if (wrap) {
                 for (int i = 0; i < length; i += 1) {
-                    this.put(JSONObject.wrap(Array.get(array, i)));
+                    this.put(JSONObject.wrap(Array.get(array, i), recursionDepth + 1, jsonParserConfiguration));
                 }
             } else {
                 for (int i = 0; i < length; i += 1) {
@@ -1657,7 +2007,7 @@ public class JSONArray implements Iterable<Object> {
             // JSONArray
             this.myArrayList.addAll(((JSONArray)array).myArrayList);
         } else if (array instanceof Collection) {
-            this.addAll((Collection<?>)array, wrap);
+            this.addAll((Collection<?>)array, wrap, recursionDepth, jsonParserConfiguration);
         } else if (array instanceof Iterable) {
             this.addAll((Iterable<?>)array, wrap);
         } else {

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

@@ -13,6 +13,16 @@ Public Domain.
  * @version 2016-01-30
  */
 public class JSONML {
+
+    /**
+     * Constructs a new JSONML object.
+     * @deprecated (Utility class cannot be instantiated)
+     */
+    @Deprecated
+    public JSONML() {
+    }
+
+
     /**
      * Parse XML values and store them in a JSONArray.
      * @param x       The XMLTokener containing the source string.
@@ -27,7 +37,32 @@ public class JSONML {
         XMLTokener x,
         boolean    arrayForm,
         JSONArray  ja,
-        boolean keepStrings
+        boolean keepStrings,
+        int currentNestingDepth
+    ) throws JSONException {
+        return parse(x,arrayForm, ja,
+            keepStrings ? JSONMLParserConfiguration.KEEP_STRINGS : JSONMLParserConfiguration.ORIGINAL,
+            currentNestingDepth);
+    }
+
+    /**
+     * Parse XML values and store them in a JSONArray.
+     * @param x       The XMLTokener containing the source string.
+     * @param arrayForm true if array form, false if object form.
+     * @param ja      The JSONArray that is containing the current tag or null
+     *     if we are at the outermost level.
+     * @param config  The parser configuration:
+     *     JSONMLParserConfiguration.ORIGINAL is the default behaviour;
+     *     JSONMLParserConfiguration.KEEP_STRINGS means Don't type-convert text nodes and attribute values.
+     * @return A JSONArray if the value is the outermost tag, otherwise null.
+     * @throws JSONException if a parsing error occurs
+     */
+    private static Object parse(
+        XMLTokener x,
+        boolean    arrayForm,
+        JSONArray  ja,
+        JSONMLParserConfiguration config,
+        int currentNestingDepth
     ) throws JSONException {
         String     attribute;
         char       c;
@@ -79,7 +114,7 @@ public class JSONML {
                             }
                         } else if (c == '[') {
                             token = x.nextToken();
-                            if (token.equals("CDATA") && x.next() == '[') {
+                            if ("CDATA".equals(token) && x.next() == '[') {
                                 if (ja != null) {
                                     ja.put(x.nextCDATA());
                                 }
@@ -152,7 +187,7 @@ public class JSONML {
                             if (!(token instanceof String)) {
                                 throw x.syntaxError("Missing value");
                             }
-                            newjo.accumulate(attribute, keepStrings ? ((String)token) :XML.stringToValue((String)token));
+                            newjo.accumulate(attribute, config.isKeepStrings() ? ((String)token) :XML.stringToValue((String)token));
                             token = null;
                         } else {
                             newjo.accumulate(attribute, "");
@@ -181,7 +216,12 @@ public class JSONML {
                         if (token != XML.GT) {
                             throw x.syntaxError("Misshaped tag");
                         }
-                        closeTag = (String)parse(x, arrayForm, newja, keepStrings);
+
+                        if (currentNestingDepth == config.getMaxNestingDepth()) {
+                            throw x.syntaxError("Maximum nesting depth of " + config.getMaxNestingDepth() + " reached");
+                        }
+
+                        closeTag = (String)parse(x, arrayForm, newja, config, currentNestingDepth + 1);
                         if (closeTag != null) {
                             if (!closeTag.equals(tagName)) {
                                 throw x.syntaxError("Mismatched '" + tagName +
@@ -202,9 +242,21 @@ public class JSONML {
                 }
             } else {
                 if (ja != null) {
-                    ja.put(token instanceof String
-                        ? keepStrings ? XML.unescape((String)token) :XML.stringToValue((String)token)
-                        : token);
+                    Object value;
+
+                    if (token instanceof String) {
+                        String strToken = (String) token;
+                        if (config.isKeepStrings()) {
+                            value = XML.unescape(strToken);
+                        } else {
+                            value = XML.stringToValue(strToken);
+                        }
+                    } else {
+                        value = token;
+                    }
+
+                    ja.put(value);
+
                 }
             }
         }
@@ -224,7 +276,7 @@ public class JSONML {
      * @throws JSONException Thrown on error converting to a JSONArray
      */
     public static JSONArray toJSONArray(String string) throws JSONException {
-        return (JSONArray)parse(new XMLTokener(string), true, null, false);
+        return (JSONArray)parse(new XMLTokener(string), true, null, JSONMLParserConfiguration.ORIGINAL, 0);
     }
 
 
@@ -235,8 +287,8 @@ public class JSONML {
      * attributes, then the second element will be JSONObject containing the
      * name/value pairs. If the tag contains children, then strings and
      * JSONArrays will represent the child tags.
-     * As opposed to toJSONArray this method does not attempt to convert 
-     * any text node or attribute value to any type 
+     * As opposed to toJSONArray this method does not attempt to convert
+     * any text node or attribute value to any type
      * but just leaves it as a string.
      * Comments, prologs, DTDs, and <pre>{@code &lt;[ [ ]]>}</pre> are ignored.
      * @param string The source string.
@@ -246,7 +298,32 @@ public class JSONML {
      * @throws JSONException Thrown on error converting to a JSONArray
      */
     public static JSONArray toJSONArray(String string, boolean keepStrings) throws JSONException {
-        return (JSONArray)parse(new XMLTokener(string), true, null, keepStrings);
+        return (JSONArray)parse(new XMLTokener(string), true, null, keepStrings, 0);
+    }
+
+
+
+    /**
+     * Convert a well-formed (but not necessarily valid) XML string into a
+     * JSONArray using the JsonML transform. Each XML tag is represented as
+     * a JSONArray in which the first element is the tag name. If the tag has
+     * attributes, then the second element will be JSONObject containing the
+     * name/value pairs. If the tag contains children, then strings and
+     * JSONArrays will represent the child tags.
+     * As opposed to toJSONArray this method does not attempt to convert
+     * any text node or attribute value to any type
+     * but just leaves it as a string.
+     * Comments, prologs, DTDs, and <pre>{@code &lt;[ [ ]]>}</pre> are ignored.
+     * @param string The source string.
+     * @param config  The parser configuration:
+     *     JSONMLParserConfiguration.ORIGINAL is the default behaviour;
+     *     JSONMLParserConfiguration.KEEP_STRINGS means values will not be coerced into boolean
+     *       or numeric values and will instead be left as strings
+     * @return A JSONArray containing the structured data from the XML string.
+     * @throws JSONException Thrown on error converting to a JSONArray
+     */
+    public static JSONArray toJSONArray(String string, JSONMLParserConfiguration config) throws JSONException {
+        return (JSONArray)parse(new XMLTokener(string), true, null, config, 0);
     }
 
 
@@ -257,8 +334,32 @@ public class JSONML {
      * attributes, then the second element will be JSONObject containing the
      * name/value pairs. If the tag contains children, then strings and
      * JSONArrays will represent the child content and tags.
-     * As opposed to toJSONArray this method does not attempt to convert 
-     * any text node or attribute value to any type 
+     * As opposed to toJSONArray this method does not attempt to convert
+     * any text node or attribute value to any type
+     * but just leaves it as a string.
+     * Comments, prologs, DTDs, and <pre>{@code &lt;[ [ ]]>}</pre> are ignored.
+     * @param x An XMLTokener.
+     * @param config  The parser configuration:
+     *     JSONMLParserConfiguration.ORIGINAL is the default behaviour;
+     *     JSONMLParserConfiguration.KEEP_STRINGS means values will not be coerced into boolean
+     *       or numeric values and will instead be left as strings
+     * @return A JSONArray containing the structured data from the XML string.
+     * @throws JSONException Thrown on error converting to a JSONArray
+     */
+    public static JSONArray toJSONArray(XMLTokener x, JSONMLParserConfiguration config) throws JSONException {
+        return (JSONArray)parse(x, true, null, config, 0);
+    }
+
+
+    /**
+     * Convert a well-formed (but not necessarily valid) XML string into a
+     * JSONArray using the JsonML transform. Each XML tag is represented as
+     * a JSONArray in which the first element is the tag name. If the tag has
+     * attributes, then the second element will be JSONObject containing the
+     * name/value pairs. If the tag contains children, then strings and
+     * JSONArrays will represent the child content and tags.
+     * As opposed to toJSONArray this method does not attempt to convert
+     * any text node or attribute value to any type
      * but just leaves it as a string.
      * Comments, prologs, DTDs, and <pre>{@code &lt;[ [ ]]>}</pre> are ignored.
      * @param x An XMLTokener.
@@ -268,7 +369,7 @@ public class JSONML {
      * @throws JSONException Thrown on error converting to a JSONArray
      */
     public static JSONArray toJSONArray(XMLTokener x, boolean keepStrings) throws JSONException {
-        return (JSONArray)parse(x, true, null, keepStrings);
+        return (JSONArray)parse(x, true, null, keepStrings, 0);
     }
 
 
@@ -285,7 +386,7 @@ public class JSONML {
      * @throws JSONException Thrown on error converting to a JSONArray
      */
     public static JSONArray toJSONArray(XMLTokener x) throws JSONException {
-        return (JSONArray)parse(x, true, null, false);
+        return (JSONArray)parse(x, true, null, false, 0);
     }
 
 
@@ -303,10 +404,10 @@ public class JSONML {
      * @throws JSONException Thrown on error converting to a JSONObject
      */
     public static JSONObject toJSONObject(String string) throws JSONException {
-        return (JSONObject)parse(new XMLTokener(string), false, null, false);
+        return (JSONObject)parse(new XMLTokener(string), false, null, false, 0);
     }
-    
-    
+
+
     /**
      * Convert a well-formed (but not necessarily valid) XML string into a
      * JSONObject using the JsonML transform. Each XML tag is represented as
@@ -323,10 +424,32 @@ public class JSONML {
      * @throws JSONException Thrown on error converting to a JSONObject
      */
     public static JSONObject toJSONObject(String string, boolean keepStrings) throws JSONException {
-        return (JSONObject)parse(new XMLTokener(string), false, null, keepStrings);
+        return (JSONObject)parse(new XMLTokener(string), false, null, keepStrings, 0);
     }
 
-    
+
+    /**
+     * Convert a well-formed (but not necessarily valid) XML string into a
+     * JSONObject using the JsonML transform. Each XML tag is represented as
+     * a JSONObject with a "tagName" property. If the tag has attributes, then
+     * the attributes will be in the JSONObject as properties. If the tag
+     * contains children, the object will have a "childNodes" property which
+     * will be an array of strings and JsonML JSONObjects.
+
+     * Comments, prologs, DTDs, and <pre>{@code &lt;[ [ ]]>}</pre> are ignored.
+     * @param string The XML source text.
+     * @param config  The parser configuration:
+     *     JSONMLParserConfiguration.ORIGINAL is the default behaviour;
+     *     JSONMLParserConfiguration.KEEP_STRINGS means values will not be coerced into boolean
+     *       or numeric values and will instead be left as strings
+     * @return A JSONObject containing the structured data from the XML string.
+     * @throws JSONException Thrown on error converting to a JSONObject
+     */
+    public static JSONObject toJSONObject(String string, JSONMLParserConfiguration config) throws JSONException {
+        return (JSONObject)parse(new XMLTokener(string), false, null, config, 0);
+    }
+
+
     /**
      * Convert a well-formed (but not necessarily valid) XML string into a
      * JSONObject using the JsonML transform. Each XML tag is represented as
@@ -341,7 +464,7 @@ public class JSONML {
      * @throws JSONException Thrown on error converting to a JSONObject
      */
     public static JSONObject toJSONObject(XMLTokener x) throws JSONException {
-           return (JSONObject)parse(x, false, null, false);
+           return (JSONObject)parse(x, false, null, false, 0);
     }
 
 
@@ -361,7 +484,29 @@ public class JSONML {
      * @throws JSONException Thrown on error converting to a JSONObject
      */
     public static JSONObject toJSONObject(XMLTokener x, boolean keepStrings) throws JSONException {
-           return (JSONObject)parse(x, false, null, keepStrings);
+           return (JSONObject)parse(x, false, null, keepStrings, 0);
+    }
+
+
+    /**
+     * Convert a well-formed (but not necessarily valid) XML string into a
+     * JSONObject using the JsonML transform. Each XML tag is represented as
+     * a JSONObject with a "tagName" property. If the tag has attributes, then
+     * the attributes will be in the JSONObject as properties. If the tag
+     * contains children, the object will have a "childNodes" property which
+     * will be an array of strings and JsonML JSONObjects.
+
+     * Comments, prologs, DTDs, and <pre>{@code &lt;[ [ ]]>}</pre> are ignored.
+     * @param x An XMLTokener of the XML source text.
+     * @param config  The parser configuration:
+     *     JSONMLParserConfiguration.ORIGINAL is the default behaviour;
+     *     JSONMLParserConfiguration.KEEP_STRINGS means values will not be coerced into boolean
+     *       or numeric values and will instead be left as strings
+     * @return A JSONObject containing the structured data from the XML string.
+     * @throws JSONException Thrown on error converting to a JSONObject
+     */
+    public static JSONObject toJSONObject(XMLTokener x, JSONMLParserConfiguration config) throws JSONException {
+        return (JSONObject)parse(x, false, null, config, 0);
     }
 
 
@@ -442,6 +587,7 @@ public class JSONML {
         return sb.toString();
     }
 
+
     /**
      * Reverse the JSONML transformation, making an XML text from a JSONObject.
      * The JSONObject must contain a "tagName" property. If it has children,

src/main/java/org/json/JSONMLParserConfiguration.java

@@ -0,0 +1,69 @@
+package org.json;
+/*
+Public Domain.
+*/
+
+/**
+ * Configuration object for the XML to JSONML parser. The configuration is immutable.
+ */
+@SuppressWarnings({""})
+public class JSONMLParserConfiguration extends ParserConfiguration {
+
+    /**
+     * We can override the default maximum nesting depth if needed.
+     */
+    public static final int DEFAULT_MAXIMUM_NESTING_DEPTH = ParserConfiguration.DEFAULT_MAXIMUM_NESTING_DEPTH;
+
+    /** Original Configuration of the XML to JSONML Parser. */
+    public static final JSONMLParserConfiguration ORIGINAL
+        = new JSONMLParserConfiguration();
+    /** Original configuration of the XML to JSONML Parser except that values are kept as strings. */
+    public static final JSONMLParserConfiguration KEEP_STRINGS
+        = new JSONMLParserConfiguration().withKeepStrings(true);
+
+    /**
+     * Default parser configuration. Does not keep strings (tries to implicitly convert values).
+     */
+    public JSONMLParserConfiguration() {
+        super();
+        this.maxNestingDepth = DEFAULT_MAXIMUM_NESTING_DEPTH;
+    }
+
+    /**
+     * Configure the parser string processing and use the default CDATA Tag Name as "content".
+     * @param keepStrings <code>true</code> to parse all values as string.
+     *      <code>false</code> to try and convert XML string values into a JSON value.
+     * @param maxNestingDepth <code>int</code> to limit the nesting depth
+     */
+    protected JSONMLParserConfiguration(final boolean keepStrings, final int maxNestingDepth) {
+        super(keepStrings, maxNestingDepth);
+    }
+
+    /**
+     * Provides a new instance of the same configuration.
+     */
+    @Override
+    protected JSONMLParserConfiguration clone() {
+        // future modifications to this method should always ensure a "deep"
+        // clone in the case of collections. i.e. if a Map is added as a configuration
+        // item, a new map instance should be created and if possible each value in the
+        // map should be cloned as well. If the values of the map are known to also
+        // be immutable, then a shallow clone of the map is acceptable.
+        return new JSONMLParserConfiguration(
+                this.keepStrings,
+                this.maxNestingDepth
+        );
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public JSONMLParserConfiguration withKeepStrings(final boolean newVal) {
+        return super.withKeepStrings(newVal);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public JSONMLParserConfiguration withMaxNestingDepth(int maxNestingDepth) {
+        return super.withMaxNestingDepth(maxNestingDepth);
+    }
+}

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

@@ -0,0 +1,152 @@
+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();
+        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();
+        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,6 +42,12 @@ 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>();
 
@@ -121,7 +127,7 @@ public class JSONPointer {
         if (pointer == null) {
             throw new NullPointerException("pointer cannot be null");
         }
-        if (pointer.isEmpty() || pointer.equals("#")) {
+        if (pointer.isEmpty() || "#".equals(pointer)) {
             this.refTokens = Collections.emptyList();
             return;
         }
@@ -163,6 +169,12 @@ 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);
     }
@@ -234,7 +246,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,10 +14,21 @@ 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/JSONPropertyIgnore.java

@@ -11,13 +11,13 @@ import java.lang.annotation.Documented;
 import java.lang.annotation.Retention;
 import java.lang.annotation.Target;
 
-@Documented
-@Retention(RUNTIME)
-@Target({METHOD})
 /**
  * Use this annotation on a getter method to override the Bean name
  * parser for Bean -> JSONObject mapping. If this annotation is
  * present at any level in the class hierarchy, then the method will
  * not be serialized from the bean into the JSONObject.
  */
+@Documented
+@Retention(RUNTIME)
+@Target({METHOD})
 public @interface JSONPropertyIgnore { }

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

@@ -11,16 +11,17 @@ import java.lang.annotation.Documented;
 import java.lang.annotation.Retention;
 import java.lang.annotation.Target;
 
-@Documented
-@Retention(RUNTIME)
-@Target({METHOD})
 /**
  * Use this annotation on a getter method to override the Bean name
  * parser for Bean -&gt; JSONObject mapping. A value set to empty string <code>""</code>
  * will have the Bean parser fall back to the default field name processing.
  */
+@Documented
+@Retention(RUNTIME)
+@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

@@ -1,11 +1,7 @@
 package org.json;
 
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.Reader;
-import java.io.StringReader;
+import java.io.*;
+import java.nio.charset.Charset;
 
 /*
 Public Domain.
@@ -36,13 +32,27 @@ 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     A reader.
+     * @param reader the source.
      */
     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);
@@ -55,25 +65,60 @@ 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(new InputStreamReader(inputStream));
+        this(inputStream, new JSONParserConfiguration());
+    }
+
+    /**
+     * 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 s     A source string.
+     * @param source A source string.
      */
-    public JSONTokener(String s) {
-        this(new StringReader(s));
+    public JSONTokener(String source) {
+        this(new StringReader(source));
     }
 
+    /**
+     * 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,
@@ -125,7 +170,7 @@ public class JSONTokener {
 
     /**
      * Checks if the end of the input has been reached.
-     *  
+     *
      * @return true if at the end of the file and we didn't step back
      */
     public boolean end() {
@@ -189,7 +234,7 @@ public class JSONTokener {
         this.previous = (char) c;
         return this.previous;
     }
-    
+
     /**
      * Get the last character read from the input or '\0' if nothing has been read yet.
      * @return the last character read from the input.
@@ -303,7 +348,8 @@ 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) {
@@ -323,10 +369,12 @@ public class JSONTokener {
                     sb.append('\r');
                     break;
                 case 'u':
+                    String next = this.next(4);
                     try {
-                        sb.append((char)Integer.parseInt(this.next(4), 16));
+                        sb.append((char)Integer.parseInt(next, 16));
                     } catch (NumberFormatException e) {
-                        throw this.syntaxError("Illegal escape.", e);
+                        throw this.syntaxError("Illegal escape. " +
+                                "\\u must be followed by a 4 digit hexadecimal number. \\" + next + " is not valid.", e);
                     }
                     break;
                 case '"':
@@ -336,7 +384,7 @@ public class JSONTokener {
                     sb.append(c);
                     break;
                 default:
-                    throw this.syntaxError("Illegal escape.");
+                    throw this.syntaxError("Illegal escape. Escape sequence  \\" + c + " is not valid.");
                 }
                 break;
             default:
@@ -406,27 +454,39 @@ public class JSONTokener {
      */
     public Object nextValue() throws JSONException {
         char c = this.nextClean();
-        String string;
-
         switch (c) {
-        case '"':
-        case '\'':
-            return this.nextString(c);
         case '{':
             this.back();
             try {
-                return new JSONObject(this);
+                return new JSONObject(this, jsonParserConfiguration);
             } catch (StackOverflowError e) {
                 throw new JSONException("JSON Array or Object depth too large to process.", e);
             }
         case '[':
             this.back();
             try {
-                return new JSONArray(this);
+                return new JSONArray(this, jsonParserConfiguration);
             } catch (StackOverflowError e) {
                 throw new JSONException("JSON Array or Object depth too large to process.", e);
             }
         }
+        return nextSimpleValue(c);
+    }
+
+    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 '\'':
+            return this.nextString(c);
+        }
 
         /*
          * Handle unquoted text. This could be the values true, false, or
@@ -449,8 +509,28 @@ public class JSONTokener {
         string = sb.toString().trim();
         if ("".equals(string)) {
             throw this.syntaxError("Missing value");
+        }  else if (jsonParserConfiguration != null &&
+                jsonParserConfiguration.isStrictMode() && string.endsWith(".")) {
+            throw this.syntaxError(String.format("Strict mode error: Value '%s' ends with dot", string));
         }
-        return JSONObject.stringToValue(string);
+        Object obj = 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;
     }
 
 
@@ -522,4 +602,15 @@ public class JSONTokener {
         return " at " + this.index + " [character " + this.character + " line " +
                 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/ParserConfiguration.java

@@ -0,0 +1,126 @@
+package org.json;
+/*
+Public Domain.
+*/
+
+/**
+ * Configuration base object for parsers. The configuration is immutable.
+ */
+@SuppressWarnings({""})
+public class ParserConfiguration {
+    /**
+     * Used to indicate there's no defined limit to the maximum nesting depth when parsing a document.
+     */
+    public static final int UNDEFINED_MAXIMUM_NESTING_DEPTH = -1;
+
+    /**
+     * The default maximum nesting depth when parsing a document.
+     */
+    public static final int DEFAULT_MAXIMUM_NESTING_DEPTH = 512;
+
+    /**
+     * 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).
+     */
+    protected boolean keepStrings;
+
+    /**
+     * The maximum nesting depth when parsing an object.
+     */
+    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;
+    }
+
+    /**
+     * Provides a new instance of the same configuration.
+     */
+    @Override
+    protected ParserConfiguration clone() {
+        // future modifications to this method should always ensure a "deep"
+        // clone in the case of collections. i.e. if a Map is added as a configuration
+        // item, a new map instance should be created and if possible each value in the
+        // map should be cloned as well. If the values of the map are known to also
+        // be immutable, then a shallow clone of the map is acceptable.
+        return new ParserConfiguration(
+                this.keepStrings,
+                this.maxNestingDepth
+        );
+    }
+
+    /**
+     * 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).
+     *
+     * @return The <code>keepStrings</code> configuration value.
+     */
+    public boolean isKeepStrings() {
+        return this.keepStrings;
+    }
+
+    /**
+     * 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 <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();
+        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.
+     *
+     * @return the maximum nesting depth set for this configuration
+     */
+    public int getMaxNestingDepth() {
+        return maxNestingDepth;
+    }
+
+    /**
+     * 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.
+     * The default max nesting depth is 512, which means the parser will throw a JsonException if
+     * 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();
+
+        if (maxNestingDepth > UNDEFINED_MAXIMUM_NESTING_DEPTH) {
+            newConfig.maxNestingDepth = maxNestingDepth;
+        } else {
+            newConfig.maxNestingDepth = UNDEFINED_MAXIMUM_NESTING_DEPTH;
+        }
+
+        return newConfig;
+    }
+}

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

@@ -13,6 +13,13 @@ 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

@@ -0,0 +1,92 @@
+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

@@ -9,7 +9,7 @@ import java.io.StringReader;
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.util.Iterator;
-
+import java.util.NoSuchElementException;
 
 /**
  * This provides static methods to convert an XML text into a JSONObject, and to
@@ -21,6 +21,12 @@ import java.util.Iterator;
 @SuppressWarnings("boxing")
 public class XML {
 
+    /**
+     * Constructs a new XML object.
+     */
+    public XML() {
+    }
+
     /** The Character '&'. */
     public static final Character AMP = '&';
 
@@ -53,6 +59,9 @@ 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";
 
     /**
@@ -72,7 +81,7 @@ public class XML {
             public Iterator<Integer> iterator() {
                 return new Iterator<Integer>() {
                     private int nextIndex = 0;
-                    private int length = string.length();
+                    private final int length = string.length();
 
                     @Override
                     public boolean hasNext() {
@@ -81,6 +90,9 @@ public class XML {
 
                     @Override
                     public Integer next() {
+                        if (!hasNext()) {
+                            throw new NoSuchElementException();
+                        }
                         int result = string.codePointAt(this.nextIndex);
                         this.nextIndex += Character.charCount(result);
                         return result;
@@ -98,7 +110,7 @@ public class XML {
     /**
      * Replace special characters with XML escapes:
      *
-     * <pre>{@code 
+     * <pre>{@code
      * &amp; (ampersand) is replaced by &amp;amp;
      * &lt; (less than) is replaced by &amp;lt;
      * &gt; (greater than) is replaced by &amp;gt;
@@ -229,10 +241,14 @@ public class XML {
      *            The JSONObject that will include the new material.
      * @param name
      *            The tag name.
+     * @param config
+     *            The XML parser configuration.
+     * @param currentNestingDepth
+     *            The current nesting depth.
      * @return true if the close tag is processed.
-     * @throws JSONException
+     * @throws JSONException Thrown if any parsing error occurs.
      */
-    private static boolean parse(XMLTokener x, JSONObject context, String name, XMLParserConfiguration config)
+    private static boolean parse(XMLTokener x, JSONObject context, String name, XMLParserConfiguration config, int currentNestingDepth)
             throws JSONException {
         char c;
         int i;
@@ -343,10 +359,20 @@ public class XML {
                                 && TYPE_ATTR.equals(string)) {
                             xmlXsiTypeConverter = config.getXsiTypeMap().get(token);
                         } else if (!nilAttributeFound) {
-                            jsonObject.accumulate(string,
-                                    config.isKeepStrings()
-                                            ? ((String) token)
-                                            : stringToValue((String) token));
+                            Object obj = stringToValue((String) token);
+                            if (obj instanceof Boolean) {
+                                jsonObject.accumulate(string,
+                                        config.isKeepBooleanAsString()
+                                                ? ((String) token)
+                                                : obj);
+                            } else if (obj instanceof Number) {
+                                jsonObject.accumulate(string,
+                                        config.isKeepNumberAsString()
+                                                ? ((String) token)
+                                                : obj);
+                            } else {
+                                jsonObject.accumulate(string, stringToValue((String) token));
+                            }
                         }
                         token = null;
                     } else {
@@ -395,14 +421,33 @@ public class XML {
                                     jsonObject.accumulate(config.getcDataTagName(),
                                             stringToValue(string, xmlXsiTypeConverter));
                                 } else {
-                                    jsonObject.accumulate(config.getcDataTagName(),
-                                            config.isKeepStrings() ? string : stringToValue(string));
+                                    Object obj = stringToValue((String) token);
+                                    if (obj instanceof Boolean) {
+                                        jsonObject.accumulate(config.getcDataTagName(),
+                                                config.isKeepBooleanAsString()
+                                                        ? ((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));
+                                    }
                                 }
                             }
 
                         } else if (token == LT) {
                             // Nested element
-                            if (parse(x, jsonObject, tagName, config)) {
+                            if (currentNestingDepth == config.getMaxNestingDepth()) {
+                                throw x.syntaxError("Maximum nesting depth of " + config.getMaxNestingDepth() + " reached");
+                            }
+
+                            if (parse(x, jsonObject, tagName, config, currentNestingDepth + 1)) {
                                 if (config.getForceList().contains(tagName)) {
                                     // Force the value to be an array
                                     if (jsonObject.length() == 0) {
@@ -420,10 +465,13 @@ public class XML {
                                             && jsonObject.opt(config.getcDataTagName()) != null) {
                                         context.accumulate(tagName, jsonObject.opt(config.getcDataTagName()));
                                     } else {
+                                        if (!config.shouldTrimWhiteSpace()) {
+                                            removeEmpty(jsonObject, config);
+                                        }
                                         context.accumulate(tagName, jsonObject);
                                     }
                                 }
-                                
+
                                 return false;
                             }
                         }
@@ -434,6 +482,118 @@ public class XML {
             }
         }
     }
+    /**
+     * This method removes any JSON entry which has the key set by XMLParserConfiguration.cDataTagName
+     * and contains whitespace as this is caused by whitespace between tags. See test XMLTest.testNestedWithWhitespaceTrimmingDisabled.
+     * @param jsonObject JSONObject which may require deletion
+     * @param config The XMLParserConfiguration which includes the cDataTagName
+     */
+    private static void removeEmpty(final JSONObject jsonObject, final XMLParserConfiguration config) {
+        if (jsonObject.has(config.getcDataTagName()))  {
+            final Object s = jsonObject.get(config.getcDataTagName());
+            if (s instanceof String) {
+                if (isStringAllWhiteSpace(s.toString())) {
+                    jsonObject.remove(config.getcDataTagName());
+                }
+            }
+            else if (s instanceof JSONArray) {
+                final JSONArray sArray = (JSONArray) s;
+                for (int k = sArray.length()-1; k >= 0; k--){
+                    final Object eachString = sArray.get(k);
+                    if (eachString instanceof String) {
+                        String s1 = (String) eachString;
+                        if (isStringAllWhiteSpace(s1)) {
+                            sArray.remove(k);
+                        }
+                    }
+                }
+                if (sArray.isEmpty()) {
+                    jsonObject.remove(config.getcDataTagName());
+                }
+            }
+        }
+    }
+
+    private static boolean isStringAllWhiteSpace(final String s) {
+        for (int k = 0; k<s.length(); k++){
+            final char eachChar = s.charAt(k);
+            if (!Character.isWhitespace(eachChar)) {
+                return false;
+            }
+        }
+        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
@@ -487,78 +647,6 @@ public class XML {
         }
         return string;
     }
-    
-    /**
-     * 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);
-    }
-
 
     /**
      * Convert a well-formed (but not necessarily valid) XML string into a
@@ -568,7 +656,7 @@ public class XML {
      * 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 
+     * "content" member. Comments, prologs, DTDs, and <pre>{@code
      * &lt;[ [ ]]>}</pre>
      * are ignored.
      *
@@ -589,7 +677,7 @@ public class XML {
      * 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 
+     * "content" member. Comments, prologs, DTDs, and <pre>{@code
      * &lt;[ [ ]]>}</pre>
      * are ignored.
      *
@@ -629,6 +717,44 @@ 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
@@ -651,11 +777,11 @@ public class XML {
      */
     public static JSONObject toJSONObject(Reader reader, XMLParserConfiguration config) throws JSONException {
         JSONObject jo = new JSONObject();
-        XMLTokener x = new XMLTokener(reader);
+        XMLTokener x = new XMLTokener(reader, config);
         while (x.more()) {
             x.skipPast("<");
             if(x.more()) {
-                parse(x, jo, null, config);
+                parse(x, jo, null, config, 0);
             }
         }
         return jo;
@@ -669,7 +795,7 @@ public class XML {
      * 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 
+     * "content" member. Comments, prologs, DTDs, and <pre>{@code
      * &lt;[ [ ]]>}</pre>
      * are ignored.
      *
@@ -695,7 +821,39 @@ public class XML {
      * 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 
+     * "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
+     * 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.
      *
@@ -752,6 +910,28 @@ public class XML {
      */
     public static String toString(final Object object, final String tagName, final XMLParserConfiguration config)
             throws JSONException {
+        return toString(object, tagName, config, 0, 0);
+    }
+
+    /**
+     * Convert a JSONObject into a well-formed, element-normal XML string,
+     * either pretty print or single-lined depending on indent factor.
+     *
+     * @param object
+     *            A JSONObject.
+     * @param tagName
+     *            The optional name of the enclosing tag.
+     * @param config
+     *            Configuration that can control output to XML.
+     * @param indentFactor
+     *            The number of spaces to add to each level of indentation.
+     * @param indent
+     *            The current ident level in spaces.
+     * @return
+     * @throws JSONException
+     */
+    private static String toString(final Object object, final String tagName, final XMLParserConfiguration config, int indentFactor, int indent)
+            throws JSONException {
         StringBuilder sb = new StringBuilder();
         JSONArray ja;
         JSONObject jo;
@@ -761,9 +941,14 @@ public class XML {
 
             // Emit <tagName>
             if (tagName != null) {
+                sb.append(indent(indent));
                 sb.append('<');
                 sb.append(tagName);
                 sb.append('>');
+                if(indentFactor > 0){
+                    sb.append("\n");
+                    indent += indentFactor;
+                }
             }
 
             // Loop thru the keys.
@@ -806,31 +991,52 @@ public class XML {
                             sb.append('<');
                             sb.append(key);
                             sb.append('>');
-                            sb.append(toString(val, null, config));
+                            sb.append(toString(val, null, config, indentFactor, indent));
                             sb.append("</");
                             sb.append(key);
                             sb.append('>');
                         } else {
-                            sb.append(toString(val, key, config));
+                            sb.append(toString(val, key, config, indentFactor, indent));
                         }
                     }
                 } else if ("".equals(value)) {
-                    sb.append('<');
-                    sb.append(key);
-                    sb.append("/>");
+                    if (config.isCloseEmptyTag()){
+                        sb.append(indent(indent));
+                        sb.append('<');
+                        sb.append(key);
+                        sb.append(">");
+                        sb.append("</");
+                        sb.append(key);
+                        sb.append(">");
+                        if (indentFactor > 0) {
+                            sb.append("\n");
+                        }
+                    }else {
+                        sb.append(indent(indent));
+                        sb.append('<');
+                        sb.append(key);
+                        sb.append("/>");
+                        if (indentFactor > 0) {
+                            sb.append("\n");
+                        }
+                    }
 
                     // Emit a new tag <k>
 
                 } else {
-                    sb.append(toString(value, key, config));
+                    sb.append(toString(value, key, config, indentFactor, indent));
                 }
             }
             if (tagName != null) {
 
                 // Emit the </tagName> close tag
+                sb.append(indent(indent - indentFactor));
                 sb.append("</");
                 sb.append(tagName);
                 sb.append('>');
+                if(indentFactor > 0){
+                    sb.append("\n");
+                }
             }
             return sb.toString();
 
@@ -849,15 +1055,85 @@ public class XML {
                 // XML does not have good support for arrays. If an array
                 // appears in a place where XML is lacking, synthesize an
                 // <array> element.
-                sb.append(toString(val, tagName == null ? "array" : tagName, config));
+                sb.append(toString(val, tagName == null ? "array" : tagName, config, indentFactor, indent));
             }
             return sb.toString();
         }
 
-        string = (object == null) ? "null" : escape(object.toString());
-        return (tagName == null) ? "\"" + string + "\""
-                : (string.length() == 0) ? "<" + tagName + "/>" : "<" + tagName
-                        + ">" + string + "</" + tagName + ">";
 
+        string = (object == null) ? "null" : escape(object.toString());
+        String indentationSuffix = (indentFactor > 0) ? "\n" : "";
+        if(tagName == null){
+            return indent(indent) + "\"" + string + "\"" + indentationSuffix;
+        } else if(string.length() == 0){
+            return indent(indent) + "<" + tagName + "/>" + indentationSuffix;
+        } else {
+            return indent(indent) + "<" + tagName
+                    + ">" + string + "</" + tagName + ">" + indentationSuffix;
+        }
+    }
+
+    /**
+     * Convert a JSONObject into a well-formed, pretty printed element-normal XML string.
+     *
+     * @param object
+     *            A JSONObject.
+     * @param indentFactor
+     *            The number of spaces to add to each level of indentation.
+     * @return A string.
+     * @throws JSONException Thrown if there is an error parsing the string
+     */
+    public static String toString(Object object, int indentFactor){
+        return toString(object, null, XMLParserConfiguration.ORIGINAL, indentFactor);
+    }
+
+    /**
+     * Convert a JSONObject into a well-formed, pretty printed element-normal XML string.
+     *
+     * @param object
+     *            A JSONObject.
+     * @param tagName
+     *            The optional name of the enclosing tag.
+     * @param indentFactor
+     *            The number of spaces to add to each level of indentation.
+     * @return A string.
+     * @throws JSONException Thrown if there is an error parsing the string
+     */
+    public static String toString(final Object object, final String tagName, int indentFactor) {
+        return toString(object, tagName, XMLParserConfiguration.ORIGINAL, indentFactor);
+    }
+
+    /**
+     * Convert a JSONObject into a well-formed, pretty printed element-normal XML string.
+     *
+     * @param object
+     *            A JSONObject.
+     * @param tagName
+     *            The optional name of the enclosing tag.
+     * @param config
+     *            Configuration that can control output to XML.
+     * @param indentFactor
+     *            The number of spaces to add to each level of indentation.
+     * @return A string.
+     * @throws JSONException Thrown if there is an error parsing the string
+     */
+    public static String toString(final Object object, final String tagName, final XMLParserConfiguration config, int indentFactor)
+            throws JSONException {
+        return toString(object, tagName, config, indentFactor, 0);
+    }
+
+    /**
+     * Return a String consisting of a number of space characters specified by indent
+     *
+     * @param indent
+     *          The number of spaces to be appended to the String.
+     * @return
+     */
+    private static final String indent(int indent) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < indent; i++) {
+            sb.append(' ');
+        }
+        return sb.toString();
     }
 }

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

@@ -15,7 +15,23 @@ import java.util.Set;
  * @author AylwardJ
  */
 @SuppressWarnings({""})
-public class XMLParserConfiguration {
+public class XMLParserConfiguration extends ParserConfiguration {
+
+    /**
+     * The default maximum nesting depth when parsing a XML document to JSON.
+     */
+//    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();
@@ -23,19 +39,13 @@ public class XMLParserConfiguration {
     public static final XMLParserConfiguration KEEP_STRINGS
         = new XMLParserConfiguration().withKeepStrings(true);
 
-    /**
-     * When parsing the XML into JSON, 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)
-     */
-    private boolean keepStrings;
-    
     /**
      * 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
      * processing.
      */
     private String cDataTagName;
-    
+
     /**
      * When parsing the XML into JSON, specifies if values with attribute xsi:nil="true"
      * should be kept as attribute(<code>false</code>), or they should be converted to
@@ -43,6 +53,13 @@ public class XMLParserConfiguration {
      */
     private boolean convertNilAttributeToNull;
 
+    /**
+     * When creating an XML from JSON Object, an empty tag by default will self-close.
+     * If it has to be closed explicitly, with empty content between start and end tag,
+     * this flag is to be turned on.
+     */
+    private boolean closeEmptyTag;
+
     /**
      * This will allow type conversion for values in XML if xsi:type attribute is defined
      */
@@ -54,16 +71,26 @@ public class XMLParserConfiguration {
      */
     private Set<String> forceList;
 
+
+    /**
+     * Flag to indicate whether white space should be trimmed when parsing XML.
+     * The default behaviour is to trim white space. When this is set to false, inputting XML
+     * with tags that are the same as the value of cDataTagName is unsupported. It is recommended to set cDataTagName
+     * to a distinct value in this case.
+     */
+    private boolean shouldTrimWhiteSpace;
+
     /**
      * Default parser configuration. Does not keep strings (tries to implicitly convert
-     * values), and the CDATA Tag Name is "content".
+     * values), and the CDATA Tag Name is "content". Trims whitespace.
      */
     public XMLParserConfiguration () {
-        this.keepStrings = false;
+        super();
         this.cDataTagName = "content";
         this.convertNilAttributeToNull = false;
         this.xsiTypeMap = Collections.emptyMap();
         this.forceList = Collections.emptySet();
+        this.shouldTrimWhiteSpace = true;
     }
 
     /**
@@ -106,7 +133,7 @@ public class XMLParserConfiguration {
      */
     @Deprecated
     public XMLParserConfiguration (final boolean keepStrings, final String cDataTagName) {
-        this.keepStrings = keepStrings;
+        super(keepStrings, DEFAULT_MAXIMUM_NESTING_DEPTH);
         this.cDataTagName = cDataTagName;
         this.convertNilAttributeToNull = false;
     }
@@ -125,7 +152,9 @@ public class XMLParserConfiguration {
      */
     @Deprecated
     public XMLParserConfiguration (final boolean keepStrings, final String cDataTagName, final boolean convertNilAttributeToNull) {
-        this.keepStrings = keepStrings;
+        super(false, DEFAULT_MAXIMUM_NESTING_DEPTH);
+        this.keepNumberAsString = keepStrings;
+        this.keepBooleanAsString = keepStrings;
         this.cDataTagName = cDataTagName;
         this.convertNilAttributeToNull = convertNilAttributeToNull;
     }
@@ -140,15 +169,21 @@ public class XMLParserConfiguration {
      *                                  <code>false</code> to parse values with attribute xsi:nil="true" as {"xsi:nil":true}.
      * @param xsiTypeMap  <code>new HashMap<String, XMLXsiTypeConverter<?>>()</code> to parse values with attribute
      *                   xsi:type="integer" as integer,  xsi:type="string" as string
-     * @param forceList  <code>new HashSet<String>()</code> to parse the provided tags' values as arrays 
+     * @param forceList  <code>new HashSet<String>()</code> to parse the provided tags' values as arrays
+     * @param maxNestingDepth <code>int</code> to limit the nesting depth
+     * @param closeEmptyTag <code>boolean</code> to turn on explicit end tag for tag with empty value
      */
     private XMLParserConfiguration (final boolean keepStrings, final String cDataTagName,
-            final boolean convertNilAttributeToNull, final Map<String, XMLXsiTypeConverter<?>> xsiTypeMap, final Set<String> forceList ) {
-        this.keepStrings = keepStrings;
+            final boolean convertNilAttributeToNull, final Map<String, XMLXsiTypeConverter<?>> xsiTypeMap, final Set<String> forceList,
+            final int maxNestingDepth, final boolean closeEmptyTag, final boolean keepNumberAsString, final boolean keepBooleanAsString) {
+        super(false, maxNestingDepth);
+        this.keepNumberAsString = keepNumberAsString;
+        this.keepBooleanAsString = keepBooleanAsString;
         this.cDataTagName = cDataTagName;
         this.convertNilAttributeToNull = convertNilAttributeToNull;
         this.xsiTypeMap = Collections.unmodifiableMap(xsiTypeMap);
         this.forceList = Collections.unmodifiableSet(forceList);
+        this.closeEmptyTag = closeEmptyTag;
     }
 
     /**
@@ -161,37 +196,69 @@ public class XMLParserConfiguration {
         // item, a new map instance should be created and if possible each value in the
         // map should be cloned as well. If the values of the map are known to also
         // be immutable, then a shallow clone of the map is acceptable.
-        return new XMLParserConfiguration(
+        final XMLParserConfiguration config = new XMLParserConfiguration(
                 this.keepStrings,
                 this.cDataTagName,
                 this.convertNilAttributeToNull,
                 this.xsiTypeMap,
-                this.forceList
+                this.forceList,
+                this.maxNestingDepth,
+                this.closeEmptyTag,
+                this.keepNumberAsString,
+                this.keepBooleanAsString
         );
-    }
-    
-    /**
-     * When parsing the XML into JSON, 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)
-     * 
-     * @return The <code>keepStrings</code> configuration value.
-     */
-    public boolean isKeepStrings() {
-        return this.keepStrings;
+        config.shouldTrimWhiteSpace = this.shouldTrimWhiteSpace;
+        return config;
     }
 
     /**
      * When parsing the XML into JSON, 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.
-     * 
+     *
      * @return The existing configuration will not be modified. A new configuration is returned.
      */
+    @SuppressWarnings("unchecked")
+    @Override
     public XMLParserConfiguration withKeepStrings(final boolean newVal) {
         XMLParserConfiguration newConfig = this.clone();
         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;
     }
 
@@ -199,21 +266,41 @@ public class XMLParserConfiguration {
      * 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
      * processing.
-     * 
+     *
      * @return The <code>cDataTagName</code> configuration value.
      */
     public String getcDataTagName() {
         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
      * processing.
-     * 
+     *
      * @param newVal
      *      new value to use for the <code>cDataTagName</code> configuration option.
-     * 
+     *
      * @return The existing configuration will not be modified. A new configuration is returned.
      */
     public XMLParserConfiguration withcDataTagName(final String newVal) {
@@ -226,7 +313,7 @@ public class XMLParserConfiguration {
      * When parsing the XML into JSON, specifies if values with attribute xsi:nil="true"
      * should be kept as attribute(<code>false</code>), or they should be converted to
      * <code>null</code>(<code>true</code>)
-     * 
+     *
      * @return The <code>convertNilAttributeToNull</code> configuration value.
      */
     public boolean isConvertNilAttributeToNull() {
@@ -237,10 +324,10 @@ public class XMLParserConfiguration {
      * When parsing the XML into JSON, specifies if values with attribute xsi:nil="true"
      * should be kept as attribute(<code>false</code>), or they should be converted to
      * <code>null</code>(<code>true</code>)
-     * 
+     *
      * @param newVal
      *      new value to use for the <code>convertNilAttributeToNull</code> configuration option.
-     * 
+     *
      * @return The existing configuration will not be modified. A new configuration is returned.
      */
     public XMLParserConfiguration withConvertNilAttributeToNull(final boolean newVal) {
@@ -278,7 +365,7 @@ public class XMLParserConfiguration {
 
     /**
      * When parsing the XML into JSON, specifies that tags that will be converted to arrays
-     * in this configuration {@code Set<String>} to parse the provided tags' values as arrays 
+     * in this configuration {@code Set<String>} to parse the provided tags' values as arrays
      * @return <code>forceList</code> unmodifiable configuration set.
      */
     public Set<String> getForceList() {
@@ -287,8 +374,8 @@ public class XMLParserConfiguration {
 
     /**
      * When parsing the XML into JSON, specifies that tags that will be converted to arrays
-     * in this configuration {@code Set<String>} to parse the provided tags' values as arrays 
-     * @param forceList  {@code new HashSet<String>()} to parse the provided tags' values as arrays 
+     * in this configuration {@code Set<String>} to parse the provided tags' values as arrays
+     * @param forceList  {@code new HashSet<String>()} to parse the provided tags' values as arrays
      * @return The existing configuration will not be modified. A new configuration is returned.
      */
     public XMLParserConfiguration withForceList(final Set<String> forceList) {
@@ -297,4 +384,61 @@ public class XMLParserConfiguration {
         newConfig.forceList = Collections.unmodifiableSet(cloneForceList);
         return newConfig;
     }
+
+    /**
+     * Defines the maximum nesting depth that the parser will descend before throwing an exception
+     * when parsing the XML into JSON. The default max nesting depth is 512, which means the parser
+     * will throw a JsonException if 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
+     * @return The existing configuration will not be modified. A new configuration is returned.
+     */
+    @SuppressWarnings("unchecked")
+    @Override
+    public XMLParserConfiguration withMaxNestingDepth(int maxNestingDepth) {
+        return super.withMaxNestingDepth(maxNestingDepth);
+    }
+
+    /**
+     * To enable explicit end tag with empty value.
+     * @param closeEmptyTag new value for the closeEmptyTag property
+     * @return same instance of configuration with empty tag config updated
+     */
+    public XMLParserConfiguration withCloseEmptyTag(boolean closeEmptyTag){
+        XMLParserConfiguration clonedConfiguration = this.clone();
+        clonedConfiguration.closeEmptyTag = closeEmptyTag;
+        return clonedConfiguration;
+    }
+
+    /**
+     * Sets whether whitespace should be trimmed inside of tags. *NOTE* Do not use this if
+     * you expect your XML tags to have names that are the same as cDataTagName as this is unsupported.
+     * cDataTagName should be set to a distinct value in these cases.
+     * @param shouldTrimWhiteSpace boolean to set trimming on or off. Off is default.
+     * @return same instance of configuration with empty tag config updated
+     */
+    public XMLParserConfiguration withShouldTrimWhitespace(boolean shouldTrimWhiteSpace){
+        XMLParserConfiguration clonedConfiguration = this.clone();
+        clonedConfiguration.shouldTrimWhiteSpace = shouldTrimWhiteSpace;
+        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/XMLTokener.java

@@ -20,6 +20,8 @@ public class XMLTokener extends JSONTokener {
     */
    public static final java.util.HashMap<String, Character> entity;
 
+   private XMLParserConfiguration configuration = XMLParserConfiguration.ORIGINAL;
+
    static {
        entity = new java.util.HashMap<String, Character>(8);
        entity.put("amp",  XML.AMP);
@@ -45,6 +47,16 @@ public class XMLTokener extends JSONTokener {
         super(s);
     }
 
+    /**
+     * Construct an XMLTokener from a Reader and an XMLParserConfiguration.
+     * @param r A source reader.
+     * @param configuration the configuration that can be used to set certain flags
+     */
+    public XMLTokener(Reader r, XMLParserConfiguration configuration) {
+        super(r);
+        this.configuration = configuration;
+    }
+
     /**
      * Get the text in the CDATA block.
      * @return The string up to the <code>]]&gt;</code>.
@@ -83,7 +95,7 @@ public class XMLTokener extends JSONTokener {
         StringBuilder sb;
         do {
             c = next();
-        } while (Character.isWhitespace(c));
+        } while (Character.isWhitespace(c) && configuration.shouldTrimWhiteSpace());
         if (c == 0) {
             return null;
         }
@@ -97,7 +109,9 @@ public class XMLTokener extends JSONTokener {
             }
             if (c == '<') {
                 back();
-                return sb.toString().trim();
+                if (configuration.shouldTrimWhiteSpace()) {
+                    return sb.toString().trim();
+                } else return sb.toString();
             }
             if (c == '&') {
                 sb.append(nextEntity(c));

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

@@ -42,5 +42,12 @@ 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/junit/CDLTest.java

@@ -24,14 +24,13 @@ 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.
      */
-    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"
-    );
+    private static final String LINES = "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";
+
 
     /**
      * CDL.toJSONArray() adds all values as strings, with no filtering or 
@@ -39,12 +38,54 @@ public class CDLTest {
      * values all must be quoted in the cases where the JSONObject parsing 
      * might normally convert the value into a non-string. 
      */
-    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:\"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}]");
+    private static final String EXPECTED_LINES =
+            "[  " +
+                "{" +
+                    "\"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\":\"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.
@@ -127,6 +168,33 @@ 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.
      */
@@ -194,8 +262,7 @@ public class CDLTest {
     public void emptyString() {
         String emptyStr = "";
         JSONArray jsonArray = CDL.toJSONArray(emptyStr);
-        assertTrue("CDL should return null when the input string is empty",
-                jsonArray == null);
+		assertNull("CDL should return null when the input string is empty", jsonArray);
     }
 
     /**
@@ -254,7 +321,7 @@ public class CDLTest {
         jsonObject.put("Col \r1", "V1");
         // \r will be filtered from value
         jsonObject.put("Col 2", "V2\r");
-        assertTrue("expected length should be 1",jsonArray.length() == 1);
+		assertEquals("expected length should be 1", 1, jsonArray.length());
         String cdlStr = CDL.toString(jsonArray);
         jsonObject = jsonArray.getJSONObject(0);
         assertTrue(cdlStr.contains("\"Col 1\""));
@@ -268,8 +335,15 @@ public class CDLTest {
      */
     @Test
     public void textToJSONArray() {
-        JSONArray jsonArray = CDL.toJSONArray(this.lines);
-        JSONArray expectedJsonArray = new JSONArray(this.expectedLines);
+        JSONArray jsonArray = CDL.toJSONArray(LINES);
+        JSONArray expectedJsonArray = new JSONArray(EXPECTED_LINES);
+        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);
     }
 
@@ -279,11 +353,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);
     }
 
@@ -293,10 +367,24 @@ public class CDLTest {
      */
     @Test
     public void textToJSONArrayAndBackToString() {
-        JSONArray jsonArray = CDL.toJSONArray(this.lines);
+        JSONArray jsonArray = CDL.toJSONArray(LINES);
         String jsonStr = CDL.toString(jsonArray);
         JSONArray finalJsonArray = CDL.toJSONArray(jsonStr);
-        JSONArray expectedJsonArray = new JSONArray(this.expectedLines);
+        JSONArray expectedJsonArray = new JSONArray(EXPECTED_LINES);
+        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

@@ -0,0 +1,107 @@
+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

@@ -6,9 +6,9 @@ Public Domain.
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotEquals;
 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;
 
@@ -29,10 +29,13 @@ import java.util.Map;
 import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONObject;
+import org.json.JSONParserConfiguration;
 import org.json.JSONPointerException;
 import org.json.JSONString;
 import org.json.JSONTokener;
+import org.json.ParserConfiguration;
 import org.json.junit.data.MyJsonString;
+import org.junit.Ignore;
 import org.junit.Test;
 
 import com.jayway.jsonpath.Configuration;
@@ -119,7 +122,7 @@ public class JSONArrayTest {
      * Expects a JSONException.
      */
     @Test
-    public void emptStr() {
+    public void emptyStr() {
         String str = "";
         try {
             assertNull("Should throw an exception", new JSONArray(str));
@@ -225,6 +228,19 @@ public class JSONArrayTest {
         Util.checkJSONArrayMaps(jaRaw);
         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.
@@ -257,6 +273,11 @@ 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),
@@ -369,16 +390,16 @@ public class JSONArrayTest {
                 "hello".equals(jsonArray.getString(4)));
         // doubles
         assertTrue("Array double",
-                new Double(23.45e-4).equals(jsonArray.getDouble(5)));
+                Double.valueOf(23.45e-4).equals(jsonArray.getDouble(5)));
         assertTrue("Array string double",
-                new Double(23.45).equals(jsonArray.getDouble(6)));
+                Double.valueOf(23.45).equals(jsonArray.getDouble(6)));
         assertTrue("Array double can be float",
-                new Float(23.45e-4f).equals(jsonArray.getFloat(5)));
+                Float.valueOf(23.45e-4f).equals(jsonArray.getFloat(5)));
         // ints
         assertTrue("Array value int",
-                new Integer(42).equals(jsonArray.getInt(7)));
+                Integer.valueOf(42).equals(jsonArray.getInt(7)));
         assertTrue("Array value string int",
-                new Integer(43).equals(jsonArray.getInt(8)));
+                Integer.valueOf(43).equals(jsonArray.getInt(8)));
         // nested objects
         JSONArray nestedJsonArray = jsonArray.getJSONArray(9);
         assertTrue("Array value JSONArray", nestedJsonArray != null);
@@ -386,9 +407,9 @@ public class JSONArrayTest {
         assertTrue("Array value JSONObject", nestedJsonObject != null);
         // longs
         assertTrue("Array value long",
-                new Long(0).equals(jsonArray.getLong(11)));
+                Long.valueOf(0).equals(jsonArray.getLong(11)));
         assertTrue("Array value string long",
-                new Long(-1).equals(jsonArray.getLong(12)));
+                Long.valueOf(-1).equals(jsonArray.getLong(12)));
 
         assertTrue("Array value null", jsonArray.isNull(-1));
         Util.checkJSONArrayMaps(jsonArray);
@@ -461,6 +482,30 @@ public class JSONArrayTest {
         Util.checkJSONArrayMaps(jsonArray);
     }
 
+    /**
+     * The JSON parser is permissive of unambiguous unquoted keys and values.
+     * Such JSON text should be allowed, even if it does not strictly conform
+     * to the spec. However, after being parsed, toString() should emit strictly
+     * conforming JSON text.  
+     */
+    @Test
+    public void unquotedText() {
+        String str = "[value1, something!, (parens), foo@bar.com, 23, 23+45]";
+        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 
      * comma-separated string. Since this is very nearly a JSON document,
@@ -538,43 +583,75 @@ public class JSONArrayTest {
         assertTrue("Array opt boolean implicit default",
                 Boolean.FALSE == jsonArray.optBoolean(-1));
 
+         assertTrue("Array opt boolean object",
+                Boolean.TRUE.equals(jsonArray.optBooleanObject(0)));
+        assertTrue("Array opt boolean object default",
+                Boolean.FALSE.equals(jsonArray.optBooleanObject(-1, Boolean.FALSE)));
+        assertTrue("Array opt boolean object implicit default",
+                Boolean.FALSE.equals(jsonArray.optBooleanObject(-1)));
+
         assertTrue("Array opt double",
-                new Double(23.45e-4).equals(jsonArray.optDouble(5)));
+                Double.valueOf(23.45e-4).equals(jsonArray.optDouble(5)));
         assertTrue("Array opt double default",
-                new Double(1).equals(jsonArray.optDouble(0, 1)));
+                Double.valueOf(1).equals(jsonArray.optDouble(0, 1)));
         assertTrue("Array opt double default implicit",
-           new Double(jsonArray.optDouble(99)).isNaN());
+           Double.valueOf(jsonArray.optDouble(99)).isNaN());
+
+        assertTrue("Array opt double object",
+                Double.valueOf(23.45e-4).equals(jsonArray.optDoubleObject(5)));
+        assertTrue("Array opt double object default",
+                Double.valueOf(1).equals(jsonArray.optDoubleObject(0, 1D)));
+        assertTrue("Array opt double object default implicit",
+                jsonArray.optDoubleObject(99).isNaN());
 
         assertTrue("Array opt float",
-                new Float(23.45e-4).equals(jsonArray.optFloat(5)));
+                Float.valueOf(Double.valueOf(23.45e-4).floatValue()).equals(jsonArray.optFloat(5)));
         assertTrue("Array opt float default",
-                new Float(1).equals(jsonArray.optFloat(0, 1)));
+                Float.valueOf(1).equals(jsonArray.optFloat(0, 1)));
         assertTrue("Array opt float default implicit",
-           new Float(jsonArray.optFloat(99)).isNaN());
+           Float.valueOf(jsonArray.optFloat(99)).isNaN());
+
+        assertTrue("Array opt float object",
+                Float.valueOf(23.45e-4F).equals(jsonArray.optFloatObject(5)));
+        assertTrue("Array opt float object default",
+                Float.valueOf(1).equals(jsonArray.optFloatObject(0, 1F)));
+        assertTrue("Array opt float object default implicit",
+                jsonArray.optFloatObject(99).isNaN());
 
         assertTrue("Array opt Number",
                 BigDecimal.valueOf(23.45e-4).equals(jsonArray.optNumber(5)));
         assertTrue("Array opt Number default",
-                new Double(1).equals(jsonArray.optNumber(0, 1d)));
+                Double.valueOf(1).equals(jsonArray.optNumber(0, 1d)));
         assertTrue("Array opt Number default implicit",
-           new Double(jsonArray.optNumber(99,Double.NaN).doubleValue()).isNaN());
+           Double.valueOf(jsonArray.optNumber(99,Double.NaN).doubleValue()).isNaN());
 
         assertTrue("Array opt int",
-                new Integer(42).equals(jsonArray.optInt(7)));
+                Integer.valueOf(42).equals(jsonArray.optInt(7)));
         assertTrue("Array opt int default",
-                new Integer(-1).equals(jsonArray.optInt(0, -1)));
+                Integer.valueOf(-1).equals(jsonArray.optInt(0, -1)));
         assertTrue("Array opt int default implicit",
                 0 == jsonArray.optInt(0));
 
+        assertTrue("Array opt int object",
+                Integer.valueOf(42).equals(jsonArray.optIntegerObject(7)));
+        assertTrue("Array opt int object default",
+                Integer.valueOf(-1).equals(jsonArray.optIntegerObject(0, -1)));
+        assertTrue("Array opt int object default implicit",
+                Integer.valueOf(0).equals(jsonArray.optIntegerObject(0)));
+
         JSONArray nestedJsonArray = jsonArray.optJSONArray(9);
         assertTrue("Array opt JSONArray", nestedJsonArray != null);
-        assertTrue("Array opt JSONArray default", 
+        assertTrue("Array opt JSONArray null",
                 null == jsonArray.optJSONArray(99));
+        assertTrue("Array opt JSONArray default",
+                "value".equals(jsonArray.optJSONArray(99, new JSONArray("[\"value\"]")).getString(0)));
 
         JSONObject nestedJsonObject = jsonArray.optJSONObject(10);
         assertTrue("Array opt JSONObject", nestedJsonObject != null);
-        assertTrue("Array opt JSONObject default", 
+        assertTrue("Array opt JSONObject null",
                 null == jsonArray.optJSONObject(99));
+        assertTrue("Array opt JSONObject default",
+                "value".equals(jsonArray.optJSONObject(99, new JSONObject("{\"key\":\"value\"}")).getString("key")));
 
         assertTrue("Array opt long",
                 0 == jsonArray.optLong(11));
@@ -583,6 +660,13 @@ public class JSONArrayTest {
         assertTrue("Array opt long default implicit",
                 0 == jsonArray.optLong(-1));
 
+        assertTrue("Array opt long object",
+                Long.valueOf(0).equals(jsonArray.optLongObject(11)));
+        assertTrue("Array opt long object default",
+                Long.valueOf(-2).equals(jsonArray.optLongObject(-1, -2L)));
+        assertTrue("Array opt long object default implicit",
+                Long.valueOf(0).equals(jsonArray.optLongObject(-1)));
+
         assertTrue("Array opt string",
                 "hello".equals(jsonArray.optString(4)));
         assertTrue("Array opt string default implicit",
@@ -600,10 +684,15 @@ public class JSONArrayTest {
     public void optStringConversion(){
         JSONArray ja = new JSONArray("[\"123\",\"true\",\"false\"]");
         assertTrue("unexpected optBoolean value",ja.optBoolean(1,false)==true);
+        assertTrue("unexpected optBooleanObject value",Boolean.valueOf(true).equals(ja.optBooleanObject(1,false)));
         assertTrue("unexpected optBoolean value",ja.optBoolean(2,true)==false);
+        assertTrue("unexpected optBooleanObject value",Boolean.valueOf(false).equals(ja.optBooleanObject(2,true)));
         assertTrue("unexpected optInt value",ja.optInt(0,0)==123);
+        assertTrue("unexpected optIntegerObject value",Integer.valueOf(123).equals(ja.optIntegerObject(0,0)));
         assertTrue("unexpected optLong value",ja.optLong(0,0)==123);
+        assertTrue("unexpected optLongObject value",Long.valueOf(123).equals(ja.optLongObject(0,0L)));
         assertTrue("unexpected optDouble value",ja.optDouble(0,0.0)==123.0);
+        assertTrue("unexpected optDoubleObject value",Double.valueOf(123.0).equals(ja.optDoubleObject(0,0.0)));
         assertTrue("unexpected optBigInteger value",ja.optBigInteger(0,BigInteger.ZERO).compareTo(new BigInteger("123"))==0);
         assertTrue("unexpected optBigDecimal value",ja.optBigDecimal(0,BigDecimal.ZERO).compareTo(new BigDecimal("123"))==0);
         Util.checkJSONArrayMaps(ja);
@@ -625,8 +714,8 @@ public class JSONArrayTest {
 
         String jsonArrayStr =
             "["+
-                "hello,"+
-                "world"+
+                "\"hello\","+
+                "\"world\""+
             "]";
         // 2
         jsonArray.put(new JSONArray(jsonArrayStr));
@@ -703,8 +792,8 @@ public class JSONArrayTest {
 
         String jsonArrayStr =
             "["+
-                "hello,"+
-                "world"+
+                "\"hello\","+
+                "\"world\""+
             "]";
         // 2
         jsonArray.put(2, new JSONArray(jsonArrayStr));
@@ -972,12 +1061,12 @@ public class JSONArrayTest {
         assertTrue("Array double [23.45e-4]",
                 new BigDecimal("0.002345").equals(it.next()));
         assertTrue("Array string double",
-                new Double(23.45).equals(Double.parseDouble((String)it.next())));
+                Double.valueOf(23.45).equals(Double.parseDouble((String)it.next())));
 
         assertTrue("Array value int",
-                new Integer(42).equals(it.next()));
+                Integer.valueOf(42).equals(it.next()));
         assertTrue("Array value string int",
-                new Integer(43).equals(Integer.parseInt((String)it.next())));
+                Integer.valueOf(43).equals(Integer.parseInt((String)it.next())));
 
         JSONArray nestedJsonArray = (JSONArray)it.next();
         assertTrue("Array value JSONArray", nestedJsonArray != null);
@@ -986,9 +1075,9 @@ public class JSONArrayTest {
         assertTrue("Array value JSONObject", nestedJsonObject != null);
 
         assertTrue("Array value long",
-                new Long(0).equals(((Number) it.next()).longValue()));
+                Long.valueOf(0).equals(((Number) it.next()).longValue()));
         assertTrue("Array value string long",
-                new Long(-1).equals(Long.parseLong((String) it.next())));
+                Long.valueOf(-1).equals(Long.parseLong((String) it.next())));
         assertTrue("should be at end of array", !it.hasNext());
         Util.checkJSONArraysMaps(new ArrayList<JSONArray>(Arrays.asList(
                 jsonArray, nestedJsonArray
@@ -1327,14 +1416,15 @@ public class JSONArrayTest {
     /**
     * Tests for stack overflow. See https://github.com/stleary/JSON-java/issues/654
     */
+    @Ignore("This test relies on system constraints and may not always pass. See: https://github.com/stleary/JSON-java/issues/821")
     @Test(expected = JSONException.class)
     public void issue654StackOverflowInputWellFormed() {
         //String input = new String(java.util.Base64.getDecoder().decode(base64Bytes));
-        final InputStream resourceAsStream = JSONObjectTest.class.getClassLoader().getResourceAsStream("Issue654WellFormedArray.json");
+        final InputStream resourceAsStream = JSONArrayTest.class.getClassLoader().getResourceAsStream("Issue654WellFormedArray.json");
         JSONTokener tokener = new JSONTokener(resourceAsStream);
         JSONArray json_input = new JSONArray(tokener);
         assertNotNull(json_input);
-        fail("Excepected Exception.");
+        fail("Excepected Exception due to stack overflow.");
         Util.checkJSONArrayMaps(json_input);
     }
 
@@ -1358,4 +1448,100 @@ public class JSONArrayTest {
                 .put(2);
         assertFalse(ja1.similar(ja3));
     }
+
+    @Test(expected = JSONException.class)
+    public void testRecursiveDepth() {
+      HashMap<String, Object> map = new HashMap<>();
+      map.put("t", map);
+      new JSONArray().put(map);
+    }
+
+    @Test(expected = JSONException.class)
+    public void testRecursiveDepthAtPosition() {
+      HashMap<String, Object> map = new HashMap<>();
+      map.put("t", map);
+      new JSONArray().put(0, map);
+    }
+
+    @Test(expected = JSONException.class)
+    public void testRecursiveDepthArray() {
+      ArrayList<Object> array = new ArrayList<>();
+      array.add(array);
+      new JSONArray(array);
+    }
+
+    @Test
+    public void testRecursiveDepthAtPositionDefaultObject() {
+        HashMap<String, Object> map = JSONObjectTest.buildNestedMap(ParserConfiguration.DEFAULT_MAXIMUM_NESTING_DEPTH);
+        new JSONArray().put(0, map);
+    }
+
+    @Test
+    public void testRecursiveDepthAtPosition1000Object() {
+        HashMap<String, Object> map = JSONObjectTest.buildNestedMap(1000);
+        new JSONArray().put(0, map, new JSONParserConfiguration().withMaxNestingDepth(1000));
+    }
+
+    @Test(expected = JSONException.class)
+    public void testRecursiveDepthAtPosition1001Object() {
+        HashMap<String, Object> map = JSONObjectTest.buildNestedMap(1001);
+        new JSONArray().put(0, map);
+    }
+
+    @Test(expected = JSONException.class)
+    public void testRecursiveDepthArrayLimitedMaps() {
+        ArrayList<Object> array = new ArrayList<>();
+        array.add(array);
+        new JSONArray(array);
+    }
+
+    @Test
+    public void testRecursiveDepthArrayForDefaultLevels() {
+        ArrayList<Object> array = buildNestedArray(ParserConfiguration.DEFAULT_MAXIMUM_NESTING_DEPTH);
+        new JSONArray(array, new JSONParserConfiguration());
+    }
+
+    @Test
+    public void testRecursiveDepthArrayFor1000Levels() {
+        try {
+            ArrayList<Object> array = buildNestedArray(1000);
+            JSONParserConfiguration parserConfiguration = new JSONParserConfiguration().withMaxNestingDepth(1000);
+            new JSONArray(array, parserConfiguration);
+        } catch (StackOverflowError e) {
+            String javaVersion = System.getProperty("java.version");
+            if (javaVersion.startsWith("11.")) {
+                System.out.println(
+                        "testRecursiveDepthArrayFor1000Levels() allowing intermittent stackoverflow, Java Version: "
+                                + javaVersion);
+            } else {
+                String errorStr = "testRecursiveDepthArrayFor1000Levels() unexpected stackoverflow, Java Version: "
+                        + javaVersion;
+                System.out.println(errorStr);
+                throw new RuntimeException(errorStr);
+            }
+        }
+    }
+
+    @Test(expected = JSONException.class)
+    public void testRecursiveDepthArrayFor1001Levels() {
+        ArrayList<Object> array = buildNestedArray(1001);
+        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<>();
+        }
+        ArrayList<Object> nestedArray = new ArrayList<>();
+        nestedArray.add(buildNestedArray(maxDepth - 1));
+        return nestedArray;
+    }
 }

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

@@ -11,19 +11,19 @@ import org.junit.Test;
 
 /**
  * Tests for org.json.JSONML.java
- * 
+ *
  * Certain inputs are expected to result in exceptions. These tests are
  * executed first. JSONML provides an API to:
- *     Convert an XML string into a JSONArray or a JSONObject. 
+ *     Convert an XML string into a JSONArray or a JSONObject.
  *     Convert a JSONArray or JSONObject into an XML string.
  * Both fromstring and tostring operations operations should be symmetrical
- * within the limits of JSONML. 
+ * within the limits of JSONML.
  * It should be possible to perform the following operations, which should
  * result in the original string being recovered, within the limits of the
  * underlying classes:
  *  Convert a string -> JSONArray -> string -> JSONObject -> string
  *  Convert a string -> JSONObject -> string -> JSONArray -> string
- * 
+ *
  */
 public class JSONMLTest {
 
@@ -56,7 +56,7 @@ public class JSONMLTest {
 
     /**
      * Attempts to call JSONML.toString() with a null JSONArray.
-     * Expects a NullPointerException. 
+     * Expects a NullPointerException.
      */
     @Test(expected=NullPointerException.class)
     public void nullJSONXMLException() {
@@ -69,7 +69,7 @@ public class JSONMLTest {
 
     /**
      * Attempts to call JSONML.toString() with a null JSONArray.
-     * Expects a JSONException. 
+     * Expects a JSONException.
      */
     @Test
     public void emptyJSONXMLException() {
@@ -125,7 +125,7 @@ public class JSONMLTest {
             "[\"addresses\","+
                 "{\"xsi:noNamespaceSchemaLocation\":\"test.xsd\","+
                     "\"xmlns:xsi\":\"http://www.w3.org/2001/XMLSchema-instance\"},"+
-                // this array has no name 
+                // this array has no name
                 "["+
                     "[\"name\"],"+
                     "[\"nocontent\"],"+
@@ -180,7 +180,7 @@ public class JSONMLTest {
     }
 
     /**
-     * Attempts to transform a malformed XML document 
+     * Attempts to transform a malformed XML document
      * (element tag has a frontslash) to a JSONArray.\
      * Expects a JSONException
      */
@@ -191,7 +191,7 @@ public class JSONMLTest {
          * In this case, the XML is invalid because the 'name' element
          * contains an invalid frontslash.
          */
-        String xmlStr = 
+        String xmlStr =
             "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"+
             "<addresses xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""+
             "   xsi:noNamespaceSchemaLocation='test.xsd'>\n"+
@@ -216,7 +216,7 @@ public class JSONMLTest {
      */
     @Test
     public void invalidBangInTagException() {
-        String xmlStr = 
+        String xmlStr =
             "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"+
             "<addresses xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""+
             "   xsi:noNamespaceSchemaLocation='test.xsd'>\n"+
@@ -246,7 +246,7 @@ public class JSONMLTest {
          * In this case, the XML is invalid because an element
          * starts with '!' and has no closing tag
          */
-        String xmlStr = 
+        String xmlStr =
             "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"+
             "<addresses xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""+
             "   xsi:noNamespaceSchemaLocation='test.xsd'>\n"+
@@ -276,7 +276,7 @@ public class JSONMLTest {
          * In this case, the XML is invalid because an element
          * has no closing '>'.
          */
-        String xmlStr = 
+        String xmlStr =
             "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"+
             "<addresses xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""+
             "   xsi:noNamespaceSchemaLocation='test.xsd'>\n"+
@@ -306,7 +306,7 @@ public class JSONMLTest {
          * In this case, the XML is invalid because an element
          * has no name after the closing tag '</'.
          */
-        String xmlStr = 
+        String xmlStr =
             "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"+
             "<addresses xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""+
             "   xsi:noNamespaceSchemaLocation='test.xsd'>\n"+
@@ -336,7 +336,7 @@ public class JSONMLTest {
          * In this case, the XML is invalid because an element
          * has '>' after the closing tag '</' and name.
          */
-        String xmlStr = 
+        String xmlStr =
             "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"+
             "<addresses xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""+
             "   xsi:noNamespaceSchemaLocation=\"test.xsd\">\n"+
@@ -364,9 +364,9 @@ public class JSONMLTest {
         /**
          * xmlStr contains XML text which is transformed into a JSONArray.
          * In this case, the XML is invalid because an element
-         * does not have a complete CDATA string. 
+         * does not have a complete CDATA string.
          */
-        String xmlStr = 
+        String xmlStr =
             "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"+
             "<addresses xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""+
             "   xsi:noNamespaceSchemaLocation='test.xsd'>\n"+
@@ -388,7 +388,7 @@ public class JSONMLTest {
     /**
      * Convert an XML document into a JSONArray, then use JSONML.toString()
      * to convert it into a string. This string is then converted back into
-     * a JSONArray. Both JSONArrays are compared against a control to 
+     * a JSONArray. Both JSONArrays are compared against a control to
      * confirm the contents.
      */
     @Test
@@ -405,7 +405,7 @@ public class JSONMLTest {
          * which is used to create a final JSONArray, which is also compared
          * against the expected JSONArray.
          */
-        String xmlStr = 
+        String xmlStr =
             "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"+
             "<addresses xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""+
                  "xsi:noNamespaceSchemaLocation='test.xsd'>\n"+
@@ -414,7 +414,7 @@ public class JSONMLTest {
                      "<nocontent/>>\n"+
                  "</address>\n"+
             "</addresses>";
-        String expectedStr = 
+        String expectedStr =
             "[\"addresses\","+
                 "{\"xsi:noNamespaceSchemaLocation\":\"test.xsd\","+
                     "\"xmlns:xsi\":\"http://www.w3.org/2001/XMLSchema-instance\"},"+
@@ -434,12 +434,12 @@ public class JSONMLTest {
     }
 
     /**
-     * Convert an XML document into a JSONObject. Use JSONML.toString() to 
+     * Convert an XML document into a JSONObject. Use JSONML.toString() to
      * convert it back into a string, and then re-convert it into a JSONObject.
      * Both JSONObjects are compared against a control JSONObject to confirm
      * the contents.
      * <p>
-     * Next convert the XML document into a JSONArray. Use JSONML.toString() to 
+     * Next convert the XML document into a JSONArray. Use JSONML.toString() to
      * convert it back into a string, and then re-convert it into a JSONArray.
      * Both JSONArrays are compared against a control JSONArray to confirm
      * the contents.
@@ -452,23 +452,23 @@ public class JSONMLTest {
         /**
          * xmlStr contains XML text which is transformed into a JSONObject,
          * restored to XML, transformed into a JSONArray, and then restored
-         * to XML again. Both JSONObject and JSONArray should contain the same 
+         * to XML again. Both JSONObject and JSONArray should contain the same
          * information and should produce the same XML, allowing for non-ordered
          * attributes.
-         * 
+         *
          * Transformation to JSONObject:
          *      The elementName is stored as a string where key="tagName"
          *      Attributes are simply stored as key/value pairs
          *      If the element has either content or child elements, they are stored
          *      in a jsonArray with key="childNodes".
-         * 
+         *
          * Transformation to JSONArray:
          *      1st entry = elementname
          *      2nd entry = attributes object (if present)
          *      3rd entry = content (if present)
          *      4th entry = child element JSONArrays (if present)
          */
-        String xmlStr = 
+        String xmlStr =
             "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"+
             "<addresses xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""+
                 "xsi:noNamespaceSchemaLocation='test.xsd'>\n"+
@@ -585,7 +585,7 @@ public class JSONMLTest {
                 "\"tagName\":\"addresses\""+
             "}";
 
-        String expectedJSONArrayStr = 
+        String expectedJSONArrayStr =
             "["+
                 "\"addresses\","+
                 "{"+
@@ -625,7 +625,7 @@ public class JSONMLTest {
                                 "\"subValue\","+
                                 "{\"svAttr\":\"svValue\"},"+
                                 "\"abc\""+
-                            "],"+
+                            "]"+
                         "],"+
                         "[\"value\",3],"+
                         "[\"value\",4.1],"+
@@ -645,12 +645,12 @@ public class JSONMLTest {
         JSONObject finalJsonObject = JSONML.toJSONObject(jsonObjectXmlToStr);
         Util.compareActualVsExpectedJsonObjects(finalJsonObject, expectedJsonObject);
 
-        // create a JSON array from the original string and make sure it 
+        // create a JSON array from the original string and make sure it
         // looks as expected
         JSONArray jsonArray = JSONML.toJSONArray(xmlStr);
         JSONArray expectedJsonArray = new JSONArray(expectedJSONArrayStr);
         Util.compareActualVsExpectedJsonArrays(jsonArray,expectedJsonArray);
-    
+
         // restore the XML, then make another JSONArray and make sure it
         // looks as expected
         String jsonArrayXmlToStr = JSONML.toString(jsonArray);
@@ -668,14 +668,14 @@ public class JSONMLTest {
      * Convert an XML document which contains embedded comments into
      * a JSONArray. Use JSONML.toString() to turn it into a string, then
      * reconvert it into a JSONArray. Compare both JSONArrays to a control
-     * JSONArray to confirm the contents. 
+     * JSONArray to confirm the contents.
      * <p>
      * This test shows how XML comments are handled.
      */
     @Test
     public void commentsInXML() {
 
-        String xmlStr = 
+        String xmlStr =
             "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"+
             "<!-- this is a comment -->\n"+
             "<addresses>\n"+
@@ -734,7 +734,7 @@ public class JSONMLTest {
         final String expectedJsonString = "[\"root\",[\"id\",\"01\"],[\"id\",\"1\"],[\"id\",\"00\"],[\"id\",\"0\"],[\"item\",{\"id\":\"01\"}],[\"title\",\"True\"]]";
         final JSONArray json = JSONML.toJSONArray(originalXml,true);
         assertEquals(expectedJsonString, json.toString());
-        
+
         final String reverseXml = JSONML.toString(json);
         assertEquals(originalXml, reverseXml);
     }
@@ -749,7 +749,7 @@ public class JSONMLTest {
         final String revertedXml = JSONML.toString(jsonArray);
         assertEquals(revertedXml, originalXml);
     }
-    
+
     /**
      * JSON string cannot be reverted to original xml. See test result in
      * comment below.
@@ -762,15 +762,15 @@ public class JSONMLTest {
         final String xml = JSONML.toString(originalObject);
         final JSONObject revertedObject = JSONML.toJSONObject(xml, false);
         final String newJson = revertedObject.toString();
-        assertTrue("JSON Objects are not similar",originalObject.similar(revertedObject));
-        assertEquals("original JSON does not equal the new JSON",originalJson, newJson);
+        assertTrue("JSON Objects are not similar", originalObject.similar(revertedObject));
+        assertTrue("JSON Strings are not similar", new JSONObject(originalJson).similar(new JSONObject(newJson)));
     }
 
 // these tests do not pass for the following reasons:
 // 1. Our XML parser does not handle generic HTML entities, only valid XML entities. Hence &nbsp;
 //     or other HTML specific entities would fail on reversability
 // 2. Our JSON implementation for storing the XML attributes uses the standard unordered map.
-//     This means that <tag attr1="v1" attr2="v2" /> can not be reversed reliably.  
+//     This means that <tag attr1="v1" attr2="v2" /> can not be reversed reliably.
 //
 //    /**
 //     * Test texts taken from jsonml.org. Currently our implementation FAILS this conversion but shouldn't.
@@ -783,13 +783,13 @@ public class JSONMLTest {
 //        final String expectedJsonString = "[\"table\",{\"class\" : \"MyTable\",\"style\" : \"background-color:yellow\"},[\"tr\",[\"td\",{\"class\" : \"MyTD\",\"style\" : \"border:1px solid black\"},\"#550758\"],[\"td\",{\"class\" : \"MyTD\",\"style\" : \"background-color:red\"},\"Example text here\"]],[\"tr\",[\"td\",{\"class\" : \"MyTD\",\"style\" : \"border:1px solid black\"},\"#993101\"],[\"td\",{\"class\" : \"MyTD\",\"style\" : \"background-color:green\"},\"127624015\"]],[\"tr\",[\"td\",{\"class\" : \"MyTD\",\"style\" : \"border:1px solid black\"},\"#E33D87\"],[\"td\",{\"class\" : \"MyTD\",\"style\" : \"background-color:blue\"},\"\u00A0\",[\"span\",{ \"style\" : \"background-color:maroon\" },\"\u00A9\"],\"\u00A0\"]]]";
 //        final JSONArray json = JSONML.toJSONArray(originalXml,true);
 //        final String actualJsonString = json.toString();
-//        
+//
 //        final String reverseXml = JSONML.toString(json);
 //        assertNotEquals(originalXml, reverseXml);
 //
 //        assertNotEquals(expectedJsonString, actualJsonString);
 //    }
-//    
+//
 //    /**
 //     * Test texts taken from jsonml.org but modified to have XML entities only.
 //     */
@@ -799,15 +799,15 @@ public class JSONMLTest {
 //        final String expectedJsonString = "[\"table\",{\"class\" : \"MyTable\",\"style\" : \"background-color:yellow\"},[\"tr\",[\"td\",{\"class\" : \"MyTD\",\"style\" : \"border:1px solid black\"},\"#550758\"],[\"td\",{\"class\" : \"MyTD\",\"style\" : \"background-color:red\"},\"Example text here\"]],[\"tr\",[\"td\",{\"class\" : \"MyTD\",\"style\" : \"border:1px solid black\"},\"#993101\"],[\"td\",{\"class\" : \"MyTD\",\"style\" : \"background-color:green\"},\"127624015\"]],[\"tr\",[\"td\",{\"class\" : \"MyTD\",\"style\" : \"border:1px solid black\"},\"#E33D87\"],[\"td\",{\"class\" : \"MyTD\",\"style\" : \"background-color:blue\"},\"&\",[\"span\",{ \"style\" : \"background-color:maroon\" },\">\"],\"<\"]]]";
 //        final JSONArray jsonML = JSONML.toJSONArray(originalXml,true);
 //        final String actualJsonString = jsonML.toString();
-//        
+//
 //        final String reverseXml = JSONML.toString(jsonML);
 //        // currently not equal because the hashing of the attribute objects makes the attribute
-//        // order not happen the same way twice 
+//        // order not happen the same way twice
 //        assertEquals(originalXml, reverseXml);
 //
 //        assertEquals(expectedJsonString, actualJsonString);
 //    }
-    
+
     @Test (timeout = 6000)
     public void testIssue484InfinteLoop1() {
         try {
@@ -819,11 +819,11 @@ public class JSONMLTest {
                     ex.getMessage());
         }
     }
-    
+
     @Test (timeout = 6000)
     public void testIssue484InfinteLoop2() {
         try {
-            String input = "??*\n" + 
+            String input = "??*\n" +
                     "??|?CglR??`??>?w??PIlr??D?$?-?o??O?*??{OD?Y??`2a????NM?bq?:O?>S$?J?B.gUK?m\b??zE???!v]?
???
???c??????h???s???g???`?qbi??:Zl?)?}1^??k?0??:$V?$?Ovs(}J??????2;gQ?
???Tg?K?`?h%c?hmGA?<!C*?9?~?t?)??,zA???S}?Q??.q?j????]";
          JSONML.toJSONObject(input);
             fail("Exception expected for invalid JSON.");
@@ -833,4 +833,157 @@ public class JSONMLTest {
                     ex.getMessage());
         }
     }
+
+    @Test
+    public void testToJSONArrayMaxNestingDepthOf42IsRespected() {
+        final String wayTooLongMalformedXML = new String(new char[6000]).replace("\0", "<a>");
+
+        final int maxNestingDepth = 42;
+
+        try {
+            JSONML.toJSONArray(wayTooLongMalformedXML, JSONMLParserConfiguration.ORIGINAL.withMaxNestingDepth(maxNestingDepth));
+
+            fail("Expecting a JSONException");
+        } catch (JSONException e) {
+            assertTrue("Wrong throwable thrown: not expecting message <" + e.getMessage() + ">",
+                e.getMessage().startsWith("Maximum nesting depth of " + maxNestingDepth));
+        }
+    }
+
+
+    @Test
+    public void testToJSONArrayMaxNestingDepthIsRespectedWithValidXML() {
+        final String perfectlyFineXML = "<Test>\n" +
+            "  <employee>\n" +
+            "    <name>sonoo</name>\n" +
+            "    <salary>56000</salary>\n" +
+            "    <married>true</married>\n" +
+            "  </employee>\n" +
+            "</Test>\n";
+
+        final int maxNestingDepth = 1;
+
+        try {
+            JSONML.toJSONArray(perfectlyFineXML, JSONMLParserConfiguration.ORIGINAL.withMaxNestingDepth(maxNestingDepth));
+
+            fail("Expecting a JSONException");
+        } catch (JSONException e) {
+            assertTrue("Wrong throwable thrown: not expecting message <" + e.getMessage() + ">",
+                e.getMessage().startsWith("Maximum nesting depth of " + maxNestingDepth));
+        }
+    }
+
+    @Test
+    public void testToJSONArrayMaxNestingDepthWithValidFittingXML() {
+        final String perfectlyFineXML = "<Test>\n" +
+            "  <employee>\n" +
+            "    <name>sonoo</name>\n" +
+            "    <salary>56000</salary>\n" +
+            "    <married>true</married>\n" +
+            "  </employee>\n" +
+            "</Test>\n";
+
+        final int maxNestingDepth = 3;
+
+        try {
+            JSONML.toJSONArray(perfectlyFineXML, JSONMLParserConfiguration.ORIGINAL.withMaxNestingDepth(maxNestingDepth));
+        } catch (JSONException e) {
+            e.printStackTrace();
+            fail("XML document should be parsed as its maximum depth fits the maxNestingDepth " +
+                "parameter of the JSONMLParserConfiguration used");
+        }
+    }
+
+
+    @Test
+    public void testToJSONObjectMaxDefaultNestingDepthIsRespected() {
+        final String wayTooLongMalformedXML = new String(new char[6000]).replace("\0", "<a>");
+
+        try {
+            JSONML.toJSONObject(wayTooLongMalformedXML, JSONMLParserConfiguration.ORIGINAL);
+
+            fail("Expecting a JSONException");
+        } catch (JSONException e) {
+            assertTrue("Wrong throwable thrown: not expecting message <" + e.getMessage() + ">",
+                e.getMessage().startsWith("Maximum nesting depth of " + JSONMLParserConfiguration.DEFAULT_MAXIMUM_NESTING_DEPTH));
+        }
+    }
+
+    @Test
+    public void testToJSONObjectUnlimitedNestingDepthIsPossible() {
+        int actualDepth = JSONMLParserConfiguration.DEFAULT_MAXIMUM_NESTING_DEPTH +10;
+        final String deeperThanDefaultMax = new String(new char[actualDepth]).replace("\0", "<a>") +
+            "value" +
+            new String(new char[actualDepth]).replace("\0", "</a>");
+
+        try {
+            JSONML.toJSONObject(deeperThanDefaultMax, JSONMLParserConfiguration.ORIGINAL
+                .withMaxNestingDepth(JSONMLParserConfiguration.UNDEFINED_MAXIMUM_NESTING_DEPTH));
+        } catch (JSONException e) {
+            e.printStackTrace();
+            fail("XML document should be parsed beyond the default maximum depth if maxNestingDepth " +
+                "parameter is set to -1 in JSONMLParserConfiguration");
+        }
+    }
+
+
+    @Test
+    public void testToJSONObjectMaxNestingDepthOf42IsRespected() {
+        final String wayTooLongMalformedXML = new String(new char[6000]).replace("\0", "<a>");
+
+        final int maxNestingDepth = 42;
+
+        try {
+            JSONML.toJSONObject(wayTooLongMalformedXML, JSONMLParserConfiguration.ORIGINAL.withMaxNestingDepth(maxNestingDepth));
+
+            fail("Expecting a JSONException");
+        } catch (JSONException e) {
+            assertTrue("Wrong throwable thrown: not expecting message <" + e.getMessage() + ">",
+                e.getMessage().startsWith("Maximum nesting depth of " + maxNestingDepth));
+        }
+    }
+
+    @Test
+    public void testToJSONObjectMaxNestingDepthIsRespectedWithValidXML() {
+        final String perfectlyFineXML = "<Test>\n" +
+            "  <employee>\n" +
+            "    <name>sonoo</name>\n" +
+            "    <salary>56000</salary>\n" +
+            "    <married>true</married>\n" +
+            "  </employee>\n" +
+            "</Test>\n";
+
+        final int maxNestingDepth = 1;
+
+        try {
+            JSONML.toJSONObject(perfectlyFineXML, JSONMLParserConfiguration.ORIGINAL.withMaxNestingDepth(maxNestingDepth));
+
+            fail("Expecting a JSONException");
+        } catch (JSONException e) {
+            assertTrue("Wrong throwable thrown: not expecting message <" + e.getMessage() + ">",
+                e.getMessage().startsWith("Maximum nesting depth of " + maxNestingDepth));
+        }
+    }
+
+    @Test
+    public void testToJSONObjectMaxNestingDepthWithValidFittingXML() {
+        final String perfectlyFineXML = "<Test>\n" +
+            "  <employee>\n" +
+            "    <name>sonoo</name>\n" +
+            "    <salary>56000</salary>\n" +
+            "    <married>true</married>\n" +
+            "  </employee>\n" +
+            "</Test>\n";
+
+        final int maxNestingDepth = 3;
+
+        try {
+            JSONML.toJSONObject(perfectlyFineXML, JSONMLParserConfiguration.ORIGINAL.withMaxNestingDepth(maxNestingDepth));
+        } catch (JSONException e) {
+            e.printStackTrace();
+            fail("XML document should be parsed as its maximum depth fits the maxNestingDepth " +
+                "parameter of the JSONMLParserConfiguration used");
+        }
+    }
+
 }

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

@@ -36,25 +36,31 @@ public class JSONObjectLocaleTest {
 
         MyLocaleBean myLocaleBean = new MyLocaleBean();
 
-        /**
-         * This is just the control case which happens when the locale.ROOT
-         * lowercasing behavior is the same as the current locale.
-         */
-        Locale.setDefault(new Locale("en"));
-        JSONObject jsonen = new JSONObject(myLocaleBean);
-        assertEquals("expected size 2, found: " +jsonen.length(), 2, jsonen.length());
-        assertEquals("expected jsonen[i] == beanI", "beanI", jsonen.getString("i"));
-        assertEquals("expected jsonen[id] == beanId", "beanId", jsonen.getString("id"));
+        // save and restore the current default locale, to avoid any side effects on other executions in the same JVM
+        Locale defaultLocale = Locale.getDefault();
+        try {
+            /**
+             * This is just the control case which happens when the locale.ROOT
+             * lowercasing behavior is the same as the current locale.
+             */
+            Locale.setDefault(new Locale("en"));
+            JSONObject jsonen = new JSONObject(myLocaleBean);
+            assertEquals("expected size 2, found: " +jsonen.length(), 2, jsonen.length());
+            assertEquals("expected jsonen[i] == beanI", "beanI", jsonen.getString("i"));
+            assertEquals("expected jsonen[id] == beanId", "beanId", jsonen.getString("id"));
 
-        /**
-         * Without the JSON-Java change, these keys would be stored internally as
-         * starting with the letter, 'ı' (dotless i), since the lowercasing of
-         * the getI and getId keys would be specific to the Turkish locale.
-         */
-        Locale.setDefault(new Locale("tr"));
-        JSONObject jsontr = new JSONObject(myLocaleBean);
-        assertEquals("expected size 2, found: " +jsontr.length(), 2, jsontr.length());
-        assertEquals("expected jsontr[i] == beanI", "beanI", jsontr.getString("i"));
-        assertEquals("expected jsontr[id] == beanId", "beanId", jsontr.getString("id"));
+            /**
+             * Without the JSON-Java change, these keys would be stored internally as
+             * starting with the letter, 'ı' (dotless i), since the lowercasing of
+             * the getI and getId keys would be specific to the Turkish locale.
+             */
+            Locale.setDefault(new Locale("tr"));
+            JSONObject jsontr = new JSONObject(myLocaleBean);
+            assertEquals("expected size 2, found: " +jsontr.length(), 2, jsontr.length());
+            assertEquals("expected jsontr[i] == beanI", "beanI", jsontr.getString("i"));
+            assertEquals("expected jsontr[id] == beanId", "beanId", jsontr.getString("id"));
+        } finally {
+            Locale.setDefault(defaultLocale);
+        }
     }
 }

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

@@ -0,0 +1,146 @@
+package org.json.junit;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.Arrays;
+import java.util.Collection;
+
+import org.json.JSONObject;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(value = Parameterized.class)
+public class JSONObjectNumberTest {
+    private final String objectString;
+    private Integer value = 50;
+
+    @Parameters(name = "{index}: {0}")
+    public static Collection<Object[]> data() {
+        return Arrays.asList(new Object[][]{
+            {"{\"value\":50}", 1},
+            {"{\"value\":50.0}", 1},
+            {"{\"value\":5e1}", 1},
+            {"{\"value\":5E1}", 1},
+            {"{\"value\":5e1}", 1},
+            {"{\"value\":\"50\"}", 1},
+            {"{\"value\":-50}", -1},
+            {"{\"value\":-50.0}", -1},
+            {"{\"value\":-5e1}", -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
+            // "{value:0x32}" // hex 50
+        });
+    }
+
+    public JSONObjectNumberTest(String objectString, int resultIsNegative) {
+        this.objectString = objectString;
+        this.value *= resultIsNegative;
+    }
+
+    private JSONObject object;
+
+    @Before
+    public void setJsonObject() {
+        object = new JSONObject(objectString);
+    }
+
+    @Test
+    public void testGetNumber() {
+        assertEquals(value.intValue(), object.getNumber("value").intValue());
+    }
+
+    @Test
+    public void testGetBigDecimal() {
+        assertTrue(BigDecimal.valueOf(value).compareTo(object.getBigDecimal("value")) == 0);
+    }
+
+    @Test
+    public void testGetBigInteger() {
+        assertEquals(BigInteger.valueOf(value), object.getBigInteger("value"));
+    }
+
+    @Test
+    public void testGetFloat() {
+        assertEquals(value.floatValue(), object.getFloat("value"), 0.0f);
+    }
+
+    @Test
+    public void testGetDouble() {
+        assertEquals(value.doubleValue(), object.getDouble("value"), 0.0d);
+    }
+
+    @Test
+    public void testGetInt() {
+        assertEquals(value.intValue(), object.getInt("value"));
+    }
+
+    @Test
+    public void testGetLong() {
+        assertEquals(value.longValue(), object.getLong("value"));
+    }
+
+    @Test
+    public void testOptNumber() {
+        assertEquals(value.intValue(), object.optNumber("value").intValue());
+    }
+
+    @Test
+    public void testOptBigDecimal() {
+        assertTrue(BigDecimal.valueOf(value).compareTo(object.optBigDecimal("value", null)) == 0);
+    }
+
+    @Test
+    public void testOptBigInteger() {
+        assertEquals(BigInteger.valueOf(value), object.optBigInteger("value", null));
+    }
+
+    @Test
+    public void testOptFloat() {
+        assertEquals(value.floatValue(), object.optFloat("value"), 0.0f);
+    }
+
+    @Test
+    public void testOptFloatObject() {
+        assertEquals((Float) value.floatValue(), object.optFloatObject("value"), 0.0f);
+    }
+
+    @Test
+    public void testOptDouble() {
+        assertEquals(value.doubleValue(), object.optDouble("value"), 0.0d);
+    }
+
+    @Test
+    public void testOptDoubleObject() {
+        assertEquals((Double) value.doubleValue(), object.optDoubleObject("value"), 0.0d);
+    }
+
+    @Test
+    public void testOptInt() {
+        assertEquals(value.intValue(), object.optInt("value"));
+    }
+
+    @Test
+    public void testOptIntegerObject() {
+        assertEquals((Integer) value.intValue(), object.optIntegerObject("value"));
+    }
+
+    @Test
+    public void testOptLong() {
+        assertEquals(value.longValue(), object.optLong("value"));
+    }
+
+    @Test
+    public void testOptLongObject() {
+        assertEquals((Long) value.longValue(), object.optLongObject("value"));
+    }
+}

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

@@ -0,0 +1,179 @@
+package org.json.junit;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.io.StringReader;
+
+import org.json.JSONObject;
+import org.json.junit.data.GenericBeanInt;
+import org.json.junit.data.MyEnum;
+import org.json.junit.data.MyNumber;
+import org.json.junit.data.PersonRecord;
+import org.junit.Ignore;
+import org.junit.Test;
+
+/**
+ * Tests for JSONObject support of Java record types.
+ * 
+ * NOTE: These tests are currently ignored because PersonRecord is not an actual Java record.
+ * The implementation now correctly detects actual Java records using reflection (Class.isRecord()).
+ * These tests will need to be enabled and run with Java 17+ where PersonRecord can be converted
+ * to an actual record type.
+ * 
+ * This ensures backward compatibility - regular classes with lowercase method names will not
+ * be treated as records unless they are actual Java record types.
+ */
+public class JSONObjectRecordTest {
+
+    /**
+     * Tests that JSONObject can be created from a record-style class.
+     * Record-style classes use accessor methods like name() instead of getName().
+     * 
+     * NOTE: Ignored until PersonRecord is converted to an actual Java record (requires Java 17+)
+     */
+    @Test
+    @Ignore("Requires actual Java record type - PersonRecord needs to be a real record (Java 17+)")
+    public void jsonObjectByRecord() {
+        PersonRecord person = new PersonRecord("John Doe", 30, true);
+        JSONObject jsonObject = new JSONObject(person);
+        
+        assertEquals("Expected 3 keys in the JSONObject", 3, jsonObject.length());
+        assertEquals("John Doe", jsonObject.get("name"));
+        assertEquals(30, jsonObject.get("age"));
+        assertEquals(true, jsonObject.get("active"));
+    }
+    
+    /**
+     * Test that Object methods (toString, hashCode, equals, etc.) are not included
+     * 
+     * NOTE: Ignored until PersonRecord is converted to an actual Java record (requires Java 17+)
+     */
+    @Test
+    @Ignore("Requires actual Java record type - PersonRecord needs to be a real record (Java 17+)")
+    public void recordStyleClassShouldNotIncludeObjectMethods() {
+        PersonRecord person = new PersonRecord("Jane Doe", 25, false);
+        JSONObject jsonObject = new JSONObject(person);
+        
+        // Should NOT include Object methods
+        assertFalse("Should not include toString", jsonObject.has("toString"));
+        assertFalse("Should not include hashCode", jsonObject.has("hashCode"));
+        assertFalse("Should not include equals", jsonObject.has("equals"));
+        assertFalse("Should not include clone", jsonObject.has("clone"));
+        assertFalse("Should not include wait", jsonObject.has("wait"));
+        assertFalse("Should not include notify", jsonObject.has("notify"));
+        assertFalse("Should not include notifyAll", jsonObject.has("notifyAll"));
+        
+        // Should only have the 3 record fields
+        assertEquals("Should only have 3 fields", 3, jsonObject.length());
+    }
+    
+    /**
+     * Test that enum methods are not included when processing an enum
+     */
+    @Test
+    public void enumsShouldNotIncludeEnumMethods() {
+        MyEnum myEnum = MyEnum.VAL1;
+        JSONObject jsonObject = new JSONObject(myEnum);
+        
+        // Should NOT include enum-specific methods like name(), ordinal(), values(), valueOf()
+        assertFalse("Should not include name method", jsonObject.has("name"));
+        assertFalse("Should not include ordinal method", jsonObject.has("ordinal"));
+        assertFalse("Should not include declaringClass", jsonObject.has("declaringClass"));
+        
+        // Enums should still work with traditional getters if they have any
+        // But should not pick up the built-in enum methods
+    }
+    
+    /**
+     * Test that Number subclass methods are not included
+     */
+    @Test
+    public void numberSubclassesShouldNotIncludeNumberMethods() {
+        MyNumber myNumber = new MyNumber();
+        JSONObject jsonObject = new JSONObject(myNumber);
+        
+        // Should NOT include Number methods like intValue(), longValue(), etc.
+        assertFalse("Should not include intValue", jsonObject.has("intValue"));
+        assertFalse("Should not include longValue", jsonObject.has("longValue"));
+        assertFalse("Should not include doubleValue", jsonObject.has("doubleValue"));
+        assertFalse("Should not include floatValue", jsonObject.has("floatValue"));
+        
+        // Should include the actual getter
+        assertTrue("Should include number", jsonObject.has("number"));
+        assertEquals("Should have 1 field", 1, jsonObject.length());
+    }
+    
+    /**
+     * Test that generic bean with get() and is() methods works correctly
+     */
+    @Test
+    public void genericBeanWithGetAndIsMethodsShouldNotBeIncluded() {
+        GenericBeanInt bean = new GenericBeanInt(42);
+        JSONObject jsonObject = new JSONObject(bean);
+        
+        // Should NOT include standalone get() or is() methods
+        assertFalse("Should not include standalone 'get' method", jsonObject.has("get"));
+        assertFalse("Should not include standalone 'is' method", jsonObject.has("is"));
+        
+        // Should include the actual getters
+        assertTrue("Should include genericValue field", jsonObject.has("genericValue"));
+        assertTrue("Should include a field", jsonObject.has("a"));
+    }
+    
+    /**
+     * Test that java.* classes don't have their methods picked up
+     */
+    @Test
+    public void javaLibraryClassesShouldNotIncludeTheirMethods() {
+        StringReader reader = new StringReader("test");
+        JSONObject jsonObject = new JSONObject(reader);
+        
+        // Should NOT include java.io.Reader methods like read(), reset(), etc.
+        assertFalse("Should not include read method", jsonObject.has("read"));
+        assertFalse("Should not include reset method", jsonObject.has("reset"));
+        assertFalse("Should not include ready method", jsonObject.has("ready"));
+        assertFalse("Should not include skip method", jsonObject.has("skip"));
+        
+        // Reader should produce empty JSONObject (no valid properties)
+        assertEquals("Reader should produce empty JSON", 0, jsonObject.length());
+    }
+    
+    /**
+     * Test mixed case - object with both traditional getters and record-style accessors
+     * 
+     * NOTE: Ignored until PersonRecord is converted to an actual Java record (requires Java 17+)
+     */
+    @Test
+    @Ignore("Requires actual Java record type - PersonRecord needs to be a real record (Java 17+)")
+    public void mixedGettersAndRecordStyleAccessors() {
+        // PersonRecord has record-style accessors: name(), age(), active()
+        // These should all be included
+        PersonRecord person = new PersonRecord("Mixed Test", 40, true);
+        JSONObject jsonObject = new JSONObject(person);
+        
+        assertEquals("Should have all 3 record-style fields", 3, jsonObject.length());
+        assertTrue("Should include name", jsonObject.has("name"));
+        assertTrue("Should include age", jsonObject.has("age"));
+        assertTrue("Should include active", jsonObject.has("active"));
+    }
+    
+    /**
+     * Test that methods starting with uppercase are not included (not valid record accessors)
+     * 
+     * NOTE: Ignored until PersonRecord is converted to an actual Java record (requires Java 17+)
+     */
+    @Test
+    @Ignore("Requires actual Java record type - PersonRecord needs to be a real record (Java 17+)")
+    public void methodsStartingWithUppercaseShouldNotBeIncluded() {
+        PersonRecord person = new PersonRecord("Test", 50, false);
+        JSONObject jsonObject = new JSONObject(person);
+        
+        // Record-style accessors must start with lowercase
+        // Methods like Name(), Age() (uppercase) should not be picked up
+        // Our PersonRecord only has lowercase accessors, which is correct
+        
+        assertEquals("Should only have lowercase accessors", 3, jsonObject.length());
+    }
+}

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

@@ -0,0 +1,624 @@
+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

@@ -72,8 +72,10 @@ public class JSONPointerTest {
 
     @Test
     public void queryByEmptyKeySubObject() {
-        assertEquals( "{\"\":\"empty key of an object with an empty key\",\"subKey\":\"Some" +
-                " other value\"}", query("/obj/").toString());
+        JSONObject json = new JSONObject("{\"\":\"empty key of an object with an empty key\",\"subKey\":\"Some" +
+                " other value\"}");
+        JSONObject obj = (JSONObject) query("/obj/");
+        assertTrue(json.similar(obj));
     }
 
     @Test
@@ -382,8 +384,7 @@ 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,6 +319,22 @@ 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,10 +16,7 @@ import java.io.InputStreamReader;
 import java.io.Reader;
 import java.io.StringReader;
 
-import org.json.JSONArray;
-import org.json.JSONException;
-import org.json.JSONObject;
-import org.json.JSONTokener;
+import org.json.*;
 import org.junit.Test;
 
 /**
@@ -98,7 +95,17 @@ public class JSONTokenerTest {
         checkValid(" []  ",JSONArray.class);
         checkValid("[1,2]",JSONArray.class);
         checkValid("\n\n[1,2]\n\n",JSONArray.class);
-        checkValid("1 2", String.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
@@ -313,4 +320,54 @@ public class JSONTokenerTest {
         assertEquals(0, t2.next());
         assertFalse(t2.more());
    }
+
+   @Test
+   public void testAutoClose(){
+       Reader reader = new StringReader("some test string");
+       try {
+           JSONTokener tokener = new JSONTokener(reader);
+           tokener.close();
+           tokener.next();
+       } catch (Exception exception){
+           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/StringBuilderWriterTest.java

@@ -0,0 +1,60 @@
+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

@@ -4,11 +4,6 @@ package org.json.junit;
 Public Domain.
 */
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
 import java.io.File;
 import java.io.FileReader;
 import java.io.FileWriter;
@@ -27,6 +22,8 @@ import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
 
+import static org.junit.Assert.*;
+
 
 /**
  * Tests for JSON-Java XML.java with XMLParserConfiguration.java
@@ -273,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/"+
@@ -557,6 +554,40 @@ public class XMLConfigurationTest {
         assertEquals(actualXML, resultXML);
     }
 
+    @Test
+    public void shouldHandleEmptyNodeValue()
+    {
+        JSONObject inputJSON = new JSONObject();
+        inputJSON.put("Emptyness", "");
+        String expectedXmlWithoutExplicitEndTag = "<Emptyness/>";
+        String expectedXmlWithExplicitEndTag = "<Emptyness></Emptyness>";
+        assertEquals(expectedXmlWithoutExplicitEndTag, XML.toString(inputJSON, null,
+                new XMLParserConfiguration().withCloseEmptyTag(false)));
+        assertEquals(expectedXmlWithExplicitEndTag, XML.toString(inputJSON, null,
+                new XMLParserConfiguration().withCloseEmptyTag(true)));
+    }
+
+    @Test
+    public void shouldKeepConfigurationIntactAndUpdateCloseEmptyTagChoice()
+    {
+        XMLParserConfiguration keepStrings = XMLParserConfiguration.KEEP_STRINGS;
+        XMLParserConfiguration keepStringsAndCloseEmptyTag = keepStrings.withCloseEmptyTag(true);
+        XMLParserConfiguration keepDigits = keepStringsAndCloseEmptyTag.withKeepStrings(false);
+        XMLParserConfiguration keepDigitsAndNoCloseEmptyTag = keepDigits.withCloseEmptyTag(false);
+        assertTrue(keepStrings.isKeepNumberAsString());
+        assertTrue(keepStrings.isKeepBooleanAsString());
+        assertFalse(keepStrings.isCloseEmptyTag());
+        assertTrue(keepStringsAndCloseEmptyTag.isKeepNumberAsString());
+        assertTrue(keepStringsAndCloseEmptyTag.isKeepBooleanAsString());
+        assertTrue(keepStringsAndCloseEmptyTag.isCloseEmptyTag());
+        assertFalse(keepDigits.isKeepNumberAsString());
+        assertFalse(keepDigits.isKeepBooleanAsString());
+        assertTrue(keepDigits.isCloseEmptyTag());
+        assertFalse(keepDigitsAndNoCloseEmptyTag.isKeepNumberAsString());
+        assertFalse(keepDigitsAndNoCloseEmptyTag.isKeepBooleanAsString());
+        assertFalse(keepDigitsAndNoCloseEmptyTag.isCloseEmptyTag());
+    }
+
     /**
      * Investigate exactly how the "content" keyword works
      */
@@ -739,6 +770,67 @@ public class XMLConfigurationTest {
         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.
      */
@@ -1051,6 +1143,29 @@ public class XMLConfigurationTest {
 
         Util.compareActualVsExpectedJsonObjects(jsonObject, expetedJsonObject);
     }
+
+    @Test
+    public void testMaxNestingDepthIsSet() {
+        XMLParserConfiguration xmlParserConfiguration = XMLParserConfiguration.ORIGINAL;
+
+        assertEquals(xmlParserConfiguration.getMaxNestingDepth(), XMLParserConfiguration.DEFAULT_MAXIMUM_NESTING_DEPTH);
+
+        xmlParserConfiguration = xmlParserConfiguration.withMaxNestingDepth(42);
+
+        assertEquals(xmlParserConfiguration.getMaxNestingDepth(), 42);
+
+        xmlParserConfiguration = xmlParserConfiguration.withMaxNestingDepth(0);
+
+        assertEquals(xmlParserConfiguration.getMaxNestingDepth(), 0);
+
+        xmlParserConfiguration = xmlParserConfiguration.withMaxNestingDepth(-31415926);
+
+        assertEquals(xmlParserConfiguration.getMaxNestingDepth(), XMLParserConfiguration.UNDEFINED_MAXIMUM_NESTING_DEPTH);
+
+        xmlParserConfiguration = xmlParserConfiguration.withMaxNestingDepth(Integer.MIN_VALUE);
+
+        assertEquals(xmlParserConfiguration.getMaxNestingDepth(), XMLParserConfiguration.UNDEFINED_MAXIMUM_NESTING_DEPTH);
+    }
     
     /**
      * Convenience method, given an input string and expected result,
@@ -1130,4 +1245,4 @@ public class XMLConfigurationTest {
             assertTrue("Error: " +e.getMessage(), false);
         }
     }
-}
+}

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

@@ -18,16 +18,11 @@ import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.Reader;
 import java.io.StringReader;
+import java.nio.charset.Charset;
 import java.util.HashMap;
 import java.util.Map;
 
-import org.json.JSONArray;
-import org.json.JSONException;
-import org.json.JSONObject;
-import org.json.JSONTokener;
-import org.json.XML;
-import org.json.XMLParserConfiguration;
-import org.json.XMLXsiTypeConverter;
+import org.json.*;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
@@ -272,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/"+
@@ -921,7 +916,7 @@ public class XMLTest {
             InputStream xmlStream = null;
             try {
                 xmlStream = XMLTest.class.getClassLoader().getResourceAsStream("Issue537.xml");
-                Reader xmlReader = new InputStreamReader(xmlStream);
+                Reader xmlReader = new InputStreamReader(xmlStream, Charset.forName("UTF-8"));
                 JSONObject actual = XML.toJSONObject(xmlReader, true);
                 InputStream jsonStream = null;
                 try {
@@ -1049,4 +1044,389 @@ public class XMLTest {
             fail("Expected to be unable to modify the config");
         } catch (Exception ignored) { }
     }
+
+    @Test
+    public void testIndentComplicatedJsonObject(){
+        String str = "{\n" +
+                "  \"success\": true,\n" +
+                "  \"error\": null,\n" +
+                "  \"response\": [\n" +
+                "    {\n" +
+                "      \"timestamp\": 1664917200,\n" +
+                "      \"dateTimeISO\": \"2022-10-05T00:00:00+03:00\",\n" +
+                "      \"loc\": {\n" +
+                "        \"lat\": 39.91987,\n" +
+                "        \"long\": 32.85427\n" +
+                "      },\n" +
+                "      \"place\": {\n" +
+                "        \"name\": \"ankara\",\n" +
+                "        \"state\": \"an\",\n" +
+                "        \"country\": \"tr\"\n" +
+                "      },\n" +
+                "      \"profile\": {\n" +
+                "        \"tz\": \"Europe/Istanbul\"\n" +
+                "      },\n" +
+                "      \"sun\": {\n" +
+                "        \"rise\": 1664941721,\n" +
+                "        \"riseISO\": \"2022-10-05T06:48:41+03:00\",\n" +
+                "        \"set\": 1664983521,\n" +
+                "        \"setISO\": \"2022-10-05T18:25:21+03:00\",\n" +
+                "        \"transit\": 1664962621,\n" +
+                "        \"transitISO\": \"2022-10-05T12:37:01+03:00\",\n" +
+                "        \"midnightSun\": false,\n" +
+                "        \"polarNight\": false,\n" +
+                "        \"twilight\": {\n" +
+                "          \"civilBegin\": 1664940106,\n" +
+                "          \"civilBeginISO\": \"2022-10-05T06:21:46+03:00\",\n" +
+                "          \"civilEnd\": 1664985136,\n" +
+                "          \"civilEndISO\": \"2022-10-05T18:52:16+03:00\",\n" +
+                "          \"nauticalBegin\": 1664938227,\n" +
+                "          \"nauticalBeginISO\": \"2022-10-05T05:50:27+03:00\",\n" +
+                "          \"nauticalEnd\": 1664987015,\n" +
+                "          \"nauticalEndISO\": \"2022-10-05T19:23:35+03:00\",\n" +
+                "          \"astronomicalBegin\": 1664936337,\n" +
+                "          \"astronomicalBeginISO\": \"2022-10-05T05:18:57+03:00\",\n" +
+                "          \"astronomicalEnd\": 1664988905,\n" +
+                "          \"astronomicalEndISO\": \"2022-10-05T19:55:05+03:00\"\n" +
+                "        }\n" +
+                "      },\n" +
+                "      \"moon\": {\n" +
+                "        \"rise\": 1664976480,\n" +
+                "        \"riseISO\": \"2022-10-05T16:28:00+03:00\",\n" +
+                "        \"set\": 1664921520,\n" +
+                "        \"setISO\": \"2022-10-05T01:12:00+03:00\",\n" +
+                "        \"transit\": 1664994240,\n" +
+                "        \"transitISO\": \"2022-10-05T21:24:00+03:00\",\n" +
+                "        \"underfoot\": 1664949360,\n" +
+                "        \"underfootISO\": \"2022-10-05T08:56:00+03:00\",\n" +
+                "        \"phase\": {\n" +
+                "          \"phase\": 0.3186,\n" +
+                "          \"name\": \"waxing gibbous\",\n" +
+                "          \"illum\": 71,\n" +
+                "          \"age\": 9.41,\n" +
+                "          \"angle\": 0.55\n" +
+                "        }\n" +
+                "      }\n" +
+                "    }\n" +
+                "  ]\n" +
+                "}" ;
+        JSONObject jsonObject = new JSONObject(str);
+        String actualIndentedXmlString = XML.toString(jsonObject, 1);
+        JSONObject actualJsonObject = XML.toJSONObject(actualIndentedXmlString);
+        String expected = "<success>true</success>\n" +
+                "<response>\n" +
+                " <dateTimeISO>2022-10-05T00:00:00+03:00</dateTimeISO>\n" +
+                " <loc>\n" +
+                "  <lat>39.91987</lat>\n" +
+                "  <long>32.85427</long>\n" +
+                " </loc>\n" +
+                " <moon>\n" +
+                "  <phase>\n" +
+                "   <phase>0.3186</phase>\n" +
+                "   <name>waxing gibbous</name>\n" +
+                "   <angle>0.55</angle>\n" +
+                "   <illum>71</illum>\n" +
+                "   <age>9.41</age>\n" +
+                "  </phase>\n" +
+                "  <setISO>2022-10-05T01:12:00+03:00</setISO>\n" +
+                "  <underfoot>1664949360</underfoot>\n" +
+                "  <set>1664921520</set>\n" +
+                "  <transit>1664994240</transit>\n" +
+                "  <transitISO>2022-10-05T21:24:00+03:00</transitISO>\n" +
+                "  <riseISO>2022-10-05T16:28:00+03:00</riseISO>\n" +
+                "  <rise>1664976480</rise>\n" +
+                "  <underfootISO>2022-10-05T08:56:00+03:00</underfootISO>\n" +
+                " </moon>\n" +
+                " <profile>\n" +
+                "  <tz>Europe/Istanbul</tz>\n" +
+                " </profile>\n" +
+                " <place>\n" +
+                "  <country>tr</country>\n" +
+                "  <name>ankara</name>\n" +
+                "  <state>an</state>\n" +
+                " </place>\n" +
+                " <sun>\n" +
+                "  <setISO>2022-10-05T18:25:21+03:00</setISO>\n" +
+                "  <midnightSun>false</midnightSun>\n" +
+                "  <set>1664983521</set>\n" +
+                "  <transit>1664962621</transit>\n" +
+                "  <polarNight>false</polarNight>\n" +
+                "  <transitISO>2022-10-05T12:37:01+03:00</transitISO>\n" +
+                "  <riseISO>2022-10-05T06:48:41+03:00</riseISO>\n" +
+                "  <rise>1664941721</rise>\n" +
+                "  <twilight>\n" +
+                "   <civilEnd>1664985136</civilEnd>\n" +
+                "   <astronomicalBegin>1664936337</astronomicalBegin>\n" +
+                "   <astronomicalEnd>1664988905</astronomicalEnd>\n" +
+                "   <astronomicalBeginISO>2022-10-05T05:18:57+03:00</astronomicalBeginISO>\n" +
+                "   <civilBegin>1664940106</civilBegin>\n" +
+                "   <nauticalEndISO>2022-10-05T19:23:35+03:00</nauticalEndISO>\n" +
+                "   <astronomicalEndISO>2022-10-05T19:55:05+03:00</astronomicalEndISO>\n" +
+                "   <nauticalBegin>1664938227</nauticalBegin>\n" +
+                "   <nauticalEnd>1664987015</nauticalEnd>\n" +
+                "   <nauticalBeginISO>2022-10-05T05:50:27+03:00</nauticalBeginISO>\n" +
+                "   <civilBeginISO>2022-10-05T06:21:46+03:00</civilBeginISO>\n" +
+                "   <civilEndISO>2022-10-05T18:52:16+03:00</civilEndISO>\n" +
+                "  </twilight>\n" +
+                " </sun>\n" +
+                " <timestamp>1664917200</timestamp>\n" +
+                "</response>\n" +
+                "<error>null</error>\n";
+        JSONObject expectedJsonObject = XML.toJSONObject(expected);
+        assertTrue(expectedJsonObject.similar(actualJsonObject));
+
+
+    }
+
+    @Test
+    public void shouldCreateExplicitEndTagWithEmptyValueWhenConfigured(){
+        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));
+        JSONObject actualJsonObject = XML.toJSONObject(xmlForm);
+        JSONObject expectedJsonObject = XML.toJSONObject(expectedXmlString);
+        assertTrue(expectedJsonObject.similar(actualJsonObject));
+    }
+
+    @Test
+    public void shouldNotCreateExplicitEndTagWithEmptyValueWhenNotConfigured(){
+        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));
+        JSONObject actualJsonObject = XML.toJSONObject(xmlForm);
+        JSONObject expectedJsonObject = XML.toJSONObject(expectedXmlString);
+        assertTrue(expectedJsonObject.similar(actualJsonObject));
+    }
+
+
+    @Test
+    public void testIndentSimpleJsonObject(){
+        String str = "{    \"employee\": {  \n" +
+                "        \"name\":       \"sonoo\",   \n" +
+                "        \"salary\":      56000,   \n" +
+                "        \"married\":    true  \n" +
+                "    }}";
+        JSONObject jsonObject = new JSONObject(str);
+        String actual = XML.toString(jsonObject, "Test", 2);
+        JSONObject actualJsonObject = XML.toJSONObject(actual);
+        String expected = "<Test>\n" +
+                "  <employee>\n" +
+                "    <name>sonoo</name>\n" +
+                "    <salary>56000</salary>\n" +
+                "    <married>true</married>\n" +
+                "  </employee>\n" +
+                "</Test>\n";
+        JSONObject expectedJsonObject = XML.toJSONObject(expected);
+        assertTrue(expectedJsonObject.similar(actualJsonObject));
+    }
+
+    @Test
+    public void testIndentSimpleJsonArray(){
+        String str = "[  \n" +
+                "    {\"name\":\"Ram\", \"email\":\"Ram@gmail.com\"},  \n" +
+                "    {\"name\":\"Bob\", \"email\":\"bob32@gmail.com\"}  \n" +
+                "]  ";
+        JSONArray jsonObject = new JSONArray(str);
+        String actual = XML.toString(jsonObject, 2);
+        JSONObject actualJsonObject = XML.toJSONObject(actual);
+        String expected = "<array>\n" +
+                "  <name>Ram</name>\n" +
+                "  <email>Ram@gmail.com</email>\n" +
+                "</array>\n" +
+                "<array>\n" +
+                "  <name>Bob</name>\n" +
+                "  <email>bob32@gmail.com</email>\n" +
+                "</array>\n";
+        JSONObject expectedJsonObject = XML.toJSONObject(expected);
+        assertTrue(expectedJsonObject.similar(actualJsonObject));
+
+
+    }
+
+    @Test
+    public void testIndentComplicatedJsonObjectWithArrayAndWithConfig(){
+        try (InputStream jsonStream = XMLTest.class.getClassLoader().getResourceAsStream("Issue593.json")) {
+            final JSONObject object = new JSONObject(new JSONTokener(jsonStream));
+            String actualString = XML.toString(object, null, XMLParserConfiguration.KEEP_STRINGS, 2);
+            try (InputStream xmlStream = XMLTest.class.getClassLoader().getResourceAsStream("Issue593.xml")) {
+                int bufferSize = 1024;
+                char[] buffer = new char[bufferSize];
+                StringBuilder expected = new StringBuilder();
+                Reader in = new InputStreamReader(xmlStream, "UTF-8");
+                for (int numRead; (numRead = in.read(buffer, 0, buffer.length)) > 0; ) {
+                    expected.append(buffer, 0, numRead);
+                }
+                assertTrue(XML.toJSONObject(expected.toString()).similar(XML.toJSONObject(actualString)));
+            }
+        } catch (IOException e) {
+            fail("file writer error: " +e.getMessage());
+        }
+    }
+
+    @Test
+    public void testMaxNestingDepthOf42IsRespected() {
+        final String wayTooLongMalformedXML = new String(new char[6000]).replace("\0", "<a>");
+
+        final int maxNestingDepth = 42;
+
+        try {
+            XML.toJSONObject(wayTooLongMalformedXML, XMLParserConfiguration.ORIGINAL.withMaxNestingDepth(maxNestingDepth));
+
+            fail("Expecting a JSONException");
+        } catch (JSONException e) {
+            assertTrue("Wrong throwable thrown: not expecting message <" + e.getMessage() + ">",
+                e.getMessage().startsWith("Maximum nesting depth of " + maxNestingDepth));
+        }
+    }
+
+    @Test
+    public void testMaxNestingDepthIsRespectedWithValidXML() {
+        final String perfectlyFineXML = "<Test>\n" +
+            "  <employee>\n" +
+            "    <name>sonoo</name>\n" +
+            "    <salary>56000</salary>\n" +
+            "    <married>true</married>\n" +
+            "  </employee>\n" +
+            "</Test>\n";
+
+        final int maxNestingDepth = 1;
+
+        try {
+            XML.toJSONObject(perfectlyFineXML, XMLParserConfiguration.ORIGINAL.withMaxNestingDepth(maxNestingDepth));
+
+            fail("Expecting a JSONException");
+        } catch (JSONException e) {
+            assertTrue("Wrong throwable thrown: not expecting message <" + e.getMessage() + ">",
+                e.getMessage().startsWith("Maximum nesting depth of " + maxNestingDepth));
+        }
+    }
+
+    @Test
+    public void testMaxNestingDepthWithValidFittingXML() {
+        final String perfectlyFineXML = "<Test>\n" +
+            "  <employee>\n" +
+            "    <name>sonoo</name>\n" +
+            "    <salary>56000</salary>\n" +
+            "    <married>true</married>\n" +
+            "  </employee>\n" +
+            "</Test>\n";
+
+        final int maxNestingDepth = 3;
+
+        try {
+            XML.toJSONObject(perfectlyFineXML, XMLParserConfiguration.ORIGINAL.withMaxNestingDepth(maxNestingDepth));
+        } catch (JSONException e) {
+            e.printStackTrace();
+            fail("XML document should be parsed as its maximum depth fits the maxNestingDepth " +
+                "parameter of the XMLParserConfiguration used");
+        }
+    }
+    @Test
+    public void testWithWhitespaceTrimmingDisabled() {
+        String originalXml = "<testXml> Test Whitespace String \t </testXml>";
+
+        JSONObject actualJson = XML.toJSONObject(originalXml, new XMLParserConfiguration().withShouldTrimWhitespace(false));
+        String expectedJsonString = "{\"testXml\":\" Test Whitespace String \t \"}";
+        JSONObject expectedJson = new JSONObject(expectedJsonString);
+        Util.compareActualVsExpectedJsonObjects(actualJson,expectedJson);
+    }
+    @Test
+    public void testNestedWithWhitespaceTrimmingDisabled() {
+        String originalXml =
+                "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"+
+                        "<addresses>\n"+
+                        "   <address>\n"+
+                        "      <name> Sherlock Holmes </name>\n"+
+                        "   </address>\n"+
+                        "</addresses>";
+
+        JSONObject actualJson = XML.toJSONObject(originalXml, new XMLParserConfiguration().withShouldTrimWhitespace(false));
+        String expectedJsonString = "{\"addresses\":{\"address\":{\"name\":\" Sherlock Holmes \"}}}";
+        JSONObject expectedJson = new JSONObject(expectedJsonString);
+        Util.compareActualVsExpectedJsonObjects(actualJson,expectedJson);
+    }
+    @Test
+    public void shouldTrimWhitespaceDoesNotSupportTagsEqualingCDataTagName() {
+    // When using withShouldTrimWhitespace = true, input containing tags with same name as cDataTagName is unsupported and should not be used in conjunction
+        String originalXml =
+                "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"+
+                        "<addresses>\n"+
+                        "   <address>\n"+
+                        "      <content> Sherlock Holmes </content>\n"+
+                        "   </address>\n"+
+                        "</addresses>";
+
+        JSONObject actualJson = XML.toJSONObject(originalXml, new XMLParserConfiguration().withShouldTrimWhitespace(false).withcDataTagName("content"));
+        String expectedJsonString = "{\"addresses\":{\"address\":[[\"\\n      \",\" Sherlock Holmes \",\"\\n   \"]]}}";
+        JSONObject expectedJson = new JSONObject(expectedJsonString);
+        Util.compareActualVsExpectedJsonObjects(actualJson,expectedJson);
+    }
+    @Test
+    public void shouldTrimWhitespaceEnabledDropsTagsEqualingCDataTagNameButValueRemains() {
+        String originalXml =
+                "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"+
+                        "<addresses>\n"+
+                        "   <address>\n"+
+                        "      <content> Sherlock Holmes </content>\n"+
+                        "   </address>\n"+
+                        "</addresses>";
+
+        JSONObject actualJson = XML.toJSONObject(originalXml, new XMLParserConfiguration().withShouldTrimWhitespace(true).withcDataTagName("content"));
+        String expectedJsonString = "{\"addresses\":{\"address\":\"Sherlock Holmes\"}}";
+        JSONObject expectedJson = new JSONObject(expectedJsonString);
+        Util.compareActualVsExpectedJsonObjects(actualJson,expectedJson);
+    }
+    @Test
+    public void testWithWhitespaceTrimmingEnabled() {
+        String originalXml = "<testXml> Test Whitespace String \t </testXml>";
+
+        JSONObject actualJson = XML.toJSONObject(originalXml, new XMLParserConfiguration().withShouldTrimWhitespace(true));
+        String expectedJsonString = "{\"testXml\":\"Test Whitespace String\"}";
+        JSONObject expectedJson = new JSONObject(expectedJsonString);
+        Util.compareActualVsExpectedJsonObjects(actualJson,expectedJson);
+    }
+    @Test
+    public void testWithWhitespaceTrimmingEnabledByDefault() {
+        String originalXml = "<testXml> Test Whitespace String \t </testXml>";
+
+        JSONObject actualJson = XML.toJSONObject(originalXml, new XMLParserConfiguration());
+        String expectedJsonString = "{\"testXml\":\"Test Whitespace String\"}";
+        JSONObject expectedJson = new JSONObject(expectedJsonString);
+        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

@@ -0,0 +1,81 @@
+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/java/org/json/junit/data/CustomClass.java

@@ -0,0 +1,23 @@
+package org.json.junit.data;
+
+public class CustomClass {
+  public int number;
+  public String name;
+  public Long longNumber;
+
+  public CustomClass() {}
+  public CustomClass (int number, String name, Long longNumber) {
+    this.number = number;
+    this.name = name;
+    this.longNumber = longNumber;
+  }
+  @Override
+  public boolean equals(Object o) {
+    CustomClass customClass = (CustomClass) o;
+
+    return (this.number == customClass.number
+    && this.name.equals(customClass.name)
+    && this.longNumber.equals(customClass.longNumber));
+  }
+}
+

src/test/java/org/json/junit/data/CustomClassA.java

@@ -0,0 +1,19 @@
+package org.json.junit.data;
+
+import java.math.BigInteger;
+
+public class CustomClassA {
+  public BigInteger largeInt;
+
+  public CustomClassA() {}
+  public CustomClassA(BigInteger largeInt) {
+    this.largeInt = largeInt;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    CustomClassA classA = (CustomClassA) o;
+    return this.largeInt.equals(classA.largeInt);
+  }
+}
+

src/test/java/org/json/junit/data/CustomClassB.java

@@ -0,0 +1,20 @@
+package org.json.junit.data;
+
+public class CustomClassB {
+  public int number;
+  public CustomClassC classC;
+
+  public CustomClassB() {}
+  public CustomClassB(int number, CustomClassC classC) {
+    this.number = number;
+    this.classC = classC;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    CustomClassB classB = (CustomClassB) o;
+    return this.number == classB.number
+    && this.classC.equals(classB.classC);
+  }
+}
+

src/test/java/org/json/junit/data/CustomClassC.java

@@ -0,0 +1,34 @@
+package org.json.junit.data;
+
+import org.json.JSONObject;
+
+public class CustomClassC {
+  public String stringName;
+  public Long longNumber;
+
+  public CustomClassC() {}
+  public CustomClassC(String stringName, Long longNumber) {
+    this.stringName = stringName;
+    this.longNumber = longNumber;
+  }
+
+  public JSONObject toJSON() {
+    JSONObject object = new JSONObject();
+    object.put("stringName", this.stringName);
+    object.put("longNumber", this.longNumber);
+    return object;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    CustomClassC classC = (CustomClassC) o;
+    return this.stringName.equals(classC.stringName)
+    && this.longNumber.equals(classC.longNumber);
+  }
+
+  @Override
+  public int hashCode() {
+    return java.util.Objects.hash(stringName, longNumber);
+  }
+}
+

src/test/java/org/json/junit/data/CustomClassD.java

@@ -0,0 +1,19 @@
+package org.json.junit.data;
+
+import java.util.List;
+
+public class CustomClassD {
+  public List<String> stringList;
+
+  public CustomClassD() {}
+  public CustomClassD(List<String> stringList) {
+    this.stringList = stringList;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    CustomClassD classD = (CustomClassD) o;
+    return this.stringList.equals(classD.stringList);
+  }
+}
+

src/test/java/org/json/junit/data/CustomClassE.java

@@ -0,0 +1,18 @@
+package org.json.junit.data;
+
+import java.util.List;
+
+public class CustomClassE {
+  public List<CustomClassC> listClassC;
+
+  public CustomClassE() {}
+  public CustomClassE(List<CustomClassC> listClassC) {
+    this.listClassC = listClassC;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    CustomClassE classE = (CustomClassE) o;
+    return this.listClassC.equals(classE.listClassC);
+  }
+}

src/test/java/org/json/junit/data/CustomClassF.java

@@ -0,0 +1,19 @@
+package org.json.junit.data;
+
+import java.util.List;
+
+public class CustomClassF {
+  public List<List<String>> listOfString;
+
+  public CustomClassF() {}
+  public CustomClassF(List<List<String>> listOfString) {
+    this.listOfString = listOfString;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    CustomClassF classF = (CustomClassF) o;
+    return this.listOfString.equals(classF.listOfString);
+  }
+}
+

src/test/java/org/json/junit/data/CustomClassG.java

@@ -0,0 +1,18 @@
+package org.json.junit.data;
+
+import java.util.Map;
+
+public class CustomClassG {
+  public Map<String, String> dataList;
+
+  public CustomClassG () {}
+  public CustomClassG (Map<String, String> dataList) {
+    this.dataList = dataList;
+  }
+
+  @Override
+  public boolean equals(Object object) {
+    CustomClassG classG = (CustomClassG) object;
+    return this.dataList.equals(classG.dataList);
+  }
+}

src/test/java/org/json/junit/data/CustomClassH.java

@@ -0,0 +1,22 @@
+package org.json.junit.data;
+
+import java.util.Map;
+import java.util.List;
+import java.util.ArrayList;
+
+public class CustomClassH {
+  public Map<String, List<Integer>> integerMap;
+
+  public CustomClassH() {}
+  public CustomClassH(Map<String, List<Integer>> integerMap) {
+    this.integerMap = integerMap;
+  }
+
+  @Override
+  public boolean equals(Object object) {
+    CustomClassH classH = (CustomClassH) object;
+    return this.integerMap.size() == classH.integerMap.size()
+    && this.integerMap.keySet().equals(classH.integerMap.keySet())
+    && new ArrayList<>(this.integerMap.values()).equals(new ArrayList<>(classH.integerMap.values()));
+  }
+}

src/test/java/org/json/junit/data/CustomClassI.java

@@ -0,0 +1,12 @@
+package org.json.junit.data;
+
+import java.util.Map;
+
+public class CustomClassI {
+    public Map<String, Map<String, Integer>> integerMap;
+
+    public CustomClassI() {}
+    public CustomClassI(Map<String, Map<String, Integer>> integerMap) {
+        this.integerMap = integerMap;
+    }
+}

src/test/java/org/json/junit/data/GenericBean.java

@@ -9,7 +9,7 @@ import java.io.StringReader;
  * @param <T>
  *            generic number value
  */
-public class GenericBean<T extends Number & Comparable<T>> implements MyBean {
+public class GenericBean<T extends Number> implements MyBean {
     /**
      * @param genericValue
      *            value to initiate with

src/test/java/org/json/junit/data/PersonRecord.java

@@ -0,0 +1,31 @@
+package org.json.junit.data;
+
+/**
+ * A test class that mimics Java record accessor patterns.
+ * Records use accessor methods without get/is prefixes (e.g., name() instead of getName()).
+ * This class simulates that behavior to test JSONObject's handling of such methods.
+ */
+public class PersonRecord {
+    private final String name;
+    private final int age;
+    private final boolean active;
+
+    public PersonRecord(String name, int age, boolean active) {
+        this.name = name;
+        this.age = age;
+        this.active = active;
+    }
+
+    // Record-style accessors (no "get" or "is" prefix)
+    public String name() {
+        return name;
+    }
+
+    public int age() {
+        return age;
+    }
+
+    public boolean active() {
+        return active;
+    }
+}

src/test/java/org/json/junit/data/WeirdList.java

@@ -12,7 +12,7 @@ import java.util.List;
  */
 public class WeirdList {
     /** */
-    private final List<Integer> list = new ArrayList();
+    private final List<Integer> list = new ArrayList<>();
 
     /**
      * @param vals
@@ -25,14 +25,14 @@ public class WeirdList {
      * @return a copy of the list
      */
     public List<Integer> get() {
-        return new ArrayList(this.list);
+        return new ArrayList<>(this.list);
     }
 
     /**
      * @return a copy of the list
      */
     public List<Integer> getALL() {
-        return new ArrayList(this.list);
+        return new ArrayList<>(this.list);
     }
 
     /**

src/test/resources/Issue593.json

@@ -0,0 +1,704 @@
+{
+ "success": true,
+ "error": null,
+ "response": [
+  {
+   "loc": {
+    "long": 31.25,
+    "lat": 30.063
+   },
+   "interval": "day",
+   "place": {
+    "name": "cairo",
+    "state": "qh",
+    "country": "eg"
+   },
+   "periods": [
+    {
+     "timestamp": 1665032400,
+     "validTime": "2022-10-06T07:00:00+02:00",
+     "dateTimeISO": "2022-10-06T07:00:00+02:00",
+     "maxTempC": 32,
+     "maxTempF": 90,
+     "minTempC": 19,
+     "minTempF": 66,
+     "avgTempC": 25,
+     "avgTempF": 78,
+     "tempC": null,
+     "tempF": null,
+     "maxFeelslikeC": 32,
+     "maxFeelslikeF": 89,
+     "minFeelslikeC": 21,
+     "minFeelslikeF": 70,
+     "avgFeelslikeC": 26,
+     "avgFeelslikeF": 80,
+     "feelslikeC": 21,
+     "feelslikeF": 70,
+     "maxDewpointC": 17,
+     "maxDewpointF": 63,
+     "minDewpointC": 11,
+     "minDewpointF": 52,
+     "avgDewpointC": 14,
+     "avgDewpointF": 58,
+     "dewpointC": 17,
+     "dewpointF": 63,
+     "maxHumidity": 77,
+     "minHumidity": 29,
+     "humidity": 77,
+     "pop": 0,
+     "precipMM": 0,
+     "precipIN": 0,
+     "iceaccum": null,
+     "iceaccumMM": null,
+     "iceaccumIN": null,
+     "snowCM": 0,
+     "snowIN": 0,
+     "pressureMB": 1015,
+     "pressureIN": 29.97,
+     "windDir": "N",
+     "windDirDEG": 353,
+     "windSpeedKTS": 5,
+     "windSpeedKPH": 9,
+     "windSpeedMPH": 6,
+     "windGustKTS": 21,
+     "windGustKPH": 40,
+     "windGustMPH": 25,
+     "windDirMax": "NNW",
+     "windDirMaxDEG": 342,
+     "windSpeedMaxKTS": 9,
+     "windSpeedMaxKPH": 16,
+     "windSpeedMaxMPH": 10,
+     "windDirMin": "N",
+     "windDirMinDEG": 353,
+     "windSpeedMinKTS": 1,
+     "windSpeedMinKPH": 2,
+     "windSpeedMinMPH": 1,
+     "windDir80m": "N",
+     "windDir80mDEG": 11,
+     "windSpeed80mKTS": 12,
+     "windSpeed80mKPH": 22,
+     "windSpeed80mMPH": 13,
+     "windGust80mKTS": 22,
+     "windGust80mKPH": 41,
+     "windGust80mMPH": 25,
+     "windDirMax80m": "NNW",
+     "windDirMax80mDEG": 343,
+     "windSpeedMax80mKTS": 22,
+     "windSpeedMax80mKPH": 41,
+     "windSpeedMax80mMPH": 25,
+     "windDirMin80m": "E",
+     "windDirMin80mDEG": 95,
+     "windSpeedMin80mKTS": 8,
+     "windSpeedMin80mKPH": 15,
+     "windSpeedMin80mMPH": 10,
+     "sky": 22,
+     "cloudsCoded": "FW",
+     "weather": "Mostly Sunny",
+     "weatherCoded": [],
+     "weatherPrimary": "Mostly Sunny",
+     "weatherPrimaryCoded": "::FW",
+     "icon": "fair.png",
+     "visibilityKM": 24.135,
+     "visibilityMI": 15,
+     "uvi": 6,
+     "solradWM2": 5608,
+     "solradMinWM2": 0,
+     "solradMaxWM2": 778,
+     "isDay": true,
+     "maxCoverage": "",
+     "sunrise": 1665028274,
+     "sunset": 1665070502,
+     "sunriseISO": "2022-10-06T05:51:14+02:00",
+     "sunsetISO": "2022-10-06T17:35:02+02:00"
+    },
+    {
+     "timestamp": 1665118800,
+     "validTime": "2022-10-07T07:00:00+02:00",
+     "dateTimeISO": "2022-10-07T07:00:00+02:00",
+     "maxTempC": 30,
+     "maxTempF": 86,
+     "minTempC": 19,
+     "minTempF": 66,
+     "avgTempC": 24,
+     "avgTempF": 76,
+     "tempC": null,
+     "tempF": null,
+     "maxFeelslikeC": 29,
+     "maxFeelslikeF": 85,
+     "minFeelslikeC": 19,
+     "minFeelslikeF": 67,
+     "avgFeelslikeC": 24,
+     "avgFeelslikeF": 76,
+     "feelslikeC": 19,
+     "feelslikeF": 67,
+     "maxDewpointC": 15,
+     "maxDewpointF": 60,
+     "minDewpointC": 10,
+     "minDewpointF": 50,
+     "avgDewpointC": 12,
+     "avgDewpointF": 54,
+     "dewpointC": 15,
+     "dewpointF": 60,
+     "maxHumidity": 77,
+     "minHumidity": 30,
+     "humidity": 77,
+     "pop": 0,
+     "precipMM": 0,
+     "precipIN": 0,
+     "iceaccum": null,
+     "iceaccumMM": null,
+     "iceaccumIN": null,
+     "snowCM": 0,
+     "snowIN": 0,
+     "pressureMB": 1014,
+     "pressureIN": 29.95,
+     "windDir": "NW",
+     "windDirDEG": 325,
+     "windSpeedKTS": 1,
+     "windSpeedKPH": 2,
+     "windSpeedMPH": 1,
+     "windGustKTS": 16,
+     "windGustKPH": 29,
+     "windGustMPH": 18,
+     "windDirMax": "WNW",
+     "windDirMaxDEG": 298,
+     "windSpeedMaxKTS": 7,
+     "windSpeedMaxKPH": 13,
+     "windSpeedMaxMPH": 8,
+     "windDirMin": "NW",
+     "windDirMinDEG": 325,
+     "windSpeedMinKTS": 1,
+     "windSpeedMinKPH": 2,
+     "windSpeedMinMPH": 1,
+     "windDir80m": "NNW",
+     "windDir80mDEG": 347,
+     "windSpeed80mKTS": 6,
+     "windSpeed80mKPH": 10,
+     "windSpeed80mMPH": 6,
+     "windGust80mKTS": 20,
+     "windGust80mKPH": 37,
+     "windGust80mMPH": 23,
+     "windDirMax80m": "NW",
+     "windDirMax80mDEG": 316,
+     "windSpeedMax80mKTS": 20,
+     "windSpeedMax80mKPH": 37,
+     "windSpeedMax80mMPH": 23,
+     "windDirMin80m": "NNW",
+     "windDirMin80mDEG": 347,
+     "windSpeedMin80mKTS": 6,
+     "windSpeedMin80mKPH": 10,
+     "windSpeedMin80mMPH": 6,
+     "sky": 30,
+     "cloudsCoded": "FW",
+     "weather": "Mostly Sunny",
+     "weatherCoded": [],
+     "weatherPrimary": "Mostly Sunny",
+     "weatherPrimaryCoded": "::FW",
+     "icon": "fair.png",
+     "visibilityKM": 24.135,
+     "visibilityMI": 15,
+     "uvi": 6,
+     "solradWM2": 5486,
+     "solradMinWM2": 0,
+     "solradMaxWM2": 742,
+     "isDay": true,
+     "maxCoverage": "",
+     "sunrise": 1665114710,
+     "sunset": 1665156831,
+     "sunriseISO": "2022-10-07T05:51:50+02:00",
+     "sunsetISO": "2022-10-07T17:33:51+02:00"
+    },
+    {
+     "timestamp": 1665205200,
+     "validTime": "2022-10-08T07:00:00+02:00",
+     "dateTimeISO": "2022-10-08T07:00:00+02:00",
+     "maxTempC": 30,
+     "maxTempF": 87,
+     "minTempC": 19,
+     "minTempF": 66,
+     "avgTempC": 25,
+     "avgTempF": 76,
+     "tempC": null,
+     "tempF": null,
+     "maxFeelslikeC": 30,
+     "maxFeelslikeF": 86,
+     "minFeelslikeC": 19,
+     "minFeelslikeF": 67,
+     "avgFeelslikeC": 25,
+     "avgFeelslikeF": 76,
+     "feelslikeC": 19,
+     "feelslikeF": 67,
+     "maxDewpointC": 15,
+     "maxDewpointF": 59,
+     "minDewpointC": 11,
+     "minDewpointF": 52,
+     "avgDewpointC": 13,
+     "avgDewpointF": 56,
+     "dewpointC": 15,
+     "dewpointF": 59,
+     "maxHumidity": 76,
+     "minHumidity": 32,
+     "humidity": 76,
+     "pop": 0,
+     "precipMM": 0,
+     "precipIN": 0,
+     "iceaccum": null,
+     "iceaccumMM": null,
+     "iceaccumIN": null,
+     "snowCM": 0,
+     "snowIN": 0,
+     "pressureMB": 1014,
+     "pressureIN": 29.94,
+     "windDir": "NNE",
+     "windDirDEG": 21,
+     "windSpeedKTS": 1,
+     "windSpeedKPH": 2,
+     "windSpeedMPH": 1,
+     "windGustKTS": 17,
+     "windGustKPH": 32,
+     "windGustMPH": 20,
+     "windDirMax": "WNW",
+     "windDirMaxDEG": 301,
+     "windSpeedMaxKTS": 7,
+     "windSpeedMaxKPH": 13,
+     "windSpeedMaxMPH": 8,
+     "windDirMin": "NNE",
+     "windDirMinDEG": 21,
+     "windSpeedMinKTS": 1,
+     "windSpeedMinKPH": 2,
+     "windSpeedMinMPH": 1,
+     "windDir80m": "NW",
+     "windDir80mDEG": 309,
+     "windSpeed80mKTS": 5,
+     "windSpeed80mKPH": 9,
+     "windSpeed80mMPH": 5,
+     "windGust80mKTS": 17,
+     "windGust80mKPH": 31,
+     "windGust80mMPH": 19,
+     "windDirMax80m": "NW",
+     "windDirMax80mDEG": 322,
+     "windSpeedMax80mKTS": 17,
+     "windSpeedMax80mKPH": 31,
+     "windSpeedMax80mMPH": 19,
+     "windDirMin80m": "NW",
+     "windDirMin80mDEG": 309,
+     "windSpeedMin80mKTS": 5,
+     "windSpeedMin80mKPH": 9,
+     "windSpeedMin80mMPH": 5,
+     "sky": 47,
+     "cloudsCoded": "SC",
+     "weather": "Partly Cloudy",
+     "weatherCoded": [],
+     "weatherPrimary": "Partly Cloudy",
+     "weatherPrimaryCoded": "::SC",
+     "icon": "pcloudy.png",
+     "visibilityKM": 24.135,
+     "visibilityMI": 15,
+     "uvi": 7,
+     "solradWM2": 4785,
+     "solradMinWM2": 0,
+     "solradMaxWM2": 682,
+     "isDay": true,
+     "maxCoverage": "",
+     "sunrise": 1665201146,
+     "sunset": 1665243161,
+     "sunriseISO": "2022-10-08T05:52:26+02:00",
+     "sunsetISO": "2022-10-08T17:32:41+02:00"
+    },
+    {
+     "timestamp": 1665291600,
+     "validTime": "2022-10-09T07:00:00+02:00",
+     "dateTimeISO": "2022-10-09T07:00:00+02:00",
+     "maxTempC": 31,
+     "maxTempF": 87,
+     "minTempC": 19,
+     "minTempF": 67,
+     "avgTempC": 25,
+     "avgTempF": 77,
+     "tempC": null,
+     "tempF": null,
+     "maxFeelslikeC": 30,
+     "maxFeelslikeF": 86,
+     "minFeelslikeC": 20,
+     "minFeelslikeF": 67,
+     "avgFeelslikeC": 25,
+     "avgFeelslikeF": 77,
+     "feelslikeC": 20,
+     "feelslikeF": 67,
+     "maxDewpointC": 17,
+     "maxDewpointF": 63,
+     "minDewpointC": 11,
+     "minDewpointF": 52,
+     "avgDewpointC": 14,
+     "avgDewpointF": 57,
+     "dewpointC": 17,
+     "dewpointF": 63,
+     "maxHumidity": 86,
+     "minHumidity": 31,
+     "humidity": 86,
+     "pop": 0,
+     "precipMM": 0,
+     "precipIN": 0,
+     "iceaccum": null,
+     "iceaccumMM": null,
+     "iceaccumIN": null,
+     "snowCM": 0,
+     "snowIN": 0,
+     "pressureMB": 1016,
+     "pressureIN": 29.99,
+     "windDir": "N",
+     "windDirDEG": 356,
+     "windSpeedKTS": 2,
+     "windSpeedKPH": 4,
+     "windSpeedMPH": 2,
+     "windGustKTS": 19,
+     "windGustKPH": 36,
+     "windGustMPH": 22,
+     "windDirMax": "NNW",
+     "windDirMaxDEG": 343,
+     "windSpeedMaxKTS": 8,
+     "windSpeedMaxKPH": 14,
+     "windSpeedMaxMPH": 9,
+     "windDirMin": "N",
+     "windDirMinDEG": 356,
+     "windSpeedMinKTS": 2,
+     "windSpeedMinKPH": 4,
+     "windSpeedMinMPH": 2,
+     "windDir80m": "NW",
+     "windDir80mDEG": 316,
+     "windSpeed80mKTS": 5,
+     "windSpeed80mKPH": 9,
+     "windSpeed80mMPH": 6,
+     "windGust80mKTS": 20,
+     "windGust80mKPH": 36,
+     "windGust80mMPH": 23,
+     "windDirMax80m": "N",
+     "windDirMax80mDEG": 354,
+     "windSpeedMax80mKTS": 20,
+     "windSpeedMax80mKPH": 36,
+     "windSpeedMax80mMPH": 23,
+     "windDirMin80m": "NW",
+     "windDirMin80mDEG": 316,
+     "windSpeedMin80mKTS": 5,
+     "windSpeedMin80mKPH": 9,
+     "windSpeedMin80mMPH": 6,
+     "sky": 47,
+     "cloudsCoded": "SC",
+     "weather": "Partly Cloudy",
+     "weatherCoded": [],
+     "weatherPrimary": "Partly Cloudy",
+     "weatherPrimaryCoded": "::SC",
+     "icon": "pcloudy.png",
+     "visibilityKM": 24.135,
+     "visibilityMI": 15,
+     "uvi": 7,
+     "solradWM2": 4768,
+     "solradMinWM2": 0,
+     "solradMaxWM2": 726,
+     "isDay": true,
+     "maxCoverage": "",
+     "sunrise": 1665287583,
+     "sunset": 1665329491,
+     "sunriseISO": "2022-10-09T05:53:03+02:00",
+     "sunsetISO": "2022-10-09T17:31:31+02:00"
+    },
+    {
+     "timestamp": 1665378000,
+     "validTime": "2022-10-10T07:00:00+02:00",
+     "dateTimeISO": "2022-10-10T07:00:00+02:00",
+     "maxTempC": 31,
+     "maxTempF": 87,
+     "minTempC": 21,
+     "minTempF": 70,
+     "avgTempC": 26,
+     "avgTempF": 78,
+     "tempC": null,
+     "tempF": null,
+     "maxFeelslikeC": 30,
+     "maxFeelslikeF": 86,
+     "minFeelslikeC": 21,
+     "minFeelslikeF": 69,
+     "avgFeelslikeC": 25,
+     "avgFeelslikeF": 78,
+     "feelslikeC": 21,
+     "feelslikeF": 69,
+     "maxDewpointC": 16,
+     "maxDewpointF": 61,
+     "minDewpointC": 13,
+     "minDewpointF": 55,
+     "avgDewpointC": 14,
+     "avgDewpointF": 58,
+     "dewpointC": 16,
+     "dewpointF": 61,
+     "maxHumidity": 75,
+     "minHumidity": 35,
+     "humidity": 75,
+     "pop": 0,
+     "precipMM": 0,
+     "precipIN": 0,
+     "iceaccum": null,
+     "iceaccumMM": null,
+     "iceaccumIN": null,
+     "snowCM": 0,
+     "snowIN": 0,
+     "pressureMB": 1017,
+     "pressureIN": 30.03,
+     "windDir": "N",
+     "windDirDEG": 358,
+     "windSpeedKTS": 2,
+     "windSpeedKPH": 4,
+     "windSpeedMPH": 2,
+     "windGustKTS": 16,
+     "windGustKPH": 30,
+     "windGustMPH": 19,
+     "windDirMax": "N",
+     "windDirMaxDEG": 10,
+     "windSpeedMaxKTS": 8,
+     "windSpeedMaxKPH": 15,
+     "windSpeedMaxMPH": 9,
+     "windDirMin": "N",
+     "windDirMinDEG": 358,
+     "windSpeedMinKTS": 2,
+     "windSpeedMinKPH": 4,
+     "windSpeedMinMPH": 2,
+     "windDir80m": "N",
+     "windDir80mDEG": 8,
+     "windSpeed80mKTS": 7,
+     "windSpeed80mKPH": 13,
+     "windSpeed80mMPH": 8,
+     "windGust80mKTS": 19,
+     "windGust80mKPH": 36,
+     "windGust80mMPH": 22,
+     "windDirMax80m": "N",
+     "windDirMax80mDEG": 10,
+     "windSpeedMax80mKTS": 19,
+     "windSpeedMax80mKPH": 36,
+     "windSpeedMax80mMPH": 22,
+     "windDirMin80m": "E",
+     "windDirMin80mDEG": 91,
+     "windSpeedMin80mKTS": 7,
+     "windSpeedMin80mKPH": 13,
+     "windSpeedMin80mMPH": 8,
+     "sky": 64,
+     "cloudsCoded": "SC",
+     "weather": "Partly Cloudy",
+     "weatherCoded": [],
+     "weatherPrimary": "Partly Cloudy",
+     "weatherPrimaryCoded": "::SC",
+     "icon": "pcloudy.png",
+     "visibilityKM": 24.135,
+     "visibilityMI": 15,
+     "uvi": 6,
+     "solradWM2": 4494,
+     "solradMinWM2": 0,
+     "solradMaxWM2": 597,
+     "isDay": true,
+     "maxCoverage": "",
+     "sunrise": 1665374020,
+     "sunset": 1665415821,
+     "sunriseISO": "2022-10-10T05:53:40+02:00",
+     "sunsetISO": "2022-10-10T17:30:21+02:00"
+    },
+    {
+     "timestamp": 1665464400,
+     "validTime": "2022-10-11T07:00:00+02:00",
+     "dateTimeISO": "2022-10-11T07:00:00+02:00",
+     "maxTempC": 31,
+     "maxTempF": 87,
+     "minTempC": 21,
+     "minTempF": 70,
+     "avgTempC": 26,
+     "avgTempF": 78,
+     "tempC": null,
+     "tempF": null,
+     "maxFeelslikeC": 31,
+     "maxFeelslikeF": 87,
+     "minFeelslikeC": 22,
+     "minFeelslikeF": 72,
+     "avgFeelslikeC": 26,
+     "avgFeelslikeF": 79,
+     "feelslikeC": 22,
+     "feelslikeF": 72,
+     "maxDewpointC": 17,
+     "maxDewpointF": 62,
+     "minDewpointC": 11,
+     "minDewpointF": 51,
+     "avgDewpointC": 13,
+     "avgDewpointF": 55,
+     "dewpointC": 17,
+     "dewpointF": 62,
+     "maxHumidity": 71,
+     "minHumidity": 30,
+     "humidity": 71,
+     "pop": 0,
+     "precipMM": 0,
+     "precipIN": 0,
+     "iceaccum": null,
+     "iceaccumMM": null,
+     "iceaccumIN": null,
+     "snowCM": 0,
+     "snowIN": 0,
+     "pressureMB": 1015,
+     "pressureIN": 29.98,
+     "windDir": "NNE",
+     "windDirDEG": 13,
+     "windSpeedKTS": 8,
+     "windSpeedKPH": 15,
+     "windSpeedMPH": 9,
+     "windGustKTS": 15,
+     "windGustKPH": 28,
+     "windGustMPH": 17,
+     "windDirMax": "NNE",
+     "windDirMaxDEG": 28,
+     "windSpeedMaxKTS": 15,
+     "windSpeedMaxKPH": 28,
+     "windSpeedMaxMPH": 18,
+     "windDirMin": "NNE",
+     "windDirMinDEG": 14,
+     "windSpeedMinKTS": 7,
+     "windSpeedMinKPH": 14,
+     "windSpeedMinMPH": 8,
+     "windDir80m": "NNE",
+     "windDir80mDEG": 16,
+     "windSpeed80mKTS": 10,
+     "windSpeed80mKPH": 19,
+     "windSpeed80mMPH": 12,
+     "windGust80mKTS": 17,
+     "windGust80mKPH": 31,
+     "windGust80mMPH": 19,
+     "windDirMax80m": "NNE",
+     "windDirMax80mDEG": 28,
+     "windSpeedMax80mKTS": 17,
+     "windSpeedMax80mKPH": 31,
+     "windSpeedMax80mMPH": 19,
+     "windDirMin80m": "NNE",
+     "windDirMin80mDEG": 13,
+     "windSpeedMin80mKTS": 9,
+     "windSpeedMin80mKPH": 18,
+     "windSpeedMin80mMPH": 11,
+     "sky": 0,
+     "cloudsCoded": "CL",
+     "weather": "Sunny",
+     "weatherCoded": [],
+     "weatherPrimary": "Sunny",
+     "weatherPrimaryCoded": "::CL",
+     "icon": "sunny.png",
+     "visibilityKM": 24.135,
+     "visibilityMI": 15,
+     "uvi": null,
+     "solradWM2": 5450,
+     "solradMinWM2": 0,
+     "solradMaxWM2": 758,
+     "isDay": true,
+     "maxCoverage": "",
+     "sunrise": 1665460458,
+     "sunset": 1665502153,
+     "sunriseISO": "2022-10-11T05:54:18+02:00",
+     "sunsetISO": "2022-10-11T17:29:13+02:00"
+    },
+    {
+     "timestamp": 1665550800,
+     "validTime": "2022-10-12T07:00:00+02:00",
+     "dateTimeISO": "2022-10-12T07:00:00+02:00",
+     "maxTempC": 31,
+     "maxTempF": 88,
+     "minTempC": 21,
+     "minTempF": 69,
+     "avgTempC": 26,
+     "avgTempF": 79,
+     "tempC": null,
+     "tempF": null,
+     "maxFeelslikeC": 31,
+     "maxFeelslikeF": 88,
+     "minFeelslikeC": 22,
+     "minFeelslikeF": 72,
+     "avgFeelslikeC": 26,
+     "avgFeelslikeF": 80,
+     "feelslikeC": 22,
+     "feelslikeF": 72,
+     "maxDewpointC": 16,
+     "maxDewpointF": 60,
+     "minDewpointC": 11,
+     "minDewpointF": 51,
+     "avgDewpointC": 13,
+     "avgDewpointF": 55,
+     "dewpointC": 16,
+     "dewpointF": 60,
+     "maxHumidity": 68,
+     "minHumidity": 29,
+     "humidity": 68,
+     "pop": 0,
+     "precipMM": 0,
+     "precipIN": 0,
+     "iceaccum": null,
+     "iceaccumMM": null,
+     "iceaccumIN": null,
+     "snowCM": 0,
+     "snowIN": 0,
+     "pressureMB": 1014,
+     "pressureIN": 29.95,
+     "windDir": "NNE",
+     "windDirDEG": 12,
+     "windSpeedKTS": 8,
+     "windSpeedKPH": 15,
+     "windSpeedMPH": 9,
+     "windGustKTS": 15,
+     "windGustKPH": 28,
+     "windGustMPH": 17,
+     "windDirMax": "E",
+     "windDirMaxDEG": 96,
+     "windSpeedMaxKTS": 14,
+     "windSpeedMaxKPH": 26,
+     "windSpeedMaxMPH": 16,
+     "windDirMin": "NNE",
+     "windDirMinDEG": 12,
+     "windSpeedMinKTS": 7,
+     "windSpeedMinKPH": 13,
+     "windSpeedMinMPH": 8,
+     "windDir80m": "NNE",
+     "windDir80mDEG": 15,
+     "windSpeed80mKTS": 10,
+     "windSpeed80mKPH": 19,
+     "windSpeed80mMPH": 12,
+     "windGust80mKTS": 18,
+     "windGust80mKPH": 33,
+     "windGust80mMPH": 21,
+     "windDirMax80m": "E",
+     "windDirMax80mDEG": 96,
+     "windSpeedMax80mKTS": 18,
+     "windSpeedMax80mKPH": 33,
+     "windSpeedMax80mMPH": 21,
+     "windDirMin80m": "NNE",
+     "windDirMin80mDEG": 15,
+     "windSpeedMin80mKTS": 10,
+     "windSpeedMin80mKPH": 18,
+     "windSpeedMin80mMPH": 11,
+     "sky": 27,
+     "cloudsCoded": "FW",
+     "weather": "Mostly Sunny",
+     "weatherCoded": [],
+     "weatherPrimary": "Mostly Sunny",
+     "weatherPrimaryCoded": "::FW",
+     "icon": "fair.png",
+     "visibilityKM": 24.135,
+     "visibilityMI": 15,
+     "uvi": null,
+     "solradWM2": 4740,
+     "solradMinWM2": 0,
+     "solradMaxWM2": 743,
+     "isDay": true,
+     "maxCoverage": "",
+     "sunrise": 1665546895,
+     "sunset": 1665588484,
+     "sunriseISO": "2022-10-12T05:54:55+02:00",
+     "sunsetISO": "2022-10-12T17:28:04+02:00"
+    }
+   ],
+   "profile": {
+    "tz": "Africa/Cairo",
+    "elevM": 23,
+    "elevFT": 75
+   }
+  }
+ ]
+}

src/test/resources/Issue593.xml

@@ -0,0 +1,691 @@
+<success>true</success>
+<response>
+  <loc>
+    <long>31.25</long>
+    <lat>30.063</lat>
+  </loc>
+  <profile>
+    <elevM>23</elevM>
+    <tz>Africa/Cairo</tz>
+    <elevFT>75</elevFT>
+  </profile>
+  <periods>
+    <dateTimeISO>2022-10-06T07:00:00+02:00</dateTimeISO>
+    <windDirMin80m>E</windDirMin80m>
+    <windDirMin80mDEG>95</windDirMin80mDEG>
+    <feelslikeC>21</feelslikeC>
+    <visibilityMI>15</visibilityMI>
+    <windSpeedMaxMPH>10</windSpeedMaxMPH>
+    <windDirDEG>353</windDirDEG>
+    <windDir>N</windDir>
+    <sunriseISO>2022-10-06T05:51:14+02:00</sunriseISO>
+    <iceaccumMM>null</iceaccumMM>
+    <windSpeedMaxKTS>9</windSpeedMaxKTS>
+    <iceaccumIN>null</iceaccumIN>
+    <minTempF>66</minTempF>
+    <snowIN>0</snowIN>
+    <weather>Mostly Sunny</weather>
+    <sunsetISO>2022-10-06T17:35:02+02:00</sunsetISO>
+    <maxFeelslikeC>32</maxFeelslikeC>
+    <humidity>77</humidity>
+    <windDir80m>N</windDir80m>
+    <maxFeelslikeF>89</maxFeelslikeF>
+    <precipMM>0</precipMM>
+    <sky>22</sky>
+    <windGust80mMPH>25</windGust80mMPH>
+    <windSpeedMax80mMPH>25</windSpeedMax80mMPH>
+    <weatherPrimary>Mostly Sunny</weatherPrimary>
+    <windGust80mKPH>41</windGust80mKPH>
+    <avgDewpointF>58</avgDewpointF>
+    <windSpeedMax80mKPH>41</windSpeedMax80mKPH>
+    <windGust80mKTS>22</windGust80mKTS>
+    <avgDewpointC>14</avgDewpointC>
+    <precipIN>0</precipIN>
+    <windSpeedMax80mKTS>22</windSpeedMax80mKTS>
+    <windDirMinDEG>353</windDirMinDEG>
+    <windSpeedMaxKPH>16</windSpeedMaxKPH>
+    <windSpeedMin80mKTS>8</windSpeedMin80mKTS>
+    <feelslikeF>70</feelslikeF>
+    <validTime>2022-10-06T07:00:00+02:00</validTime>
+    <windSpeedMin80mMPH>10</windSpeedMin80mMPH>
+    <solradMaxWM2>778</solradMaxWM2>
+    <avgTempC>25</avgTempC>
+    <windSpeedMin80mKPH>15</windSpeedMin80mKPH>
+    <weatherPrimaryCoded>::FW</weatherPrimaryCoded>
+    <sunrise>1665028274</sunrise>
+    <avgTempF>78</avgTempF>
+    <windDirMin>N</windDirMin>
+    <maxCoverage/>
+    <icon>fair.png</icon>
+    <minFeelslikeC>21</minFeelslikeC>
+    <dewpointC>17</dewpointC>
+    <cloudsCoded>FW</cloudsCoded>
+    <minFeelslikeF>70</minFeelslikeF>
+    <minHumidity>29</minHumidity>
+    <dewpointF>63</dewpointF>
+    <windSpeed80mKTS>12</windSpeed80mKTS>
+    <pop>0</pop>
+    <snowCM>0</snowCM>
+    <windDirMax>NNW</windDirMax>
+    <windSpeed80mMPH>13</windSpeed80mMPH>
+    <windSpeed80mKPH>22</windSpeed80mKPH>
+    <windDir80mDEG>11</windDir80mDEG>
+    <maxTempC>32</maxTempC>
+    <pressureMB>1015</pressureMB>
+    <visibilityKM>24.135</visibilityKM>
+    <timestamp>1665032400</timestamp>
+    <maxTempF>90</maxTempF>
+    <tempF>null</tempF>
+    <minDewpointC>11</minDewpointC>
+    <solradMinWM2>0</solradMinWM2>
+    <windSpeedMinKTS>1</windSpeedMinKTS>
+    <windDirMax80mDEG>343</windDirMax80mDEG>
+    <windGustKTS>21</windGustKTS>
+    <windSpeedMinKPH>2</windSpeedMinKPH>
+    <maxDewpointF>63</maxDewpointF>
+    <windSpeedMinMPH>1</windSpeedMinMPH>
+    <avgFeelslikeC>26</avgFeelslikeC>
+    <uvi>6</uvi>
+    <windDirMax80m>NNW</windDirMax80m>
+    <maxDewpointC>17</maxDewpointC>
+    <pressureIN>29.97</pressureIN>
+    <avgFeelslikeF>80</avgFeelslikeF>
+    <iceaccum>null</iceaccum>
+    <isDay>true</isDay>
+    <minTempC>19</minTempC>
+    <minDewpointF>52</minDewpointF>
+    <windSpeedKTS>5</windSpeedKTS>
+    <sunset>1665070502</sunset>
+    <solradWM2>5608</solradWM2>
+    <windSpeedKPH>9</windSpeedKPH>
+    <windGustMPH>25</windGustMPH>
+    <maxHumidity>77</maxHumidity>
+    <windSpeedMPH>6</windSpeedMPH>
+    <windGustKPH>40</windGustKPH>
+    <windDirMaxDEG>342</windDirMaxDEG>
+    <tempC>null</tempC>
+  </periods>
+  <periods>
+    <dateTimeISO>2022-10-07T07:00:00+02:00</dateTimeISO>
+    <windDirMin80m>NNW</windDirMin80m>
+    <windDirMin80mDEG>347</windDirMin80mDEG>
+    <feelslikeC>19</feelslikeC>
+    <visibilityMI>15</visibilityMI>
+    <windSpeedMaxMPH>8</windSpeedMaxMPH>
+    <windDirDEG>325</windDirDEG>
+    <windDir>NW</windDir>
+    <sunriseISO>2022-10-07T05:51:50+02:00</sunriseISO>
+    <iceaccumMM>null</iceaccumMM>
+    <windSpeedMaxKTS>7</windSpeedMaxKTS>
+    <iceaccumIN>null</iceaccumIN>
+    <minTempF>66</minTempF>
+    <snowIN>0</snowIN>
+    <weather>Mostly Sunny</weather>
+    <sunsetISO>2022-10-07T17:33:51+02:00</sunsetISO>
+    <maxFeelslikeC>29</maxFeelslikeC>
+    <humidity>77</humidity>
+    <windDir80m>NNW</windDir80m>
+    <maxFeelslikeF>85</maxFeelslikeF>
+    <precipMM>0</precipMM>
+    <sky>30</sky>
+    <windGust80mMPH>23</windGust80mMPH>
+    <windSpeedMax80mMPH>23</windSpeedMax80mMPH>
+    <weatherPrimary>Mostly Sunny</weatherPrimary>
+    <windGust80mKPH>37</windGust80mKPH>
+    <avgDewpointF>54</avgDewpointF>
+    <windSpeedMax80mKPH>37</windSpeedMax80mKPH>
+    <windGust80mKTS>20</windGust80mKTS>
+    <avgDewpointC>12</avgDewpointC>
+    <precipIN>0</precipIN>
+    <windSpeedMax80mKTS>20</windSpeedMax80mKTS>
+    <windDirMinDEG>325</windDirMinDEG>
+    <windSpeedMaxKPH>13</windSpeedMaxKPH>
+    <windSpeedMin80mKTS>6</windSpeedMin80mKTS>
+    <feelslikeF>67</feelslikeF>
+    <validTime>2022-10-07T07:00:00+02:00</validTime>
+    <windSpeedMin80mMPH>6</windSpeedMin80mMPH>
+    <solradMaxWM2>742</solradMaxWM2>
+    <avgTempC>24</avgTempC>
+    <windSpeedMin80mKPH>10</windSpeedMin80mKPH>
+    <weatherPrimaryCoded>::FW</weatherPrimaryCoded>
+    <sunrise>1665114710</sunrise>
+    <avgTempF>76</avgTempF>
+    <windDirMin>NW</windDirMin>
+    <maxCoverage/>
+    <icon>fair.png</icon>
+    <minFeelslikeC>19</minFeelslikeC>
+    <dewpointC>15</dewpointC>
+    <cloudsCoded>FW</cloudsCoded>
+    <minFeelslikeF>67</minFeelslikeF>
+    <minHumidity>30</minHumidity>
+    <dewpointF>60</dewpointF>
+    <windSpeed80mKTS>6</windSpeed80mKTS>
+    <pop>0</pop>
+    <snowCM>0</snowCM>
+    <windDirMax>WNW</windDirMax>
+    <windSpeed80mMPH>6</windSpeed80mMPH>
+    <windSpeed80mKPH>10</windSpeed80mKPH>
+    <windDir80mDEG>347</windDir80mDEG>
+    <maxTempC>30</maxTempC>
+    <pressureMB>1014</pressureMB>
+    <visibilityKM>24.135</visibilityKM>
+    <timestamp>1665118800</timestamp>
+    <maxTempF>86</maxTempF>
+    <tempF>null</tempF>
+    <minDewpointC>10</minDewpointC>
+    <solradMinWM2>0</solradMinWM2>
+    <windSpeedMinKTS>1</windSpeedMinKTS>
+    <windDirMax80mDEG>316</windDirMax80mDEG>
+    <windGustKTS>16</windGustKTS>
+    <windSpeedMinKPH>2</windSpeedMinKPH>
+    <maxDewpointF>60</maxDewpointF>
+    <windSpeedMinMPH>1</windSpeedMinMPH>
+    <avgFeelslikeC>24</avgFeelslikeC>
+    <uvi>6</uvi>
+    <windDirMax80m>NW</windDirMax80m>
+    <maxDewpointC>15</maxDewpointC>
+    <pressureIN>29.95</pressureIN>
+    <avgFeelslikeF>76</avgFeelslikeF>
+    <iceaccum>null</iceaccum>
+    <isDay>true</isDay>
+    <minTempC>19</minTempC>
+    <minDewpointF>50</minDewpointF>
+    <windSpeedKTS>1</windSpeedKTS>
+    <sunset>1665156831</sunset>
+    <solradWM2>5486</solradWM2>
+    <windSpeedKPH>2</windSpeedKPH>
+    <windGustMPH>18</windGustMPH>
+    <maxHumidity>77</maxHumidity>
+    <windSpeedMPH>1</windSpeedMPH>
+    <windGustKPH>29</windGustKPH>
+    <windDirMaxDEG>298</windDirMaxDEG>
+    <tempC>null</tempC>
+  </periods>
+  <periods>
+    <dateTimeISO>2022-10-08T07:00:00+02:00</dateTimeISO>
+    <windDirMin80m>NW</windDirMin80m>
+    <windDirMin80mDEG>309</windDirMin80mDEG>
+    <feelslikeC>19</feelslikeC>
+    <visibilityMI>15</visibilityMI>
+    <windSpeedMaxMPH>8</windSpeedMaxMPH>
+    <windDirDEG>21</windDirDEG>
+    <windDir>NNE</windDir>
+    <sunriseISO>2022-10-08T05:52:26+02:00</sunriseISO>
+    <iceaccumMM>null</iceaccumMM>
+    <windSpeedMaxKTS>7</windSpeedMaxKTS>
+    <iceaccumIN>null</iceaccumIN>
+    <minTempF>66</minTempF>
+    <snowIN>0</snowIN>
+    <weather>Partly Cloudy</weather>
+    <sunsetISO>2022-10-08T17:32:41+02:00</sunsetISO>
+    <maxFeelslikeC>30</maxFeelslikeC>
+    <humidity>76</humidity>
+    <windDir80m>NW</windDir80m>
+    <maxFeelslikeF>86</maxFeelslikeF>
+    <precipMM>0</precipMM>
+    <sky>47</sky>
+    <windGust80mMPH>19</windGust80mMPH>
+    <windSpeedMax80mMPH>19</windSpeedMax80mMPH>
+    <weatherPrimary>Partly Cloudy</weatherPrimary>
+    <windGust80mKPH>31</windGust80mKPH>
+    <avgDewpointF>56</avgDewpointF>
+    <windSpeedMax80mKPH>31</windSpeedMax80mKPH>
+    <windGust80mKTS>17</windGust80mKTS>
+    <avgDewpointC>13</avgDewpointC>
+    <precipIN>0</precipIN>
+    <windSpeedMax80mKTS>17</windSpeedMax80mKTS>
+    <windDirMinDEG>21</windDirMinDEG>
+    <windSpeedMaxKPH>13</windSpeedMaxKPH>
+    <windSpeedMin80mKTS>5</windSpeedMin80mKTS>
+    <feelslikeF>67</feelslikeF>
+    <validTime>2022-10-08T07:00:00+02:00</validTime>
+    <windSpeedMin80mMPH>5</windSpeedMin80mMPH>
+    <solradMaxWM2>682</solradMaxWM2>
+    <avgTempC>25</avgTempC>
+    <windSpeedMin80mKPH>9</windSpeedMin80mKPH>
+    <weatherPrimaryCoded>::SC</weatherPrimaryCoded>
+    <sunrise>1665201146</sunrise>
+    <avgTempF>76</avgTempF>
+    <windDirMin>NNE</windDirMin>
+    <maxCoverage/>
+    <icon>pcloudy.png</icon>
+    <minFeelslikeC>19</minFeelslikeC>
+    <dewpointC>15</dewpointC>
+    <cloudsCoded>SC</cloudsCoded>
+    <minFeelslikeF>67</minFeelslikeF>
+    <minHumidity>32</minHumidity>
+    <dewpointF>59</dewpointF>
+    <windSpeed80mKTS>5</windSpeed80mKTS>
+    <pop>0</pop>
+    <snowCM>0</snowCM>
+    <windDirMax>WNW</windDirMax>
+    <windSpeed80mMPH>5</windSpeed80mMPH>
+    <windSpeed80mKPH>9</windSpeed80mKPH>
+    <windDir80mDEG>309</windDir80mDEG>
+    <maxTempC>30</maxTempC>
+    <pressureMB>1014</pressureMB>
+    <visibilityKM>24.135</visibilityKM>
+    <timestamp>1665205200</timestamp>
+    <maxTempF>87</maxTempF>
+    <tempF>null</tempF>
+    <minDewpointC>11</minDewpointC>
+    <solradMinWM2>0</solradMinWM2>
+    <windSpeedMinKTS>1</windSpeedMinKTS>
+    <windDirMax80mDEG>322</windDirMax80mDEG>
+    <windGustKTS>17</windGustKTS>
+    <windSpeedMinKPH>2</windSpeedMinKPH>
+    <maxDewpointF>59</maxDewpointF>
+    <windSpeedMinMPH>1</windSpeedMinMPH>
+    <avgFeelslikeC>25</avgFeelslikeC>
+    <uvi>7</uvi>
+    <windDirMax80m>NW</windDirMax80m>
+    <maxDewpointC>15</maxDewpointC>
+    <pressureIN>29.94</pressureIN>
+    <avgFeelslikeF>76</avgFeelslikeF>
+    <iceaccum>null</iceaccum>
+    <isDay>true</isDay>
+    <minTempC>19</minTempC>
+    <minDewpointF>52</minDewpointF>
+    <windSpeedKTS>1</windSpeedKTS>
+    <sunset>1665243161</sunset>
+    <solradWM2>4785</solradWM2>
+    <windSpeedKPH>2</windSpeedKPH>
+    <windGustMPH>20</windGustMPH>
+    <maxHumidity>76</maxHumidity>
+    <windSpeedMPH>1</windSpeedMPH>
+    <windGustKPH>32</windGustKPH>
+    <windDirMaxDEG>301</windDirMaxDEG>
+    <tempC>null</tempC>
+  </periods>
+  <periods>
+    <dateTimeISO>2022-10-09T07:00:00+02:00</dateTimeISO>
+    <windDirMin80m>NW</windDirMin80m>
+    <windDirMin80mDEG>316</windDirMin80mDEG>
+    <feelslikeC>20</feelslikeC>
+    <visibilityMI>15</visibilityMI>
+    <windSpeedMaxMPH>9</windSpeedMaxMPH>
+    <windDirDEG>356</windDirDEG>
+    <windDir>N</windDir>
+    <sunriseISO>2022-10-09T05:53:03+02:00</sunriseISO>
+    <iceaccumMM>null</iceaccumMM>
+    <windSpeedMaxKTS>8</windSpeedMaxKTS>
+    <iceaccumIN>null</iceaccumIN>
+    <minTempF>67</minTempF>
+    <snowIN>0</snowIN>
+    <weather>Partly Cloudy</weather>
+    <sunsetISO>2022-10-09T17:31:31+02:00</sunsetISO>
+    <maxFeelslikeC>30</maxFeelslikeC>
+    <humidity>86</humidity>
+    <windDir80m>NW</windDir80m>
+    <maxFeelslikeF>86</maxFeelslikeF>
+    <precipMM>0</precipMM>
+    <sky>47</sky>
+    <windGust80mMPH>23</windGust80mMPH>
+    <windSpeedMax80mMPH>23</windSpeedMax80mMPH>
+    <weatherPrimary>Partly Cloudy</weatherPrimary>
+    <windGust80mKPH>36</windGust80mKPH>
+    <avgDewpointF>57</avgDewpointF>
+    <windSpeedMax80mKPH>36</windSpeedMax80mKPH>
+    <windGust80mKTS>20</windGust80mKTS>
+    <avgDewpointC>14</avgDewpointC>
+    <precipIN>0</precipIN>
+    <windSpeedMax80mKTS>20</windSpeedMax80mKTS>
+    <windDirMinDEG>356</windDirMinDEG>
+    <windSpeedMaxKPH>14</windSpeedMaxKPH>
+    <windSpeedMin80mKTS>5</windSpeedMin80mKTS>
+    <feelslikeF>67</feelslikeF>
+    <validTime>2022-10-09T07:00:00+02:00</validTime>
+    <windSpeedMin80mMPH>6</windSpeedMin80mMPH>
+    <solradMaxWM2>726</solradMaxWM2>
+    <avgTempC>25</avgTempC>
+    <windSpeedMin80mKPH>9</windSpeedMin80mKPH>
+    <weatherPrimaryCoded>::SC</weatherPrimaryCoded>
+    <sunrise>1665287583</sunrise>
+    <avgTempF>77</avgTempF>
+    <windDirMin>N</windDirMin>
+    <maxCoverage/>
+    <icon>pcloudy.png</icon>
+    <minFeelslikeC>20</minFeelslikeC>
+    <dewpointC>17</dewpointC>
+    <cloudsCoded>SC</cloudsCoded>
+    <minFeelslikeF>67</minFeelslikeF>
+    <minHumidity>31</minHumidity>
+    <dewpointF>63</dewpointF>
+    <windSpeed80mKTS>5</windSpeed80mKTS>
+    <pop>0</pop>
+    <snowCM>0</snowCM>
+    <windDirMax>NNW</windDirMax>
+    <windSpeed80mMPH>6</windSpeed80mMPH>
+    <windSpeed80mKPH>9</windSpeed80mKPH>
+    <windDir80mDEG>316</windDir80mDEG>
+    <maxTempC>31</maxTempC>
+    <pressureMB>1016</pressureMB>
+    <visibilityKM>24.135</visibilityKM>
+    <timestamp>1665291600</timestamp>
+    <maxTempF>87</maxTempF>
+    <tempF>null</tempF>
+    <minDewpointC>11</minDewpointC>
+    <solradMinWM2>0</solradMinWM2>
+    <windSpeedMinKTS>2</windSpeedMinKTS>
+    <windDirMax80mDEG>354</windDirMax80mDEG>
+    <windGustKTS>19</windGustKTS>
+    <windSpeedMinKPH>4</windSpeedMinKPH>
+    <maxDewpointF>63</maxDewpointF>
+    <windSpeedMinMPH>2</windSpeedMinMPH>
+    <avgFeelslikeC>25</avgFeelslikeC>
+    <uvi>7</uvi>
+    <windDirMax80m>N</windDirMax80m>
+    <maxDewpointC>17</maxDewpointC>
+    <pressureIN>29.99</pressureIN>
+    <avgFeelslikeF>77</avgFeelslikeF>
+    <iceaccum>null</iceaccum>
+    <isDay>true</isDay>
+    <minTempC>19</minTempC>
+    <minDewpointF>52</minDewpointF>
+    <windSpeedKTS>2</windSpeedKTS>
+    <sunset>1665329491</sunset>
+    <solradWM2>4768</solradWM2>
+    <windSpeedKPH>4</windSpeedKPH>
+    <windGustMPH>22</windGustMPH>
+    <maxHumidity>86</maxHumidity>
+    <windSpeedMPH>2</windSpeedMPH>
+    <windGustKPH>36</windGustKPH>
+    <windDirMaxDEG>343</windDirMaxDEG>
+    <tempC>null</tempC>
+  </periods>
+  <periods>
+    <dateTimeISO>2022-10-10T07:00:00+02:00</dateTimeISO>
+    <windDirMin80m>E</windDirMin80m>
+    <windDirMin80mDEG>91</windDirMin80mDEG>
+    <feelslikeC>21</feelslikeC>
+    <visibilityMI>15</visibilityMI>
+    <windSpeedMaxMPH>9</windSpeedMaxMPH>
+    <windDirDEG>358</windDirDEG>
+    <windDir>N</windDir>
+    <sunriseISO>2022-10-10T05:53:40+02:00</sunriseISO>
+    <iceaccumMM>null</iceaccumMM>
+    <windSpeedMaxKTS>8</windSpeedMaxKTS>
+    <iceaccumIN>null</iceaccumIN>
+    <minTempF>70</minTempF>
+    <snowIN>0</snowIN>
+    <weather>Partly Cloudy</weather>
+    <sunsetISO>2022-10-10T17:30:21+02:00</sunsetISO>
+    <maxFeelslikeC>30</maxFeelslikeC>
+    <humidity>75</humidity>
+    <windDir80m>N</windDir80m>
+    <maxFeelslikeF>86</maxFeelslikeF>
+    <precipMM>0</precipMM>
+    <sky>64</sky>
+    <windGust80mMPH>22</windGust80mMPH>
+    <windSpeedMax80mMPH>22</windSpeedMax80mMPH>
+    <weatherPrimary>Partly Cloudy</weatherPrimary>
+    <windGust80mKPH>36</windGust80mKPH>
+    <avgDewpointF>58</avgDewpointF>
+    <windSpeedMax80mKPH>36</windSpeedMax80mKPH>
+    <windGust80mKTS>19</windGust80mKTS>
+    <avgDewpointC>14</avgDewpointC>
+    <precipIN>0</precipIN>
+    <windSpeedMax80mKTS>19</windSpeedMax80mKTS>
+    <windDirMinDEG>358</windDirMinDEG>
+    <windSpeedMaxKPH>15</windSpeedMaxKPH>
+    <windSpeedMin80mKTS>7</windSpeedMin80mKTS>
+    <feelslikeF>69</feelslikeF>
+    <validTime>2022-10-10T07:00:00+02:00</validTime>
+    <windSpeedMin80mMPH>8</windSpeedMin80mMPH>
+    <solradMaxWM2>597</solradMaxWM2>
+    <avgTempC>26</avgTempC>
+    <windSpeedMin80mKPH>13</windSpeedMin80mKPH>
+    <weatherPrimaryCoded>::SC</weatherPrimaryCoded>
+    <sunrise>1665374020</sunrise>
+    <avgTempF>78</avgTempF>
+    <windDirMin>N</windDirMin>
+    <maxCoverage/>
+    <icon>pcloudy.png</icon>
+    <minFeelslikeC>21</minFeelslikeC>
+    <dewpointC>16</dewpointC>
+    <cloudsCoded>SC</cloudsCoded>
+    <minFeelslikeF>69</minFeelslikeF>
+    <minHumidity>35</minHumidity>
+    <dewpointF>61</dewpointF>
+    <windSpeed80mKTS>7</windSpeed80mKTS>
+    <pop>0</pop>
+    <snowCM>0</snowCM>
+    <windDirMax>N</windDirMax>
+    <windSpeed80mMPH>8</windSpeed80mMPH>
+    <windSpeed80mKPH>13</windSpeed80mKPH>
+    <windDir80mDEG>8</windDir80mDEG>
+    <maxTempC>31</maxTempC>
+    <pressureMB>1017</pressureMB>
+    <visibilityKM>24.135</visibilityKM>
+    <timestamp>1665378000</timestamp>
+    <maxTempF>87</maxTempF>
+    <tempF>null</tempF>
+    <minDewpointC>13</minDewpointC>
+    <solradMinWM2>0</solradMinWM2>
+    <windSpeedMinKTS>2</windSpeedMinKTS>
+    <windDirMax80mDEG>10</windDirMax80mDEG>
+    <windGustKTS>16</windGustKTS>
+    <windSpeedMinKPH>4</windSpeedMinKPH>
+    <maxDewpointF>61</maxDewpointF>
+    <windSpeedMinMPH>2</windSpeedMinMPH>
+    <avgFeelslikeC>25</avgFeelslikeC>
+    <uvi>6</uvi>
+    <windDirMax80m>N</windDirMax80m>
+    <maxDewpointC>16</maxDewpointC>
+    <pressureIN>30.03</pressureIN>
+    <avgFeelslikeF>78</avgFeelslikeF>
+    <iceaccum>null</iceaccum>
+    <isDay>true</isDay>
+    <minTempC>21</minTempC>
+    <minDewpointF>55</minDewpointF>
+    <windSpeedKTS>2</windSpeedKTS>
+    <sunset>1665415821</sunset>
+    <solradWM2>4494</solradWM2>
+    <windSpeedKPH>4</windSpeedKPH>
+    <windGustMPH>19</windGustMPH>
+    <maxHumidity>75</maxHumidity>
+    <windSpeedMPH>2</windSpeedMPH>
+    <windGustKPH>30</windGustKPH>
+    <windDirMaxDEG>10</windDirMaxDEG>
+    <tempC>null</tempC>
+  </periods>
+  <periods>
+    <dateTimeISO>2022-10-11T07:00:00+02:00</dateTimeISO>
+    <windDirMin80m>NNE</windDirMin80m>
+    <windDirMin80mDEG>13</windDirMin80mDEG>
+    <feelslikeC>22</feelslikeC>
+    <visibilityMI>15</visibilityMI>
+    <windSpeedMaxMPH>18</windSpeedMaxMPH>
+    <windDirDEG>13</windDirDEG>
+    <windDir>NNE</windDir>
+    <sunriseISO>2022-10-11T05:54:18+02:00</sunriseISO>
+    <iceaccumMM>null</iceaccumMM>
+    <windSpeedMaxKTS>15</windSpeedMaxKTS>
+    <iceaccumIN>null</iceaccumIN>
+    <minTempF>70</minTempF>
+    <snowIN>0</snowIN>
+    <weather>Sunny</weather>
+    <sunsetISO>2022-10-11T17:29:13+02:00</sunsetISO>
+    <maxFeelslikeC>31</maxFeelslikeC>
+    <humidity>71</humidity>
+    <windDir80m>NNE</windDir80m>
+    <maxFeelslikeF>87</maxFeelslikeF>
+    <precipMM>0</precipMM>
+    <sky>0</sky>
+    <windGust80mMPH>19</windGust80mMPH>
+    <windSpeedMax80mMPH>19</windSpeedMax80mMPH>
+    <weatherPrimary>Sunny</weatherPrimary>
+    <windGust80mKPH>31</windGust80mKPH>
+    <avgDewpointF>55</avgDewpointF>
+    <windSpeedMax80mKPH>31</windSpeedMax80mKPH>
+    <windGust80mKTS>17</windGust80mKTS>
+    <avgDewpointC>13</avgDewpointC>
+    <precipIN>0</precipIN>
+    <windSpeedMax80mKTS>17</windSpeedMax80mKTS>
+    <windDirMinDEG>14</windDirMinDEG>
+    <windSpeedMaxKPH>28</windSpeedMaxKPH>
+    <windSpeedMin80mKTS>9</windSpeedMin80mKTS>
+    <feelslikeF>72</feelslikeF>
+    <validTime>2022-10-11T07:00:00+02:00</validTime>
+    <windSpeedMin80mMPH>11</windSpeedMin80mMPH>
+    <solradMaxWM2>758</solradMaxWM2>
+    <avgTempC>26</avgTempC>
+    <windSpeedMin80mKPH>18</windSpeedMin80mKPH>
+    <weatherPrimaryCoded>::CL</weatherPrimaryCoded>
+    <sunrise>1665460458</sunrise>
+    <avgTempF>78</avgTempF>
+    <windDirMin>NNE</windDirMin>
+    <maxCoverage/>
+    <icon>sunny.png</icon>
+    <minFeelslikeC>22</minFeelslikeC>
+    <dewpointC>17</dewpointC>
+    <cloudsCoded>CL</cloudsCoded>
+    <minFeelslikeF>72</minFeelslikeF>
+    <minHumidity>30</minHumidity>
+    <dewpointF>62</dewpointF>
+    <windSpeed80mKTS>10</windSpeed80mKTS>
+    <pop>0</pop>
+    <snowCM>0</snowCM>
+    <windDirMax>NNE</windDirMax>
+    <windSpeed80mMPH>12</windSpeed80mMPH>
+    <windSpeed80mKPH>19</windSpeed80mKPH>
+    <windDir80mDEG>16</windDir80mDEG>
+    <maxTempC>31</maxTempC>
+    <pressureMB>1015</pressureMB>
+    <visibilityKM>24.135</visibilityKM>
+    <timestamp>1665464400</timestamp>
+    <maxTempF>87</maxTempF>
+    <tempF>null</tempF>
+    <minDewpointC>11</minDewpointC>
+    <solradMinWM2>0</solradMinWM2>
+    <windSpeedMinKTS>7</windSpeedMinKTS>
+    <windDirMax80mDEG>28</windDirMax80mDEG>
+    <windGustKTS>15</windGustKTS>
+    <windSpeedMinKPH>14</windSpeedMinKPH>
+    <maxDewpointF>62</maxDewpointF>
+    <windSpeedMinMPH>8</windSpeedMinMPH>
+    <avgFeelslikeC>26</avgFeelslikeC>
+    <uvi>null</uvi>
+    <windDirMax80m>NNE</windDirMax80m>
+    <maxDewpointC>17</maxDewpointC>
+    <pressureIN>29.98</pressureIN>
+    <avgFeelslikeF>79</avgFeelslikeF>
+    <iceaccum>null</iceaccum>
+    <isDay>true</isDay>
+    <minTempC>21</minTempC>
+    <minDewpointF>51</minDewpointF>
+    <windSpeedKTS>8</windSpeedKTS>
+    <sunset>1665502153</sunset>
+    <solradWM2>5450</solradWM2>
+    <windSpeedKPH>15</windSpeedKPH>
+    <windGustMPH>17</windGustMPH>
+    <maxHumidity>71</maxHumidity>
+    <windSpeedMPH>9</windSpeedMPH>
+    <windGustKPH>28</windGustKPH>
+    <windDirMaxDEG>28</windDirMaxDEG>
+    <tempC>null</tempC>
+  </periods>
+  <periods>
+    <dateTimeISO>2022-10-12T07:00:00+02:00</dateTimeISO>
+    <windDirMin80m>NNE</windDirMin80m>
+    <windDirMin80mDEG>15</windDirMin80mDEG>
+    <feelslikeC>22</feelslikeC>
+    <visibilityMI>15</visibilityMI>
+    <windSpeedMaxMPH>16</windSpeedMaxMPH>
+    <windDirDEG>12</windDirDEG>
+    <windDir>NNE</windDir>
+    <sunriseISO>2022-10-12T05:54:55+02:00</sunriseISO>
+    <iceaccumMM>null</iceaccumMM>
+    <windSpeedMaxKTS>14</windSpeedMaxKTS>
+    <iceaccumIN>null</iceaccumIN>
+    <minTempF>69</minTempF>
+    <snowIN>0</snowIN>
+    <weather>Mostly Sunny</weather>
+    <sunsetISO>2022-10-12T17:28:04+02:00</sunsetISO>
+    <maxFeelslikeC>31</maxFeelslikeC>
+    <humidity>68</humidity>
+    <windDir80m>NNE</windDir80m>
+    <maxFeelslikeF>88</maxFeelslikeF>
+    <precipMM>0</precipMM>
+    <sky>27</sky>
+    <windGust80mMPH>21</windGust80mMPH>
+    <windSpeedMax80mMPH>21</windSpeedMax80mMPH>
+    <weatherPrimary>Mostly Sunny</weatherPrimary>
+    <windGust80mKPH>33</windGust80mKPH>
+    <avgDewpointF>55</avgDewpointF>
+    <windSpeedMax80mKPH>33</windSpeedMax80mKPH>
+    <windGust80mKTS>18</windGust80mKTS>
+    <avgDewpointC>13</avgDewpointC>
+    <precipIN>0</precipIN>
+    <windSpeedMax80mKTS>18</windSpeedMax80mKTS>
+    <windDirMinDEG>12</windDirMinDEG>
+    <windSpeedMaxKPH>26</windSpeedMaxKPH>
+    <windSpeedMin80mKTS>10</windSpeedMin80mKTS>
+    <feelslikeF>72</feelslikeF>
+    <validTime>2022-10-12T07:00:00+02:00</validTime>
+    <windSpeedMin80mMPH>11</windSpeedMin80mMPH>
+    <solradMaxWM2>743</solradMaxWM2>
+    <avgTempC>26</avgTempC>
+    <windSpeedMin80mKPH>18</windSpeedMin80mKPH>
+    <weatherPrimaryCoded>::FW</weatherPrimaryCoded>
+    <sunrise>1665546895</sunrise>
+    <avgTempF>79</avgTempF>
+    <windDirMin>NNE</windDirMin>
+    <maxCoverage/>
+    <icon>fair.png</icon>
+    <minFeelslikeC>22</minFeelslikeC>
+    <dewpointC>16</dewpointC>
+    <cloudsCoded>FW</cloudsCoded>
+    <minFeelslikeF>72</minFeelslikeF>
+    <minHumidity>29</minHumidity>
+    <dewpointF>60</dewpointF>
+    <windSpeed80mKTS>10</windSpeed80mKTS>
+    <pop>0</pop>
+    <snowCM>0</snowCM>
+    <windDirMax>E</windDirMax>
+    <windSpeed80mMPH>12</windSpeed80mMPH>
+    <windSpeed80mKPH>19</windSpeed80mKPH>
+    <windDir80mDEG>15</windDir80mDEG>
+    <maxTempC>31</maxTempC>
+    <pressureMB>1014</pressureMB>
+    <visibilityKM>24.135</visibilityKM>
+    <timestamp>1665550800</timestamp>
+    <maxTempF>88</maxTempF>
+    <tempF>null</tempF>
+    <minDewpointC>11</minDewpointC>
+    <solradMinWM2>0</solradMinWM2>
+    <windSpeedMinKTS>7</windSpeedMinKTS>
+    <windDirMax80mDEG>96</windDirMax80mDEG>
+    <windGustKTS>15</windGustKTS>
+    <windSpeedMinKPH>13</windSpeedMinKPH>
+    <maxDewpointF>60</maxDewpointF>
+    <windSpeedMinMPH>8</windSpeedMinMPH>
+    <avgFeelslikeC>26</avgFeelslikeC>
+    <uvi>null</uvi>
+    <windDirMax80m>E</windDirMax80m>
+    <maxDewpointC>16</maxDewpointC>
+    <pressureIN>29.95</pressureIN>
+    <avgFeelslikeF>80</avgFeelslikeF>
+    <iceaccum>null</iceaccum>
+    <isDay>true</isDay>
+    <minTempC>21</minTempC>
+    <minDewpointF>51</minDewpointF>
+    <windSpeedKTS>8</windSpeedKTS>
+    <sunset>1665588484</sunset>
+    <solradWM2>4740</solradWM2>
+    <windSpeedKPH>15</windSpeedKPH>
+    <windGustMPH>17</windGustMPH>
+    <maxHumidity>68</maxHumidity>
+    <windSpeedMPH>9</windSpeedMPH>
+    <windGustKPH>28</windGustKPH>
+    <windDirMaxDEG>96</windDirMaxDEG>
+    <tempC>null</tempC>
+  </periods>
+  <interval>day</interval>
+  <place>
+    <country>eg</country>
+    <name>cairo</name>
+    <state>qh</state>
+  </place>
+</response>
+<error>null</error>

src/test/resources/compliantJsonArray.json

@@ -0,0 +1,317 @@
+[
+  {
+    "_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"
+  }
+]