Update pom.xml

Update RELEASES.md
Merge pull request #646 from Zetmas/feature/issue#595
2026-01-24 00:03:17 -05:00 · 2021-12-05 09:12:55 -06:00 · 2021-12-05 09:10:32 -06:00 · 2021-12-03 19:37:00 -06:00 · 2021-12-03 19:35:26 -06:00 · 2021-11-26 20:07:21 -05:00
29 changed files with 1386 additions and 286 deletions
--- a/.github/workflows/pipeline.yml
+++ b/.github/workflows/pipeline.yml
@@ -12,7 +12,7 @@ on:
 jobs:
  # old-school build and jar method. No tests run or compiled.
  build-1_6: 
-    runs-on: ubuntu-16.04
+    runs-on: ubuntu-latest
    strategy:
      matrix:
        # build for java 1.6, however don't run any tests
@@ -38,7 +38,7 @@ jobs:
          path: target/org.json.jar
      
  build:
-    runs-on: ubuntu-16.04
+    runs-on: ubuntu-latest
    strategy:
      matrix:
        # build against supported Java LTS versions:
@@ -71,4 +71,4 @@ jobs:
        uses: actions/upload-artifact@v1
        with:
          name: Test Report ${{ matrix.java }}
-          path: target/site/
+          path: target/site/
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@@ -0,0 +1,76 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+ advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+ address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+ professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at jsonjava060@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -0,0 +1,22 @@
+# Contribution Guidelines
+
+Feel free to work on any issue with a #hacktoberfest label.
+
+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.
+
+# Who is allowed to submit pull requests for this project?
+
+Anyone can submit pull requests for code, tests, or documentation.
+
+# How do you decide which pull requests to accept?
+
+* Does it call out a bug that needs to be fixed? If so, it goes to the top of the list.
+* Does it fix a major user inconvenience? These are given high priority as well.
+* Does it align with the specs? If not, it will probably not be accepted. It turns out there are gray areas in the specs. If this is in a gray area, it will likely be given the benefit of the doubt.
+* Does it break the existing behavior of the lib? If so, it will not be accepted, unless it fixes an egregious bug. This is happening less frequently now.
+
+# For more guidance, see these links:
+
+[README.md (includes build instructions)](https://github.com/stleary/JSON-java#readme)
+
+[FAQ - all your questions answered](https://github.com/stleary/JSON-java/wiki/FAQ)
--- a/Examples.md
+++ b/Examples.md
@@ -0,0 +1,433 @@
+<h1>Examples</h1>
+<p>Imports used in the examples: </p>
+
+```
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Properties;
+```
+
+<p>This document's intention is to explain to new-comers the basics of this project</p>
+
+	
+<h2>Part 1: Creating a JSON document</h2>
+
+<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
+
+		 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
+
+		  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.
+
+		  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() {
+
+		//We can also create an Array without a String by creating an empty array and adding elements to it
+
+		  JSONArray array = new JSONArray();
+
+		//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
+
+		 JSONArray list = listNumberArray(array.length());
+		 JSONObject object = array.toJSONObject(list);
+		 System.out.println("Final JSONOBject: " + object);
+	}
+```
+
+<h3>Using JSONStringer</h3>
+
+```
+	private static void JSONExampleStringer() {
+
+		//We initializate the JSONStringer
+
+		JSONStringer jsonStringer = new JSONStringer();
+
+		//Now we start the process of adding elements with .object()
+
+        jsonStringer.object();
+
+        //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);
+
+        //We end this prcedure with .ednObject
+
+        jsonStringer.endObject();
+
+       //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);
+	}
+```
+<h3>Using JSONObject</h3>
+
+```
+	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 JSONExampleObject2() {
+
+		//We can also create a JSONObject directly without messing around with any of the other functions.
+
+		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 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);
+	}
+```
+<h3>Using JSONWriter</h3>
+
+```	
+	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
+
+		StringBuilder write = new StringBuilder();
+		JSONWriter jsonWriter = new JSONWriter(write);
+
+		//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.
+		
+		
+	}
+```
+```	
+	private static void JSONExampleTokener() {
+
+		//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
+
+		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 docuemnt to work. This project also admits conversions from other type of files.</p>
+<p>Secondly, we can also convert from JSON to those type of files.</p>
+	
+<h3>Extra: Conversion to JSONArray</h3>
+
+```
+	private static void JSONObjectToArray() {
+		//We start with a JSONObject
+
+		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);
+	}
+```
+<h3>XML Conversions</h3>
+
+```		
+	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 obtain a String with XML format with toString()
+
+		String output = XML.toString(example);
+		System.out.println("Final XML: " + output);
+	}
+```
+```	
+	private static void XMLFromExampleConversion() {
+
+		//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>";
+
+		//We obtain a JSONObject with toJSONOBject()
+
+		JSONObject output = XML.toJSONObject(string);
+		
+		System.out.println("Final JSONObject: " + output);
+	}
+```
+<h3>Cookie Conversions</h3>
+
+```
+	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 CookieFromExampleConversion() {
+
+		//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);
+	}
+```
+
+<h3>HTTP Conversions</h3>
+
+```
+	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 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);
+	}
+```
+<h3>CDL Conversions</h3>
+
+```	
+private static void CDLToExampleConversion() {
+
+		//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
+
+		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);
+	}
+```	
+```	
+private static void CDLFromExampleConversion() {
+
+	//We start wtih a String with the CDL format
+
+	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);
+	System.out.println("Final JSONArray: " + output);
+}
+```
+<h3>Properties Conversions</h3>
+
+```
+	private static Properties PropertyToExampleConversion() {
+
+	//We start with a JSONObject
+
+	String string = "{\"0\":\"value\",\"1\":5,\"2\":-2.345E68,\"3\":true}";
+	JSONObject example = new JSONObject(string);
+
+	//We obtain a String with Properties format with toString()
+
+	Properties output = Property.toProperties(example);
+	System.out.println("Final Properties: " + output);
+
+	return output;
+	}
+```
+```	
+	private static void PropertyFromExampleConversion() {
+
+		//We start with a Properties object
+
+		Properties input = PropertyToExampleConversion();
+
+		//We obtain a JSONObject with toJSONOBject()
+
+		JSONObject output = Property.toJSONObject(input);
+		System.out.println("Final JSONObject: " + output);
+	}
+```
+<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();
+	}
+```
+
--- a/README.md
+++ b/README.md
@@ -1,9 +1,15 @@
+![Json-Java logo](https://github.com/stleary/JSON-java/blob/master/images/JsonJava.png?raw=true)
+
+<sub><sup>image credit: Ismael Pérez Ortiz</sup></sub>
+
+
 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)

-**[Click here if you just want the latest release jar file.](https://repo1.maven.org/maven2/org/json/json/20201115/json-20201115.jar)**
+**[Click here if you just want the latest release jar file.](https://search.maven.org/remotecontent?filepath=org/json/json/20210307/json-20210307.jar)**
+

 # Overview

@@ -24,7 +30,9 @@ The files in this package implement JSON encoders and decoders. The package can

 The license includes this restriction: ["The software shall be used for good, not evil."](https://en.wikipedia.org/wiki/Douglas_Crockford#%22Good,_not_Evil%22) If your conscience cannot live with that, then choose a different package.

-**If you would like to contribute to this project**
+# If you would like to contribute to this project
+
+For more information on contributions, please see [CONTRIBUTING.md](https://github.com/stleary/JSON-java/blob/master/docs/CONTRIBUTING.md)

 Bug fixes, code improvements, and unit test coverage changes are welcome! Because this project is currently in the maintenance phase, the kinds of changes that can be accepted are limited. For more information, please read the [FAQ](https://github.com/stleary/JSON-java/wiki/FAQ).

@@ -36,7 +44,7 @@ The org.json package can be built from the command line, Maven, and Gradle. The

 *Build the class files from the package root directory src/main/java*
 ````
-javac org\json\*.java
+javac org/json/*.java
 ````

 *Create the jar file in the current directory*
@@ -46,7 +54,8 @@ jar cf json-java.jar org/json/*.class

 *Compile a program that uses the jar (see example code below)*
 ````
-javac -cp .;json-java.jar Test.java 
+javac -cp .;json-java.jar Test.java (Windows)
+javac -cp .:json-java.jar Test.java (Unix Systems)
 ````

 *Test file contents*
@@ -63,7 +72,8 @@ public class Test {

 *Execute the Test file*
 ```` 
-java -cp .;json-java.jar Test
+java -cp .;json-java.jar Test (Windows)
+java -cp .:json-java.jar Test (Unix Systems)
 ````

 *Expected output*
@@ -88,192 +98,12 @@ gradlew clean build test

 # Notes

-**Recent directory structure change**
-
-_Due to a recent commit - [#515 Merge tests and pom and code](https://github.com/stleary/JSON-java/pull/515) - the structure of the project has changed from a flat directory containing all of the Java files to a directory structure that includes unit tests and several tools used to build the project jar and run the unit tests. If you have difficulty using the new structure, please open an issue so we can work through it._
-
-**Implementation notes**
-
-Numeric types in this package comply with
-[ECMA-404: The JSON Data Interchange Format](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf) and
-[RFC 8259: The JavaScript Object Notation (JSON) Data Interchange Format](https://tools.ietf.org/html/rfc8259#section-6).
-This package fully supports `Integer`, `Long`, and `Double` Java types. Partial support
-for `BigInteger` and `BigDecimal` values in `JSONObject` and `JSONArray` objects is provided
-in the form of `get()`, `opt()`, and `put()` API methods.
-
-Although 1.6 compatibility is currently supported, it is not a project goal and might be
-removed in some future release.
-
-In compliance with RFC8259 page 10 section 9, the parser is more lax with what is valid
-JSON then the Generator. For Example, the tab character (U+0009) is allowed when reading
-JSON Text strings, but when output by the Generator, the tab is properly converted to \t in
-the string. Other instances may occur where reading invalid JSON text does not cause an
-error to be generated. Malformed JSON Texts such as missing end " (quote) on strings or
-invalid number formats (1.2e6.3) will cause errors as such documents can not be read
-reliably.
-
-Some notable exceptions that the JSON Parser in this library accepts are:
-* Unquoted keys `{ key: "value" }`
-* Unquoted values `{ "key": value }`
-* Unescaped literals like "tab" in string values `{ "key": "value   with an unescaped tab" }`
-* Numbers out of range for `Double` or `Long` are parsed as strings
-
-Recent pull requests added a new method `putAll` on the JSONArray. The `putAll` method
-works similarly to other `put` methods in that it does not call `JSONObject.wrap` for items
-added. This can lead to inconsistent object representation in JSONArray structures.
-
-For example, code like this will create a mixed JSONArray, some items wrapped, others
-not:
-
-```java
-SomeBean[] myArr = new SomeBean[]{ new SomeBean(1), new SomeBean(2) };
-// these will be wrapped
-JSONArray jArr = new JSONArray(myArr);
-// these will not be wrapped
-jArr.putAll(new SomeBean[]{ new SomeBean(3), new SomeBean(4) });
-```
-
-For structure consistency, it would be recommended that the above code is changed
-to look like 1 of 2 ways.
-
-Option 1:
-```Java
-SomeBean[] myArr = new SomeBean[]{ new SomeBean(1), new SomeBean(2) };
-JSONArray jArr = new JSONArray();
-// these will not be wrapped
-jArr.putAll(myArr);
-// these will not be wrapped
-jArr.putAll(new SomeBean[]{ new SomeBean(3), new SomeBean(4) });
-// our jArr is now consistent.
-```
-
-Option 2:
-```Java
-SomeBean[] myArr = new SomeBean[]{ new SomeBean(1), new SomeBean(2) };
-// these will be wrapped
-JSONArray jArr = new JSONArray(myArr);
-// these will be wrapped
-jArr.putAll(new JSONArray(new SomeBean[]{ new SomeBean(3), new SomeBean(4) }));
-// our jArr is now consistent.
-```
-
-**Unit Test Conventions**
-
-Test filenames should consist of the name of the module being tested, with the suffix "Test". 
-For example, <b>Cookie.java</b> is tested by <b>CookieTest.java</b>.
-
-<b>The fundamental issues with JSON-Java testing are:</b><br>
-* <b>JSONObjects</b> are unordered, making simple string comparison ineffective. 
-* Comparisons via **equals()** is not currently supported. Neither <b>JSONArray</b> nor <b>JSONObject</b> override <b>hashCode()</b> or <b>equals()</b>, so comparison defaults to the <b>Object</b> equals(), which is not useful.
-* Access to the <b>JSONArray</b> and <b>JSONObject</b> internal containers for comparison is not currently available.
-
-<b>General issues with unit testing are:</b><br>
-* Just writing tests to make coverage goals tends to result in poor tests. 
-* Unit tests are a form of documentation - how a given method works is demonstrated by the test. So for a code reviewer or future developer looking at code a good test helps explain how a function is supposed to work according to the original author. This can be difficult if you are not the original developer.
-*   It is difficult to evaluate unit tests in a vacuum. You also need to see the code being tested to understand if a test is good. 
-* Without unit tests, it is hard to feel confident about the quality of the code, especially when fixing bugs or refactoring. Good tests prevent regressions and keep the intent of the code correct.
-* If you have unit test results along with pull requests, the reviewer has an easier time understanding your code and determining if it works as intended.
-
+For more information, please see [NOTES.md](https://github.com/stleary/JSON-java/blob/master/docs/NOTES.md)

 # Files

-**JSONObject.java**: The `JSONObject` can parse text from a `String` or a `JSONTokener`
-to produce a map-like object. The object provides methods for manipulating its
-contents, and for producing a JSON compliant object serialization.
-
-**JSONArray.java**: The `JSONArray` can parse text from a String or a `JSONTokener`
-to produce a vector-like object. The object provides methods for manipulating
-its contents, and for producing a JSON compliant array serialization.
-
-**JSONTokener.java**: The `JSONTokener` breaks a text into a sequence of individual
-tokens. It can be constructed from a `String`, `Reader`, or `InputStream`. It also can 
-parse text from a `String`, `Number`, `Boolean` or `null` like `"hello"`, `42`, `true`, 
-`null` to produce a simple json object.
-
-**JSONException.java**: The `JSONException` is the standard exception type thrown
-by this package.
-
-**JSONPointer.java**: Implementation of
-[JSON Pointer (RFC 6901)](https://tools.ietf.org/html/rfc6901). Supports
-JSON Pointers both in the form of string representation and URI fragment
-representation.
-
-**JSONPropertyIgnore.java**: Annotation class that can be used on Java Bean getter methods.
-When used on a bean method that would normally be serialized into a `JSONObject`, it
-overrides the getter-to-key-name logic and forces the property to be excluded from the
-resulting `JSONObject`.
-
-**JSONPropertyName.java**: Annotation class that can be used on Java Bean getter methods.
-When used on a bean method that would normally be serialized into a `JSONObject`, it
-overrides the getter-to-key-name logic and uses the value of the annotation. The Bean
-processor will look through the class hierarchy. This means you can use the annotation on
-a base class or interface and the value of the annotation will be used even if the getter
-is overridden in a child class.   
-
-**JSONString.java**: The `JSONString` interface requires a `toJSONString` method,
-allowing an object to provide its own serialization.
-
-**JSONStringer.java**: The `JSONStringer` provides a convenient facility for
-building JSON strings.
-
-**JSONWriter.java**: The `JSONWriter` provides a convenient facility for building
-JSON text through a writer.
-
-
-**CDL.java**: `CDL` provides support for converting between JSON and comma
-delimited lists.
-
-**Cookie.java**: `Cookie` provides support for converting between JSON and cookies.
-
-**CookieList.java**: `CookieList` provides support for converting between JSON and
-cookie lists.
-
-**HTTP.java**: `HTTP` provides support for converting between JSON and HTTP headers.
-
-**HTTPTokener.java**: `HTTPTokener` extends `JSONTokener` for parsing HTTP headers.
-
-**XML.java**: `XML` provides support for converting between JSON and XML.
-
-**JSONML.java**: `JSONML` provides support for converting between JSONML and XML.
-
-**XMLTokener.java**: `XMLTokener` extends `JSONTokener` for parsing XML text.
-
+For more information on files, please see [FILES.md](https://github.com/stleary/JSON-java/blob/master/docs/FILES.md)

 # Release history:

-JSON-java releases can be found by searching the Maven repository for groupId "org.json"
-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)
-
-~~~
-20210307    Recent commits and potentially breaking fix to JSONPointer
-
-20201115    Recent commits and first release after project structure change
-
-20200518    Recent commits and snapshot before project structure change
-
-20190722    Recent commits
-
-20180813    POM change to include Automatic-Module-Name (#431)
-
-20180130    Recent commits
-
-20171018    Checkpoint for recent commits.
-
-20170516    Roll up recent commits.
-
-20160810    Revert code that was breaking opt*() methods.
-
-20160807    This release contains a bug in the JSONObject.opt*() and JSONArray.opt*() methods,
-it is not recommended for use.
-Java 1.6 compatability fixed, JSONArray.toList() and JSONObject.toMap(),
-RFC4180 compatibility, JSONPointer, some exception fixes, optional XML type conversion.
-Contains the latest code as of 7 Aug 2016
-
-20160212    Java 1.6 compatibility, OSGi bundle. Contains the latest code as of 12 Feb 2016.
-
-20151123    JSONObject and JSONArray initialization with generics. Contains the latest code as of 23 Nov 2015.
-
-20150729    Checkpoint for Maven central repository release. Contains the latest code
-as of 29 July 2015.
-~~~
+For the release history, please see [RELEASES.md](https://github.com/stleary/JSON-java/blob/master/docs/RELEASES.md)
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -0,0 +1,5 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+Please follow the instructions in the ["How are vulnerabilities and exploits handled?"](https://github.com/stleary/JSON-java/wiki/FAQ#how-are-vulnerabilities-and-exploits-handled) section in the FAQ.
--- a/docs/CONTRIBUTING.md
+++ b/docs/CONTRIBUTING.md
@@ -0,0 +1,22 @@
+# Contribution Guidelines
+
+Feel free to work on any issue with a #hacktoberfest label.
+
+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.
+
+# Who is allowed to submit pull requests for this project?
+
+Anyone can submit pull requests for code, tests, or documentation.
+
+# How do you decide which pull requests to accept?
+
+* Does it call out a bug that needs to be fixed? If so, it goes to the top of the list.
+* Does it fix a major user inconvenience? These are given high priority as well.
+* Does it align with the specs? If not, it will probably not be accepted. It turns out there are gray areas in the specs. If this is in a gray area, it will likely be given the benefit of the doubt.
+* Does it break the existing behavior of the lib? If so, it will not be accepted, unless it fixes an egregious bug. This is happening less frequently now.
+
+# For more guidance, see these links:
+
+[README.md (includes build instructions)](https://github.com/stleary/JSON-java#readme)
+
+[FAQ - all your questions answered](https://github.com/stleary/JSON-java/wiki/FAQ)
--- a/docs/FILES.md
+++ b/docs/FILES.md
@@ -0,0 +1,62 @@
+# Files
+
+**JSONObject.java**: The `JSONObject` can parse text from a `String` or a `JSONTokener`
+to produce a map-like object. The object provides methods for manipulating its
+contents, and for producing a JSON compliant object serialization.
+
+**JSONArray.java**: The `JSONArray` can parse text from a String or a `JSONTokener`
+to produce a vector-like object. The object provides methods for manipulating
+its contents, and for producing a JSON compliant array serialization.
+
+**JSONTokener.java**: The `JSONTokener` breaks a text into a sequence of individual
+tokens. It can be constructed from a `String`, `Reader`, or `InputStream`. It also can 
+parse text from a `String`, `Number`, `Boolean` or `null` like `"hello"`, `42`, `true`, 
+`null` to produce a simple json object.
+
+**JSONException.java**: The `JSONException` is the standard exception type thrown
+by this package.
+
+**JSONPointer.java**: Implementation of
+[JSON Pointer (RFC 6901)](https://tools.ietf.org/html/rfc6901). Supports
+JSON Pointers both in the form of string representation and URI fragment
+representation.
+
+**JSONPropertyIgnore.java**: Annotation class that can be used on Java Bean getter methods.
+When used on a bean method that would normally be serialized into a `JSONObject`, it
+overrides the getter-to-key-name logic and forces the property to be excluded from the
+resulting `JSONObject`.
+
+**JSONPropertyName.java**: Annotation class that can be used on Java Bean getter methods.
+When used on a bean method that would normally be serialized into a `JSONObject`, it
+overrides the getter-to-key-name logic and uses the value of the annotation. The Bean
+processor will look through the class hierarchy. This means you can use the annotation on
+a base class or interface and the value of the annotation will be used even if the getter
+is overridden in a child class.   
+
+**JSONString.java**: The `JSONString` interface requires a `toJSONString` method,
+allowing an object to provide its own serialization.
+
+**JSONStringer.java**: The `JSONStringer` provides a convenient facility for
+building JSON strings.
+
+**JSONWriter.java**: The `JSONWriter` provides a convenient facility for building
+JSON text through a writer.
+
+
+**CDL.java**: `CDL` provides support for converting between JSON and comma
+delimited lists.
+
+**Cookie.java**: `Cookie` provides support for converting between JSON and cookies.
+
+**CookieList.java**: `CookieList` provides support for converting between JSON and
+cookie lists.
+
+**HTTP.java**: `HTTP` provides support for converting between JSON and HTTP headers.
+
+**HTTPTokener.java**: `HTTPTokener` extends `JSONTokener` for parsing HTTP headers.
+
+**XML.java**: `XML` provides support for converting between JSON and XML.
+
+**JSONML.java**: `JSONML` provides support for converting between JSONML and XML.
+
+**XMLTokener.java**: `XMLTokener` extends `JSONTokener` for parsing XML text.
--- a/docs/NOTES.md
+++ b/docs/NOTES.md
@@ -0,0 +1,87 @@
+# Notes
+
+**Recent directory structure change**
+
+_Due to a recent commit - [#515 Merge tests and pom and code](https://github.com/stleary/JSON-java/pull/515) - the structure of the project has changed from a flat directory containing all of the Java files to a directory structure that includes unit tests and several tools used to build the project jar and run the unit tests. If you have difficulty using the new structure, please open an issue so we can work through it._
+
+**Implementation notes**
+
+Numeric types in this package comply with
+[ECMA-404: The JSON Data Interchange Format](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf) and
+[RFC 8259: The JavaScript Object Notation (JSON) Data Interchange Format](https://tools.ietf.org/html/rfc8259#section-6).
+This package fully supports `Integer`, `Long`, and `Double` Java types. Partial support
+for `BigInteger` and `BigDecimal` values in `JSONObject` and `JSONArray` objects is provided
+in the form of `get()`, `opt()`, and `put()` API methods.
+
+Although 1.6 compatibility is currently supported, it is not a project goal and might be
+removed in some future release.
+
+In compliance with RFC8259 page 10 section 9, the parser is more lax with what is valid
+JSON then the Generator. For Example, the tab character (U+0009) is allowed when reading
+JSON Text strings, but when output by the Generator, the tab is properly converted to \t in
+the string. Other instances may occur where reading invalid JSON text does not cause an
+error to be generated. Malformed JSON Texts such as missing end " (quote) on strings or
+invalid number formats (1.2e6.3) will cause errors as such documents can not be read
+reliably.
+
+Some notable exceptions that the JSON Parser in this library accepts are:
+* Unquoted keys `{ key: "value" }`
+* Unquoted values `{ "key": value }`
+* Unescaped literals like "tab" in string values `{ "key": "value   with an unescaped tab" }`
+* Numbers out of range for `Double` or `Long` are parsed as strings
+
+Recent pull requests added a new method `putAll` on the JSONArray. The `putAll` method
+works similarly to other `put` methods in that it does not call `JSONObject.wrap` for items
+added. This can lead to inconsistent object representation in JSONArray structures.
+
+For example, code like this will create a mixed JSONArray, some items wrapped, others
+not:
+
+```java
+SomeBean[] myArr = new SomeBean[]{ new SomeBean(1), new SomeBean(2) };
+// these will be wrapped
+JSONArray jArr = new JSONArray(myArr);
+// these will not be wrapped
+jArr.putAll(new SomeBean[]{ new SomeBean(3), new SomeBean(4) });
+```
+
+For structure consistency, it would be recommended that the above code is changed
+to look like 1 of 2 ways.
+
+Option 1:
+```Java
+SomeBean[] myArr = new SomeBean[]{ new SomeBean(1), new SomeBean(2) };
+JSONArray jArr = new JSONArray();
+// these will not be wrapped
+jArr.putAll(myArr);
+// these will not be wrapped
+jArr.putAll(new SomeBean[]{ new SomeBean(3), new SomeBean(4) });
+// our jArr is now consistent.
+```
+
+Option 2:
+```Java
+SomeBean[] myArr = new SomeBean[]{ new SomeBean(1), new SomeBean(2) };
+// these will be wrapped
+JSONArray jArr = new JSONArray(myArr);
+// these will be wrapped
+jArr.putAll(new JSONArray(new SomeBean[]{ new SomeBean(3), new SomeBean(4) }));
+// our jArr is now consistent.
+```
+
+**Unit Test Conventions**
+
+Test filenames should consist of the name of the module being tested, with the suffix "Test". 
+For example, <b>Cookie.java</b> is tested by <b>CookieTest.java</b>.
+
+<b>The fundamental issues with JSON-Java testing are:</b><br>
+* <b>JSONObjects</b> are unordered, making simple string comparison ineffective. 
+* Comparisons via **equals()** is not currently supported. Neither <b>JSONArray</b> nor <b>JSONObject</b> override <b>hashCode()</b> or <b>equals()</b>, so comparison defaults to the <b>Object</b> equals(), which is not useful.
+* Access to the <b>JSONArray</b> and <b>JSONObject</b> internal containers for comparison is not currently available.
+
+<b>General issues with unit testing are:</b><br>
+* Just writing tests to make coverage goals tends to result in poor tests. 
+* Unit tests are a form of documentation - how a given method works is demonstrated by the test. So for a code reviewer or future developer looking at code a good test helps explain how a function is supposed to work according to the original author. This can be difficult if you are not the original developer.
+*   It is difficult to evaluate unit tests in a vacuum. You also need to see the code being tested to understand if a test is good. 
+* Without unit tests, it is hard to feel confident about the quality of the code, especially when fixing bugs or refactoring. Good tests prevent regressions and keep the intent of the code correct.
+* If you have unit test results along with pull requests, the reviewer has an easier time understanding your code and determining if it works as intended.
--- a/docs/RELEASES.md
+++ b/docs/RELEASES.md
@@ -0,0 +1,40 @@
+# Release history:
+
+JSON-java releases can be found by searching the Maven repository for groupId "org.json"
+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)
+
+~~~
+20211205    Recent commits and some bug fixes for similar()
+
+20210307    Recent commits and potentially breaking fix to JSONPointer
+
+20201115    Recent commits and first release after project structure change
+
+20200518    Recent commits and snapshot before project structure change
+
+20190722    Recent commits
+
+20180813    POM change to include Automatic-Module-Name (#431)
+
+20180130    Recent commits
+
+20171018    Checkpoint for recent commits.
+
+20170516    Roll up recent commits.
+
+20160810    Revert code that was breaking opt*() methods.
+
+20160807    This release contains a bug in the JSONObject.opt*() and JSONArray.opt*() methods,
+it is not recommended for use.
+Java 1.6 compatability fixed, JSONArray.toList() and JSONObject.toMap(),
+RFC4180 compatibility, JSONPointer, some exception fixes, optional XML type conversion.
+Contains the latest code as of 7 Aug 2016
+
+20160212    Java 1.6 compatibility, OSGi bundle. Contains the latest code as of 12 Feb 2016.
+
+20151123    JSONObject and JSONArray initialization with generics. Contains the latest code as of 23 Nov 2015.
+
+20150729    Checkpoint for Maven central repository release. Contains the latest code
+as of 29 July 2015.
+~~~
--- a/docs/SECURITY.md
+++ b/docs/SECURITY.md
@@ -0,0 +1,5 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+Please follow the instructions in the ["How are vulnerabilities and exploits handled?"](https://github.com/stleary/JSON-java/wiki/FAQ#how-are-vulnerabilities-and-exploits-handled) section in the FAQ.
--- a/images/JsonJava.png
+++ b/images/JsonJava.png
--- a/pom.xml
+++ b/pom.xml
@@ -3,7 +3,7 @@

    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
-    <version>20210307</version>
+    <version>20211205</version>
    <packaging>bundle</packaging>

    <name>JSON in Java</name>
--- a/src/main/java/org/json/Cookie.java
+++ b/src/main/java/org/json/Cookie.java
@@ -109,7 +109,7 @@ public class Cookie {
        // parse the remaining cookie attributes
        while (x.more()) {
            name = unescape(x.nextTo("=;")).trim().toLowerCase(Locale.ROOT);
-            // don't allow a cookies attributes to overwrite it's name or value.
+            // don't allow a cookies attributes to overwrite its name or value.
            if("name".equalsIgnoreCase(name)) {
                throw new JSONException("Illegal attribute name: 'name'");
            }
--- a/src/main/java/org/json/JSONArray.java
+++ b/src/main/java/org/json/JSONArray.java
@@ -326,7 +326,7 @@ public class JSONArray implements Iterable<Object> {
    public float getFloat(int index) throws JSONException {
        final Object object = this.get(index);
        if(object instanceof Number) {
-            return ((Float)object).floatValue();
+            return ((Number)object).floatValue();
        }
        try {
            return Float.parseFloat(object.toString());
@@ -385,7 +385,7 @@ public class JSONArray implements Iterable<Object> {

    /**
     * Get the BigDecimal value associated with an index. If the value is float
-     * or double, the the {@link BigDecimal#BigDecimal(double)} constructor
+     * or double, the {@link BigDecimal#BigDecimal(double)} constructor
     * will be used. See notes on the constructor for conversion issues that
     * may arise.
     *
@@ -792,7 +792,7 @@ public class JSONArray implements Iterable<Object> {
     * Get the optional BigDecimal 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. If the value
-     * is float or double, the the {@link BigDecimal#BigDecimal(double)}
+     * is float or double, the {@link BigDecimal#BigDecimal(double)}
     * constructor will be used. See notes on the constructor for conversion
     * issues that may arise.
     *
@@ -1157,7 +1157,7 @@ public class JSONArray implements Iterable<Object> {
     *            The Map value.
     * @return this.
     * @throws JSONException
-     *             If the index is negative or if the the value is an invalid
+     *             If the index is negative or if the value is an invalid
     *             number.
     * @throws NullPointerException
     *             If a key in the map is <code>null</code>
@@ -1180,7 +1180,7 @@ public class JSONArray implements Iterable<Object> {
     *            String, or the JSONObject.NULL object.
     * @return this.
     * @throws JSONException
-     *             If the index is negative or if the the value is an invalid
+     *             If the index is negative or if the value is an invalid
     *             number.
     */
    public JSONArray put(int index, Object value) throws JSONException {
@@ -1383,7 +1383,9 @@ public class JSONArray implements Iterable<Object> {
                    return false;
                }
            } else if (valueThis instanceof Number && valueOther instanceof Number) {
-                return JSONObject.isNumberSimilar((Number)valueThis, (Number)valueOther);
+                if (!JSONObject.isNumberSimilar((Number)valueThis, (Number)valueOther)) {
+                	return false;
+                }
            } else if (!valueThis.equals(valueOther)) {
                return false;
            }
--- a/src/main/java/org/json/JSONObject.java
+++ b/src/main/java/org/json/JSONObject.java
@@ -37,8 +37,10 @@ import java.lang.reflect.Modifier;
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.Enumeration;
 import java.util.HashMap;
+import java.util.IdentityHashMap;
 import java.util.Iterator;
 import java.util.Locale;
 import java.util.Map;
@@ -128,6 +130,7 @@ public class JSONObject {
         *         null.
         */
        @Override
+        @SuppressWarnings("lgtm[java/unchecked-cast-in-equals]")
        public boolean equals(Object object) {
            return object == null || object == this;
        }
@@ -364,6 +367,11 @@ public class JSONObject {
        this.populateMap(bean);
    }

+    private JSONObject(Object bean, Set<Object> objectsRecord) {
+        this();
+        this.populateMap(bean, objectsRecord);
+    }
+
    /**
     * Construct a JSONObject from an Object, using reflection to find the
     * public members. The resulting JSONObject's keys will be the strings from
@@ -644,7 +652,7 @@ public class JSONObject {

    /**
     * Get the BigDecimal value associated with a key. If the value is float or
-     * double, the the {@link BigDecimal#BigDecimal(double)} constructor will
+     * double, the {@link BigDecimal#BigDecimal(double)} constructor will
     * be used. See notes on the constructor for conversion issues that may
     * arise.
     *
@@ -1159,6 +1167,18 @@ public class JSONObject {
     *          to convert.
     */
    static BigDecimal objectToBigDecimal(Object val, BigDecimal defaultValue) {
+        return objectToBigDecimal(val, defaultValue, true);
+    }
+    
+    /**
+     * @param val value to convert
+     * @param defaultValue default value to return is the conversion doesn't work or is null.
+     * @param exact When <code>true</code>, then {@link Double} and {@link Float} values will be converted exactly.
+     *      When <code>false</code>, they will be converted to {@link String} values before converting to {@link BigDecimal}.
+     * @return BigDecimal conversion of the original value, or the defaultValue if unable
+     *          to convert.
+     */
+    static BigDecimal objectToBigDecimal(Object val, BigDecimal defaultValue, boolean exact) {
        if (NULL.equals(val)) {
            return defaultValue;
        }
@@ -1172,7 +1192,14 @@ public class JSONObject {
            if (!numberIsFinite((Number)val)) {
                return defaultValue;
            }
-            return new BigDecimal(((Number) val).doubleValue());
+            if (exact) {
+                return new BigDecimal(((Number)val).doubleValue());
+            }else {
+                // use the string constructor so that we maintain "nice" values for doubles and floats
+                // the double constructor will translate doubles to "exact" values instead of the likely
+                // intended representation
+                return new BigDecimal(val.toString());
+            }
        }
        if (val instanceof Long || val instanceof Integer
                || val instanceof Short || val instanceof Byte){
@@ -1370,9 +1397,21 @@ public class JSONObject {
     *            A key string.
     * @return A JSONObject which is the value.
     */
-    public JSONObject optJSONObject(String key) {
+    public JSONObject optJSONObject(String key) { return this.optJSONObject(key, null); }
+
+    /**
+     * Get an optional JSONObject associated with a key, or the default if there
+     * is no such key or if the value is not a JSONObject.
+     *
+     * @param key
+     *            A key string.
+     * @param defaultValue
+     *            The default.
+     * @return An JSONObject which is the value.
+     */
+    public JSONObject optJSONObject(String key, JSONObject defaultValue) {
        Object object = this.opt(key);
-        return object instanceof JSONObject ? (JSONObject) object : null;
+        return object instanceof JSONObject ? (JSONObject) object : defaultValue;
    }

    /**
@@ -1488,6 +1527,10 @@ public class JSONObject {
     *            the bean
     */
    private void populateMap(Object bean) {
+        populateMap(bean, Collections.newSetFromMap(new IdentityHashMap<Object, Boolean>()));
+    }
+
+    private void populateMap(Object bean, Set<Object> objectsRecord) {
        Class<?> klass = bean.getClass();

        // If klass is a System class then set includeSuperClass to false.
@@ -1508,10 +1551,22 @@ public class JSONObject {
                    try {
                        final Object result = method.invoke(bean);
                        if (result != null) {
-                            this.map.put(key, wrap(result));
+                            // check cyclic dependency and throw error if needed
+                            // the wrap and populateMap combination method is 
+                            // itself DFS recursive
+                            if (objectsRecord.contains(result)) {
+                                throw recursivelyDefinedObjectException(key);
+                            }
+                            
+                            objectsRecord.add(result);
+
+                            this.map.put(key, wrap(result, objectsRecord));
+
+                            objectsRecord.remove(result);
+
                            // we don't use the result anywhere outside of wrap
                            // if it's a resource we should be sure to close it
-                            // after calling toString
+                            // after calling toString 
                            if (result instanceof Closeable) {
                                try {
                                    ((Closeable) result).close();
@@ -1581,7 +1636,7 @@ public class JSONObject {
     * @param annotationClass
     *            annotation to look for
     * @return the {@link Annotation} if the annotation exists on the current method
-     *         or one of it's super class definitions
+     *         or one of its super class definitions
     */
    private static <A extends Annotation> A getAnnotation(final Method m, final Class<A> annotationClass) {
        // if we have invalid data the result is null
@@ -1627,9 +1682,6 @@ public class JSONObject {
     * implementations and interfaces has the annotation. Returns the depth of the
     * annotation in the hierarchy.
     *
-     * @param <A>
-     *            type of the annotation
-     *
     * @param m
     *            method to check
     * @param annotationClass
@@ -2080,7 +2132,9 @@ public class JSONObject {
                        return false;
                    }
                } else if (valueThis instanceof Number && valueOther instanceof Number) {
-                    return isNumberSimilar((Number)valueThis, (Number)valueOther);
+                    if (!isNumberSimilar((Number)valueThis, (Number)valueOther)) {
+                    	return false;
+                    };
                } else if (!valueThis.equals(valueOther)) {
                    return false;
                }
@@ -2123,8 +2177,8 @@ public class JSONObject {
        // BigDecimal should be able to handle all of our number types that we support through
        // documentation. Convert to BigDecimal first, then use the Compare method to
        // decide equality.
-        final BigDecimal lBigDecimal = objectToBigDecimal(l, null);
-        final BigDecimal rBigDecimal = objectToBigDecimal(r, null);
+        final BigDecimal lBigDecimal = objectToBigDecimal(l, null, false);
+        final BigDecimal rBigDecimal = objectToBigDecimal(r, null, false);
        if (lBigDecimal == null || rBigDecimal == null) {
            return false;
        }
@@ -2205,7 +2259,7 @@ public class JSONObject {
            // This will narrow any values to the smallest reasonable Object representation
            // (Integer, Long, or BigInteger)

-            // BigInteger down conversion: We use a similar bitLenth compare as
+            // 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.
@@ -2400,6 +2454,10 @@ public class JSONObject {
     * @return The wrapped value
     */
    public static Object wrap(Object object) {
+        return wrap(object, null);
+    }
+
+    private static Object wrap(Object object, Set<Object> objectsRecord) {
        try {
            if (NULL.equals(object)) {
                return NULL;
@@ -2434,7 +2492,15 @@ public class JSONObject {
                    || object.getClass().getClassLoader() == null) {
                return object.toString();
            }
-            return new JSONObject(object);
+            if (objectsRecord != null) {
+                return new JSONObject(object, objectsRecord);
+            }
+            else {
+                return new JSONObject(object);
+            }
+        }
+        catch (JSONException exception) {
+            throw exception;
        } catch (Exception exception) {
            return null;
        }
@@ -2645,4 +2711,15 @@ public class JSONObject {
                "JSONObject[" + quote(key) + "] is not a " + valueType + " (" + value + ")."
                , cause);
    }
+
+    /**
+     * Create a new JSONException in a common format for recursive object definition.
+     * @param key name of the key
+     * @return JSONException that can be thrown.
+     */
+    private static JSONException recursivelyDefinedObjectException(String key) {
+        return new JSONException(
+            "JavaBean object contains recursively defined member variable of key " + quote(key)
+        );
+    }
 }
--- a/src/main/java/org/json/JSONPointer.java
+++ b/src/main/java/org/json/JSONPointer.java
@@ -188,7 +188,7 @@ public class JSONPointer {
    }

    /**
-     * @see https://tools.ietf.org/html/rfc6901#section-3
+     * @see <a href="https://tools.ietf.org/html/rfc6901#section-3">rfc6901 section 3</a>
     */
    private static String unescape(String token) {
        return token.replace("~1", "/").replace("~0", "~");
@@ -268,7 +268,7 @@ public class JSONPointer {
     * @param token the JSONPointer segment value to be escaped
     * @return the escaped value for the token
     * 
-     * @see https://tools.ietf.org/html/rfc6901#section-3
+     * @see <a href="https://tools.ietf.org/html/rfc6901#section-3">rfc6901 section 3</a>
     */
    private static String escape(String token) {
        return token.replace("~", "~0")
--- a/src/main/java/org/json/JSONStringer.java
+++ b/src/main/java/org/json/JSONStringer.java
@@ -50,7 +50,7 @@ import java.io.StringWriter;
 * <p>
 * The first method called must be <code>array</code> or <code>object</code>.
 * There are no methods for adding commas or colons. JSONStringer adds them for
- * you. Objects and arrays can be nested up to 20 levels deep.
+ * you. Objects and arrays can be nested up to 200 levels deep.
 * <p>
 * This can sometimes be easier than using a JSONObject to build a string.
 * @author JSON.org
--- a/src/main/java/org/json/XML.java
+++ b/src/main/java/org/json/XML.java
@@ -380,12 +380,23 @@ public class XML {
                    if (x.nextToken() != GT) {
                        throw x.syntaxError("Misshaped tag");
                    }
-                    if (nilAttributeFound) {
-                        context.accumulate(tagName, JSONObject.NULL);
-                    } else if (jsonObject.length() > 0) {
-                        context.accumulate(tagName, jsonObject);
+                    if (config.getForceList().contains(tagName)) {
+                        // Force the value to be an array
+                        if (nilAttributeFound) {
+                            context.append(tagName, JSONObject.NULL);
+                        } else if (jsonObject.length() > 0) {
+                            context.append(tagName, jsonObject);
+                        } else {
+                            context.put(tagName, new JSONArray());
+                        }
                    } else {
-                        context.accumulate(tagName, "");
+                        if (nilAttributeFound) {
+                            context.accumulate(tagName, JSONObject.NULL);
+                        } else if (jsonObject.length() > 0) {
+                            context.accumulate(tagName, jsonObject);
+                        } else {
+                            context.accumulate(tagName, "");
+                        }
                    }
                    return false;

@@ -413,14 +424,27 @@ public class XML {
                        } else if (token == LT) {
                            // Nested element
                            if (parse(x, jsonObject, tagName, config)) {
-                                if (jsonObject.length() == 0) {
-                                    context.accumulate(tagName, "");
-                                } else if (jsonObject.length() == 1
-                                        && jsonObject.opt(config.getcDataTagName()) != null) {
-                                    context.accumulate(tagName, jsonObject.opt(config.getcDataTagName()));
+                                if (config.getForceList().contains(tagName)) {
+                                    // Force the value to be an array
+                                    if (jsonObject.length() == 0) {
+                                        context.put(tagName, new JSONArray());
+                                    } else if (jsonObject.length() == 1
+                                            && jsonObject.opt(config.getcDataTagName()) != null) {
+                                        context.append(tagName, jsonObject.opt(config.getcDataTagName()));
+                                    } else {
+                                        context.append(tagName, jsonObject);
+                                    }
                                } else {
-                                    context.accumulate(tagName, jsonObject);
+                                    if (jsonObject.length() == 0) {
+                                        context.accumulate(tagName, "");
+                                    } else if (jsonObject.length() == 1
+                                            && jsonObject.opt(config.getcDataTagName()) != null) {
+                                        context.accumulate(tagName, jsonObject.opt(config.getcDataTagName()));
+                                    } else {
+                                        context.accumulate(tagName, jsonObject);
+                                    }
                                }
+                                
                                return false;
                            }
                        }
@@ -532,7 +556,7 @@ public class XML {
            // This will narrow any values to the smallest reasonable Object representation
            // (Integer, Long, or BigInteger)
            
-            // BigInteger down conversion: We use a similar bitLenth compare as
+            // 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.
--- a/src/main/java/org/json/XMLParserConfiguration.java
+++ b/src/main/java/org/json/XMLParserConfiguration.java
@@ -25,7 +25,9 @@ SOFTWARE.

 import java.util.Collections;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Map;
+import java.util.Set;


 /**
@@ -66,6 +68,12 @@ public class XMLParserConfiguration {
     */
    private Map<String, XMLXsiTypeConverter<?>> xsiTypeMap;

+    /**
+     * When parsing the XML into JSON, specifies the tags whose values should be converted
+     * to arrays
+     */
+    private Set<String> forceList;
+
    /**
     * Default parser configuration. Does not keep strings (tries to implicitly convert
     * values), and the CDATA Tag Name is "content".
@@ -75,6 +83,7 @@ public class XMLParserConfiguration {
        this.cDataTagName = "content";
        this.convertNilAttributeToNull = false;
        this.xsiTypeMap = Collections.emptyMap();
+        this.forceList = Collections.emptySet();
    }

    /**
@@ -94,7 +103,7 @@ public class XMLParserConfiguration {
     * Configure the parser string processing to try and convert XML values to JSON values and
     * use the passed CDATA Tag Name the processing value. Pass <code>null</code> to
     * disable CDATA processing
-     * @param cDataTagName<code>null</code> to disable CDATA processing. Any other value
+     * @param cDataTagName <code>null</code> to disable CDATA processing. Any other value
     *      to use that value as the JSONObject key name to process as CDATA.
     * @deprecated This constructor has been deprecated in favor of using the new builder
     *      pattern for the configuration.
@@ -109,7 +118,7 @@ public class XMLParserConfiguration {
     * Configure the parser to use custom settings.
     * @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 cDataTagName<code>null</code> to disable CDATA processing. Any other value
+     * @param cDataTagName <code>null</code> to disable CDATA processing. Any other value
     *      to use that value as the JSONObject key name to process as CDATA.
     * @deprecated This constructor has been deprecated in favor of using the new builder
     *      pattern for the configuration.
@@ -151,13 +160,15 @@ 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 
     */
    private XMLParserConfiguration (final boolean keepStrings, final String cDataTagName,
-            final boolean convertNilAttributeToNull, final Map<String, XMLXsiTypeConverter<?>> xsiTypeMap ) {
+            final boolean convertNilAttributeToNull, final Map<String, XMLXsiTypeConverter<?>> xsiTypeMap, final Set<String> forceList ) {
        this.keepStrings = keepStrings;
        this.cDataTagName = cDataTagName;
        this.convertNilAttributeToNull = convertNilAttributeToNull;
        this.xsiTypeMap = Collections.unmodifiableMap(xsiTypeMap);
+        this.forceList = Collections.unmodifiableSet(forceList);
    }

    /**
@@ -174,7 +185,8 @@ public class XMLParserConfiguration {
                this.keepStrings,
                this.cDataTagName,
                this.convertNilAttributeToNull,
-                this.xsiTypeMap
+                this.xsiTypeMap,
+                this.forceList
        );
    }
    
@@ -182,7 +194,7 @@ public class XMLParserConfiguration {
     * 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 {@link #keepStrings} configuration value.
+     * @return The <code>keepStrings</code> configuration value.
     */
    public boolean isKeepStrings() {
        return this.keepStrings;
@@ -193,7 +205,7 @@ public class XMLParserConfiguration {
     * they should try to be guessed into JSON values (numeric, boolean, string)
     * 
     * @param newVal
-     *      new value to use for the {@link #keepStrings} configuration option.
+     *      new value to use for the <code>keepStrings</code> configuration option.
     * 
     * @return The existing configuration will not be modified. A new configuration is returned.
     */
@@ -208,7 +220,7 @@ public class XMLParserConfiguration {
     * been the value "content" but can be changed. Use <code>null</code> to indicate no CDATA
     * processing.
     * 
-     * @return The {@link #cDataTagName} configuration value.
+     * @return The <code>cDataTagName</code> configuration value.
     */
    public String getcDataTagName() {
        return this.cDataTagName;
@@ -220,7 +232,7 @@ public class XMLParserConfiguration {
     * processing.
     * 
     * @param newVal
-     *      new value to use for the {@link #cDataTagName} configuration option.
+     *      new value to use for the <code>cDataTagName</code> configuration option.
     * 
     * @return The existing configuration will not be modified. A new configuration is returned.
     */
@@ -235,7 +247,7 @@ public class XMLParserConfiguration {
     * should be kept as attribute(<code>false</code>), or they should be converted to
     * <code>null</code>(<code>true</code>)
     * 
-     * @return The {@link #convertNilAttributeToNull} configuration value.
+     * @return The <code>convertNilAttributeToNull</code> configuration value.
     */
    public boolean isConvertNilAttributeToNull() {
        return this.convertNilAttributeToNull;
@@ -247,7 +259,7 @@ public class XMLParserConfiguration {
     * <code>null</code>(<code>true</code>)
     * 
     * @param newVal
-     *      new value to use for the {@link #convertNilAttributeToNull} configuration option.
+     *      new value to use for the <code>convertNilAttributeToNull</code> configuration option.
     * 
     * @return The existing configuration will not be modified. A new configuration is returned.
     */
@@ -262,7 +274,7 @@ public class XMLParserConfiguration {
     * will be converted to target type defined to client in this configuration
     * {@code Map<String, XMLXsiTypeConverter<?>>} to parse values with attribute
     * xsi:type="integer" as integer,  xsi:type="string" as string
-     * @return {@link #xsiTypeMap} unmodifiable configuration map.
+     * @return <code>xsiTypeMap</code> unmodifiable configuration map.
     */
    public Map<String, XMLXsiTypeConverter<?>> getXsiTypeMap() {
        return this.xsiTypeMap;
@@ -283,4 +295,26 @@ public class XMLParserConfiguration {
        newConfig.xsiTypeMap = Collections.unmodifiableMap(cloneXsiTypeMap);
        return newConfig;
    }
+
+    /**
+     * 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 
+     * @return <code>forceList</code> unmodifiable configuration set.
+     */
+    public Set<String> getForceList() {
+        return this.forceList;
+    }
+
+    /**
+     * 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 
+     * @return The existing configuration will not be modified. A new configuration is returned.
+     */
+    public XMLParserConfiguration withForceList(final Set<String> forceList) {
+        XMLParserConfiguration newConfig = this.clone();
+        Set<String> cloneForceList = new HashSet<String>(forceList);
+        newConfig.forceList = Collections.unmodifiableSet(cloneForceList);
+        return newConfig;
+    }
 }
--- a/src/test/java/org/json/junit/EnumTest.java
+++ b/src/test/java/org/json/junit/EnumTest.java
@@ -93,7 +93,7 @@ public class EnumTest {

    /**
     * To serialize an enum by its set of allowed values, use getNames()
-     * and the the JSONObject Object with names constructor. 
+     * and the JSONObject Object with names constructor.
     */
    @Test
    public void jsonObjectFromEnumWithNames() {
--- a/src/test/java/org/json/junit/JSONArrayTest.java
+++ b/src/test/java/org/json/junit/JSONArrayTest.java
@@ -87,6 +87,7 @@ public class JSONArrayTest {
    @Test
    public void verifySimilar() {
        final String string1 = "HasSameRef";
+        final String string2 = "HasDifferentRef";
        JSONArray obj1 = new JSONArray()
                .put("abc")
                .put(string1)
@@ -101,10 +102,20 @@ public class JSONArrayTest {
                .put("abc")
                .put(new String(string1))
                .put(2);
+
+        JSONArray obj4 = new JSONArray()
+                .put("abc")
+                .put(2.0)
+        		.put(new String(string1));
+
+        JSONArray obj5 = new JSONArray()
+                .put("abc")
+                .put(2.0)
+        		.put(new String(string2));
        
-        assertFalse("Should eval to false", obj1.similar(obj2));
-        
-        assertTrue("Should eval to true", obj1.similar(obj3));
+        assertFalse("obj1-obj2 Should eval to false", obj1.similar(obj2));
+        assertTrue("obj1-obj3 Should eval to true", obj1.similar(obj3));
+        assertFalse("obj4-obj5 Should eval to false", obj4.similar(obj5));
    }
        
    /**
@@ -364,6 +375,8 @@ public class JSONArrayTest {
                new Double(23.45e-4).equals(jsonArray.getDouble(5)));
        assertTrue("Array string double",
                new Double(23.45).equals(jsonArray.getDouble(6)));
+        assertTrue("Array double can be float",
+                new Float(23.45e-4f).equals(jsonArray.getFloat(5)));
        // ints
        assertTrue("Array value int",
                new Integer(42).equals(jsonArray.getInt(7)));
--- a/src/test/java/org/json/junit/JSONObjectTest.java
+++ b/src/test/java/org/json/junit/JSONObjectTest.java
@@ -73,6 +73,8 @@ import org.json.junit.data.MyJsonString;
 import org.json.junit.data.MyNumber;
 import org.json.junit.data.MyNumberContainer;
 import org.json.junit.data.MyPublicClass;
+import org.json.junit.data.RecursiveBean;
+import org.json.junit.data.RecursiveBeanEquals;
 import org.json.junit.data.Singleton;
 import org.json.junit.data.SingletonEnum;
 import org.json.junit.data.WeirdList;
@@ -100,6 +102,7 @@ public class JSONObjectTest {
    @Test
    public void verifySimilar() {
        final String string1 = "HasSameRef";
+        final String string2 = "HasDifferentRef";
        JSONObject obj1 = new JSONObject()
                .put("key1", "abc")
                .put("key2", 2)
@@ -119,13 +122,23 @@ public class JSONObjectTest {
                .put("key1", "abc")
                .put("key2", 2.0)
                .put("key3", new String(string1));
-        
-        assertFalse("Should eval to false", obj1.similar(obj2));

-        assertTrue("Should eval to true", obj1.similar(obj3));
-        
-        assertTrue("Should eval to true", obj1.similar(obj4));
+        JSONObject obj5 = new JSONObject()
+                .put("key1", "abc")
+                .put("key2", 2.0)
+                .put("key3", new String(string2));
        
+        assertFalse("obj1-obj2 Should eval to false", obj1.similar(obj2));
+        assertTrue("obj1-obj3 Should eval to true", obj1.similar(obj3));
+        assertTrue("obj1-obj4 Should eval to true", obj1.similar(obj4));
+        assertFalse("obj1-obj5 Should eval to false", obj1.similar(obj5));
+        // verify that a double and big decimal are "similar"
+        assertTrue("should eval to true",new JSONObject().put("a",1.1d).similar(new JSONObject("{\"a\":1.1}")));
+        // Confirm #618 is fixed (compare should not exit early if similar numbers are found)
+        // Note that this test may not work if the JSONObject map entry order changes
+        JSONObject first = new JSONObject("{\"a\": 1, \"b\": 2, \"c\": 3}");
+        JSONObject second = new JSONObject("{\"a\": 1, \"b\": 2.0, \"c\": 4}");
+        assertFalse("first-second should eval to false", first.similar(second));
    }
    
    @Test
@@ -940,7 +953,7 @@ public class JSONObjectTest {
        assertTrue("-0 Should be a Double!",JSONObject.stringToValue("-0")  instanceof Double);
        assertTrue("-0.0 Should be a Double!",JSONObject.stringToValue("-0.0") instanceof Double);
        assertTrue("'-' Should be a String!",JSONObject.stringToValue("-") instanceof String);
-        assertTrue( "0.2 should be a Double!",
+        assertTrue( "0.2 should be a BigDecimal!",
                JSONObject.stringToValue( "0.2" ) instanceof BigDecimal );
        assertTrue( "Doubles should be BigDecimal, even when incorrectly converting floats!",
                JSONObject.stringToValue( new Double( "0.2f" ).toString() ) instanceof BigDecimal );
@@ -1667,7 +1680,7 @@ public class JSONObjectTest {
        // correct implementation (with change of behavior) would be:
        // this.put(key, new Float((Float) value + 1)); 
        // Probably it would be better to deprecate the method and remove some day, while convenient processing the "payload" is not
-        // really in the the scope of a JSON-library (IMHO.)
+        // really in the scope of a JSON-library (IMHO.)

    }

@@ -2404,8 +2417,8 @@ public class JSONObjectTest {
                MyEnum.VAL1.equals(jsonObject.optEnum(MyEnum.class, "myKey", MyEnum.VAL1)));
        assertTrue("optJSONArray() should return null ",
                null==jsonObject.optJSONArray("myKey"));
-        assertTrue("optJSONObject() should return null ",
-                null==jsonObject.optJSONObject("myKey"));
+        assertTrue("optJSONObject() should return default JSONObject ",
+                jsonObject.optJSONObject("myKey", new JSONObject("{\"testKey\":\"testValue\"}")).getString("testKey").equals("testValue"));
        assertTrue("optLong() should return default long",
                42l == jsonObject.optLong("myKey", 42l));
        assertTrue("optDouble() should return default double",
@@ -2440,8 +2453,8 @@ public class JSONObjectTest {
                 MyEnum.VAL1.equals(jsonObject.optEnum(MyEnum.class, "myKey", MyEnum.VAL1)));
         assertTrue("optJSONArray() should return null ",
                 null==jsonObject.optJSONArray("myKey"));
-         assertTrue("optJSONObject() should return null ",
-                 null==jsonObject.optJSONObject("myKey"));
+         assertTrue("optJSONObject() should return default JSONObject ",
+                jsonObject.optJSONObject("myKey", new JSONObject("{\"testKey\":\"testValue\"}")).getString("testKey").equals("testValue"));
         assertTrue("optLong() should return default long",
                 42l == jsonObject.optLong("myKey", 42l));
         assertTrue("optDouble() should return default double",
@@ -3207,6 +3220,114 @@ public class JSONObjectTest {
        jsonObject.put(null, new Object());
        fail("Expected an exception");
    }
+    @Test(expected=JSONException.class)
+    public void testSelfRecursiveObject() {
+        // A -> A ...
+        RecursiveBean ObjA = new RecursiveBean("ObjA");
+        ObjA.setRef(ObjA);
+        new JSONObject(ObjA);
+        fail("Expected an exception");
+    }
+    @Test(expected=JSONException.class)
+    public void testLongSelfRecursiveObject() {
+        // B -> A -> A ...
+        RecursiveBean ObjA = new RecursiveBean("ObjA");
+        RecursiveBean ObjB = new RecursiveBean("ObjB");
+        ObjB.setRef(ObjA);
+        ObjA.setRef(ObjA);
+        new JSONObject(ObjB);
+        fail("Expected an exception");
+    }
+    @Test(expected=JSONException.class)
+    public void testSimpleRecursiveObject() {
+        // B -> A -> B ...
+        RecursiveBean ObjA = new RecursiveBean("ObjA");
+        RecursiveBean ObjB = new RecursiveBean("ObjB");
+        ObjB.setRef(ObjA);
+        ObjA.setRef(ObjB);
+        new JSONObject(ObjA);
+        fail("Expected an exception");
+    }
+    @Test(expected=JSONException.class)
+    public void testLongRecursiveObject() {
+        // D -> C -> B -> A -> D ...
+        RecursiveBean ObjA = new RecursiveBean("ObjA");
+        RecursiveBean ObjB = new RecursiveBean("ObjB");
+        RecursiveBean ObjC = new RecursiveBean("ObjC");
+        RecursiveBean ObjD = new RecursiveBean("ObjD");
+        ObjC.setRef(ObjB);
+        ObjB.setRef(ObjA);
+        ObjD.setRef(ObjC);
+        ObjA.setRef(ObjD);
+        new JSONObject(ObjB);
+        fail("Expected an exception");
+    }
+    @Test(expected=JSONException.class)
+    public void testRepeatObjectRecursive() {
+        // C -> B -> A -> D -> C ...
+        //        -> D -> C ...
+        RecursiveBean ObjA = new RecursiveBean("ObjA");
+        RecursiveBean ObjB = new RecursiveBean("ObjB");
+        RecursiveBean ObjC = new RecursiveBean("ObjC");
+        RecursiveBean ObjD = new RecursiveBean("ObjD");
+        ObjC.setRef(ObjB);
+        ObjB.setRef(ObjA);
+        ObjB.setRef2(ObjD);
+        ObjA.setRef(ObjD);
+        ObjD.setRef(ObjC);
+        new JSONObject(ObjC);
+        fail("Expected an exception");
+    }
+    @Test
+    public void testRepeatObjectNotRecursive() {
+        // C -> B -> A
+        //        -> A
+        RecursiveBean ObjA = new RecursiveBean("ObjA");
+        RecursiveBean ObjB = new RecursiveBean("ObjB");
+        RecursiveBean ObjC = new RecursiveBean("ObjC");
+        ObjC.setRef(ObjA);
+        ObjB.setRef(ObjA);
+        ObjB.setRef2(ObjA);
+        new JSONObject(ObjC);
+        new JSONObject(ObjB);
+        new JSONObject(ObjA);
+    }
+    @Test
+    public void testLongRepeatObjectNotRecursive() {
+        // C -> B -> A -> D -> E
+        //        -> D -> E
+        RecursiveBean ObjA = new RecursiveBean("ObjA");
+        RecursiveBean ObjB = new RecursiveBean("ObjB");
+        RecursiveBean ObjC = new RecursiveBean("ObjC");
+        RecursiveBean ObjD = new RecursiveBean("ObjD");
+        RecursiveBean ObjE = new RecursiveBean("ObjE");
+        ObjC.setRef(ObjB);
+        ObjB.setRef(ObjA);
+        ObjB.setRef2(ObjD);
+        ObjA.setRef(ObjD);
+        ObjD.setRef(ObjE);
+        new JSONObject(ObjC);
+        new JSONObject(ObjB);
+        new JSONObject(ObjA);
+        new JSONObject(ObjD);
+        new JSONObject(ObjE);
+    }
+    @Test(expected=JSONException.class)
+    public void testRecursiveEquals() {
+        RecursiveBeanEquals a = new RecursiveBeanEquals("same");
+        a.setRef(a);
+        new JSONObject(a);
+    }
+    @Test
+    public void testNotRecursiveEquals() {
+        RecursiveBeanEquals a = new RecursiveBeanEquals("same");
+        RecursiveBeanEquals b = new RecursiveBeanEquals("same");
+        RecursiveBeanEquals c = new RecursiveBeanEquals("same");
+        a.setRef(b);
+        b.setRef(c);
+        new JSONObject(a);
+    }
+

    @Test
    public void testIssue548ObjectWithEmptyJsonArray() {
--- a/src/test/java/org/json/junit/JSONPointerTest.java
+++ b/src/test/java/org/json/junit/JSONPointerTest.java
@@ -25,7 +25,6 @@ SOFTWARE.
 */

 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;

@@ -41,7 +40,12 @@ import org.junit.Test;
 public class JSONPointerTest {

    private static final JSONObject document;
+    private static final String EXPECTED_COMPLETE_DOCUMENT = "{\"\":0,\" \":7,\"g|h\":4,\"c%d\":2,\"k\\\"l\":6,\"a/b\":1,\"i\\\\j\":5," +
+    		"\"obj\":{\"\":{\"\":\"empty key of an object with an empty key\",\"subKey\":\"Some other value\"}," +
+            "\"other~key\":{\"another/key\":[\"val\"]},\"key\":\"value\"},\"foo\":[\"bar\",\"baz\"],\"e^f\":3," +
+            "\"m~n\":8}";

+    
    static {
        @SuppressWarnings("resource")
        InputStream resourceAsStream = JSONPointerTest.class.getClassLoader().getResourceAsStream("jsonpointer-testdoc.json");
@@ -57,7 +61,7 @@ public class JSONPointerTest {

    @Test
    public void emptyPointer() {
-        assertSame(document, query(""));
+        assertTrue(new JSONObject(EXPECTED_COMPLETE_DOCUMENT).similar(query("")));
    }

    @SuppressWarnings("unused")
@@ -68,12 +72,12 @@ public class JSONPointerTest {

    @Test
    public void objectPropertyQuery() {
-        assertSame(document.get("foo"), query("/foo"));
+        assertEquals("[\"bar\",\"baz\"]", query("/foo").toString());
    }

    @Test
    public void arrayIndexQuery() {
-        assertSame(document.getJSONArray("foo").get(0), query("/foo/0"));
+        assertEquals("bar", query("/foo/0"));
    }

    @Test(expected = JSONPointerException.class)
@@ -83,81 +87,76 @@ public class JSONPointerTest {

    @Test
    public void queryByEmptyKey() {
-        assertSame(document.get(""), query("/"));
+        assertEquals(0, query("/"));
    }

    @Test
    public void queryByEmptyKeySubObject() {
-        assertSame(document.getJSONObject("obj").getJSONObject(""), query("/obj/"));
+        assertEquals( "{\"\":\"empty key of an object with an empty key\",\"subKey\":\"Some" +
+                " other value\"}", query("/obj/").toString());
    }

    @Test
    public void queryByEmptyKeySubObjectSubOject() {
-        assertSame(
-            document.getJSONObject("obj").getJSONObject("").get(""),
-            query("/obj//")
-        );
+        assertEquals("empty key of an object with an empty key", query("/obj//"));
    }
    
    @Test
    public void queryByEmptyKeySubObjectValue() {
-        assertSame(
-            document.getJSONObject("obj").getJSONObject("").get("subKey"),
-            query("/obj//subKey")
-        );
+        assertEquals("Some other value", query("/obj//subKey"));
    }

    @Test
    public void slashEscaping() {
-        assertSame(document.get("a/b"), query("/a~1b"));
+        assertEquals(1, query("/a~1b"));
    }

    @Test
    public void tildeEscaping() {
-        assertSame(document.get("m~n"), query("/m~0n"));
+        assertEquals(8, query("/m~0n"));
    }

    /**
     * We pass backslashes as-is
     * 
-     * @see https://tools.ietf.org/html/rfc6901#section-3
+     * @see <a href="https://tools.ietf.org/html/rfc6901#section-3">rfc6901 section 3</a>
     */
    @Test
    public void backslashHandling() {
-        assertSame(document.get("i\\j"), query("/i\\j"));
+        assertEquals(5, query("/i\\j"));
    }
-
+    
    /**
     * We pass quotations as-is
     * 
-     * @see https://tools.ietf.org/html/rfc6901#section-3
+     * @see <a href="https://tools.ietf.org/html/rfc6901#section-3">rfc6901 section 3</a>
     */
    @Test
    public void quotationHandling() {
-        assertSame(document.get("k\"l"), query("/k\"l"));
+        assertEquals(6, query("/k\"l"));
    }
-
+   
    @Test
    public void whitespaceKey() {
-        assertSame(document.get(" "), query("/ "));
+        assertEquals(7, query("/ "));
    }

    @Test
    public void uriFragmentNotation() {
-        assertSame(document.get("foo"), query("#/foo"));
+        assertEquals("[\"bar\",\"baz\"]", query("#/foo").toString());
    }

    @Test
    public void uriFragmentNotationRoot() {
-        assertSame(document, query("#"));
+        assertTrue(new JSONObject(EXPECTED_COMPLETE_DOCUMENT).similar(query("#")));
    }

    @Test
    public void uriFragmentPercentHandling() {
-        assertSame(document.get("c%d"), query("#/c%25d"));
-        assertSame(document.get("e^f"), query("#/e%5Ef"));
-        assertSame(document.get("g|h"), query("#/g%7Ch"));
-        assertSame(document.get("m~n"), query("#/m~0n"));
+        assertEquals(2, query("#/c%25d"));
+        assertEquals(3, query("#/e%5Ef"));
+        assertEquals(4, query("#/g%7Ch"));
+        assertEquals(8, query("#/m~0n"));
    }

    @SuppressWarnings("unused")
@@ -391,4 +390,28 @@ public class JSONPointerTest {
        obj = jsonArray.optQuery(new JSONPointer("/a/b/c"));
        assertTrue("Expected null", obj == null);
    }
+    
+    /**
+     * When creating a jsonObject we need to parse escaped characters "\\\\"
+     *  --> it's the string representation of  "\\", so when query'ing via the JSONPointer 
+     *  we DON'T escape them
+     *  
+     */
+    @Test
+    public void queryFromJSONObjectUsingPointer0() {
+    	String str = "{"+
+                "\"string\\\\\\\\Key\":\"hello world!\","+
+
+                "\"\\\\\":\"slash test\"," + 
+                "}"+
+                "}";
+            JSONObject jsonObject = new JSONObject(str);
+            //Summary of issue: When a KEY in the jsonObject is "\\\\" --> it's held
+            // as "\\" which means when querying, we need to use "\\"
+            Object twoBackslahObj = jsonObject.optQuery(new JSONPointer("/\\"));
+            assertEquals("slash test", twoBackslahObj);
+
+            Object fourBackslashObj = jsonObject.optQuery(new JSONPointer("/string\\\\Key"));
+            assertEquals("hello world!", fourBackslashObj);
+    }
 }
--- a/src/test/java/org/json/junit/XMLConfigurationTest.java
+++ b/src/test/java/org/json/junit/XMLConfigurationTest.java
@@ -35,6 +35,8 @@ import java.io.FileWriter;
 import java.io.IOException;
 import java.io.Reader;
 import java.io.StringReader;
+import java.util.HashSet;
+import java.util.Set;

 import org.json.JSONArray;
 import org.json.JSONException;
@@ -903,7 +905,172 @@ public class XMLConfigurationTest {
        Util.compareActualVsExpectedJsonArrays(jsonArray, expectedJsonArray);

    }
-    
+
+    /**
+     * Test forceList parameter
+     */
+    @Test
+    public void testSimpleForceList() {
+        String xmlStr = 
+                "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"+
+                "<addresses>\n"+
+                "   <address>\n"+
+                "      <name>Sherlock Holmes</name>\n"+
+                "   </address>\n"+
+                "</addresses>";
+
+        String expectedStr = 
+                "{\"addresses\":[{\"address\":{\"name\":\"Sherlock Holmes\"}}]}";
+        
+        Set<String> forceList = new HashSet<String>();
+        forceList.add("addresses");
+
+        XMLParserConfiguration config = 
+                new XMLParserConfiguration()
+                        .withForceList(forceList);
+        JSONObject jsonObject = XML.toJSONObject(xmlStr, config);
+        JSONObject expetedJsonObject = new JSONObject(expectedStr);
+
+        Util.compareActualVsExpectedJsonObjects(jsonObject, expetedJsonObject);
+    }
+    @Test
+    public void testLongForceList() {
+        String xmlStr = 
+                "<servers>"+
+                    "<server>"+
+                        "<name>host1</name>"+
+                        "<os>Linux</os>"+
+                        "<interfaces>"+
+                            "<interface>"+
+                                "<name>em0</name>"+
+                                "<ip_address>10.0.0.1</ip_address>"+
+                            "</interface>"+
+                        "</interfaces>"+
+                    "</server>"+
+                "</servers>";
+
+        String expectedStr = 
+                "{"+
+                    "\"servers\": ["+
+                        "{"+
+                            "\"server\": {"+
+                            "\"name\": \"host1\","+
+                            "\"os\": \"Linux\","+
+                            "\"interfaces\": ["+
+                                "{"+
+                                    "\"interface\": {"+
+                                    "\"name\": \"em0\","+
+                                    "\"ip_address\": \"10.0.0.1\""+
+                                    "}}]}}]}";
+        
+        Set<String> forceList = new HashSet<String>();
+        forceList.add("servers");
+        forceList.add("interfaces");
+
+        XMLParserConfiguration config = 
+                new XMLParserConfiguration()
+                        .withForceList(forceList);
+        JSONObject jsonObject = XML.toJSONObject(xmlStr, config);
+        JSONObject expetedJsonObject = new JSONObject(expectedStr);
+
+        Util.compareActualVsExpectedJsonObjects(jsonObject, expetedJsonObject);
+    }
+    @Test
+    public void testMultipleTagForceList() {
+        String xmlStr = 
+                "<addresses>\n"+
+                "   <address>\n"+
+                "      <name>Sherlock Holmes</name>\n"+
+                "      <name>John H. Watson</name>\n"+
+                "   </address>\n"+
+                "</addresses>";
+
+        String expectedStr = 
+                "{"+
+                    "\"addresses\":["+
+                    "{"+
+                        "\"address\":["+
+                            "{"+
+                                "\"name\":["+
+                                "\"Sherlock Holmes\","+
+                                "\"John H. Watson\""+
+                                "]"+
+                            "}"+
+                        "]"+
+                    "}"+
+                    "]"+
+                "}";
+        
+        Set<String> forceList = new HashSet<String>();
+        forceList.add("addresses");
+        forceList.add("address");
+        forceList.add("name");
+
+        XMLParserConfiguration config = 
+                new XMLParserConfiguration()
+                        .withForceList(forceList);
+        JSONObject jsonObject = XML.toJSONObject(xmlStr, config);
+        JSONObject expetedJsonObject = new JSONObject(expectedStr);
+
+        Util.compareActualVsExpectedJsonObjects(jsonObject, expetedJsonObject);
+    }
+    @Test
+    public void testEmptyForceList() {
+        String xmlStr = 
+                "<addresses></addresses>";
+
+        String expectedStr = 
+                "{\"addresses\":[]}";
+        
+        Set<String> forceList = new HashSet<String>();
+        forceList.add("addresses");
+
+        XMLParserConfiguration config = 
+                new XMLParserConfiguration()
+                        .withForceList(forceList);
+        JSONObject jsonObject = XML.toJSONObject(xmlStr, config);
+        JSONObject expetedJsonObject = new JSONObject(expectedStr);
+
+        Util.compareActualVsExpectedJsonObjects(jsonObject, expetedJsonObject);
+    }
+    @Test
+    public void testContentForceList() {
+        String xmlStr = 
+                "<addresses>Baker Street</addresses>";
+
+        String expectedStr = 
+                "{\"addresses\":[\"Baker Street\"]}";
+        
+        Set<String> forceList = new HashSet<String>();
+        forceList.add("addresses");
+
+        XMLParserConfiguration config = 
+                new XMLParserConfiguration()
+                        .withForceList(forceList);
+        JSONObject jsonObject = XML.toJSONObject(xmlStr, config);
+        JSONObject expetedJsonObject = new JSONObject(expectedStr);
+
+        Util.compareActualVsExpectedJsonObjects(jsonObject, expetedJsonObject);
+    }
+    @Test
+    public void testEmptyTagForceList() {
+        String xmlStr = 
+                "<addresses />";
+
+        String expectedStr = 
+                "{\"addresses\":[]}";
+        
+        Set<String> forceList = new HashSet<String>();
+        forceList.add("addresses");
+
+        XMLParserConfiguration config = 
+                new XMLParserConfiguration()
+                        .withForceList(forceList);
+        JSONObject jsonObject = XML.toJSONObject(xmlStr, config);
+        JSONObject expetedJsonObject = new JSONObject(expectedStr);
+
+        Util.compareActualVsExpectedJsonObjects(jsonObject, expetedJsonObject);
+    }
    
    /**
     * Convenience method, given an input string and expected result,
--- a/src/test/java/org/json/junit/XMLTest.java
+++ b/src/test/java/org/json/junit/XMLTest.java
@@ -65,6 +65,7 @@ public class XMLTest {
    @Rule
    public TemporaryFolder testFolder = new TemporaryFolder();

+    
    /**
     * JSONObject from a null XML string.
     * Expects a NullPointerException
--- a/src/test/java/org/json/junit/data/ExceptionalBean.java
+++ b/src/test/java/org/json/junit/data/ExceptionalBean.java
@@ -8,7 +8,7 @@ import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;

 /**
- * Object for testing the exception handling in {@link JSONObject#populateMap}.
+ * Object for testing the exception handling in {@link org.json.JSONObject#populateMap}.
 * 
 * @author John Aylward
 */
--- a/src/test/java/org/json/junit/data/RecursiveBean.java
+++ b/src/test/java/org/json/junit/data/RecursiveBean.java
@@ -0,0 +1,23 @@
+package org.json.junit.data;
+
+/**
+ * test class for verifying if recursively defined bean can be correctly identified
+ * @author Zetmas
+ *
+ */
+public class RecursiveBean {
+    private String name;
+    private Object reference;
+    private Object reference2;
+    public String getName() { return name; }
+    public Object getRef() {return reference;}
+    public Object getRef2() {return reference2;}
+    public void setRef(Object refObj) {reference = refObj;}
+    public void setRef2(Object refObj) {reference2 = refObj;}
+
+    public RecursiveBean(String name) {
+        this.name = name;
+        reference = null;
+        reference2 = null;
+    }
+}
--- a/src/test/java/org/json/junit/data/RecursiveBeanEquals.java
+++ b/src/test/java/org/json/junit/data/RecursiveBeanEquals.java
@@ -0,0 +1,33 @@
+package org.json.junit.data;
+
+/** test class for verifying if recursively defined bean can be correctly identified */
+public class RecursiveBeanEquals {
+  private final String name;
+  private Object reference;
+
+  public RecursiveBeanEquals(String name) {
+    this.name = name;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public Object getRef() {
+    return reference;
+  }
+
+  public void setRef(Object refObj) {
+    reference = refObj;
+  }
+
+  @Override
+  public boolean equals(Object other) {
+    return other instanceof RecursiveBeanEquals && name.equals(((RecursiveBeanEquals) other).name);
+  }
+
+  @Override
+  public int hashCode() {
+    return name.hashCode();
+  }
+}
Author	SHA1	Message	Date
Sean Leary	8ef8e1463d	Update pom.xml	2021-12-05 09:12:55 -06:00
Sean Leary	48b6aa3e4c	Update RELEASES.md	2021-12-05 09:10:32 -06:00
Sean Leary	cff5cc6c74	Merge pull request #646 from Zetmas/feature/issue#595 XMLParserConfiguration support for xml to json arrays	2021-12-03 19:37:00 -06:00
Sean Leary	04e8ea84dc	Merge pull request #651 from cushon/i650 Use IdentityHashSet for cycle detection	2021-12-03 19:35:26 -06:00
Liam Miller-Cushon	812955e39d	Use IdentityHashSet for cycle detection Fixes https://github.com/stleary/JSON-java/issues/650	2021-11-26 20:07:21 -05:00
Sean Leary	bc623e36d6	Merge pull request #645 from Zetmas/feature/issue#632 Detect and handle circular references when parsing Java beans	2021-11-21 11:31:48 -06:00
Zach	5dd78bc0b9	Test case passed with tags with multiple entries set forceList	2021-11-19 21:22:38 -06:00
Zach	e638955034	Pass test case for empty tag with forceList	2021-11-19 21:05:05 -06:00
Zach	3f9b53fee4	longer forcelist tests	2021-11-19 20:55:10 -06:00
Zach	a0f90b776d	Passed simple test	2021-11-19 20:46:15 -06:00
Zach	fafaeb7aa6	Added simple test case	2021-11-19 20:32:36 -06:00
Zach	e356739a2f	Added forceList configuration to XMLParserConfiguration	2021-11-19 19:42:00 -06:00
Zach	fca7e17b38	Added test cases for self recursion and complex but no recursion	2021-11-18 14:53:22 -06:00
Zach	fb96e870a9	add test case and modified old ones	2021-11-17 20:00:12 -06:00
Zach	638273af7a	long circle test	2021-11-17 19:41:00 -06:00
Zach	1ffcf3915c	successful test	2021-11-17 19:35:53 -06:00
Zach	4565bddcbb	data class for recursive test	2021-11-17 17:23:40 -06:00
Zach	b5bcb68968	added set check logic	2021-11-17 16:57:41 -06:00
Zach	7823d3a4f3	locate the pace for cyclic check	2021-11-17 15:28:01 -06:00
Sean Leary	d6227c83d7	Merge pull request #640 from katldewitt/561-backslashes Address #561: Add unit tests for multiple backslashes	2021-11-02 11:44:49 -05:00
Sean Leary	f54b5e4b0d	Merge pull request #626 from loic5/patch-1 Create CODE_OF_CONDUCT.md	2021-10-29 15:49:43 -05:00
Loïc Lengrand	30b3680050	Update CODE_OF_CONDUCT.md I replaced the email address	2021-10-29 09:38:19 +02:00
katldewitt	3ed9154f63	fix: refactor tests context: the backslash unit tests cannot be in the complete document as uriFragmentNotationRoot() will fail due to backslash handling	2021-10-28 05:59:22 -07:00
katldewitt	669316d29e	chore: write unit tests for behavior	2021-10-28 05:45:23 -07:00
katldewitt	30a70c8886	chore: initial unit tests	2021-10-24 08:41:57 -07:00
Sean Leary	93f4b34890	Merge pull request #637 from Ronqn/master Reorganized README.md	2021-10-17 20:44:46 -05:00
Ronqn	9c87d6e214	Updated README.md	2021-10-16 16:43:10 +02:00
Ronqn	f27e5fe04d	Docs folder containing the contributions files	2021-10-16 16:42:55 +02:00
Sean Leary	2528e60b09	Merge pull request #634 from JanitSri/update-README updated the README to include commands for Unix systems	2021-10-16 09:17:45 -05:00
Sean Leary	4e601fd46e	Merge pull request #631 from sreekesh93/techdebt/refactor-test Refactor JSONPointerTest	2021-10-14 16:58:45 -05:00
Janit Sriganeshaelankovan	9f19c22b77	updated the README to include commands for Unix systems	2021-10-14 16:43:30 -04:00
sreekesh93	9000901a11	Fix test to support oreder mismatch	2021-10-11 19:55:31 +05:30
sreekesh93	f03eb56071	Fix test to support oreder mismatch	2021-10-11 19:46:27 +05:30
sreekesh93	b4bbc58644	Refactor JSONPointerTest	2021-10-11 10:42:31 +05:30
Sean Leary	cf43419015	Update pipeline.yml replace hardcoded Ubuntu version with "Ubuntu-latest"	2021-10-09 10:14:47 -05:00
Loïc Lengrand	e896497602	Create CODE_OF_CONDUCT.md hello i propose to create a Code of conduct :)	2021-10-08 16:35:55 +02:00
Sean Leary	d284c81e16	Update README.md	2021-10-05 21:01:55 -05:00
Sean Leary	a526b41b67	Create CONTRIBUTING.md	2021-10-05 20:56:25 -05:00
Sean Leary	9f07853f19	Merge pull request #622 from pedrombmachado/patch-1 Update README.md	2021-08-28 15:38:21 -05:00
Pedro Machado	e29c541353	Update README.md corrected the backward slash into forwarding slash	2021-08-28 21:28:31 +01:00
Sean Leary	de5f768cff	Merge pull request #621 from cushon/typos Fix some typos	2021-08-25 20:10:30 -05:00
Liam Miller-Cushon	8ca8a80753	Fix some typos	2021-08-25 13:56:44 -07:00
Sean Leary	fb71d9d40f	Merge pull request #606 from artem-smotrakov/fix-javadoc Fix javadoc	2021-08-17 20:40:04 -05:00
Sean Leary	b80141a19c	Merge pull request #607 from artem-smotrakov/add-security-policy Added a security policy	2021-08-14 15:02:05 -05:00
Sean Leary	c0e467c848	Merge pull request #613 from stleary/fix-similar-check Fixes Issue #611 JsonObject.similar() returns after number entry check	2021-07-26 18:12:44 -05:00
stleary	8680b10716	merge from master to pick up #616 and add one more test	2021-07-26 18:07:38 -05:00
stleary	2559114dbb	Merge branch 'master' into fix-similar-check	2021-07-26 17:53:20 -05:00
Sean Leary	bb048e3ffb	Merge pull request #617 from johnjaylward/issue-616-similar-bug Fixes #616 similar() problem comparing double vs BigDecimal	2021-07-26 17:47:03 -05:00
John Aylward	579784d73e	correct error in converting doubles to big decimals	2021-07-22 23:46:31 -04:00
John Aylward	c03054b1a6	Add test to show bug	2021-07-22 22:57:15 -04:00
John Aylward	4e0faebe62	fix javadoc errors that prevent compilation in Eclipse	2021-07-22 22:54:46 -04:00
stleary	c6089e53f5	Fixes Issue #611 JsonArray.similar() returns after number entry check	2021-07-18 19:53:23 -05:00
stleary	cfbc306673	Fixes Issue #611 JsonObject.similar() returns after number entry check	2021-07-18 10:32:49 -05:00
Sean Leary	449ec8745e	Merge pull request #610 from tilds/optJSONObject-defaultValue New JSONObject.optJSONObject method with defaultValue parameter	2021-06-28 22:01:37 -05:00
Niels Frederiksen	f91d0c8a52	New JSONObject.optJSONObject method with defaultValue parameter	2021-06-23 15:15:00 +02:00
stleary	4571978840	Merge branch 'master' of https://github.com/stleary/JSON-java	2021-06-22 19:46:44 -05:00
stleary	76ec2fe5a2	Revert accidentally changed file	2021-06-22 19:46:33 -05:00
Sean Leary	0200c984cc	Update README.md	2021-06-22 19:41:31 -05:00
stleary	8f3e5ade18	Add logo image	2021-06-22 19:34:22 -05:00
Artem Smotrakov	8fa9be742c	Added a security policy	2021-05-31 15:16:27 +02:00
Artem Smotrakov	b48abe6558	Suppress java/unchecked-cast-in-equals warning for JSONObject.Null.equals()	2021-05-31 15:00:29 +02:00
Artem Smotrakov	97023e1098	Fix Javadoc formatting in JSONObject and XMLParserConfiguration	2021-05-31 14:53:59 +02:00
Sean Leary	143db39d27	Merge pull request #604 from ianlovejoy/master Fixed incorrect cast getting float from array	2021-05-01 08:50:54 -05:00
Ian Lovejoy	75894086e5	Fixed incorrect cast getting float from array Added test for getting float from array	2021-04-27 19:03:35 -07:00
Sean Leary	fa46da45f4	Merge pull request #601 from AISS-2021-L5-G02/master Added some examples for new-comers in a Markdown file	2021-04-21 00:31:12 -05:00
TheNeoStormZ	f912e5d1c4	Merge pull request #2 from TheNeoStormZ/master Changed JSONExamples to a Markdown file (and another place) with mino…	2021-04-02 19:31:42 +02:00
Pablo Marín Gómez	6bf3d38889	Changed JSONExamples to a Markdown file (and another place) with minor tweaks	2021-04-02 19:28:37 +02:00
TheNeoStormZ	c62df81b3e	Merge pull request #1 from TheNeoStormZ/master Added some examples for new-comers	2021-04-02 11:28:25 +02:00
Pablo Marín Gómez	e1f69ff3fe	Added some examples for new-comers	2021-04-02 11:25:57 +02:00
Sean Leary	50d619698f	Merge pull request #594 from anton0xf/patch-1 JSONStringer.java: fix max nesting level in javadoc	2021-03-18 19:42:49 -05:00
anton0xf	29103e3228	JSONStringer.java: fix max nesting level in javadoc	2021-03-14 22:45:38 +05:00
Sean Leary	2630676f36	Update README.md	2021-03-09 19:54:54 -06:00