objectsRecord) {
if (object instanceof Collection) {
Collection coll = (Collection) object;
- return new JSONArray(coll);
+ return new JSONArray(coll, recursionDepth, jsonParserConfiguration);
}
if (object.getClass().isArray()) {
return new JSONArray(object);
}
if (object instanceof Map) {
Map map = (Map) object;
- return new JSONObject(map);
+ return new JSONObject(map, recursionDepth, jsonParserConfiguration);
}
Package objectPackage = object.getClass().getPackage();
String objectPackageName = objectPackage != null ? objectPackage
@@ -2515,6 +2811,7 @@ static final Writer writeValue(Writer writer, Object value,
if (value == null || value.equals(null)) {
writer.write("null");
} else if (value instanceof JSONString) {
+ // JSONString must be checked first, so it can overwrite behaviour of other types below
Object o;
try {
o = ((JSONString) value).toJSONString();
@@ -2522,6 +2819,10 @@ static final Writer writeValue(Writer writer, Object value,
throw new JSONException(e);
}
writer.write(o != null ? o.toString() : quote(value.toString()));
+ } else if (value instanceof String) {
+ // assuming most values are Strings, so testing it early
+ quote(value.toString(), writer);
+ return writer;
} else if (value instanceof Number) {
// not all Numbers may match actual JSON Numbers. i.e. fractions or Imaginary
final String numberAsString = numberToString((Number) value);
@@ -2709,4 +3010,24 @@ private static JSONException recursivelyDefinedObjectException(String key) {
"JavaBean object contains recursively defined member variable of key " + quote(key)
);
}
+
+ /**
+ * For a prospective number, remove the leading zeros
+ * @param value prospective number
+ * @return number without leading zeros
+ */
+ private static String removeLeadingZerosOfNumber(String value){
+ if (value.equals("-")){return value;}
+ boolean negativeFirstChar = (value.charAt(0) == '-');
+ int counter = negativeFirstChar ? 1:0;
+ while (counter < value.length()){
+ if (value.charAt(counter) != '0'){
+ if (negativeFirstChar) {return "-".concat(value.substring(counter));}
+ return value.substring(counter);
+ }
+ ++counter;
+ }
+ if (negativeFirstChar) {return "-0";}
+ return "0";
+ }
}
diff --git a/src/main/java/org/json/JSONParserConfiguration.java b/src/main/java/org/json/JSONParserConfiguration.java
new file mode 100644
index 000000000..0cfa2eaef
--- /dev/null
+++ b/src/main/java/org/json/JSONParserConfiguration.java
@@ -0,0 +1,152 @@
+package org.json;
+
+/**
+ * Configuration object for the JSON parser. The configuration is immutable.
+ */
+public class JSONParserConfiguration extends ParserConfiguration {
+ /**
+ * Used to indicate whether to overwrite duplicate key or not.
+ */
+ private boolean overwriteDuplicateKey;
+
+ /**
+ * Used to indicate whether to convert java null values to JSONObject.NULL or ignoring the entry when converting java maps.
+ */
+ private boolean useNativeNulls;
+
+ /**
+ * Configuration with the default values.
+ */
+ public JSONParserConfiguration() {
+ super();
+ this.overwriteDuplicateKey = false;
+ // DO NOT DELETE THE FOLLOWING LINE -- it is used for strictMode testing
+ // this.strictMode = true;
+ }
+
+ /**
+ * This flag, when set to true, instructs the parser to enforce strict mode when parsing JSON text.
+ * Garbage chars at the end of the doc, unquoted string, and single-quoted strings are all disallowed.
+ */
+ private boolean strictMode;
+
+ @Override
+ protected JSONParserConfiguration clone() {
+ JSONParserConfiguration clone = new JSONParserConfiguration();
+ clone.overwriteDuplicateKey = overwriteDuplicateKey;
+ clone.strictMode = strictMode;
+ clone.maxNestingDepth = maxNestingDepth;
+ clone.keepStrings = keepStrings;
+ clone.useNativeNulls = useNativeNulls;
+ return clone;
+ }
+
+ /**
+ * Defines the maximum nesting depth that the parser will descend before throwing an exception
+ * when parsing a map into JSONObject or parsing a {@link java.util.Collection} instance into
+ * JSONArray. The default max nesting depth is 512, which means the parser will throw a JsonException
+ * if the maximum depth is reached.
+ *
+ * @param maxNestingDepth the maximum nesting depth allowed to the JSON parser
+ * @return The existing configuration will not be modified. A new configuration is returned.
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public JSONParserConfiguration withMaxNestingDepth(final int maxNestingDepth) {
+ JSONParserConfiguration clone = this.clone();
+ clone.maxNestingDepth = maxNestingDepth;
+
+ return clone;
+ }
+
+ /**
+ * Controls the parser's behavior when meeting duplicate keys.
+ * If set to false, the parser will throw a JSONException when meeting a duplicate key.
+ * Or the duplicate key's value will be overwritten.
+ *
+ * @param overwriteDuplicateKey defines should the parser overwrite duplicate keys.
+ * @return The existing configuration will not be modified. A new configuration is returned.
+ */
+ public JSONParserConfiguration withOverwriteDuplicateKey(final boolean overwriteDuplicateKey) {
+ JSONParserConfiguration clone = this.clone();
+ clone.overwriteDuplicateKey = overwriteDuplicateKey;
+
+ return clone;
+ }
+
+ /**
+ * Controls the parser's behavior when meeting Java null values while converting maps.
+ * If set to true, the parser will put a JSONObject.NULL into the resulting JSONObject.
+ * Or the map entry will be ignored.
+ *
+ * @param useNativeNulls defines if the parser should convert null values in Java maps
+ * @return The existing configuration will not be modified. A new configuration is returned.
+ */
+ public JSONParserConfiguration withUseNativeNulls(final boolean useNativeNulls) {
+ JSONParserConfiguration clone = this.clone();
+ clone.useNativeNulls = useNativeNulls;
+
+ return clone;
+ }
+
+ /**
+ * Sets the strict mode configuration for the JSON parser with default true value
+ *
+ * When strict mode is enabled, the parser will throw a JSONException if it encounters an invalid character
+ * immediately following the final ']' character in the input. This is useful for ensuring strict adherence to the
+ * JSON syntax, as any characters after the final closing bracket of a JSON array are considered invalid.
+ * @return a new JSONParserConfiguration instance with the updated strict mode setting
+ */
+ public JSONParserConfiguration withStrictMode() {
+ return withStrictMode(true);
+ }
+
+ /**
+ * Sets the strict mode configuration for the JSON parser.
+ *
+ * When strict mode is enabled, the parser will throw a JSONException if it encounters an invalid character
+ * immediately following the final ']' character in the input. This is useful for ensuring strict adherence to the
+ * JSON syntax, as any characters after the final closing bracket of a JSON array are considered invalid.
+ *
+ * @param mode a boolean value indicating whether strict mode should be enabled or not
+ * @return a new JSONParserConfiguration instance with the updated strict mode setting
+ */
+ public JSONParserConfiguration withStrictMode(final boolean mode) {
+ JSONParserConfiguration clone = this.clone();
+ clone.strictMode = mode;
+
+ return clone;
+ }
+
+ /**
+ * The parser's behavior when meeting duplicate keys, controls whether the parser should
+ * overwrite duplicate keys or not.
+ *
+ * @return The overwriteDuplicateKey configuration value.
+ */
+ public boolean isOverwriteDuplicateKey() {
+ return this.overwriteDuplicateKey;
+ }
+
+ /**
+ * The parser's behavior when meeting a null value in a java map, controls whether the parser should
+ * write a JSON entry with a null value (isUseNativeNulls() == true)
+ * or ignore that map entry (isUseNativeNulls() == false).
+ *
+ * @return The useNativeNulls configuration value.
+ */
+ public boolean isUseNativeNulls() {
+ return this.useNativeNulls;
+ }
+
+
+ /**
+ * The parser throws an Exception when strict mode is true and tries to parse invalid JSON characters.
+ * Otherwise, the parser is more relaxed and might tolerate some invalid characters.
+ *
+ * @return the current strict mode setting.
+ */
+ public boolean isStrictMode() {
+ return this.strictMode;
+ }
+}
diff --git a/src/main/java/org/json/JSONPointer.java b/src/main/java/org/json/JSONPointer.java
index 963fdec3e..859e1e644 100644
--- a/src/main/java/org/json/JSONPointer.java
+++ b/src/main/java/org/json/JSONPointer.java
@@ -42,6 +42,12 @@ public class JSONPointer {
*/
public static class Builder {
+ /**
+ * Constructs a new Builder object.
+ */
+ public Builder() {
+ }
+
// Segments for the eventual JSONPointer string
private final List refTokens = new ArrayList();
@@ -163,6 +169,12 @@ public JSONPointer(final String pointer) {
//}
}
+ /**
+ * Constructs a new JSONPointer instance with the provided list of reference tokens.
+ *
+ * @param refTokens A list of strings representing the reference tokens for the JSON Pointer.
+ * Each token identifies a step in the path to the targeted value.
+ */
public JSONPointer(List refTokens) {
this.refTokens = new ArrayList(refTokens);
}
diff --git a/src/main/java/org/json/JSONPointerException.java b/src/main/java/org/json/JSONPointerException.java
index a0e128cd5..dc5a25ad6 100644
--- a/src/main/java/org/json/JSONPointerException.java
+++ b/src/main/java/org/json/JSONPointerException.java
@@ -14,10 +14,21 @@
public class JSONPointerException extends JSONException {
private static final long serialVersionUID = 8872944667561856751L;
+ /**
+ * Constructs a new JSONPointerException with the specified error message.
+ *
+ * @param message The detail message describing the reason for the exception.
+ */
public JSONPointerException(String message) {
super(message);
}
+ /**
+ * Constructs a new JSONPointerException with the specified error message and cause.
+ *
+ * @param message The detail message describing the reason for the exception.
+ * @param cause The cause of the exception.
+ */
public JSONPointerException(String message, Throwable cause) {
super(message, cause);
}
diff --git a/src/main/java/org/json/JSONPropertyName.java b/src/main/java/org/json/JSONPropertyName.java
index 4391bb76c..0e4123f37 100644
--- a/src/main/java/org/json/JSONPropertyName.java
+++ b/src/main/java/org/json/JSONPropertyName.java
@@ -21,6 +21,7 @@
@Target({METHOD})
public @interface JSONPropertyName {
/**
+ * The value of the JSON property.
* @return The name of the property as to be used in the JSON Object.
*/
String value();
diff --git a/src/main/java/org/json/JSONTokener.java b/src/main/java/org/json/JSONTokener.java
index c18058013..a90d51ae3 100644
--- a/src/main/java/org/json/JSONTokener.java
+++ b/src/main/java/org/json/JSONTokener.java
@@ -1,6 +1,7 @@
package org.json;
import java.io.*;
+import java.nio.charset.Charset;
/*
Public Domain.
@@ -31,13 +32,27 @@ public class JSONTokener {
/** the number of characters read in the previous line. */
private long characterPreviousLine;
+ // access to this object is required for strict mode checking
+ private JSONParserConfiguration jsonParserConfiguration;
/**
* Construct a JSONTokener from a Reader. The caller must close the Reader.
*
- * @param reader A reader.
+ * @param reader the source.
*/
public JSONTokener(Reader reader) {
+ this(reader, new JSONParserConfiguration());
+ }
+
+ /**
+ * Construct a JSONTokener from a Reader with a given JSONParserConfiguration. The caller must close the Reader.
+ *
+ * @param reader the source.
+ * @param jsonParserConfiguration A JSONParserConfiguration instance that controls the behavior of the parser.
+ *
+ */
+ public JSONTokener(Reader reader, JSONParserConfiguration jsonParserConfiguration) {
+ this.jsonParserConfiguration = jsonParserConfiguration;
this.reader = reader.markSupported()
? reader
: new BufferedReader(reader);
@@ -50,25 +65,60 @@ public JSONTokener(Reader reader) {
this.line = 1;
}
-
/**
* Construct a JSONTokener from an InputStream. The caller must close the input stream.
* @param inputStream The source.
*/
public JSONTokener(InputStream inputStream) {
- this(new InputStreamReader(inputStream));
+ this(inputStream, new JSONParserConfiguration());
+ }
+
+ /**
+ * Construct a JSONTokener from an InputStream. The caller must close the input stream.
+ * @param inputStream The source.
+ * @param jsonParserConfiguration A JSONParserConfiguration instance that controls the behavior of the parser.
+ */
+ public JSONTokener(InputStream inputStream, JSONParserConfiguration jsonParserConfiguration) {
+ this(new InputStreamReader(inputStream, Charset.forName("UTF-8")), jsonParserConfiguration);
}
/**
* Construct a JSONTokener from a string.
*
- * @param s A source string.
+ * @param source A source string.
+ */
+ public JSONTokener(String source) {
+ this(new StringReader(source));
+ }
+
+ /**
+ * Construct a JSONTokener from an InputStream. The caller must close the input stream.
+ * @param source The source.
+ * @param jsonParserConfiguration A JSONParserConfiguration instance that controls the behavior of the parser.
*/
- public JSONTokener(String s) {
- this(new StringReader(s));
+ public JSONTokener(String source, JSONParserConfiguration jsonParserConfiguration) {
+ this(new StringReader(source), jsonParserConfiguration);
}
+ /**
+ * Getter
+ * @return jsonParserConfiguration
+ */
+ public JSONParserConfiguration getJsonParserConfiguration() {
+ return jsonParserConfiguration;
+ }
+
+ /**
+ * Setter
+ * @param jsonParserConfiguration new value for jsonParserConfiguration
+ *
+ * @deprecated method should not be used
+ */
+ @Deprecated
+ public void setJsonParserConfiguration(JSONParserConfiguration jsonParserConfiguration) {
+ this.jsonParserConfiguration = jsonParserConfiguration;
+ }
/**
* Back up one character. This provides a sort of lookahead capability,
@@ -120,7 +170,7 @@ public static int dehexchar(char c) {
/**
* Checks if the end of the input has been reached.
- *
+ *
* @return true if at the end of the file and we didn't step back
*/
public boolean end() {
@@ -184,7 +234,7 @@ public char next() throws JSONException {
this.previous = (char) c;
return this.previous;
}
-
+
/**
* Get the last character read from the input or '\0' if nothing has been read yet.
* @return the last character read from the input.
@@ -298,7 +348,8 @@ public String nextString(char quote) throws JSONException {
case 0:
case '\n':
case '\r':
- throw this.syntaxError("Unterminated string");
+ throw this.syntaxError("Unterminated string. " +
+ "Character with int code " + (int) c + " is not allowed within a quoted string.");
case '\\':
c = this.next();
switch (c) {
@@ -318,10 +369,12 @@ public String nextString(char quote) throws JSONException {
sb.append('\r');
break;
case 'u':
+ String next = this.next(4);
try {
- sb.append((char)Integer.parseInt(this.next(4), 16));
+ sb.append((char)Integer.parseInt(next, 16));
} catch (NumberFormatException e) {
- throw this.syntaxError("Illegal escape.", e);
+ throw this.syntaxError("Illegal escape. " +
+ "\\u must be followed by a 4 digit hexadecimal number. \\" + next + " is not valid.", e);
}
break;
case '"':
@@ -331,7 +384,7 @@ public String nextString(char quote) throws JSONException {
sb.append(c);
break;
default:
- throw this.syntaxError("Illegal escape.");
+ throw this.syntaxError("Illegal escape. Escape sequence \\" + c + " is not valid.");
}
break;
default:
@@ -401,27 +454,39 @@ public String nextTo(String delimiters) throws JSONException {
*/
public Object nextValue() throws JSONException {
char c = this.nextClean();
- String string;
-
switch (c) {
- case '"':
- case '\'':
- return this.nextString(c);
case '{':
this.back();
try {
- return new JSONObject(this);
+ return new JSONObject(this, jsonParserConfiguration);
} catch (StackOverflowError e) {
throw new JSONException("JSON Array or Object depth too large to process.", e);
}
case '[':
this.back();
try {
- return new JSONArray(this);
+ return new JSONArray(this, jsonParserConfiguration);
} catch (StackOverflowError e) {
throw new JSONException("JSON Array or Object depth too large to process.", e);
}
}
+ return nextSimpleValue(c);
+ }
+
+ Object nextSimpleValue(char c) {
+ String string;
+
+ // Strict mode only allows strings with explicit double quotes
+ if (jsonParserConfiguration != null &&
+ jsonParserConfiguration.isStrictMode() &&
+ c == '\'') {
+ throw this.syntaxError("Strict mode error: Single quoted strings are not allowed");
+ }
+ switch (c) {
+ case '"':
+ case '\'':
+ return this.nextString(c);
+ }
/*
* Handle unquoted text. This could be the values true, false, or
@@ -445,7 +510,14 @@ public Object nextValue() throws JSONException {
if ("".equals(string)) {
throw this.syntaxError("Missing value");
}
- return JSONObject.stringToValue(string);
+ Object obj = JSONObject.stringToValue(string);
+ // Strict mode only allows strings with explicit double quotes
+ if (jsonParserConfiguration != null &&
+ jsonParserConfiguration.isStrictMode() &&
+ obj instanceof String) {
+ throw this.syntaxError(String.format("Strict mode error: Value '%s' is not surrounded by quotes", obj));
+ }
+ return obj;
}
@@ -518,6 +590,11 @@ public String toString() {
this.line + "]";
}
+ /**
+ * Closes the underlying reader, releasing any resources associated with it.
+ *
+ * @throws IOException If an I/O error occurs while closing the reader.
+ */
public void close() throws IOException {
if(reader!=null){
reader.close();
diff --git a/src/main/java/org/json/ParserConfiguration.java b/src/main/java/org/json/ParserConfiguration.java
index 519e2099d..06cc44366 100644
--- a/src/main/java/org/json/ParserConfiguration.java
+++ b/src/main/java/org/json/ParserConfiguration.java
@@ -20,20 +20,29 @@ public class ParserConfiguration {
/**
* Specifies if values should be kept as strings (true), or if
- * they should try to be guessed into JSON values (numeric, boolean, string)
+ * they should try to be guessed into JSON values (numeric, boolean, string).
*/
protected boolean keepStrings;
/**
- * The maximum nesting depth when parsing a document.
+ * The maximum nesting depth when parsing an object.
*/
protected int maxNestingDepth;
+ /**
+ * Constructs a new ParserConfiguration with default settings.
+ */
public ParserConfiguration() {
this.keepStrings = false;
this.maxNestingDepth = DEFAULT_MAXIMUM_NESTING_DEPTH;
}
+ /**
+ * Constructs a new ParserConfiguration with the specified settings.
+ *
+ * @param keepStrings A boolean indicating whether to preserve strings during parsing.
+ * @param maxNestingDepth An integer representing the maximum allowed nesting depth.
+ */
protected ParserConfiguration(final boolean keepStrings, final int maxNestingDepth) {
this.keepStrings = keepStrings;
this.maxNestingDepth = maxNestingDepth;
@@ -50,14 +59,14 @@ protected ParserConfiguration clone() {
// map should be cloned as well. If the values of the map are known to also
// be immutable, then a shallow clone of the map is acceptable.
return new ParserConfiguration(
- this.keepStrings,
- this.maxNestingDepth
+ this.keepStrings,
+ this.maxNestingDepth
);
}
/**
* When parsing the XML into JSONML, specifies if values should be kept as strings (true), or if
- * they should try to be guessed into JSON values (numeric, boolean, string)
+ * they should try to be guessed into JSON values (numeric, boolean, string).
*
* @return The keepStrings configuration value.
*/
@@ -69,20 +78,21 @@ public boolean isKeepStrings() {
* When parsing the XML into JSONML, specifies if values should be kept as strings (true), or if
* they should try to be guessed into JSON values (numeric, boolean, string)
*
- * @param newVal
- * new value to use for the keepStrings configuration option.
- *
+ * @param newVal new value to use for the keepStrings configuration option.
+ * @param the type of the configuration object
* @return The existing configuration will not be modified. A new configuration is returned.
*/
+ @SuppressWarnings("unchecked")
public T withKeepStrings(final boolean newVal) {
- T newConfig = (T)this.clone();
+ T newConfig = (T) this.clone();
newConfig.keepStrings = newVal;
return newConfig;
}
/**
* The maximum nesting depth that the parser will descend before throwing an exception
- * when parsing the XML into JSONML.
+ * when parsing an object (e.g. Map, Collection) into JSON-related objects.
+ *
* @return the maximum nesting depth set for this configuration
*/
public int getMaxNestingDepth() {
@@ -91,15 +101,19 @@ public int getMaxNestingDepth() {
/**
* Defines the maximum nesting depth that the parser will descend before throwing an exception
- * when parsing the XML into JSONML. The default max nesting depth is 512, which means the parser
- * will throw a JsonException if the maximum depth is reached.
+ * when parsing an object (e.g. Map, Collection) into JSON-related objects.
+ * The default max nesting depth is 512, which means the parser will throw a JsonException if
+ * the maximum depth is reached.
* Using any negative value as a parameter is equivalent to setting no limit to the nesting depth,
* which means the parses will go as deep as the maximum call stack size allows.
+ *
* @param maxNestingDepth the maximum nesting depth allowed to the XML parser
+ * @param the type of the configuration object
* @return The existing configuration will not be modified. A new configuration is returned.
*/
+ @SuppressWarnings("unchecked")
public T withMaxNestingDepth(int maxNestingDepth) {
- T newConfig = (T)this.clone();
+ T newConfig = (T) this.clone();
if (maxNestingDepth > UNDEFINED_MAXIMUM_NESTING_DEPTH) {
newConfig.maxNestingDepth = maxNestingDepth;
diff --git a/src/main/java/org/json/Property.java b/src/main/java/org/json/Property.java
index 83694c055..ba6c56967 100644
--- a/src/main/java/org/json/Property.java
+++ b/src/main/java/org/json/Property.java
@@ -13,6 +13,13 @@
* @version 2015-05-05
*/
public class Property {
+
+ /**
+ * Constructs a new Property object.
+ */
+ public Property() {
+ }
+
/**
* Converts a property file object into a JSONObject. The property file object is a table of name value pairs.
* @param properties java.util.Properties
diff --git a/src/main/java/org/json/StringBuilderWriter.java b/src/main/java/org/json/StringBuilderWriter.java
new file mode 100644
index 000000000..4aaa4903f
--- /dev/null
+++ b/src/main/java/org/json/StringBuilderWriter.java
@@ -0,0 +1,92 @@
+package org.json;
+
+import java.io.IOException;
+import java.io.Writer;
+
+/**
+ * Performance optimised alternative for {@link java.io.StringWriter}
+ * using internally a {@link StringBuilder} instead of a {@link StringBuffer}.
+ */
+public class StringBuilderWriter extends Writer {
+ private final StringBuilder builder;
+
+ /**
+ * Create a new string builder writer using the default initial string-builder buffer size.
+ */
+ public StringBuilderWriter() {
+ builder = new StringBuilder();
+ lock = builder;
+ }
+
+ /**
+ * Create a new string builder writer using the specified initial string-builder buffer size.
+ *
+ * @param initialSize The number of {@code char} values that will fit into this buffer
+ * before it is automatically expanded
+ *
+ * @throws IllegalArgumentException If {@code initialSize} is negative
+ */
+ public StringBuilderWriter(int initialSize) {
+ builder = new StringBuilder(initialSize);
+ lock = builder;
+ }
+
+ @Override
+ public void write(int c) {
+ builder.append((char) c);
+ }
+
+ @Override
+ public void write(char[] cbuf, int offset, int length) {
+ if ((offset < 0) || (offset > cbuf.length) || (length < 0) ||
+ ((offset + length) > cbuf.length) || ((offset + length) < 0)) {
+ throw new IndexOutOfBoundsException();
+ } else if (length == 0) {
+ return;
+ }
+ builder.append(cbuf, offset, length);
+ }
+
+ @Override
+ public void write(String str) {
+ builder.append(str);
+ }
+
+ @Override
+ public void write(String str, int offset, int length) {
+ builder.append(str, offset, offset + length);
+ }
+
+ @Override
+ public StringBuilderWriter append(CharSequence csq) {
+ write(String.valueOf(csq));
+ return this;
+ }
+
+ @Override
+ public StringBuilderWriter append(CharSequence csq, int start, int end) {
+ if (csq == null) {
+ csq = "null";
+ }
+ return append(csq.subSequence(start, end));
+ }
+
+ @Override
+ public StringBuilderWriter append(char c) {
+ write(c);
+ return this;
+ }
+
+ @Override
+ public String toString() {
+ return builder.toString();
+ }
+
+ @Override
+ public void flush() {
+ }
+
+ @Override
+ public void close() throws IOException {
+ }
+}
diff --git a/src/main/java/org/json/XML.java b/src/main/java/org/json/XML.java
index 925f056b1..4bf475935 100644
--- a/src/main/java/org/json/XML.java
+++ b/src/main/java/org/json/XML.java
@@ -10,7 +10,6 @@
import java.math.BigInteger;
import java.util.Iterator;
-
/**
* This provides static methods to convert an XML text into a JSONObject, and to
* covert a JSONObject into an XML text.
@@ -21,6 +20,12 @@
@SuppressWarnings("boxing")
public class XML {
+ /**
+ * Constructs a new XML object.
+ */
+ public XML() {
+ }
+
/** The Character '&'. */
public static final Character AMP = '&';
@@ -53,6 +58,9 @@ public class XML {
*/
public static final String NULL_ATTR = "xsi:nil";
+ /**
+ * Represents the XML attribute name for specifying type information.
+ */
public static final String TYPE_ATTR = "xsi:type";
/**
@@ -347,10 +355,20 @@ private static boolean parse(XMLTokener x, JSONObject context, String name, XMLP
&& TYPE_ATTR.equals(string)) {
xmlXsiTypeConverter = config.getXsiTypeMap().get(token);
} else if (!nilAttributeFound) {
- jsonObject.accumulate(string,
- config.isKeepStrings()
- ? ((String) token)
- : stringToValue((String) token));
+ Object obj = stringToValue((String) token);
+ if (obj instanceof Boolean) {
+ jsonObject.accumulate(string,
+ config.isKeepBooleanAsString()
+ ? ((String) token)
+ : obj);
+ } else if (obj instanceof Number) {
+ jsonObject.accumulate(string,
+ config.isKeepNumberAsString()
+ ? ((String) token)
+ : obj);
+ } else {
+ jsonObject.accumulate(string, stringToValue((String) token));
+ }
}
token = null;
} else {
@@ -399,8 +417,20 @@ private static boolean parse(XMLTokener x, JSONObject context, String name, XMLP
jsonObject.accumulate(config.getcDataTagName(),
stringToValue(string, xmlXsiTypeConverter));
} else {
- jsonObject.accumulate(config.getcDataTagName(),
- config.isKeepStrings() ? string : stringToValue(string));
+ Object obj = stringToValue((String) token);
+ if (obj instanceof Boolean) {
+ jsonObject.accumulate(config.getcDataTagName(),
+ config.isKeepBooleanAsString()
+ ? ((String) token)
+ : obj);
+ } else if (obj instanceof Number) {
+ jsonObject.accumulate(config.getcDataTagName(),
+ config.isKeepNumberAsString()
+ ? ((String) token)
+ : obj);
+ } else {
+ jsonObject.accumulate(config.getcDataTagName(), stringToValue((String) token));
+ }
}
}
@@ -428,6 +458,9 @@ private static boolean parse(XMLTokener x, JSONObject context, String name, XMLP
&& jsonObject.opt(config.getcDataTagName()) != null) {
context.accumulate(tagName, jsonObject.opt(config.getcDataTagName()));
} else {
+ if (!config.shouldTrimWhiteSpace()) {
+ removeEmpty(jsonObject, config);
+ }
context.accumulate(tagName, jsonObject);
}
}
@@ -442,58 +475,46 @@ private static boolean parse(XMLTokener x, JSONObject context, String name, XMLP
}
}
}
-
/**
- * This method tries to convert the given string value to the target object
- * @param string String to convert
- * @param typeConverter value converter to convert string to integer, boolean e.t.c
- * @return JSON value of this string or the string
+ * This method removes any JSON entry which has the key set by XMLParserConfiguration.cDataTagName
+ * and contains whitespace as this is caused by whitespace between tags. See test XMLTest.testNestedWithWhitespaceTrimmingDisabled.
+ * @param jsonObject JSONObject which may require deletion
+ * @param config The XMLParserConfiguration which includes the cDataTagName
*/
- public static Object stringToValue(String string, XMLXsiTypeConverter typeConverter) {
- if(typeConverter != null) {
- return typeConverter.convert(string);
+ private static void removeEmpty(final JSONObject jsonObject, final XMLParserConfiguration config) {
+ if (jsonObject.has(config.getcDataTagName())) {
+ final Object s = jsonObject.get(config.getcDataTagName());
+ if (s instanceof String) {
+ if (isStringAllWhiteSpace(s.toString())) {
+ jsonObject.remove(config.getcDataTagName());
+ }
+ }
+ else if (s instanceof JSONArray) {
+ final JSONArray sArray = (JSONArray) s;
+ for (int k = sArray.length()-1; k >= 0; k--){
+ final Object eachString = sArray.get(k);
+ if (eachString instanceof String) {
+ String s1 = (String) eachString;
+ if (isStringAllWhiteSpace(s1)) {
+ sArray.remove(k);
+ }
+ }
+ }
+ if (sArray.isEmpty()) {
+ jsonObject.remove(config.getcDataTagName());
+ }
+ }
}
- return stringToValue(string);
}
- /**
- * This method is the same as {@link JSONObject#stringToValue(String)}.
- *
- * @param string String to convert
- * @return JSON value of this string or the string
- */
- // To maintain compatibility with the Android API, this method is a direct copy of
- // the one in JSONObject. Changes made here should be reflected there.
- // This method should not make calls out of the XML object.
- public static Object stringToValue(String string) {
- if ("".equals(string)) {
- return string;
- }
-
- // check JSON key words true/false/null
- if ("true".equalsIgnoreCase(string)) {
- return Boolean.TRUE;
- }
- if ("false".equalsIgnoreCase(string)) {
- return Boolean.FALSE;
- }
- if ("null".equalsIgnoreCase(string)) {
- return JSONObject.NULL;
- }
-
- /*
- * If it might be a number, try converting it. If a number cannot be
- * produced, then the value will just be a string.
- */
-
- char initial = string.charAt(0);
- if ((initial >= '0' && initial <= '9') || initial == '-') {
- try {
- return stringToNumber(string);
- } catch (Exception ignore) {
+ private static boolean isStringAllWhiteSpace(final String s) {
+ for (int k = 0; k -1 || "-0".equals(val);
}
+ /**
+ * This method tries to convert the given string value to the target object
+ * @param string String to convert
+ * @param typeConverter value converter to convert string to integer, boolean e.t.c
+ * @return JSON value of this string or the string
+ */
+ public static Object stringToValue(String string, XMLXsiTypeConverter typeConverter) {
+ if(typeConverter != null) {
+ return typeConverter.convert(string);
+ }
+ return stringToValue(string);
+ }
+
+ /**
+ * This method is the same as {@link JSONObject#stringToValue(String)}.
+ *
+ * @param string String to convert
+ * @return JSON value of this string or the string
+ */
+ // To maintain compatibility with the Android API, this method is a direct copy of
+ // the one in JSONObject. Changes made here should be reflected there.
+ // This method should not make calls out of the XML object.
+ public static Object stringToValue(String string) {
+ if ("".equals(string)) {
+ return string;
+ }
+
+ // check JSON key words true/false/null
+ if ("true".equalsIgnoreCase(string)) {
+ return Boolean.TRUE;
+ }
+ if ("false".equalsIgnoreCase(string)) {
+ return Boolean.FALSE;
+ }
+ if ("null".equalsIgnoreCase(string)) {
+ return JSONObject.NULL;
+ }
+
+ /*
+ * If it might be a number, try converting it. If a number cannot be
+ * produced, then the value will just be a string.
+ */
+
+ char initial = string.charAt(0);
+ if ((initial >= '0' && initial <= '9') || initial == '-') {
+ try {
+ return stringToNumber(string);
+ } catch (Exception ignore) {
+ }
+ }
+ return string;
+ }
/**
* Convert a well-formed (but not necessarily valid) XML string into a
@@ -637,6 +710,44 @@ public static JSONObject toJSONObject(Reader reader, boolean keepStrings) throws
return toJSONObject(reader, XMLParserConfiguration.ORIGINAL);
}
+ /**
+ * Convert a well-formed (but not necessarily valid) XML into a
+ * JSONObject. Some information may be lost in this transformation because
+ * JSON is a data format and XML is a document format. XML uses elements,
+ * attributes, and content text, while JSON uses unordered collections of
+ * name/value pairs and arrays of values. JSON does not does not like to
+ * distinguish between elements and attributes. Sequences of similar
+ * elements are represented as JSONArrays. Content text may be placed in a
+ * "content" member. Comments, prologs, DTDs, and {@code
+ * <[ [ ]]>}
+ * are ignored.
+ *
+ * All numbers are converted as strings, for 1, 01, 29.0 will not be coerced to
+ * numbers but will instead be the exact value as seen in the XML document depending
+ * on how flag is set.
+ * All booleans are converted as strings, for true, false will not be coerced to
+ * booleans but will instead be the exact value as seen in the XML document depending
+ * on how flag is set.
+ *
+ * @param reader The XML source reader.
+ * @param keepNumberAsString If true, then numeric values will not be coerced into
+ * numeric values and will instead be left as strings
+ * @param keepBooleanAsString If true, then boolean values will not be coerced into
+ * * numeric values and will instead be left as strings
+ * @return A JSONObject containing the structured data from the XML string.
+ * @throws JSONException Thrown if there is an errors while parsing the string
+ */
+ public static JSONObject toJSONObject(Reader reader, boolean keepNumberAsString, boolean keepBooleanAsString) throws JSONException {
+ XMLParserConfiguration xmlParserConfiguration = new XMLParserConfiguration();
+ if(keepNumberAsString) {
+ xmlParserConfiguration = xmlParserConfiguration.withKeepNumberAsString(keepNumberAsString);
+ }
+ if(keepBooleanAsString) {
+ xmlParserConfiguration = xmlParserConfiguration.withKeepBooleanAsString(keepBooleanAsString);
+ }
+ return toJSONObject(reader, xmlParserConfiguration);
+ }
+
/**
* Convert a well-formed (but not necessarily valid) XML into a
* JSONObject. Some information may be lost in this transformation because
@@ -659,7 +770,7 @@ public static JSONObject toJSONObject(Reader reader, boolean keepStrings) throws
*/
public static JSONObject toJSONObject(Reader reader, XMLParserConfiguration config) throws JSONException {
JSONObject jo = new JSONObject();
- XMLTokener x = new XMLTokener(reader);
+ XMLTokener x = new XMLTokener(reader, config);
while (x.more()) {
x.skipPast("<");
if(x.more()) {
@@ -695,6 +806,38 @@ public static JSONObject toJSONObject(String string, boolean keepStrings) throws
return toJSONObject(new StringReader(string), keepStrings);
}
+ /**
+ * Convert a well-formed (but not necessarily valid) XML string into a
+ * JSONObject. Some information may be lost in this transformation because
+ * JSON is a data format and XML is a document format. XML uses elements,
+ * attributes, and content text, while JSON uses unordered collections of
+ * name/value pairs and arrays of values. JSON does not does not like to
+ * distinguish between elements and attributes. Sequences of similar
+ * elements are represented as JSONArrays. Content text may be placed in a
+ * "content" member. Comments, prologs, DTDs, and {@code
+ * <[ [ ]]>}
+ * are ignored.
+ *
+ * All numbers are converted as strings, for 1, 01, 29.0 will not be coerced to
+ * numbers but will instead be the exact value as seen in the XML document depending
+ * on how flag is set.
+ * All booleans are converted as strings, for true, false will not be coerced to
+ * booleans but will instead be the exact value as seen in the XML document depending
+ * on how flag is set.
+ *
+ * @param string
+ * The source string.
+ * @param keepNumberAsString If true, then numeric values will not be coerced into
+ * numeric values and will instead be left as strings
+ * @param keepBooleanAsString If true, then boolean values will not be coerced into
+ * numeric values and will instead be left as strings
+ * @return A JSONObject containing the structured data from the XML string.
+ * @throws JSONException Thrown if there is an errors while parsing the string
+ */
+ public static JSONObject toJSONObject(String string, boolean keepNumberAsString, boolean keepBooleanAsString) throws JSONException {
+ return toJSONObject(new StringReader(string), keepNumberAsString, keepBooleanAsString);
+ }
+
/**
* Convert a well-formed (but not necessarily valid) XML string into a
* JSONObject. Some information may be lost in this transformation because
@@ -850,12 +993,25 @@ private static String toString(final Object object, final String tagName, final
}
}
} else if ("".equals(value)) {
- sb.append(indent(indent));
- sb.append('<');
- sb.append(key);
- sb.append("/>");
- if(indentFactor > 0){
- sb.append("\n");
+ if (config.isCloseEmptyTag()){
+ sb.append(indent(indent));
+ sb.append('<');
+ sb.append(key);
+ sb.append(">");
+ sb.append("");
+ if (indentFactor > 0) {
+ sb.append("\n");
+ }
+ }else {
+ sb.append(indent(indent));
+ sb.append('<');
+ sb.append(key);
+ sb.append("/>");
+ if (indentFactor > 0) {
+ sb.append("\n");
+ }
}
// Emit a new tag
@@ -899,14 +1055,14 @@ private static String toString(final Object object, final String tagName, final
string = (object == null) ? "null" : escape(object.toString());
-
+ String indentationSuffix = (indentFactor > 0) ? "\n" : "";
if(tagName == null){
- return indent(indent) + "\"" + string + "\"" + ((indentFactor > 0) ? "\n" : "");
+ return indent(indent) + "\"" + string + "\"" + indentationSuffix;
} else if(string.length() == 0){
- return indent(indent) + "<" + tagName + "/>" + ((indentFactor > 0) ? "\n" : "");
+ return indent(indent) + "<" + tagName + "/>" + indentationSuffix;
} else {
return indent(indent) + "<" + tagName
- + ">" + string + "" + ((indentFactor > 0) ? "\n" : "");
+ + ">" + string + "" + indentationSuffix;
}
}
diff --git a/src/main/java/org/json/XMLParserConfiguration.java b/src/main/java/org/json/XMLParserConfiguration.java
index 566146d6d..de84b90cb 100644
--- a/src/main/java/org/json/XMLParserConfiguration.java
+++ b/src/main/java/org/json/XMLParserConfiguration.java
@@ -22,6 +22,16 @@ public class XMLParserConfiguration extends ParserConfiguration {
*/
// public static final int DEFAULT_MAXIMUM_NESTING_DEPTH = 512; // We could override
+ /**
+ * Allow user to control how numbers are parsed
+ */
+ private boolean keepNumberAsString;
+
+ /**
+ * Allow user to control how booleans are parsed
+ */
+ private boolean keepBooleanAsString;
+
/** Original Configuration of the XML Parser. */
public static final XMLParserConfiguration ORIGINAL
= new XMLParserConfiguration();
@@ -43,6 +53,13 @@ public class XMLParserConfiguration extends ParserConfiguration {
*/
private boolean convertNilAttributeToNull;
+ /**
+ * When creating an XML from JSON Object, an empty tag by default will self-close.
+ * If it has to be closed explicitly, with empty content between start and end tag,
+ * this flag is to be turned on.
+ */
+ private boolean closeEmptyTag;
+
/**
* This will allow type conversion for values in XML if xsi:type attribute is defined
*/
@@ -54,9 +71,18 @@ public class XMLParserConfiguration extends ParserConfiguration {
*/
private Set forceList;
+
+ /**
+ * Flag to indicate whether white space should be trimmed when parsing XML.
+ * The default behaviour is to trim white space. When this is set to false, inputting XML
+ * with tags that are the same as the value of cDataTagName is unsupported. It is recommended to set cDataTagName
+ * to a distinct value in this case.
+ */
+ private boolean shouldTrimWhiteSpace;
+
/**
* Default parser configuration. Does not keep strings (tries to implicitly convert
- * values), and the CDATA Tag Name is "content".
+ * values), and the CDATA Tag Name is "content". Trims whitespace.
*/
public XMLParserConfiguration () {
super();
@@ -64,6 +90,7 @@ public XMLParserConfiguration () {
this.convertNilAttributeToNull = false;
this.xsiTypeMap = Collections.emptyMap();
this.forceList = Collections.emptySet();
+ this.shouldTrimWhiteSpace = true;
}
/**
@@ -125,7 +152,9 @@ public XMLParserConfiguration (final boolean keepStrings, final String cDataTagN
*/
@Deprecated
public XMLParserConfiguration (final boolean keepStrings, final String cDataTagName, final boolean convertNilAttributeToNull) {
- super(keepStrings, DEFAULT_MAXIMUM_NESTING_DEPTH);
+ super(false, DEFAULT_MAXIMUM_NESTING_DEPTH);
+ this.keepNumberAsString = keepStrings;
+ this.keepBooleanAsString = keepStrings;
this.cDataTagName = cDataTagName;
this.convertNilAttributeToNull = convertNilAttributeToNull;
}
@@ -142,15 +171,19 @@ public XMLParserConfiguration (final boolean keepStrings, final String cDataTagN
* xsi:type="integer" as integer, xsi:type="string" as string
* @param forceList new HashSet() to parse the provided tags' values as arrays
* @param maxNestingDepth int to limit the nesting depth
+ * @param closeEmptyTag boolean to turn on explicit end tag for tag with empty value
*/
private XMLParserConfiguration (final boolean keepStrings, final String cDataTagName,
final boolean convertNilAttributeToNull, final Map> xsiTypeMap, final Set forceList,
- final int maxNestingDepth) {
- super(keepStrings, maxNestingDepth);
+ final int maxNestingDepth, final boolean closeEmptyTag, final boolean keepNumberAsString, final boolean keepBooleanAsString) {
+ super(false, maxNestingDepth);
+ this.keepNumberAsString = keepNumberAsString;
+ this.keepBooleanAsString = keepBooleanAsString;
this.cDataTagName = cDataTagName;
this.convertNilAttributeToNull = convertNilAttributeToNull;
this.xsiTypeMap = Collections.unmodifiableMap(xsiTypeMap);
this.forceList = Collections.unmodifiableSet(forceList);
+ this.closeEmptyTag = closeEmptyTag;
}
/**
@@ -163,14 +196,19 @@ protected XMLParserConfiguration clone() {
// item, a new map instance should be created and if possible each value in the
// map should be cloned as well. If the values of the map are known to also
// be immutable, then a shallow clone of the map is acceptable.
- return new XMLParserConfiguration(
+ final XMLParserConfiguration config = new XMLParserConfiguration(
this.keepStrings,
this.cDataTagName,
this.convertNilAttributeToNull,
this.xsiTypeMap,
this.forceList,
- this.maxNestingDepth
+ this.maxNestingDepth,
+ this.closeEmptyTag,
+ this.keepNumberAsString,
+ this.keepBooleanAsString
);
+ config.shouldTrimWhiteSpace = this.shouldTrimWhiteSpace;
+ return config;
}
/**
@@ -182,9 +220,46 @@ protected XMLParserConfiguration clone() {
*
* @return The existing configuration will not be modified. A new configuration is returned.
*/
+ @SuppressWarnings("unchecked")
@Override
public XMLParserConfiguration withKeepStrings(final boolean newVal) {
- return super.withKeepStrings(newVal);
+ XMLParserConfiguration newConfig = this.clone();
+ newConfig.keepStrings = newVal;
+ newConfig.keepNumberAsString = newVal;
+ newConfig.keepBooleanAsString = newVal;
+ return newConfig;
+ }
+
+ /**
+ * When parsing the XML into JSON, specifies if numbers should be kept as strings (1), or if
+ * they should try to be guessed into JSON values (numeric, boolean, string)
+ *
+ * @param newVal
+ * new value to use for the keepNumberAsString configuration option.
+ *
+ * @return The existing configuration will not be modified. A new configuration is returned.
+ */
+ public XMLParserConfiguration withKeepNumberAsString(final boolean newVal) {
+ XMLParserConfiguration newConfig = this.clone();
+ newConfig.keepNumberAsString = newVal;
+ newConfig.keepStrings = newConfig.keepBooleanAsString && newConfig.keepNumberAsString;
+ return newConfig;
+ }
+
+ /**
+ * When parsing the XML into JSON, specifies if booleans should be kept as strings (true), or if
+ * they should try to be guessed into JSON values (numeric, boolean, string)
+ *
+ * @param newVal
+ * new value to use for the withKeepBooleanAsString configuration option.
+ *
+ * @return The existing configuration will not be modified. A new configuration is returned.
+ */
+ public XMLParserConfiguration withKeepBooleanAsString(final boolean newVal) {
+ XMLParserConfiguration newConfig = this.clone();
+ newConfig.keepBooleanAsString = newVal;
+ newConfig.keepStrings = newConfig.keepBooleanAsString && newConfig.keepNumberAsString;
+ return newConfig;
}
/**
@@ -198,6 +273,26 @@ public String getcDataTagName() {
return this.cDataTagName;
}
+ /**
+ * When parsing the XML into JSONML, specifies if numbers should be kept as strings (true), or if
+ * they should try to be guessed into JSON values (numeric, boolean, string).
+ *
+ * @return The keepStrings configuration value.
+ */
+ public boolean isKeepNumberAsString() {
+ return this.keepNumberAsString;
+ }
+
+ /**
+ * When parsing the XML into JSONML, specifies if booleans should be kept as strings (true), or if
+ * they should try to be guessed into JSON values (numeric, boolean, string).
+ *
+ * @return The keepStrings configuration value.
+ */
+ public boolean isKeepBooleanAsString() {
+ return this.keepBooleanAsString;
+ }
+
/**
* The name of the key in a JSON Object that indicates a CDATA section. Historically this has
* been the value "content" but can be changed. Use null to indicate no CDATA
@@ -299,8 +394,51 @@ public XMLParserConfiguration withForceList(final Set forceList) {
* @param maxNestingDepth the maximum nesting depth allowed to the XML parser
* @return The existing configuration will not be modified. A new configuration is returned.
*/
+ @SuppressWarnings("unchecked")
@Override
public XMLParserConfiguration withMaxNestingDepth(int maxNestingDepth) {
return super.withMaxNestingDepth(maxNestingDepth);
}
+
+ /**
+ * To enable explicit end tag with empty value.
+ * @param closeEmptyTag new value for the closeEmptyTag property
+ * @return same instance of configuration with empty tag config updated
+ */
+ public XMLParserConfiguration withCloseEmptyTag(boolean closeEmptyTag){
+ XMLParserConfiguration clonedConfiguration = this.clone();
+ clonedConfiguration.closeEmptyTag = closeEmptyTag;
+ return clonedConfiguration;
+ }
+
+ /**
+ * Sets whether whitespace should be trimmed inside of tags. *NOTE* Do not use this if
+ * you expect your XML tags to have names that are the same as cDataTagName as this is unsupported.
+ * cDataTagName should be set to a distinct value in these cases.
+ * @param shouldTrimWhiteSpace boolean to set trimming on or off. Off is default.
+ * @return same instance of configuration with empty tag config updated
+ */
+ public XMLParserConfiguration withShouldTrimWhitespace(boolean shouldTrimWhiteSpace){
+ XMLParserConfiguration clonedConfiguration = this.clone();
+ clonedConfiguration.shouldTrimWhiteSpace = shouldTrimWhiteSpace;
+ return clonedConfiguration;
+ }
+
+ /**
+ * Checks if the parser should automatically close empty XML tags.
+ *
+ * @return {@code true} if empty XML tags should be automatically closed, {@code false} otherwise.
+ */
+ public boolean isCloseEmptyTag() {
+ return this.closeEmptyTag;
+ }
+
+ /**
+ * Checks if the parser should trim white spaces from XML content.
+ *
+ * @return {@code true} if white spaces should be trimmed, {@code false} otherwise.
+ */
+ public boolean shouldTrimWhiteSpace() {
+ return this.shouldTrimWhiteSpace;
+ }
}
diff --git a/src/main/java/org/json/XMLTokener.java b/src/main/java/org/json/XMLTokener.java
index 957498ca2..bc18b31c9 100644
--- a/src/main/java/org/json/XMLTokener.java
+++ b/src/main/java/org/json/XMLTokener.java
@@ -20,6 +20,8 @@ public class XMLTokener extends JSONTokener {
*/
public static final java.util.HashMap entity;
+ private XMLParserConfiguration configuration = XMLParserConfiguration.ORIGINAL;
+
static {
entity = new java.util.HashMap(8);
entity.put("amp", XML.AMP);
@@ -45,6 +47,16 @@ public XMLTokener(String s) {
super(s);
}
+ /**
+ * Construct an XMLTokener from a Reader and an XMLParserConfiguration.
+ * @param r A source reader.
+ * @param configuration the configuration that can be used to set certain flags
+ */
+ public XMLTokener(Reader r, XMLParserConfiguration configuration) {
+ super(r);
+ this.configuration = configuration;
+ }
+
/**
* Get the text in the CDATA block.
* @return The string up to the ]]>.
@@ -83,7 +95,7 @@ public Object nextContent() throws JSONException {
StringBuilder sb;
do {
c = next();
- } while (Character.isWhitespace(c));
+ } while (Character.isWhitespace(c) && configuration.shouldTrimWhiteSpace());
if (c == 0) {
return null;
}
@@ -97,7 +109,9 @@ public Object nextContent() throws JSONException {
}
if (c == '<') {
back();
- return sb.toString().trim();
+ if (configuration.shouldTrimWhiteSpace()) {
+ return sb.toString().trim();
+ } else return sb.toString();
}
if (c == '&') {
sb.append(nextEntity(c));
diff --git a/src/main/java/org/json/XMLXsiTypeConverter.java b/src/main/java/org/json/XMLXsiTypeConverter.java
index 0011effae..ea6739d34 100644
--- a/src/main/java/org/json/XMLXsiTypeConverter.java
+++ b/src/main/java/org/json/XMLXsiTypeConverter.java
@@ -42,5 +42,12 @@
* @param return type of convert method
*/
public interface XMLXsiTypeConverter {
+
+ /**
+ * Converts an XML xsi:type attribute value to the specified type {@code T}.
+ *
+ * @param value The string representation of the XML xsi:type attribute value to be converted.
+ * @return An object of type {@code T} representing the converted value.
+ */
T convert(String value);
}
diff --git a/src/test/java/org/json/junit/CDLTest.java b/src/test/java/org/json/junit/CDLTest.java
index f3364fbba..e5eb9eda8 100644
--- a/src/test/java/org/json/junit/CDLTest.java
+++ b/src/test/java/org/json/junit/CDLTest.java
@@ -24,14 +24,13 @@ public class CDLTest {
* String of lines where the column names are in the first row,
* and all subsequent rows are values. All keys and values should be legal.
*/
- String lines = new String(
- "Col 1, Col 2, \tCol 3, Col 4, Col 5, Col 6, Col 7\n" +
- "val1, val2, val3, val4, val5, val6, val7\n" +
- "1, 2, 3, 4\t, 5, 6, 7\n" +
- "true, false, true, true, false, false, false\n" +
- "0.23, 57.42, 5e27, -234.879, 2.34e5, 0.0, 9e-3\n" +
- "\"va\tl1\", \"v\bal2\", \"val3\", \"val\f4\", \"val5\", va\'l6, val7\n"
- );
+ private static final String LINES = "Col 1, Col 2, \tCol 3, Col 4, Col 5, Col 6, Col 7\n" +
+ "val1, val2, val3, val4, val5, val6, val7\n" +
+ "1, 2, 3, 4\t, 5, 6, 7\n" +
+ "true, false, true, true, false, false, false\n" +
+ "0.23, 57.42, 5e27, -234.879, 2.34e5, 0.0, 9e-3\n" +
+ "\"va\tl1\", \"v\bal2\", \"val3\", \"val\f4\", \"val5\", \"va'l6\", val7\n";
+
/**
* CDL.toJSONArray() adds all values as strings, with no filtering or
@@ -39,12 +38,54 @@ public class CDLTest {
* values all must be quoted in the cases where the JSONObject parsing
* might normally convert the value into a non-string.
*/
- String expectedLines = new String(
- "[{Col 1:val1, Col 2:val2, Col 3:val3, Col 4:val4, Col 5:val5, Col 6:val6, Col 7:val7}, "+
- "{Col 1:\"1\", Col 2:\"2\", Col 3:\"3\", Col 4:\"4\", Col 5:\"5\", Col 6:\"6\", Col 7:\"7\"}, "+
- "{Col 1:\"true\", Col 2:\"false\", Col 3:\"true\", Col 4:\"true\", Col 5:\"false\", Col 6:\"false\", Col 7:\"false\"}, "+
- "{Col 1:\"0.23\", Col 2:\"57.42\", Col 3:\"5e27\", Col 4:\"-234.879\", Col 5:\"2.34e5\", Col 6:\"0.0\", Col 7:\"9e-3\"}, "+
- "{Col 1:\"va\tl1\", Col 2:\"v\bal2\", Col 3:val3, Col 4:\"val\f4\", Col 5:val5, Col 6:va\'l6, Col 7:val7}]");
+ private static final String EXPECTED_LINES =
+ "[ " +
+ "{" +
+ "\"Col 1\":\"val1\", " +
+ "\"Col 2\":\"val2\", " +
+ "\"Col 3\":\"val3\", " +
+ "\"Col 4\":\"val4\", " +
+ "\"Col 5\":\"val5\", " +
+ "\"Col 6\":\"val6\", " +
+ "\"Col 7\":\"val7\"" +
+ "}, " +
+ " {" +
+ "\"Col 1\":\"1\", " +
+ "\"Col 2\":\"2\", " +
+ "\"Col 3\":\"3\", " +
+ "\"Col 4\":\"4\", " +
+ "\"Col 5\":\"5\", " +
+ "\"Col 6\":\"6\", " +
+ "\"Col 7\":\"7\"" +
+ "}, " +
+ " {" +
+ "\"Col 1\":\"true\", " +
+ "\"Col 2\":\"false\", " +
+ "\"Col 3\":\"true\", " +
+ "\"Col 4\":\"true\", " +
+ "\"Col 5\":\"false\", " +
+ "\"Col 6\":\"false\", " +
+ "\"Col 7\":\"false\"" +
+ "}, " +
+ "{" +
+ "\"Col 1\":\"0.23\", " +
+ "\"Col 2\":\"57.42\", " +
+ "\"Col 3\":\"5e27\", " +
+ "\"Col 4\":\"-234.879\", " +
+ "\"Col 5\":\"2.34e5\", " +
+ "\"Col 6\":\"0.0\", " +
+ "\"Col 7\":\"9e-3\"" +
+ "}, " +
+ "{" +
+ "\"Col 1\":\"va\tl1\", " +
+ "\"Col 2\":\"v\bal2\", " +
+ "\"Col 3\":\"val3\", " +
+ "\"Col 4\":\"val\f4\", " +
+ "\"Col 5\":\"val5\", " +
+ "\"Col 6\":\"va'l6\", " +
+ "\"Col 7\":\"val7\"" +
+ "}" +
+ "]";
/**
* Attempts to create a JSONArray from a null string.
@@ -127,6 +168,33 @@ public void unbalancedEscapedQuote(){
}
}
+ /**
+ * Csv parsing skip last row if last field of this row is empty #943
+ */
+ @Test
+ public void csvParsingCatchesLastRow(){
+ String data = "Field 1,Field 2,Field 3\n" +
+ "value11,value12,\n" +
+ "value21,value22,";
+
+ JSONArray jsonArray = CDL.toJSONArray(data);
+
+ JSONArray expectedJsonArray = new JSONArray();
+ JSONObject jsonObject = new JSONObject();
+ jsonObject.put("Field 1", "value11");
+ jsonObject.put("Field 2", "value12");
+ jsonObject.put("Field 3", "");
+ expectedJsonArray.put(jsonObject);
+
+ jsonObject = new JSONObject();
+ jsonObject.put("Field 1", "value21");
+ jsonObject.put("Field 2", "value22");
+ jsonObject.put("Field 3", "");
+ expectedJsonArray.put(jsonObject);
+
+ Util.compareActualVsExpectedJsonArrays(jsonArray, expectedJsonArray);
+ }
+
/**
* Assert that there is no error for a single escaped quote within a properly embedded quote.
*/
@@ -194,8 +262,7 @@ public void nullJSONArrayToString() {
public void emptyString() {
String emptyStr = "";
JSONArray jsonArray = CDL.toJSONArray(emptyStr);
- assertTrue("CDL should return null when the input string is empty",
- jsonArray == null);
+ assertNull("CDL should return null when the input string is empty", jsonArray);
}
/**
@@ -254,7 +321,7 @@ public void checkSpecialChars() {
jsonObject.put("Col \r1", "V1");
// \r will be filtered from value
jsonObject.put("Col 2", "V2\r");
- assertTrue("expected length should be 1",jsonArray.length() == 1);
+ assertEquals("expected length should be 1", 1, jsonArray.length());
String cdlStr = CDL.toString(jsonArray);
jsonObject = jsonArray.getJSONObject(0);
assertTrue(cdlStr.contains("\"Col 1\""));
@@ -268,8 +335,15 @@ public void checkSpecialChars() {
*/
@Test
public void textToJSONArray() {
- JSONArray jsonArray = CDL.toJSONArray(this.lines);
- JSONArray expectedJsonArray = new JSONArray(this.expectedLines);
+ JSONArray jsonArray = CDL.toJSONArray(LINES);
+ JSONArray expectedJsonArray = new JSONArray(EXPECTED_LINES);
+ Util.compareActualVsExpectedJsonArrays(jsonArray, expectedJsonArray);
+ }
+ @Test
+ public void textToJSONArrayPipeDelimited() {
+ char delimiter = '|';
+ JSONArray jsonArray = CDL.toJSONArray(LINES.replaceAll(",", String.valueOf(delimiter)), delimiter);
+ JSONArray expectedJsonArray = new JSONArray(EXPECTED_LINES);
Util.compareActualVsExpectedJsonArrays(jsonArray, expectedJsonArray);
}
@@ -279,11 +353,11 @@ public void textToJSONArray() {
*/
@Test
public void jsonArrayToJSONArray() {
- String nameArrayStr = "[Col1, Col2]";
+ String nameArrayStr = "[\"Col1\", \"Col2\"]";
String values = "V1, V2";
JSONArray nameJSONArray = new JSONArray(nameArrayStr);
JSONArray jsonArray = CDL.toJSONArray(nameJSONArray, values);
- JSONArray expectedJsonArray = new JSONArray("[{Col1:V1,Col2:V2}]");
+ JSONArray expectedJsonArray = new JSONArray("[{\"Col1\":\"V1\",\"Col2\":\"V2\"}]");
Util.compareActualVsExpectedJsonArrays(jsonArray, expectedJsonArray);
}
@@ -293,10 +367,24 @@ public void jsonArrayToJSONArray() {
*/
@Test
public void textToJSONArrayAndBackToString() {
- JSONArray jsonArray = CDL.toJSONArray(this.lines);
+ JSONArray jsonArray = CDL.toJSONArray(LINES);
String jsonStr = CDL.toString(jsonArray);
JSONArray finalJsonArray = CDL.toJSONArray(jsonStr);
- JSONArray expectedJsonArray = new JSONArray(this.expectedLines);
+ JSONArray expectedJsonArray = new JSONArray(EXPECTED_LINES);
+ Util.compareActualVsExpectedJsonArrays(finalJsonArray, expectedJsonArray);
+ }
+
+ /**
+ * Create a JSONArray from a string of lines,
+ * then convert to string and then back to JSONArray
+ * with a custom delimiter
+ */
+ @Test
+ public void textToJSONArrayAndBackToStringCustomDelimiter() {
+ JSONArray jsonArray = CDL.toJSONArray(LINES, ',');
+ String jsonStr = CDL.toString(jsonArray, ';');
+ JSONArray finalJsonArray = CDL.toJSONArray(jsonStr, ';');
+ JSONArray expectedJsonArray = new JSONArray(EXPECTED_LINES);
Util.compareActualVsExpectedJsonArrays(finalJsonArray, expectedJsonArray);
}
diff --git a/src/test/java/org/json/junit/JSONArrayTest.java b/src/test/java/org/json/junit/JSONArrayTest.java
index aa8657f06..429620396 100644
--- a/src/test/java/org/json/junit/JSONArrayTest.java
+++ b/src/test/java/org/json/junit/JSONArrayTest.java
@@ -8,6 +8,7 @@
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
@@ -28,10 +29,13 @@
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
+import org.json.JSONParserConfiguration;
import org.json.JSONPointerException;
import org.json.JSONString;
import org.json.JSONTokener;
+import org.json.ParserConfiguration;
import org.json.junit.data.MyJsonString;
+import org.junit.Ignore;
import org.junit.Test;
import com.jayway.jsonpath.Configuration;
@@ -118,7 +122,7 @@ public void nullException() {
* Expects a JSONException.
*/
@Test
- public void emptStr() {
+ public void emptyStr() {
String str = "";
try {
assertNull("Should throw an exception", new JSONArray(str));
@@ -224,6 +228,19 @@ public void verifyConstructor() {
Util.checkJSONArrayMaps(jaRaw);
Util.checkJSONArrayMaps(jaInt);
}
+
+ @Test
+ public void jsonArrayByListWithNestedNullValue() {
+ List> list = new ArrayList>();
+ Map sub = new HashMap();
+ sub.put("nullKey", null);
+ list.add(sub);
+ JSONParserConfiguration parserConfiguration = new JSONParserConfiguration().withUseNativeNulls(true);
+ JSONArray jsonArray = new JSONArray(list, parserConfiguration);
+ JSONObject subObject = jsonArray.getJSONObject(0);
+ assertTrue(subObject.has("nullKey"));
+ assertEquals(JSONObject.NULL, subObject.get("nullKey"));
+ }
/**
* Tests consecutive calls to putAll with array and collection.
@@ -256,6 +273,11 @@ public void verifyPutAll() {
jsonArray.length(),
len);
+ // collection as object
+ @SuppressWarnings("RedundantCast")
+ Object myListAsObject = (Object) myList;
+ jsonArray.putAll(myListAsObject);
+
for (int i = 0; i < myList.size(); i++) {
assertEquals("collection elements should be equal",
myList.get(i),
@@ -368,16 +390,16 @@ public void getArrayValues() {
"hello".equals(jsonArray.getString(4)));
// doubles
assertTrue("Array double",
- new Double(23.45e-4).equals(jsonArray.getDouble(5)));
+ Double.valueOf(23.45e-4).equals(jsonArray.getDouble(5)));
assertTrue("Array string double",
- new Double(23.45).equals(jsonArray.getDouble(6)));
+ Double.valueOf(23.45).equals(jsonArray.getDouble(6)));
assertTrue("Array double can be float",
- new Float(23.45e-4f).equals(jsonArray.getFloat(5)));
+ Float.valueOf(23.45e-4f).equals(jsonArray.getFloat(5)));
// ints
assertTrue("Array value int",
- new Integer(42).equals(jsonArray.getInt(7)));
+ Integer.valueOf(42).equals(jsonArray.getInt(7)));
assertTrue("Array value string int",
- new Integer(43).equals(jsonArray.getInt(8)));
+ Integer.valueOf(43).equals(jsonArray.getInt(8)));
// nested objects
JSONArray nestedJsonArray = jsonArray.getJSONArray(9);
assertTrue("Array value JSONArray", nestedJsonArray != null);
@@ -385,9 +407,9 @@ public void getArrayValues() {
assertTrue("Array value JSONObject", nestedJsonObject != null);
// longs
assertTrue("Array value long",
- new Long(0).equals(jsonArray.getLong(11)));
+ Long.valueOf(0).equals(jsonArray.getLong(11)));
assertTrue("Array value string long",
- new Long(-1).equals(jsonArray.getLong(12)));
+ Long.valueOf(-1).equals(jsonArray.getLong(12)));
assertTrue("Array value null", jsonArray.isNull(-1));
Util.checkJSONArrayMaps(jsonArray);
@@ -460,6 +482,30 @@ public void failedGetArrayValues() {
Util.checkJSONArrayMaps(jsonArray);
}
+ /**
+ * The JSON parser is permissive of unambiguous unquoted keys and values.
+ * Such JSON text should be allowed, even if it does not strictly conform
+ * to the spec. However, after being parsed, toString() should emit strictly
+ * conforming JSON text.
+ */
+ @Test
+ public void unquotedText() {
+ String str = "[value1, something!, (parens), foo@bar.com, 23, 23+45]";
+ List expected = Arrays.asList("value1", "something!", "(parens)", "foo@bar.com", 23, "23+45");
+
+ // Test should fail if default strictMode is true, pass if false
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration();
+ if (jsonParserConfiguration.isStrictMode()) {
+ try {
+ JSONArray jsonArray = new JSONArray(str);
+ assertEquals("Expected to throw exception due to invalid string", true, false);
+ } catch (JSONException e) { }
+ } else {
+ JSONArray jsonArray = new JSONArray(str);
+ assertEquals(expected, jsonArray.toList());
+ }
+ }
+
/**
* Exercise JSONArray.join() by converting a JSONArray into a
* comma-separated string. Since this is very nearly a JSON document,
@@ -537,43 +583,75 @@ public void opt() {
assertTrue("Array opt boolean implicit default",
Boolean.FALSE == jsonArray.optBoolean(-1));
+ assertTrue("Array opt boolean object",
+ Boolean.TRUE.equals(jsonArray.optBooleanObject(0)));
+ assertTrue("Array opt boolean object default",
+ Boolean.FALSE.equals(jsonArray.optBooleanObject(-1, Boolean.FALSE)));
+ assertTrue("Array opt boolean object implicit default",
+ Boolean.FALSE.equals(jsonArray.optBooleanObject(-1)));
+
assertTrue("Array opt double",
- new Double(23.45e-4).equals(jsonArray.optDouble(5)));
+ Double.valueOf(23.45e-4).equals(jsonArray.optDouble(5)));
assertTrue("Array opt double default",
- new Double(1).equals(jsonArray.optDouble(0, 1)));
+ Double.valueOf(1).equals(jsonArray.optDouble(0, 1)));
assertTrue("Array opt double default implicit",
- new Double(jsonArray.optDouble(99)).isNaN());
+ Double.valueOf(jsonArray.optDouble(99)).isNaN());
+
+ assertTrue("Array opt double object",
+ Double.valueOf(23.45e-4).equals(jsonArray.optDoubleObject(5)));
+ assertTrue("Array opt double object default",
+ Double.valueOf(1).equals(jsonArray.optDoubleObject(0, 1D)));
+ assertTrue("Array opt double object default implicit",
+ jsonArray.optDoubleObject(99).isNaN());
assertTrue("Array opt float",
- new Float(23.45e-4).equals(jsonArray.optFloat(5)));
+ Float.valueOf(Double.valueOf(23.45e-4).floatValue()).equals(jsonArray.optFloat(5)));
assertTrue("Array opt float default",
- new Float(1).equals(jsonArray.optFloat(0, 1)));
+ Float.valueOf(1).equals(jsonArray.optFloat(0, 1)));
assertTrue("Array opt float default implicit",
- new Float(jsonArray.optFloat(99)).isNaN());
+ Float.valueOf(jsonArray.optFloat(99)).isNaN());
+
+ assertTrue("Array opt float object",
+ Float.valueOf(23.45e-4F).equals(jsonArray.optFloatObject(5)));
+ assertTrue("Array opt float object default",
+ Float.valueOf(1).equals(jsonArray.optFloatObject(0, 1F)));
+ assertTrue("Array opt float object default implicit",
+ jsonArray.optFloatObject(99).isNaN());
assertTrue("Array opt Number",
BigDecimal.valueOf(23.45e-4).equals(jsonArray.optNumber(5)));
assertTrue("Array opt Number default",
- new Double(1).equals(jsonArray.optNumber(0, 1d)));
+ Double.valueOf(1).equals(jsonArray.optNumber(0, 1d)));
assertTrue("Array opt Number default implicit",
- new Double(jsonArray.optNumber(99,Double.NaN).doubleValue()).isNaN());
+ Double.valueOf(jsonArray.optNumber(99,Double.NaN).doubleValue()).isNaN());
assertTrue("Array opt int",
- new Integer(42).equals(jsonArray.optInt(7)));
+ Integer.valueOf(42).equals(jsonArray.optInt(7)));
assertTrue("Array opt int default",
- new Integer(-1).equals(jsonArray.optInt(0, -1)));
+ Integer.valueOf(-1).equals(jsonArray.optInt(0, -1)));
assertTrue("Array opt int default implicit",
0 == jsonArray.optInt(0));
+ assertTrue("Array opt int object",
+ Integer.valueOf(42).equals(jsonArray.optIntegerObject(7)));
+ assertTrue("Array opt int object default",
+ Integer.valueOf(-1).equals(jsonArray.optIntegerObject(0, -1)));
+ assertTrue("Array opt int object default implicit",
+ Integer.valueOf(0).equals(jsonArray.optIntegerObject(0)));
+
JSONArray nestedJsonArray = jsonArray.optJSONArray(9);
assertTrue("Array opt JSONArray", nestedJsonArray != null);
- assertTrue("Array opt JSONArray default",
+ assertTrue("Array opt JSONArray null",
null == jsonArray.optJSONArray(99));
+ assertTrue("Array opt JSONArray default",
+ "value".equals(jsonArray.optJSONArray(99, new JSONArray("[\"value\"]")).getString(0)));
JSONObject nestedJsonObject = jsonArray.optJSONObject(10);
assertTrue("Array opt JSONObject", nestedJsonObject != null);
- assertTrue("Array opt JSONObject default",
+ assertTrue("Array opt JSONObject null",
null == jsonArray.optJSONObject(99));
+ assertTrue("Array opt JSONObject default",
+ "value".equals(jsonArray.optJSONObject(99, new JSONObject("{\"key\":\"value\"}")).getString("key")));
assertTrue("Array opt long",
0 == jsonArray.optLong(11));
@@ -582,6 +660,13 @@ public void opt() {
assertTrue("Array opt long default implicit",
0 == jsonArray.optLong(-1));
+ assertTrue("Array opt long object",
+ Long.valueOf(0).equals(jsonArray.optLongObject(11)));
+ assertTrue("Array opt long object default",
+ Long.valueOf(-2).equals(jsonArray.optLongObject(-1, -2L)));
+ assertTrue("Array opt long object default implicit",
+ Long.valueOf(0).equals(jsonArray.optLongObject(-1)));
+
assertTrue("Array opt string",
"hello".equals(jsonArray.optString(4)));
assertTrue("Array opt string default implicit",
@@ -599,10 +684,15 @@ public void opt() {
public void optStringConversion(){
JSONArray ja = new JSONArray("[\"123\",\"true\",\"false\"]");
assertTrue("unexpected optBoolean value",ja.optBoolean(1,false)==true);
+ assertTrue("unexpected optBooleanObject value",Boolean.valueOf(true).equals(ja.optBooleanObject(1,false)));
assertTrue("unexpected optBoolean value",ja.optBoolean(2,true)==false);
+ assertTrue("unexpected optBooleanObject value",Boolean.valueOf(false).equals(ja.optBooleanObject(2,true)));
assertTrue("unexpected optInt value",ja.optInt(0,0)==123);
+ assertTrue("unexpected optIntegerObject value",Integer.valueOf(123).equals(ja.optIntegerObject(0,0)));
assertTrue("unexpected optLong value",ja.optLong(0,0)==123);
+ assertTrue("unexpected optLongObject value",Long.valueOf(123).equals(ja.optLongObject(0,0L)));
assertTrue("unexpected optDouble value",ja.optDouble(0,0.0)==123.0);
+ assertTrue("unexpected optDoubleObject value",Double.valueOf(123.0).equals(ja.optDoubleObject(0,0.0)));
assertTrue("unexpected optBigInteger value",ja.optBigInteger(0,BigInteger.ZERO).compareTo(new BigInteger("123"))==0);
assertTrue("unexpected optBigDecimal value",ja.optBigDecimal(0,BigDecimal.ZERO).compareTo(new BigDecimal("123"))==0);
Util.checkJSONArrayMaps(ja);
@@ -624,8 +714,8 @@ public void put() {
String jsonArrayStr =
"["+
- "hello,"+
- "world"+
+ "\"hello\","+
+ "\"world\""+
"]";
// 2
jsonArray.put(new JSONArray(jsonArrayStr));
@@ -702,8 +792,8 @@ public void putIndex() {
String jsonArrayStr =
"["+
- "hello,"+
- "world"+
+ "\"hello\","+
+ "\"world\""+
"]";
// 2
jsonArray.put(2, new JSONArray(jsonArrayStr));
@@ -971,12 +1061,12 @@ public void iteratorTest() {
assertTrue("Array double [23.45e-4]",
new BigDecimal("0.002345").equals(it.next()));
assertTrue("Array string double",
- new Double(23.45).equals(Double.parseDouble((String)it.next())));
+ Double.valueOf(23.45).equals(Double.parseDouble((String)it.next())));
assertTrue("Array value int",
- new Integer(42).equals(it.next()));
+ Integer.valueOf(42).equals(it.next()));
assertTrue("Array value string int",
- new Integer(43).equals(Integer.parseInt((String)it.next())));
+ Integer.valueOf(43).equals(Integer.parseInt((String)it.next())));
JSONArray nestedJsonArray = (JSONArray)it.next();
assertTrue("Array value JSONArray", nestedJsonArray != null);
@@ -985,9 +1075,9 @@ public void iteratorTest() {
assertTrue("Array value JSONObject", nestedJsonObject != null);
assertTrue("Array value long",
- new Long(0).equals(((Number) it.next()).longValue()));
+ Long.valueOf(0).equals(((Number) it.next()).longValue()));
assertTrue("Array value string long",
- new Long(-1).equals(Long.parseLong((String) it.next())));
+ Long.valueOf(-1).equals(Long.parseLong((String) it.next())));
assertTrue("should be at end of array", !it.hasNext());
Util.checkJSONArraysMaps(new ArrayList(Arrays.asList(
jsonArray, nestedJsonArray
@@ -1326,14 +1416,15 @@ public void jsonArrayClearMethodTest() {
/**
* Tests for stack overflow. See https://github.com/stleary/JSON-java/issues/654
*/
+ @Ignore("This test relies on system constraints and may not always pass. See: https://github.com/stleary/JSON-java/issues/821")
@Test(expected = JSONException.class)
public void issue654StackOverflowInputWellFormed() {
//String input = new String(java.util.Base64.getDecoder().decode(base64Bytes));
- final InputStream resourceAsStream = JSONObjectTest.class.getClassLoader().getResourceAsStream("Issue654WellFormedArray.json");
+ final InputStream resourceAsStream = JSONArrayTest.class.getClassLoader().getResourceAsStream("Issue654WellFormedArray.json");
JSONTokener tokener = new JSONTokener(resourceAsStream);
JSONArray json_input = new JSONArray(tokener);
assertNotNull(json_input);
- fail("Excepected Exception.");
+ fail("Excepected Exception due to stack overflow.");
Util.checkJSONArrayMaps(json_input);
}
@@ -1357,4 +1448,100 @@ public String toJSONString() {
.put(2);
assertFalse(ja1.similar(ja3));
}
+
+ @Test(expected = JSONException.class)
+ public void testRecursiveDepth() {
+ HashMap map = new HashMap<>();
+ map.put("t", map);
+ new JSONArray().put(map);
+ }
+
+ @Test(expected = JSONException.class)
+ public void testRecursiveDepthAtPosition() {
+ HashMap map = new HashMap<>();
+ map.put("t", map);
+ new JSONArray().put(0, map);
+ }
+
+ @Test(expected = JSONException.class)
+ public void testRecursiveDepthArray() {
+ ArrayList array = new ArrayList<>();
+ array.add(array);
+ new JSONArray(array);
+ }
+
+ @Test
+ public void testRecursiveDepthAtPositionDefaultObject() {
+ HashMap map = JSONObjectTest.buildNestedMap(ParserConfiguration.DEFAULT_MAXIMUM_NESTING_DEPTH);
+ new JSONArray().put(0, map);
+ }
+
+ @Test
+ public void testRecursiveDepthAtPosition1000Object() {
+ HashMap map = JSONObjectTest.buildNestedMap(1000);
+ new JSONArray().put(0, map, new JSONParserConfiguration().withMaxNestingDepth(1000));
+ }
+
+ @Test(expected = JSONException.class)
+ public void testRecursiveDepthAtPosition1001Object() {
+ HashMap map = JSONObjectTest.buildNestedMap(1001);
+ new JSONArray().put(0, map);
+ }
+
+ @Test(expected = JSONException.class)
+ public void testRecursiveDepthArrayLimitedMaps() {
+ ArrayList array = new ArrayList<>();
+ array.add(array);
+ new JSONArray(array);
+ }
+
+ @Test
+ public void testRecursiveDepthArrayForDefaultLevels() {
+ ArrayList array = buildNestedArray(ParserConfiguration.DEFAULT_MAXIMUM_NESTING_DEPTH);
+ new JSONArray(array, new JSONParserConfiguration());
+ }
+
+ @Test
+ public void testRecursiveDepthArrayFor1000Levels() {
+ try {
+ ArrayList array = buildNestedArray(1000);
+ JSONParserConfiguration parserConfiguration = new JSONParserConfiguration().withMaxNestingDepth(1000);
+ new JSONArray(array, parserConfiguration);
+ } catch (StackOverflowError e) {
+ String javaVersion = System.getProperty("java.version");
+ if (javaVersion.startsWith("11.")) {
+ System.out.println(
+ "testRecursiveDepthArrayFor1000Levels() allowing intermittent stackoverflow, Java Version: "
+ + javaVersion);
+ } else {
+ String errorStr = "testRecursiveDepthArrayFor1000Levels() unexpected stackoverflow, Java Version: "
+ + javaVersion;
+ System.out.println(errorStr);
+ throw new RuntimeException(errorStr);
+ }
+ }
+ }
+
+ @Test(expected = JSONException.class)
+ public void testRecursiveDepthArrayFor1001Levels() {
+ ArrayList array = buildNestedArray(1001);
+ new JSONArray(array);
+ }
+
+ @Test
+ public void testStrictModeJSONTokener_expectException(){
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration().withStrictMode();
+ JSONTokener tokener = new JSONTokener("[\"value\"]invalidCharacters", jsonParserConfiguration);
+
+ assertThrows(JSONException.class, () -> { new JSONArray(tokener); });
+ }
+
+ public static ArrayList buildNestedArray(int maxDepth) {
+ if (maxDepth <= 0) {
+ return new ArrayList<>();
+ }
+ ArrayList nestedArray = new ArrayList<>();
+ nestedArray.add(buildNestedArray(maxDepth - 1));
+ return nestedArray;
+ }
}
diff --git a/src/test/java/org/json/junit/JSONMLTest.java b/src/test/java/org/json/junit/JSONMLTest.java
index 35c0af2c4..5a360dd59 100644
--- a/src/test/java/org/json/junit/JSONMLTest.java
+++ b/src/test/java/org/json/junit/JSONMLTest.java
@@ -625,7 +625,7 @@ public void toJSONObjectToJSONArray() {
"\"subValue\","+
"{\"svAttr\":\"svValue\"},"+
"\"abc\""+
- "],"+
+ "]"+
"],"+
"[\"value\",3],"+
"[\"value\",4.1],"+
@@ -762,8 +762,8 @@ public void testToJSONObject_reversibility() {
final String xml = JSONML.toString(originalObject);
final JSONObject revertedObject = JSONML.toJSONObject(xml, false);
final String newJson = revertedObject.toString();
- assertTrue("JSON Objects are not similar",originalObject.similar(revertedObject));
- assertEquals("original JSON does not equal the new JSON",originalJson, newJson);
+ assertTrue("JSON Objects are not similar", originalObject.similar(revertedObject));
+ assertTrue("JSON Strings are not similar", new JSONObject(originalJson).similar(new JSONObject(newJson)));
}
// these tests do not pass for the following reasons:
diff --git a/src/test/java/org/json/junit/JSONObjectNumberTest.java b/src/test/java/org/json/junit/JSONObjectNumberTest.java
index f6e13c63d..0f2af2902 100644
--- a/src/test/java/org/json/junit/JSONObjectNumberTest.java
+++ b/src/test/java/org/json/junit/JSONObjectNumberTest.java
@@ -23,18 +23,18 @@ public class JSONObjectNumberTest {
@Parameters(name = "{index}: {0}")
public static Collection data() {
return Arrays.asList(new Object[][]{
- {"{value:50}", 1},
- {"{value:50.0}", 1},
- {"{value:5e1}", 1},
- {"{value:5E1}", 1},
- {"{value:5e1}", 1},
- {"{value:'50'}", 1},
- {"{value:-50}", -1},
- {"{value:-50.0}", -1},
- {"{value:-5e1}", -1},
- {"{value:-5E1}", -1},
- {"{value:-5e1}", -1},
- {"{value:'-50'}", -1}
+ {"{\"value\":50}", 1},
+ {"{\"value\":50.0}", 1},
+ {"{\"value\":5e1}", 1},
+ {"{\"value\":5E1}", 1},
+ {"{\"value\":5e1}", 1},
+ {"{\"value\":\"50\"}", 1},
+ {"{\"value\":-50}", -1},
+ {"{\"value\":-50.0}", -1},
+ {"{\"value\":-5e1}", -1},
+ {"{\"value\":-5E1}", -1},
+ {"{\"value\":-5e1}", -1},
+ {"{\"value\":\"-50\"}", -1}
// JSON does not support octal or hex numbers;
// see https://stackoverflow.com/a/52671839/6323312
// "{value:062}", // octal 50
@@ -109,18 +109,38 @@ public void testOptFloat() {
assertEquals(value.floatValue(), object.optFloat("value"), 0.0f);
}
+ @Test
+ public void testOptFloatObject() {
+ assertEquals((Float) value.floatValue(), object.optFloatObject("value"), 0.0f);
+ }
+
@Test
public void testOptDouble() {
assertEquals(value.doubleValue(), object.optDouble("value"), 0.0d);
}
+ @Test
+ public void testOptDoubleObject() {
+ assertEquals((Double) value.doubleValue(), object.optDoubleObject("value"), 0.0d);
+ }
+
@Test
public void testOptInt() {
assertEquals(value.intValue(), object.optInt("value"));
}
+ @Test
+ public void testOptIntegerObject() {
+ assertEquals((Integer) value.intValue(), object.optIntegerObject("value"));
+ }
+
@Test
public void testOptLong() {
assertEquals(value.longValue(), object.optLong("value"));
}
+
+ @Test
+ public void testOptLongObject() {
+ assertEquals((Long) value.longValue(), object.optLongObject("value"));
+ }
}
diff --git a/src/test/java/org/json/junit/JSONObjectTest.java b/src/test/java/org/json/junit/JSONObjectTest.java
index ea0cec39c..e7553cd9b 100644
--- a/src/test/java/org/json/junit/JSONObjectTest.java
+++ b/src/test/java/org/json/junit/JSONObjectTest.java
@@ -9,6 +9,7 @@
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.mock;
@@ -30,8 +31,10 @@
import org.json.JSONException;
import org.json.JSONObject;
import org.json.JSONPointerException;
+import org.json.JSONParserConfiguration;
import org.json.JSONString;
import org.json.JSONTokener;
+import org.json.ParserConfiguration;
import org.json.XML;
import org.json.junit.data.BrokenToString;
import org.json.junit.data.ExceptionalBean;
@@ -53,8 +56,9 @@
import org.json.junit.data.Singleton;
import org.json.junit.data.SingletonEnum;
import org.json.junit.data.WeirdList;
+import org.junit.After;
+import org.junit.Ignore;
import org.junit.Test;
-import org.json.junit.Util;
import com.jayway.jsonpath.Configuration;
import com.jayway.jsonpath.JsonPath;
@@ -72,6 +76,14 @@ public class JSONObjectTest {
*/
static final Pattern NUMBER_PATTERN = Pattern.compile("-?(?:0|[1-9]\\d*)(?:\\.\\d+)?(?:[eE][+-]?\\d+)?");
+ @After
+ public void tearDown() {
+ SingletonEnum.getInstance().setSomeInt(0);
+ SingletonEnum.getInstance().setSomeString(null);
+ Singleton.getInstance().setSomeInt(0);
+ Singleton.getInstance().setSomeString(null);
+ }
+
/**
* Tests that the similar method is working as expected.
*/
@@ -206,14 +218,28 @@ public void jsonObjectByNullBean() {
*/
@Test
public void unquotedText() {
- String str = "{key1:value1, key2:42}";
- JSONObject jsonObject = new JSONObject(str);
- String textStr = jsonObject.toString();
- assertTrue("expected key1", textStr.contains("\"key1\""));
- assertTrue("expected value1", textStr.contains("\"value1\""));
- assertTrue("expected key2", textStr.contains("\"key2\""));
- assertTrue("expected 42", textStr.contains("42"));
- Util.checkJSONObjectMaps(jsonObject);
+ String str = "{key1:value1, key2:42, 1.2 : 3.4, -7e5 : something!}";
+
+ // Test should fail if default strictMode is true, pass if false
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration();
+ if (jsonParserConfiguration.isStrictMode()) {
+ try {
+ JSONObject jsonObject = new JSONObject(str);
+ assertEquals("Expected to throw exception due to invalid string", true, false);
+ } catch (JSONException e) { }
+ } else {
+ JSONObject jsonObject = new JSONObject(str);
+ String textStr = jsonObject.toString();
+ assertTrue("expected key1", textStr.contains("\"key1\""));
+ assertTrue("expected value1", textStr.contains("\"value1\""));
+ assertTrue("expected key2", textStr.contains("\"key2\""));
+ assertTrue("expected 42", textStr.contains("42"));
+ assertTrue("expected 1.2", textStr.contains("\"1.2\""));
+ assertTrue("expected 3.4", textStr.contains("3.4"));
+ assertTrue("expected -7E+5", textStr.contains("\"-7E+5\""));
+ assertTrue("expected something!", textStr.contains("\"something!\""));
+ Util.checkJSONObjectMaps(jsonObject);
+ }
}
@Test
@@ -231,6 +257,11 @@ public void testLongFromString(){
assert 26315000000253009L == actualLong : "Incorrect key value. Got "
+ actualLong + " expected " + str;
+ final Long actualLongObject = json.optLongObject("key");
+ assert actualLongObject != 0L : "Unable to extract Long value for string " + str;
+ assert Long.valueOf(26315000000253009L).equals(actualLongObject) : "Incorrect key value. Got "
+ + actualLongObject + " expected " + str;
+
final String actualString = json.optString("key");
assert str.equals(actualString) : "Incorrect key value. Got "
+ actualString + " expected " + str;
@@ -299,12 +330,12 @@ public void jsonObjectByNullMap() {
@Test
public void jsonObjectByMap() {
Map map = new HashMap();
- map.put("trueKey", new Boolean(true));
- map.put("falseKey", new Boolean(false));
+ map.put("trueKey", Boolean.valueOf(true));
+ map.put("falseKey", Boolean.valueOf(false));
map.put("stringKey", "hello world!");
map.put("escapeStringKey", "h\be\tllo w\u1234orld!");
- map.put("intKey", new Long(42));
- map.put("doubleKey", new Double(-23.45e67));
+ map.put("intKey", Long.valueOf(42));
+ map.put("doubleKey", Double.valueOf(-23.45e67));
JSONObject jsonObject = new JSONObject(map);
// validate JSON
@@ -565,13 +596,13 @@ public void jsonObjectByMapWithUnsupportedValues() {
@Test
public void jsonObjectByMapWithNullValue() {
Map map = new HashMap();
- map.put("trueKey", new Boolean(true));
- map.put("falseKey", new Boolean(false));
+ map.put("trueKey", Boolean.valueOf(true));
+ map.put("falseKey", Boolean.valueOf(false));
map.put("stringKey", "hello world!");
map.put("nullKey", null);
map.put("escapeStringKey", "h\be\tllo w\u1234orld!");
- map.put("intKey", new Long(42));
- map.put("doubleKey", new Double(-23.45e67));
+ map.put("intKey", Long.valueOf(42));
+ map.put("doubleKey", Double.valueOf(-23.45e67));
JSONObject jsonObject = new JSONObject(map);
// validate JSON
@@ -585,6 +616,46 @@ public void jsonObjectByMapWithNullValue() {
assertTrue("expected \"doubleKey\":-23.45e67", Double.valueOf("-23.45e67").equals(jsonObject.query("/doubleKey")));
Util.checkJSONObjectMaps(jsonObject);
}
+
+ @Test
+ public void jsonObjectByMapWithNullValueAndParserConfiguration() {
+ Map map = new HashMap();
+ map.put("nullKey", null);
+
+ // by default, null values are ignored
+ JSONObject obj1 = new JSONObject(map);
+ assertTrue("expected null value to be ignored by default", obj1.isEmpty());
+
+ // if configured, null values are written as such into the JSONObject.
+ JSONParserConfiguration parserConfiguration = new JSONParserConfiguration().withUseNativeNulls(true);
+ JSONObject obj2 = new JSONObject(map, parserConfiguration);
+ assertFalse("expected null value to accepted when configured", obj2.isEmpty());
+ assertTrue(obj2.has("nullKey"));
+ assertEquals(JSONObject.NULL, obj2.get("nullKey"));
+ }
+
+ @Test
+ public void jsonObjectByMapWithNestedNullValueAndParserConfiguration() {
+ Map map = new HashMap();
+ Map nestedMap = new HashMap();
+ nestedMap.put("nullKey", null);
+ map.put("nestedMap", nestedMap);
+ List> nestedList = new ArrayList>();
+ nestedList.add(nestedMap);
+ map.put("nestedList", nestedList);
+
+ JSONParserConfiguration parserConfiguration = new JSONParserConfiguration().withUseNativeNulls(true);
+ JSONObject jsonObject = new JSONObject(map, parserConfiguration);
+
+ JSONObject nestedObject = jsonObject.getJSONObject("nestedMap");
+ assertTrue(nestedObject.has("nullKey"));
+ assertEquals(JSONObject.NULL, nestedObject.get("nullKey"));
+
+ JSONArray nestedArray = jsonObject.getJSONArray("nestedList");
+ assertEquals(1, nestedArray.length());
+ assertTrue(nestedArray.getJSONObject(0).has("nullKey"));
+ assertEquals(JSONObject.NULL, nestedArray.getJSONObject(0).get("nullKey"));
+ }
/**
* JSONObject built from a bean. In this case all but one of the
@@ -621,9 +692,9 @@ public void jsonObjectByBean1() {
assertTrue("expected 42", Integer.valueOf("42").equals(jsonObject.query("/intKey")));
assertTrue("expected -23.45e7", Double.valueOf("-23.45e7").equals(jsonObject.query("/doubleKey")));
// sorry, mockito artifact
- assertTrue("expected 2 callbacks items", ((List)(JsonPath.read(doc, "$.callbacks"))).size() == 2);
- assertTrue("expected 0 handler items", ((Map)(JsonPath.read(doc, "$.callbacks[0].handler"))).size() == 0);
- assertTrue("expected 0 callbacks[1] items", ((Map)(JsonPath.read(doc, "$.callbacks[1]"))).size() == 0);
+ assertTrue("expected 2 mockitoInterceptor items", ((Map)(JsonPath.read(doc, "$.mockitoInterceptor"))).size() == 2);
+ assertTrue("expected 0 mockitoInterceptor.serializationSupport items",
+ ((Map)(JsonPath.read(doc, "$.mockitoInterceptor.serializationSupport"))).size() == 0);
Util.checkJSONObjectMaps(jsonObject);
}
@@ -830,7 +901,7 @@ public void jsonObjectAppend() {
public void jsonObjectDoubleToString() {
String [] expectedStrs = {"1", "1", "-23.4", "-2.345E68", "null", "null" };
Double [] doubles = { 1.0, 00001.00000, -23.4, -23.45e67,
- Double.NaN, Double.NEGATIVE_INFINITY };
+ Double.NaN, Double.NEGATIVE_INFINITY };
for (int i = 0; i < expectedStrs.length; ++i) {
String actualStr = JSONObject.doubleToString(doubles[i]);
assertTrue("value expected ["+expectedStrs[i]+
@@ -866,9 +937,11 @@ public void jsonObjectValues() {
JSONObject jsonObject = new JSONObject(str);
assertTrue("trueKey should be true", jsonObject.getBoolean("trueKey"));
assertTrue("opt trueKey should be true", jsonObject.optBoolean("trueKey"));
+ assertTrue("opt trueKey should be true", jsonObject.optBooleanObject("trueKey"));
assertTrue("falseKey should be false", !jsonObject.getBoolean("falseKey"));
assertTrue("trueStrKey should be true", jsonObject.getBoolean("trueStrKey"));
assertTrue("trueStrKey should be true", jsonObject.optBoolean("trueStrKey"));
+ assertTrue("trueStrKey should be true", jsonObject.optBooleanObject("trueStrKey"));
assertTrue("falseStrKey should be false", !jsonObject.getBoolean("falseStrKey"));
assertTrue("stringKey should be string",
jsonObject.getString("stringKey").equals("hello world!"));
@@ -884,6 +957,10 @@ public void jsonObjectValues() {
jsonObject.optDouble("doubleKey") == -23.45e7);
assertTrue("opt doubleKey with Default should be double",
jsonObject.optDouble("doubleStrKey", Double.NaN) == 1);
+ assertTrue("opt doubleKey should be Double",
+ Double.valueOf(-23.45e7).equals(jsonObject.optDoubleObject("doubleKey")));
+ assertTrue("opt doubleKey with Default should be Double",
+ Double.valueOf(1).equals(jsonObject.optDoubleObject("doubleStrKey", Double.NaN)));
assertTrue("opt negZeroKey should be a Double",
jsonObject.opt("negZeroKey") instanceof Double);
assertTrue("get negZeroKey should be a Double",
@@ -896,6 +973,10 @@ public void jsonObjectValues() {
Double.compare(jsonObject.optDouble("negZeroKey"), -0.0d) == 0);
assertTrue("opt negZeroStrKey with Default should be double",
Double.compare(jsonObject.optDouble("negZeroStrKey"), -0.0d) == 0);
+ assertTrue("opt negZeroKey should be Double",
+ Double.valueOf(-0.0d).equals(jsonObject.optDoubleObject("negZeroKey")));
+ assertTrue("opt negZeroStrKey with Default should be Double",
+ Double.valueOf(-0.0d).equals(jsonObject.optDoubleObject("negZeroStrKey")));
assertTrue("optNumber negZeroKey should be -0.0",
Double.compare(jsonObject.optNumber("negZeroKey").doubleValue(), -0.0d) == 0);
assertTrue("optNumber negZeroStrKey should be -0.0",
@@ -904,10 +985,18 @@ public void jsonObjectValues() {
jsonObject.optFloat("doubleKey") == -23.45e7f);
assertTrue("optFloat doubleKey with Default should be float",
jsonObject.optFloat("doubleStrKey", Float.NaN) == 1f);
+ assertTrue("optFloat doubleKey should be Float",
+ Float.valueOf(-23.45e7f).equals(jsonObject.optFloatObject("doubleKey")));
+ assertTrue("optFloat doubleKey with Default should be Float",
+ Float.valueOf(1f).equals(jsonObject.optFloatObject("doubleStrKey", Float.NaN)));
assertTrue("intKey should be int",
jsonObject.optInt("intKey") == 42);
assertTrue("opt intKey should be int",
jsonObject.optInt("intKey", 0) == 42);
+ assertTrue("intKey should be Integer",
+ Integer.valueOf(42).equals(jsonObject.optIntegerObject("intKey")));
+ assertTrue("opt intKey should be Integer",
+ Integer.valueOf(42).equals(jsonObject.optIntegerObject("intKey", 0)));
assertTrue("opt intKey with default should be int",
jsonObject.getInt("intKey") == 42);
assertTrue("intStrKey should be int",
@@ -918,6 +1007,10 @@ public void jsonObjectValues() {
jsonObject.optLong("longKey") == 1234567890123456789L);
assertTrue("opt longKey with default should be long",
jsonObject.optLong("longKey", 0) == 1234567890123456789L);
+ assertTrue("opt longKey should be Long",
+ Long.valueOf(1234567890123456789L).equals(jsonObject.optLongObject("longKey")));
+ assertTrue("opt longKey with default should be Long",
+ Long.valueOf(1234567890123456789L).equals(jsonObject.optLongObject("longKey", 0L)));
assertTrue("longStrKey should be long",
jsonObject.getLong("longStrKey") == 987654321098765432L);
assertTrue("optNumber int should return Integer",
@@ -969,7 +1062,7 @@ public void stringToValueNumbersTest() {
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 );
+ JSONObject.stringToValue( Double.valueOf( "0.2f" ).toString() ) instanceof BigDecimal );
/**
* This test documents a need for BigDecimal conversion.
*/
@@ -979,13 +1072,13 @@ public void stringToValueNumbersTest() {
assertTrue( "1 should be an Integer!",
JSONObject.stringToValue( "1" ) instanceof Integer );
assertTrue( "Integer.MAX_VALUE should still be an Integer!",
- JSONObject.stringToValue( new Integer( Integer.MAX_VALUE ).toString() ) instanceof Integer );
+ JSONObject.stringToValue( Integer.valueOf( Integer.MAX_VALUE ).toString() ) instanceof Integer );
assertTrue( "Large integers should be a Long!",
JSONObject.stringToValue( Long.valueOf(((long)Integer.MAX_VALUE) + 1 ) .toString() ) instanceof Long );
assertTrue( "Long.MAX_VALUE should still be an Integer!",
- JSONObject.stringToValue( new Long( Long.MAX_VALUE ).toString() ) instanceof Long );
+ JSONObject.stringToValue( Long.valueOf( Long.MAX_VALUE ).toString() ) instanceof Long );
- String str = new BigInteger( new Long( Long.MAX_VALUE ).toString() ).add( BigInteger.ONE ).toString();
+ String str = new BigInteger( Long.valueOf( Long.MAX_VALUE ).toString() ).add( BigInteger.ONE ).toString();
assertTrue( "Really large integers currently evaluate to BigInteger",
JSONObject.stringToValue(str).equals(new BigInteger("9223372036854775808")));
}
@@ -1026,48 +1119,58 @@ public void jsonValidNumberValuesNeitherLongNorIEEE754Compatible() {
*/
@Test
public void jsonInvalidNumberValues() {
- // Number-notations supported by Java and invalid as JSON
- String str =
- "{"+
- "\"hexNumber\":-0x123,"+
- "\"tooManyZeros\":00,"+
- "\"negativeInfinite\":-Infinity,"+
- "\"negativeNaN\":-NaN,"+
- "\"negativeFraction\":-.01,"+
- "\"tooManyZerosFraction\":00.001,"+
- "\"negativeHexFloat\":-0x1.fffp1,"+
- "\"hexFloat\":0x1.0P-1074,"+
- "\"floatIdentifier\":0.1f,"+
- "\"doubleIdentifier\":0.1d"+
- "}";
- JSONObject jsonObject = new JSONObject(str);
- Object obj;
- obj = jsonObject.get( "hexNumber" );
- assertFalse( "hexNumber must not be a number (should throw exception!?)",
- obj instanceof Number );
- assertTrue("hexNumber currently evaluates to string",
- obj.equals("-0x123"));
- assertTrue( "tooManyZeros currently evaluates to string",
- jsonObject.get( "tooManyZeros" ).equals("00"));
- obj = jsonObject.get("negativeInfinite");
- assertTrue( "negativeInfinite currently evaluates to string",
- obj.equals("-Infinity"));
- obj = jsonObject.get("negativeNaN");
- assertTrue( "negativeNaN currently evaluates to string",
- obj.equals("-NaN"));
- assertTrue( "negativeFraction currently evaluates to double -0.01",
- jsonObject.get( "negativeFraction" ).equals(BigDecimal.valueOf(-0.01)));
- assertTrue( "tooManyZerosFraction currently evaluates to double 0.001",
- jsonObject.get( "tooManyZerosFraction" ).equals(BigDecimal.valueOf(0.001)));
- assertTrue( "negativeHexFloat currently evaluates to double -3.99951171875",
- jsonObject.get( "negativeHexFloat" ).equals(Double.valueOf(-3.99951171875)));
- assertTrue("hexFloat currently evaluates to double 4.9E-324",
- jsonObject.get("hexFloat").equals(Double.valueOf(4.9E-324)));
- assertTrue("floatIdentifier currently evaluates to double 0.1",
- jsonObject.get("floatIdentifier").equals(Double.valueOf(0.1)));
- assertTrue("doubleIdentifier currently evaluates to double 0.1",
- jsonObject.get("doubleIdentifier").equals(Double.valueOf(0.1)));
- Util.checkJSONObjectMaps(jsonObject);
+ // Number-notations supported by Java and invalid as JSON
+ String str =
+ "{" +
+ "\"hexNumber\":-0x123," +
+ "\"tooManyZeros\":00," +
+ "\"negativeInfinite\":-Infinity," +
+ "\"negativeNaN\":-NaN," +
+ "\"negativeFraction\":-.01," +
+ "\"tooManyZerosFraction\":00.001," +
+ "\"negativeHexFloat\":-0x1.fffp1," +
+ "\"hexFloat\":0x1.0P-1074," +
+ "\"floatIdentifier\":0.1f," +
+ "\"doubleIdentifier\":0.1d" +
+ "}";
+
+ // Test should fail if default strictMode is true, pass if false
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration();
+ if (jsonParserConfiguration.isStrictMode()) {
+ try {
+ JSONObject jsonObject = new JSONObject(str);
+ assertEquals("Expected to throw exception due to invalid string", true, false);
+ } catch (JSONException e) { }
+ } else {
+ JSONObject jsonObject = new JSONObject(str);
+ Object obj;
+ obj = jsonObject.get("hexNumber");
+ assertFalse("hexNumber must not be a number (should throw exception!?)",
+ obj instanceof Number);
+ assertTrue("hexNumber currently evaluates to string",
+ obj.equals("-0x123"));
+ assertTrue("tooManyZeros currently evaluates to string",
+ jsonObject.get("tooManyZeros").equals("00"));
+ obj = jsonObject.get("negativeInfinite");
+ assertTrue("negativeInfinite currently evaluates to string",
+ obj.equals("-Infinity"));
+ obj = jsonObject.get("negativeNaN");
+ assertTrue("negativeNaN currently evaluates to string",
+ obj.equals("-NaN"));
+ assertTrue("negativeFraction currently evaluates to double -0.01",
+ jsonObject.get("negativeFraction").equals(BigDecimal.valueOf(-0.01)));
+ assertTrue("tooManyZerosFraction currently evaluates to double 0.001",
+ jsonObject.optLong("tooManyZerosFraction") == 0);
+ assertTrue("negativeHexFloat currently evaluates to double -3.99951171875",
+ jsonObject.get("negativeHexFloat").equals(Double.valueOf(-3.99951171875)));
+ assertTrue("hexFloat currently evaluates to double 4.9E-324",
+ jsonObject.get("hexFloat").equals(Double.valueOf(4.9E-324)));
+ assertTrue("floatIdentifier currently evaluates to double 0.1",
+ jsonObject.get("floatIdentifier").equals(Double.valueOf(0.1)));
+ assertTrue("doubleIdentifier currently evaluates to double 0.1",
+ jsonObject.get("doubleIdentifier").equals(Double.valueOf(0.1)));
+ Util.checkJSONObjectMaps(jsonObject);
+ }
}
/**
@@ -1232,8 +1335,8 @@ public void unexpectedDoubleToIntConversion() {
String key30 = "key30";
String key31 = "key31";
JSONObject jsonObject = new JSONObject();
- jsonObject.put(key30, new Double(3.0));
- jsonObject.put(key31, new Double(3.1));
+ jsonObject.put(key30, Double.valueOf(3.0));
+ jsonObject.put(key31, Double.valueOf(3.1));
assertTrue("3.0 should remain a double",
jsonObject.getDouble(key30) == 3);
@@ -1485,7 +1588,7 @@ public void jsonObjectNames() {
"{"+
"\"trueKey\":true,"+
"\"falseKey\":false,"+
- "\"stringKey\":\"hello world!\","+
+ "\"stringKey\":\"hello world!\""+
"}";
JSONObject jsonObject2 = new JSONObject(str);
names = JSONObject.getNames(jsonObject2);
@@ -1580,7 +1683,7 @@ public void jsonObjectNamesToJsonAray() {
"{"+
"\"trueKey\":true,"+
"\"falseKey\":false,"+
- "\"stringKey\":\"hello world!\","+
+ "\"stringKey\":\"hello world!\""+
"}";
JSONObject jsonObject = new JSONObject(str);
@@ -1686,19 +1789,19 @@ public void jsonObjectIncrement() {
*/
assertFalse("Document unexpected behaviour with explicit type-casting float as double!", (double)0.2f == 0.2d );
assertFalse("Document unexpected behaviour with implicit type-cast!", 0.2f == 0.2d );
- Double d1 = new Double( 1.1f );
- Double d2 = new Double( "1.1f" );
+ Double d1 = Double.valueOf( 1.1f );
+ Double d2 = Double.valueOf( "1.1f" );
assertFalse( "Document implicit type cast from float to double before calling Double(double d) constructor", d1.equals( d2 ) );
- assertTrue( "Correctly converting float to double via base10 (string) representation!", new Double( 3.1d ).equals( new Double( new Float( 3.1f ).toString() ) ) );
+ assertTrue( "Correctly converting float to double via base10 (string) representation!", Double.valueOf( 3.1d ).equals( Double.valueOf( Float.valueOf( 3.1f ).toString() ) ) );
// Pinpointing the not so obvious "buggy" conversion from float to double in JSONObject
JSONObject jo = new JSONObject();
jo.put( "bug", 3.1f ); // will call put( String key, double value ) with implicit and "buggy" type-cast from float to double
- assertFalse( "The java-compiler did add some zero bits for you to the mantissa (unexpected, but well documented)", jo.get( "bug" ).equals( new Double( 3.1d ) ) );
+ assertFalse( "The java-compiler did add some zero bits for you to the mantissa (unexpected, but well documented)", jo.get( "bug" ).equals( Double.valueOf( 3.1d ) ) );
JSONObject inc = new JSONObject();
- inc.put( "bug", new Float( 3.1f ) ); // This will put in instance of Float into JSONObject, i.e. call put( String key, Object value )
+ inc.put( "bug", Float.valueOf( 3.1f ) ); // This will put in instance of Float into JSONObject, i.e. call put( String key, Object value )
assertTrue( "Everything is ok here!", inc.get( "bug" ) instanceof Float );
inc.increment( "bug" ); // after adding 1, increment will call put( String key, double value ) with implicit and "buggy" type-cast from float to double!
// this.put(key, (Float) value + 1);
@@ -1942,7 +2045,7 @@ public void jsonObjectToStringIndent() {
@Test
public void jsonObjectToStringSuppressWarningOnCastToMap() {
JSONObject jsonObject = new JSONObject();
- Map map = new HashMap();
+ Map map = new HashMap<>();
map.put("abc", "def");
jsonObject.put("key", map);
@@ -2000,7 +2103,9 @@ public void valueToString() {
"}";
JSONObject jsonObject = new JSONObject(jsonObjectStr);
assertTrue("jsonObject valueToString() incorrect",
- JSONObject.valueToString(jsonObject).equals(jsonObject.toString()));
+ new JSONObject(JSONObject.valueToString(jsonObject))
+ .similar(new JSONObject(jsonObject.toString()))
+ );
String jsonArrayStr =
"[1,2,3]";
JSONArray jsonArray = new JSONArray(jsonArrayStr);
@@ -2011,16 +2116,17 @@ public void valueToString() {
map.put("key2", "val2");
map.put("key3", "val3");
assertTrue("map valueToString() incorrect",
- jsonObject.toString().equals(JSONObject.valueToString(map)));
+ new JSONObject(jsonObject.toString())
+ .similar(new JSONObject(JSONObject.valueToString(map))));
Collection collection = new ArrayList();
- collection.add(new Integer(1));
- collection.add(new Integer(2));
- collection.add(new Integer(3));
+ collection.add(Integer.valueOf(1));
+ collection.add(Integer.valueOf(2));
+ collection.add(Integer.valueOf(3));
assertTrue("collection valueToString() expected: "+
jsonArray.toString()+ " actual: "+
JSONObject.valueToString(collection),
jsonArray.toString().equals(JSONObject.valueToString(collection)));
- Integer[] array = { new Integer(1), new Integer(2), new Integer(3) };
+ Integer[] array = { Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(3) };
assertTrue("array valueToString() incorrect",
jsonArray.toString().equals(JSONObject.valueToString(array)));
Util.checkJSONObjectMaps(jsonObject);
@@ -2058,7 +2164,7 @@ public void wrapObject() {
JSONObject.NULL == JSONObject.wrap(null));
// wrap(Integer) returns Integer
- Integer in = new Integer(1);
+ Integer in = Integer.valueOf(1);
assertTrue("Integer wrap() incorrect",
in == JSONObject.wrap(in));
@@ -2085,9 +2191,9 @@ public void wrapObject() {
// wrap collection returns JSONArray
Collection collection = new ArrayList();
- collection.add(new Integer(1));
- collection.add(new Integer(2));
- collection.add(new Integer(3));
+ collection.add(Integer.valueOf(1));
+ collection.add(Integer.valueOf(2));
+ collection.add(Integer.valueOf(3));
JSONArray jsonArray = (JSONArray) (JSONObject.wrap(collection));
// validate JSON
@@ -2098,7 +2204,7 @@ public void wrapObject() {
assertTrue("expected 3", Integer.valueOf(3).equals(jsonArray.query("/2")));
// wrap Array returns JSONArray
- Integer[] array = { new Integer(1), new Integer(2), new Integer(3) };
+ Integer[] array = { Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(3) };
JSONArray integerArrayJsonArray = (JSONArray)(JSONObject.wrap(array));
// validate JSON
@@ -2156,122 +2262,279 @@ public void jsonObjectParseControlCharacters(){
}
}
- /**
- * Explore how JSONObject handles parsing errors.
- */
- @SuppressWarnings({"boxing", "unused"})
@Test
- public void jsonObjectParsingErrors() {
+ public void jsonObjectParseControlCharacterEOFAssertExceptionMessage(){
+ char c = '\0';
+ final String source = "{\"key\":\"" + c + "\"}";
try {
- // does not start with '{'
- String str = "abc";
- assertNull("Expected an exception",new JSONObject(str));
- } catch (JSONException e) {
- assertEquals("Expecting an exception message",
- "A JSONObject text must begin with '{' at 1 [character 2 line 1]",
- e.getMessage());
+ JSONObject jo = new JSONObject(source);
+ fail("JSONException should be thrown");
+ } catch (JSONException ex) {
+ assertEquals("Unterminated string. " + "Character with int code 0" +
+ " is not allowed within a quoted string. at 8 [character 9 line 1]", ex.getMessage());
+ }
+ }
+
+ @Test
+ public void jsonObjectParseControlCharacterNewLineAssertExceptionMessage(){
+ char[] chars = {'\n', '\r'};
+ for( char c : chars) {
+ final String source = "{\"key\":\"" + c + "\"}";
+ try {
+ JSONObject jo = new JSONObject(source);
+ fail("JSONException should be thrown");
+ } catch (JSONException ex) {
+ assertEquals("Unterminated string. " + "Character with int code " + (int) c +
+ " is not allowed within a quoted string. at 9 [character 0 line 2]", ex.getMessage());
+ }
+ }
+ }
+
+ @Test
+ public void jsonObjectParseUTF8EncodingAssertExceptionMessage(){
+ String c = "\\u123x";
+ final String source = "{\"key\":\"" + c + "\"}";
+ try {
+ JSONObject jo = new JSONObject(source);
+ fail("JSONException should be thrown");
+ } catch (JSONException ex) {
+ assertEquals("Illegal escape. \\u must be followed by a 4 digit hexadecimal number. " +
+ "\\123x is not valid. at 14 [character 15 line 1]", ex.getMessage());
}
+ }
+
+ @Test
+ public void jsonObjectParseIllegalEscapeAssertExceptionMessage(){
+ String c = "\\x";
+ final String source = "{\"key\":\"" + c + "\"}";
+ try {
+ JSONObject jo = new JSONObject(source);
+ fail("JSONException should be thrown");
+ } catch (JSONException ex) {
+ assertEquals("Illegal escape. Escape sequence " + c + " is not valid." +
+ " at 10 [character 11 line 1]", ex.getMessage());
+ }
+ }
+
+ @Test
+ public void parsingErrorTrailingCurlyBrace () {
try {
// does not end with '}'
String str = "{";
- assertNull("Expected an exception",new JSONObject(str));
- } catch (JSONException e) {
- assertEquals("Expecting an exception message",
+ assertNull("Expected an exception", new JSONObject(str));
+ } catch (JSONException e) {
+ assertEquals("Expecting an exception message",
"A JSONObject text must end with '}' at 1 [character 2 line 1]",
e.getMessage());
}
+ }
+
+ @Test
+ public void parsingErrorInitialCurlyBrace() {
+ try {
+ // does not start with '{'
+ String str = "abc";
+ assertNull("Expected an exception", new JSONObject(str));
+ } catch (JSONException e) {
+ assertEquals("Expecting an exception message",
+ "A JSONObject text must begin with '{' at 1 [character 2 line 1]",
+ e.getMessage());
+ }
+ }
+
+ @Test
+ public void parsingErrorNoColon() {
try {
// key with no ':'
String str = "{\"myKey\" = true}";
- assertNull("Expected an exception",new JSONObject(str));
- } catch (JSONException e) {
- assertEquals("Expecting an exception message",
+ assertNull("Expected an exception", new JSONObject(str));
+ } catch (JSONException e) {
+ assertEquals("Expecting an exception message",
"Expected a ':' after a key at 10 [character 11 line 1]",
e.getMessage());
}
+ }
+
+ @Test
+ public void parsingErrorNoCommaSeparator() {
try {
// entries with no ',' separator
String str = "{\"myKey\":true \"myOtherKey\":false}";
- assertNull("Expected an exception",new JSONObject(str));
- } catch (JSONException e) {
- assertEquals("Expecting an exception message",
+ assertNull("Expected an exception", new JSONObject(str));
+ } catch (JSONException e) {
+ assertEquals("Expecting an exception message",
"Expected a ',' or '}' at 15 [character 16 line 1]",
e.getMessage());
}
+ }
+
+ @Test
+ public void parsingErrorKeyIsNestedMap() {
+ try {
+ // key is a nested map
+ String str = "{{\"foo\": \"bar\"}: \"baz\"}";
+ assertNull("Expected an exception", new JSONObject(str));
+ } catch (JSONException e) {
+ assertEquals("Expecting an exception message",
+ "Missing value at 1 [character 2 line 1]",
+ e.getMessage());
+ }
+ }
+
+ @Test
+ public void parsingErrorKeyIsNestedArrayWithMap() {
try {
- // append to wrong key
+ // key is a nested array containing a map
+ String str = "{\"a\": 1, [{\"foo\": \"bar\"}]: \"baz\"}";
+ assertNull("Expected an exception", new JSONObject(str));
+ } catch (JSONException e) {
+ assertEquals("Expecting an exception message",
+ "Missing value at 9 [character 10 line 1]",
+ e.getMessage());
+ }
+ }
+
+ @Test
+ public void parsingErrorKeyContainsCurlyBrace() {
+ try {
+ // key contains }
+ String str = "{foo}: 2}";
+ assertNull("Expected an exception", new JSONObject(str));
+ } catch (JSONException e) {
+// assertEquals("Expecting an exception message",
+// "Expected a ':' after a key at 5 [character 6 line 1]",
+// e.getMessage());
+ }
+ }
+
+ @Test
+ public void parsingErrorKeyContainsSquareBrace() {
+ try {
+ // key contains ]
+ String str = "{foo]: 2}";
+ assertNull("Expected an exception", new JSONObject(str));
+ } catch (JSONException e) {
+// assertEquals("Expecting an exception message",
+// "Expected a ':' after a key at 5 [character 6 line 1]",
+// e.getMessage());
+ }
+ }
+
+ @Test
+ public void parsingErrorKeyContainsBinaryZero() {
+ try {
+ // \0 after ,
+ String str = "{\"myKey\":true, \0\"myOtherKey\":false}";
+ assertNull("Expected an exception", new JSONObject(str));
+ } catch (JSONException e) {
+ assertEquals("Expecting an exception message",
+ "A JSONObject text must end with '}' at 15 [character 16 line 1]",
+ e.getMessage());
+ }
+ }
+
+ @Test
+ public void parsingErrorAppendToWrongValue() {
+ try {
+ // append to wrong value
String str = "{\"myKey\":true, \"myOtherKey\":false}";
JSONObject jsonObject = new JSONObject(str);
jsonObject.append("myKey", "hello");
fail("Expected an exception");
- } catch (JSONException e) {
+ } catch (JSONException e) {
assertEquals("Expecting an exception message",
"JSONObject[\"myKey\"] is not a JSONArray (null).",
e.getMessage());
}
+ }
+
+ @Test
+ public void parsingErrorIncrementWrongValue() {
try {
- // increment wrong key
+ // increment wrong value
String str = "{\"myKey\":true, \"myOtherKey\":false}";
JSONObject jsonObject = new JSONObject(str);
jsonObject.increment("myKey");
fail("Expected an exception");
- } catch (JSONException e) {
+ } catch (JSONException e) {
assertEquals("Expecting an exception message",
"Unable to increment [\"myKey\"].",
e.getMessage());
}
+ }
+ @Test
+ public void parsingErrorInvalidKey() {
try {
// invalid key
String str = "{\"myKey\":true, \"myOtherKey\":false}";
JSONObject jsonObject = new JSONObject(str);
jsonObject.get(null);
fail("Expected an exception");
- } catch (JSONException e) {
+ } catch (JSONException e) {
assertEquals("Expecting an exception message",
"Null key.",
e.getMessage());
}
+ }
+
+ @Test
+ public void parsingErrorNumberToString() {
try {
// invalid numberToString()
- JSONObject.numberToString((Number)null);
+ JSONObject.numberToString((Number) null);
fail("Expected an exception");
- } catch (JSONException e) {
- assertEquals("Expecting an exception message",
+ } catch (JSONException e) {
+ assertEquals("Expecting an exception message",
"Null pointer",
e.getMessage());
}
+ }
+ @Test
+ public void parsingErrorPutOnceDuplicateKey() {
try {
- // multiple putOnce key
+ // multiple putOnce key
JSONObject jsonObject = new JSONObject("{}");
jsonObject.putOnce("hello", "world");
jsonObject.putOnce("hello", "world!");
fail("Expected an exception");
- } catch (JSONException e) {
+ } catch (JSONException e) {
assertTrue("", true);
}
+ }
+
+ @Test
+ public void parsingErrorInvalidDouble() {
try {
- // test validity of invalid double
+ // test validity of invalid double
JSONObject.testValidity(Double.NaN);
fail("Expected an exception");
- } catch (JSONException e) {
+ } catch (JSONException e) {
assertTrue("", true);
}
+ }
+
+ @Test
+ public void parsingErrorInvalidFloat() {
try {
- // test validity of invalid float
+ // test validity of invalid float
JSONObject.testValidity(Float.NEGATIVE_INFINITY);
fail("Expected an exception");
- } catch (JSONException e) {
+ } catch (JSONException e) {
assertTrue("", true);
}
+ }
+
+ @Test
+ public void parsingErrorDuplicateKeyException() {
try {
// test exception message when including a duplicate key (level 0)
String str = "{\n"
- +" \"attr01\":\"value-01\",\n"
- +" \"attr02\":\"value-02\",\n"
- +" \"attr03\":\"value-03\",\n"
- +" \"attr03\":\"value-04\"\n"
- + "}";
+ + " \"attr01\":\"value-01\",\n"
+ + " \"attr02\":\"value-02\",\n"
+ + " \"attr03\":\"value-03\",\n"
+ + " \"attr03\":\"value-04\"\n"
+ + "}";
new JSONObject(str);
fail("Expected an exception");
} catch (JSONException e) {
@@ -2279,18 +2542,22 @@ public void jsonObjectParsingErrors() {
"Duplicate key \"attr03\" at 90 [character 13 line 5]",
e.getMessage());
}
+ }
+
+ @Test
+ public void parsingErrorNestedDuplicateKeyException() {
try {
// test exception message when including a duplicate key (level 0) holding an object
String str = "{\n"
- +" \"attr01\":\"value-01\",\n"
- +" \"attr02\":\"value-02\",\n"
- +" \"attr03\":\"value-03\",\n"
- +" \"attr03\": {"
- +" \"attr04-01\":\"value-04-01\",n"
- +" \"attr04-02\":\"value-04-02\",n"
- +" \"attr04-03\":\"value-04-03\"n"
- + " }\n"
- + "}";
+ + " \"attr01\":\"value-01\",\n"
+ + " \"attr02\":\"value-02\",\n"
+ + " \"attr03\":\"value-03\",\n"
+ + " \"attr03\": {"
+ + " \"attr04-01\":\"value-04-01\",n"
+ + " \"attr04-02\":\"value-04-02\",n"
+ + " \"attr04-03\":\"value-04-03\"n"
+ + " }\n"
+ + "}";
new JSONObject(str);
fail("Expected an exception");
} catch (JSONException e) {
@@ -2298,20 +2565,24 @@ public void jsonObjectParsingErrors() {
"Duplicate key \"attr03\" at 90 [character 13 line 5]",
e.getMessage());
}
+ }
+
+ @Test
+ public void parsingErrorNestedDuplicateKeyWithArrayException() {
try {
// test exception message when including a duplicate key (level 0) holding an array
String str = "{\n"
- +" \"attr01\":\"value-01\",\n"
- +" \"attr02\":\"value-02\",\n"
- +" \"attr03\":\"value-03\",\n"
- +" \"attr03\": [\n"
- +" {"
- +" \"attr04-01\":\"value-04-01\",n"
- +" \"attr04-02\":\"value-04-02\",n"
- +" \"attr04-03\":\"value-04-03\"n"
- +" }\n"
- + " ]\n"
- + "}";
+ + " \"attr01\":\"value-01\",\n"
+ + " \"attr02\":\"value-02\",\n"
+ + " \"attr03\":\"value-03\",\n"
+ + " \"attr03\": [\n"
+ + " {"
+ + " \"attr04-01\":\"value-04-01\",n"
+ + " \"attr04-02\":\"value-04-02\",n"
+ + " \"attr04-03\":\"value-04-03\"n"
+ + " }\n"
+ + " ]\n"
+ + "}";
new JSONObject(str);
fail("Expected an exception");
} catch (JSONException e) {
@@ -2319,19 +2590,23 @@ public void jsonObjectParsingErrors() {
"Duplicate key \"attr03\" at 90 [character 13 line 5]",
e.getMessage());
}
+ }
+
+ @Test
+ public void parsingErrorDuplicateKeyWithinNestedDictExceptionMessage() {
try {
// test exception message when including a duplicate key (level 1)
String str = "{\n"
- +" \"attr01\":\"value-01\",\n"
- +" \"attr02\":\"value-02\",\n"
- +" \"attr03\":\"value-03\",\n"
- +" \"attr04\": {\n"
- +" \"attr04-01\":\"value04-01\",\n"
- +" \"attr04-02\":\"value04-02\",\n"
- +" \"attr04-03\":\"value04-03\",\n"
- +" \"attr04-03\":\"value04-04\"\n"
- + " }\n"
- + "}";
+ + " \"attr01\":\"value-01\",\n"
+ + " \"attr02\":\"value-02\",\n"
+ + " \"attr03\":\"value-03\",\n"
+ + " \"attr04\": {\n"
+ + " \"attr04-01\":\"value04-01\",\n"
+ + " \"attr04-02\":\"value04-02\",\n"
+ + " \"attr04-03\":\"value04-03\",\n"
+ + " \"attr04-03\":\"value04-04\"\n"
+ + " }\n"
+ + "}";
new JSONObject(str);
fail("Expected an exception");
} catch (JSONException e) {
@@ -2339,23 +2614,28 @@ public void jsonObjectParsingErrors() {
"Duplicate key \"attr04-03\" at 215 [character 20 line 9]",
e.getMessage());
}
+ }
+
+ @Test
+ public void parsingErrorDuplicateKeyDoubleNestedDictExceptionMessage() {
try {
- // test exception message when including a duplicate key (level 1) holding an object
+ // test exception message when including a duplicate key (level 1) holding an
+ // object
String str = "{\n"
- +" \"attr01\":\"value-01\",\n"
- +" \"attr02\":\"value-02\",\n"
- +" \"attr03\":\"value-03\",\n"
- +" \"attr04\": {\n"
- +" \"attr04-01\":\"value04-01\",\n"
- +" \"attr04-02\":\"value04-02\",\n"
- +" \"attr04-03\":\"value04-03\",\n"
- +" \"attr04-03\": {\n"
- +" \"attr04-04-01\":\"value04-04-01\",\n"
- +" \"attr04-04-02\":\"value04-04-02\",\n"
- +" \"attr04-04-03\":\"value04-04-03\",\n"
- +" }\n"
- +" }\n"
- + "}";
+ + " \"attr01\":\"value-01\",\n"
+ + " \"attr02\":\"value-02\",\n"
+ + " \"attr03\":\"value-03\",\n"
+ + " \"attr04\": {\n"
+ + " \"attr04-01\":\"value04-01\",\n"
+ + " \"attr04-02\":\"value04-02\",\n"
+ + " \"attr04-03\":\"value04-03\",\n"
+ + " \"attr04-03\": {\n"
+ + " \"attr04-04-01\":\"value04-04-01\",\n"
+ + " \"attr04-04-02\":\"value04-04-02\",\n"
+ + " \"attr04-04-03\":\"value04-04-03\",\n"
+ + " }\n"
+ + " }\n"
+ + "}";
new JSONObject(str);
fail("Expected an exception");
} catch (JSONException e) {
@@ -2363,25 +2643,30 @@ public void jsonObjectParsingErrors() {
"Duplicate key \"attr04-03\" at 215 [character 20 line 9]",
e.getMessage());
}
+ }
+
+ @Test
+ public void parsingErrorDuplicateKeyNestedWithArrayExceptionMessage() {
try {
- // test exception message when including a duplicate key (level 1) holding an array
+ // test exception message when including a duplicate key (level 1) holding an
+ // array
String str = "{\n"
- +" \"attr01\":\"value-01\",\n"
- +" \"attr02\":\"value-02\",\n"
- +" \"attr03\":\"value-03\",\n"
- +" \"attr04\": {\n"
- +" \"attr04-01\":\"value04-01\",\n"
- +" \"attr04-02\":\"value04-02\",\n"
- +" \"attr04-03\":\"value04-03\",\n"
- +" \"attr04-03\": [\n"
- +" {\n"
- +" \"attr04-04-01\":\"value04-04-01\",\n"
- +" \"attr04-04-02\":\"value04-04-02\",\n"
- +" \"attr04-04-03\":\"value04-04-03\",\n"
- +" }\n"
- +" ]\n"
- +" }\n"
- + "}";
+ + " \"attr01\":\"value-01\",\n"
+ + " \"attr02\":\"value-02\",\n"
+ + " \"attr03\":\"value-03\",\n"
+ + " \"attr04\": {\n"
+ + " \"attr04-01\":\"value04-01\",\n"
+ + " \"attr04-02\":\"value04-02\",\n"
+ + " \"attr04-03\":\"value04-03\",\n"
+ + " \"attr04-03\": [\n"
+ + " {\n"
+ + " \"attr04-04-01\":\"value04-04-01\",\n"
+ + " \"attr04-04-02\":\"value04-04-02\",\n"
+ + " \"attr04-04-03\":\"value04-04-03\",\n"
+ + " }\n"
+ + " ]\n"
+ + " }\n"
+ + "}";
new JSONObject(str);
fail("Expected an exception");
} catch (JSONException e) {
@@ -2389,18 +2674,23 @@ public void jsonObjectParsingErrors() {
"Duplicate key \"attr04-03\" at 215 [character 20 line 9]",
e.getMessage());
}
+ }
+
+ @Test
+ public void parsingErrorDuplicateKeyWithinArrayExceptionMessage() {
try {
- // test exception message when including a duplicate key in object (level 0) within an array
+ // test exception message when including a duplicate key in object (level 0)
+ // within an array
String str = "[\n"
- +" {\n"
- +" \"attr01\":\"value-01\",\n"
- +" \"attr02\":\"value-02\"\n"
- +" },\n"
- +" {\n"
- +" \"attr01\":\"value-01\",\n"
- +" \"attr01\":\"value-02\"\n"
- +" }\n"
- + "]";
+ + " {\n"
+ + " \"attr01\":\"value-01\",\n"
+ + " \"attr02\":\"value-02\"\n"
+ + " },\n"
+ + " {\n"
+ + " \"attr01\":\"value-01\",\n"
+ + " \"attr01\":\"value-02\"\n"
+ + " }\n"
+ + "]";
new JSONArray(str);
fail("Expected an exception");
} catch (JSONException e) {
@@ -2408,24 +2698,29 @@ public void jsonObjectParsingErrors() {
"Duplicate key \"attr01\" at 124 [character 17 line 8]",
e.getMessage());
}
+ }
+
+ @Test
+ public void parsingErrorDuplicateKeyDoubleNestedWithinArrayExceptionMessage() {
try {
- // test exception message when including a duplicate key in object (level 1) within an array
+ // test exception message when including a duplicate key in object (level 1)
+ // within an array
String str = "[\n"
- +" {\n"
- +" \"attr01\":\"value-01\",\n"
- +" \"attr02\": {\n"
- +" \"attr02-01\":\"value-02-01\",\n"
- +" \"attr02-02\":\"value-02-02\"\n"
- +" }\n"
- +" },\n"
- +" {\n"
- +" \"attr01\":\"value-01\",\n"
- +" \"attr02\": {\n"
- +" \"attr02-01\":\"value-02-01\",\n"
- +" \"attr02-01\":\"value-02-02\"\n"
- +" }\n"
- +" }\n"
- + "]";
+ + " {\n"
+ + " \"attr01\":\"value-01\",\n"
+ + " \"attr02\": {\n"
+ + " \"attr02-01\":\"value-02-01\",\n"
+ + " \"attr02-02\":\"value-02-02\"\n"
+ + " }\n"
+ + " },\n"
+ + " {\n"
+ + " \"attr01\":\"value-01\",\n"
+ + " \"attr02\": {\n"
+ + " \"attr02-01\":\"value-02-01\",\n"
+ + " \"attr02-01\":\"value-02-02\"\n"
+ + " }\n"
+ + " }\n"
+ + "]";
new JSONArray(str);
fail("Expected an exception");
} catch (JSONException e) {
@@ -2465,20 +2760,32 @@ public void jsonObjectOptDefault() {
BigInteger.TEN.compareTo(jsonObject.optBigInteger("myKey",BigInteger.TEN ))==0);
assertTrue("optBoolean() should return default boolean",
jsonObject.optBoolean("myKey", true));
+ assertTrue("optBooleanObject() should return default Boolean",
+ jsonObject.optBooleanObject("myKey", true));
assertTrue("optInt() should return default int",
42 == jsonObject.optInt("myKey", 42));
+ assertTrue("optIntegerObject() should return default Integer",
+ Integer.valueOf(42).equals(jsonObject.optIntegerObject("myKey", 42)));
assertTrue("optEnum() should return default Enum",
MyEnum.VAL1.equals(jsonObject.optEnum(MyEnum.class, "myKey", MyEnum.VAL1)));
assertTrue("optJSONArray() should return null ",
null==jsonObject.optJSONArray("myKey"));
+ assertTrue("optJSONArray() should return default JSONArray",
+ "value".equals(jsonObject.optJSONArray("myKey", new JSONArray("[\"value\"]")).getString(0)));
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("optLongObject() should return default Long",
+ Long.valueOf(42l).equals(jsonObject.optLongObject("myKey", 42l)));
assertTrue("optDouble() should return default double",
42.3d == jsonObject.optDouble("myKey", 42.3d));
+ assertTrue("optDoubleObject() should return default Double",
+ Double.valueOf(42.3d).equals(jsonObject.optDoubleObject("myKey", 42.3d)));
assertTrue("optFloat() should return default float",
42.3f == jsonObject.optFloat("myKey", 42.3f));
+ assertTrue("optFloatObject() should return default Float",
+ Float.valueOf(42.3f).equals(jsonObject.optFloatObject("myKey", 42.3f)));
assertTrue("optNumber() should return default Number",
42l == jsonObject.optNumber("myKey", Long.valueOf(42)).longValue());
assertTrue("optString() should return default string",
@@ -2502,20 +2809,32 @@ public void jsonObjectOptNoKey() {
BigInteger.TEN.compareTo(jsonObject.optBigInteger("myKey",BigInteger.TEN ))==0);
assertTrue("optBoolean() should return default boolean",
jsonObject.optBoolean("myKey", true));
+ assertTrue("optBooleanObject() should return default Boolean",
+ jsonObject.optBooleanObject("myKey", true));
assertTrue("optInt() should return default int",
42 == jsonObject.optInt("myKey", 42));
+ assertTrue("optIntegerObject() should return default Integer",
+ Integer.valueOf(42).equals(jsonObject.optIntegerObject("myKey", 42)));
assertTrue("optEnum() should return default Enum",
MyEnum.VAL1.equals(jsonObject.optEnum(MyEnum.class, "myKey", MyEnum.VAL1)));
+ assertTrue("optJSONArray() should return default JSONArray",
+ "value".equals(jsonObject.optJSONArray("myKey", new JSONArray("[\"value\"]")).getString(0)));
assertTrue("optJSONArray() should return null ",
null==jsonObject.optJSONArray("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("optLongObject() should return default Long",
+ Long.valueOf(42l).equals(jsonObject.optLongObject("myKey", 42l)));
assertTrue("optDouble() should return default double",
42.3d == jsonObject.optDouble("myKey", 42.3d));
+ assertTrue("optDoubleObject() should return default Double",
+ Double.valueOf(42.3d).equals(jsonObject.optDoubleObject("myKey", 42.3d)));
assertTrue("optFloat() should return default float",
42.3f == jsonObject.optFloat("myKey", 42.3f));
+ assertTrue("optFloatObject() should return default Float",
+ Float.valueOf(42.3f).equals(jsonObject.optFloatObject("myKey", 42.3f)));
assertTrue("optNumber() should return default Number",
42l == jsonObject.optNumber("myKey", Long.valueOf(42)).longValue());
assertTrue("optString() should return default string",
@@ -2530,11 +2849,17 @@ public void jsonObjectOptNoKey() {
public void jsonObjectOptStringConversion() {
JSONObject jo = new JSONObject("{\"int\":\"123\",\"true\":\"true\",\"false\":\"false\"}");
assertTrue("unexpected optBoolean value",jo.optBoolean("true",false)==true);
+ assertTrue("unexpected optBooleanObject value",Boolean.valueOf(true).equals(jo.optBooleanObject("true",false)));
assertTrue("unexpected optBoolean value",jo.optBoolean("false",true)==false);
+ assertTrue("unexpected optBooleanObject value",Boolean.valueOf(false).equals(jo.optBooleanObject("false",true)));
assertTrue("unexpected optInt value",jo.optInt("int",0)==123);
+ assertTrue("unexpected optIntegerObject value",Integer.valueOf(123).equals(jo.optIntegerObject("int",0)));
assertTrue("unexpected optLong value",jo.optLong("int",0)==123l);
+ assertTrue("unexpected optLongObject value",Long.valueOf(123l).equals(jo.optLongObject("int",0L)));
assertTrue("unexpected optDouble value",jo.optDouble("int",0.0d)==123.0d);
+ assertTrue("unexpected optDoubleObject value",Double.valueOf(123.0d).equals(jo.optDoubleObject("int",0.0d)));
assertTrue("unexpected optFloat value",jo.optFloat("int",0.0f)==123.0f);
+ assertTrue("unexpected optFloatObject value",Float.valueOf(123.0f).equals(jo.optFloatObject("int",0.0f)));
assertTrue("unexpected optBigInteger value",jo.optBigInteger("int",BigInteger.ZERO).compareTo(new BigInteger("123"))==0);
assertTrue("unexpected optBigDecimal value",jo.optBigDecimal("int",BigDecimal.ZERO).compareTo(new BigDecimal("123"))==0);
assertTrue("unexpected optBigDecimal value",jo.optBigDecimal("int",BigDecimal.ZERO).compareTo(new BigDecimal("123"))==0);
@@ -2555,23 +2880,35 @@ public void jsonObjectOptCoercion() {
assertEquals(new BigDecimal("19007199254740993.35481234487103587486413587843213584"), jo.optBigDecimal("largeNumber",null));
assertEquals(new BigInteger("19007199254740993"), jo.optBigInteger("largeNumber",null));
assertEquals(1.9007199254740992E16, jo.optDouble("largeNumber"),0.0);
+ assertEquals(1.9007199254740992E16, jo.optDoubleObject("largeNumber"),0.0);
assertEquals(1.90071995E16f, jo.optFloat("largeNumber"),0.0f);
+ assertEquals(1.90071995E16f, jo.optFloatObject("largeNumber"),0.0f);
assertEquals(19007199254740993l, jo.optLong("largeNumber"));
+ assertEquals(Long.valueOf(19007199254740993l), jo.optLongObject("largeNumber"));
assertEquals(1874919425, jo.optInt("largeNumber"));
+ assertEquals(Integer.valueOf(1874919425), jo.optIntegerObject("largeNumber"));
// conversion from a string
assertEquals(new BigDecimal("19007199254740993.35481234487103587486413587843213584"), jo.optBigDecimal("largeNumberStr",null));
assertEquals(new BigInteger("19007199254740993"), jo.optBigInteger("largeNumberStr",null));
assertEquals(1.9007199254740992E16, jo.optDouble("largeNumberStr"),0.0);
+ assertEquals(1.9007199254740992E16, jo.optDoubleObject("largeNumberStr"),0.0);
assertEquals(1.90071995E16f, jo.optFloat("largeNumberStr"),0.0f);
+ assertEquals(1.90071995E16f, jo.optFloatObject("largeNumberStr"),0.0f);
assertEquals(19007199254740993l, jo.optLong("largeNumberStr"));
+ assertEquals(Long.valueOf(19007199254740993l), jo.optLongObject("largeNumberStr"));
assertEquals(1874919425, jo.optInt("largeNumberStr"));
+ assertEquals(Integer.valueOf(1874919425), jo.optIntegerObject("largeNumberStr"));
// the integer portion of the actual value is larger than a double can hold.
assertNotEquals((long)Double.parseDouble("19007199254740993.35481234487103587486413587843213584"), jo.optLong("largeNumber"));
+ assertNotEquals(Long.valueOf((long)Double.parseDouble("19007199254740993.35481234487103587486413587843213584")), jo.optLongObject("largeNumber"));
assertNotEquals((int)Double.parseDouble("19007199254740993.35481234487103587486413587843213584"), jo.optInt("largeNumber"));
+ assertNotEquals(Integer.valueOf((int)Double.parseDouble("19007199254740993.35481234487103587486413587843213584")), jo.optIntegerObject("largeNumber"));
assertNotEquals((long)Double.parseDouble("19007199254740993.35481234487103587486413587843213584"), jo.optLong("largeNumberStr"));
+ assertNotEquals(Long.valueOf((long)Double.parseDouble("19007199254740993.35481234487103587486413587843213584")), jo.optLongObject("largeNumberStr"));
assertNotEquals((int)Double.parseDouble("19007199254740993.35481234487103587486413587843213584"), jo.optInt("largeNumberStr"));
+ assertNotEquals(Integer.valueOf((int)Double.parseDouble("19007199254740993.35481234487103587486413587843213584")), jo.optIntegerObject("largeNumberStr"));
assertEquals(19007199254740992l, (long)Double.parseDouble("19007199254740993.35481234487103587486413587843213584"));
assertEquals(2147483647, (int)Double.parseDouble("19007199254740993.35481234487103587486413587843213584"));
Util.checkJSONObjectMaps(jo);
@@ -3166,7 +3503,7 @@ public void testSingletonEnumBean() {
@SuppressWarnings("boxing")
@Test
public void testGenericBean() {
- GenericBean bean = new GenericBean(42);
+ GenericBean bean = new GenericBean<>(42);
final JSONObject jo = new JSONObject(bean);
assertEquals(jo.keySet().toString(), 8, jo.length());
assertEquals(42, jo.get("genericValue"));
@@ -3215,6 +3552,7 @@ public void testWierdListBean() {
* Sample test case from https://github.com/stleary/JSON-java/issues/531
* which verifies that no regression in double/BigDecimal support is present.
*/
+ @Test
public void testObjectToBigDecimal() {
double value = 1412078745.01074;
Reader reader = new StringReader("[{\"value\": " + value + "}]");
@@ -3479,6 +3817,7 @@ public void issue654IncorrectNestingNoKey2() {
/**
* Tests for stack overflow. See https://github.com/stleary/JSON-java/issues/654
*/
+ @Ignore("This test relies on system constraints and may not always pass. See: https://github.com/stleary/JSON-java/issues/821")
@Test(expected = JSONException.class)
public void issue654StackOverflowInputWellFormed() {
//String input = new String(java.util.Base64.getDecoder().decode(base64Bytes));
@@ -3486,7 +3825,7 @@ public void issue654StackOverflowInputWellFormed() {
JSONTokener tokener = new JSONTokener(resourceAsStream);
JSONObject json_input = new JSONObject(tokener);
assertNotNull(json_input);
- fail("Excepected Exception.");
+ fail("Excepected Exception due to stack overflow.");
}
@Test
@@ -3509,4 +3848,168 @@ public String toJSONString() {
.put("b", 2);
assertFalse(jo1.similar(jo3));
}
+
+ private static final Number[] NON_FINITE_NUMBERS = { Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, Double.NaN,
+ Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, Float.NaN };
+
+ @Test
+ public void issue713MapConstructorWithNonFiniteNumbers() {
+ for (Number nonFinite : NON_FINITE_NUMBERS) {
+ Map map = new HashMap<>();
+ map.put("a", nonFinite);
+
+ assertThrows(JSONException.class, () -> new JSONObject(map));
+ }
+ }
+
+ @Test
+ public void issue713BeanConstructorWithNonFiniteNumbers() {
+ for (Number nonFinite : NON_FINITE_NUMBERS) {
+ GenericBean bean = new GenericBean<>(nonFinite);
+ assertThrows(JSONException.class, () -> new JSONObject(bean));
+ }
+ }
+
+ @Test(expected = JSONException.class)
+ public void issue743SerializationMap() {
+ HashMap map = new HashMap<>();
+ map.put("t", map);
+ JSONObject object = new JSONObject(map);
+ String jsonString = object.toString();
+ }
+
+ @Test(expected = JSONException.class)
+ public void testCircularReferenceMultipleLevel() {
+ HashMap inside = new HashMap<>();
+ HashMap jsonObject = new HashMap<>();
+ inside.put("inside", jsonObject);
+ jsonObject.put("test", inside);
+ new JSONObject(jsonObject);
+ }
+
+ @Test
+ public void issue743SerializationMapWith512Objects() {
+ HashMap map = buildNestedMap(ParserConfiguration.DEFAULT_MAXIMUM_NESTING_DEPTH);
+ JSONObject object = new JSONObject(map);
+ String jsonString = object.toString();
+ }
+
+ @Test
+ public void issue743SerializationMapWith1000Objects() {
+ HashMap map = buildNestedMap(1000);
+ JSONParserConfiguration parserConfiguration = new JSONParserConfiguration().withMaxNestingDepth(1000);
+ JSONObject object = new JSONObject(map, parserConfiguration);
+ String jsonString = object.toString();
+ }
+
+ @Test(expected = JSONException.class)
+ public void issue743SerializationMapWith1001Objects() {
+ HashMap map = buildNestedMap(1001);
+ JSONObject object = new JSONObject(map);
+ String jsonString = object.toString();
+ }
+
+ @Test(expected = JSONException.class)
+ public void testCircleReferenceFirstLevel() {
+ Map jsonObject = new HashMap<>();
+
+ jsonObject.put("test", jsonObject);
+
+ new JSONObject(jsonObject, new JSONParserConfiguration());
+ }
+
+ @Test(expected = StackOverflowError.class)
+ public void testCircleReferenceMultiplyLevel_notConfigured_expectedStackOverflow() {
+ Map inside = new HashMap<>();
+
+ Map jsonObject = new HashMap<>();
+ inside.put("test", jsonObject);
+ jsonObject.put("test", inside);
+
+ new JSONObject(jsonObject, new JSONParserConfiguration().withMaxNestingDepth(99999));
+ }
+
+ @Test(expected = JSONException.class)
+ public void testCircleReferenceMultiplyLevel_configured_expectedJSONException() {
+ Map inside = new HashMap<>();
+
+ Map jsonObject = new HashMap<>();
+ inside.put("test", jsonObject);
+ jsonObject.put("test", inside);
+
+ new JSONObject(jsonObject, new JSONParserConfiguration());
+ }
+
+ @Test
+ public void testDifferentKeySameInstanceNotACircleReference() {
+ Map map1 = new HashMap<>();
+ Map map2 = new HashMap<>();
+
+ map1.put("test1", map2);
+ map1.put("test2", map2);
+
+ new JSONObject(map1);
+ }
+
+ @Test
+ public void clarifyCurrentBehavior() {
+ // Behavior documented in #653 optLong vs getLong inconsistencies
+ // This problem still exists.
+ // Internally, both number_1 and number_2 are stored as strings. This is reasonable since they are parsed as strings.
+ // However, getLong and optLong should return similar results
+ JSONObject json = new JSONObject("{\"number_1\":\"01234\", \"number_2\": \"332211\"}");
+ assertEquals(json.getLong("number_1"), 1234L);
+ assertEquals(json.optLong("number_1"), 0); //THIS VALUE IS NOT RETURNED AS A NUMBER
+ assertEquals(json.getLong("number_2"), 332211L);
+ assertEquals(json.optLong("number_2"), 332211L);
+
+ // Behavior documented in #826 JSONObject parsing 0-led numeric strings as ints
+ // After reverting the code, personId is stored as a string, and the behavior is as expected
+ String personId = "\"0123\"";
+ JSONObject j1 = new JSONObject("{\"personId\": " + personId + "}");
+ assertEquals(j1.getString("personId"), "0123");
+
+ // Also #826. Here is input with missing quotes. Because of the leading zero, it should not be parsed as a number.
+ // This example was mentioned in the same ticket
+ // After reverting the code, personId is stored as a string, and the behavior is as expected
+ JSONObject j2 = new JSONObject("{\"personId\":\"0123\"}");
+ assertEquals(j2.getString("personId"), "0123");
+
+ // Behavior uncovered while working on the code
+ // All of the values are stored as strings except for hex4, which is stored as a number. This is probably incorrect
+ JSONObject j3 = new JSONObject("{ " +
+ "\"hex1\": \"010e4\", \"hex2\": \"00f0\", \"hex3\": \"0011\", " +
+ "\"hex4\": 00e0, \"hex5\": \"00f0\", \"hex6\": \"0011\" }");
+ assertEquals(j3.getString("hex1"), "010e4");
+ assertEquals(j3.getString("hex2"), "00f0");
+ assertEquals(j3.getString("hex3"), "0011");
+ assertEquals(j3.getLong("hex4"), 0, .1);
+ assertEquals(j3.getString("hex5"), "00f0");
+ assertEquals(j3.getString("hex6"), "0011");
+ }
+
+
+ @Test
+ public void testStrictModeJSONTokener_expectException(){
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration().withStrictMode();
+ JSONTokener tokener = new JSONTokener("{\"key\":\"value\"}invalidCharacters", jsonParserConfiguration);
+
+ assertThrows(JSONException.class, () -> { new JSONObject(tokener); });
+ }
+
+ /**
+ * Method to build nested map of max maxDepth
+ *
+ * @param maxDepth
+ * @return
+ */
+ public static HashMap buildNestedMap(int maxDepth) {
+ if (maxDepth <= 0) {
+ return new HashMap<>();
+ }
+ HashMap nestedMap = new HashMap<>();
+ nestedMap.put("t", buildNestedMap(maxDepth - 1));
+ return nestedMap;
+ }
+
}
diff --git a/src/test/java/org/json/junit/JSONParserConfigurationTest.java b/src/test/java/org/json/junit/JSONParserConfigurationTest.java
new file mode 100644
index 000000000..926c49f41
--- /dev/null
+++ b/src/test/java/org/json/junit/JSONParserConfigurationTest.java
@@ -0,0 +1,624 @@
+package org.json.junit;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.json.JSONParserConfiguration;
+import org.json.JSONTokener;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+public class JSONParserConfigurationTest {
+ private static final String TEST_SOURCE = "{\"key\": \"value1\", \"key\": \"value2\"}";
+
+ @Test(expected = JSONException.class)
+ public void testThrowException() {
+ new JSONObject(TEST_SOURCE);
+ }
+
+ @Test
+ public void testOverwrite() {
+ JSONObject jsonObject = new JSONObject(TEST_SOURCE,
+ new JSONParserConfiguration().withOverwriteDuplicateKey(true));
+
+ assertEquals("duplicate key should be overwritten", "value2", jsonObject.getString("key"));
+ }
+
+ @Test
+ public void strictModeIsCloned(){
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(true)
+ .withMaxNestingDepth(12);
+
+ assertTrue(jsonParserConfiguration.isStrictMode());
+ }
+
+ @Test
+ public void maxNestingDepthIsCloned(){
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withKeepStrings(true)
+ .withStrictMode(true);
+
+ assertTrue(jsonParserConfiguration.isKeepStrings());
+ }
+
+ @Test
+ public void useNativeNullsIsCloned() {
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withUseNativeNulls(true)
+ .withStrictMode(true);
+ assertTrue(jsonParserConfiguration.isUseNativeNulls());
+ }
+
+ @Test
+ public void verifyDuplicateKeyThenMaxDepth() {
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withOverwriteDuplicateKey(true)
+ .withMaxNestingDepth(42);
+
+ assertEquals(42, jsonParserConfiguration.getMaxNestingDepth());
+ assertTrue(jsonParserConfiguration.isOverwriteDuplicateKey());
+ }
+
+ @Test
+ public void verifyMaxDepthThenDuplicateKey() {
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withMaxNestingDepth(42)
+ .withOverwriteDuplicateKey(true);
+
+ assertTrue(jsonParserConfiguration.isOverwriteDuplicateKey());
+ assertEquals(42, jsonParserConfiguration.getMaxNestingDepth());
+ }
+
+ @Test
+ public void givenInvalidInput_testStrictModeTrue_shouldThrowJsonException() {
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(true);
+ List strictModeInputTestCases = getNonCompliantJSONArrayList();
+ // this is a lot easier to debug when things stop working
+ for (int i = 0; i < strictModeInputTestCases.size(); ++i) {
+ String testCase = strictModeInputTestCases.get(i);
+ try {
+ JSONArray jsonArray = new JSONArray(testCase, jsonParserConfiguration);
+ String s = jsonArray.toString();
+ String msg = "Expected an exception, but got: " + s + " Noncompliant Array index: " + i;
+ fail(msg);
+ } catch (Exception e) {
+ // its all good
+ }
+ }
+ }
+
+ @Test
+ public void givenInvalidInputObjects_testStrictModeTrue_shouldThrowJsonException() {
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(true);
+ List strictModeInputTestCases = getNonCompliantJSONObjectList();
+ // this is a lot easier to debug when things stop working
+ for (int i = 0; i < strictModeInputTestCases.size(); ++i) {
+ String testCase = strictModeInputTestCases.get(i);
+ try {
+ JSONObject jsonObject = new JSONObject(testCase, jsonParserConfiguration);
+ String s = jsonObject.toString();
+ String msg = "Expected an exception, but got: " + s + " Noncompliant Array index: " + i;
+ fail(msg);
+ } catch (Exception e) {
+ // its all good
+ }
+ }
+ }
+
+ @Test
+ public void givenEmptyArray_testStrictModeTrue_shouldNotThrowJsonException() {
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(true);
+ String testCase = "[]";
+ JSONArray jsonArray = new JSONArray(testCase, jsonParserConfiguration);
+ assertEquals(testCase, jsonArray.toString());
+ }
+
+ @Test
+ public void givenEmptyObject_testStrictModeTrue_shouldNotThrowJsonException() {
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(true);
+ String testCase = "{}";
+ JSONObject jsonObject = new JSONObject(testCase, jsonParserConfiguration);
+ assertEquals(testCase, jsonObject.toString());
+ }
+
+ @Test
+ public void givenValidNestedArray_testStrictModeTrue_shouldNotThrowJsonException() {
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(true);
+
+ String testCase = "[[\"c\"], [10.2], [true, false, true]]";
+
+ JSONArray jsonArray = new JSONArray(testCase, jsonParserConfiguration);
+ JSONArray arrayShouldContainStringAt0 = jsonArray.getJSONArray(0);
+ JSONArray arrayShouldContainNumberAt0 = jsonArray.getJSONArray(1);
+ JSONArray arrayShouldContainBooleanAt0 = jsonArray.getJSONArray(2);
+
+ assertTrue(arrayShouldContainStringAt0.get(0) instanceof String);
+ assertTrue(arrayShouldContainNumberAt0.get(0) instanceof Number);
+ assertTrue(arrayShouldContainBooleanAt0.get(0) instanceof Boolean);
+ }
+
+ @Test
+ public void givenValidNestedObject_testStrictModeTrue_shouldNotThrowJsonException() {
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(true);
+
+ String testCase = "{\"a0\":[\"c\"], \"a1\":[10.2], \"a2\":[true, false, true]}";
+
+ JSONObject jsonObject = new JSONObject(testCase, jsonParserConfiguration);
+ JSONArray arrayShouldContainStringAt0 = jsonObject.getJSONArray("a0");
+ JSONArray arrayShouldContainNumberAt0 = jsonObject.getJSONArray("a1");
+ JSONArray arrayShouldContainBooleanAt0 = jsonObject.getJSONArray("a2");
+
+ assertTrue(arrayShouldContainStringAt0.get(0) instanceof String);
+ assertTrue(arrayShouldContainNumberAt0.get(0) instanceof Number);
+ assertTrue(arrayShouldContainBooleanAt0.get(0) instanceof Boolean);
+ }
+
+ @Test
+ public void givenValidEmptyArrayInsideArray_testStrictModeTrue_shouldNotThrowJsonException(){
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(true);
+ String testCase = "[[]]";
+ JSONArray jsonArray = new JSONArray(testCase, jsonParserConfiguration);
+ assertEquals(testCase, jsonArray.toString());
+ }
+
+ @Test
+ public void givenValidEmptyArrayInsideObject_testStrictModeTrue_shouldNotThrowJsonException(){
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(true);
+ String testCase = "{\"a0\":[]}";
+ JSONObject jsonObject = new JSONObject(testCase, jsonParserConfiguration);
+ assertEquals(testCase, jsonObject.toString());
+ }
+
+ @Test
+ public void givenValidEmptyArrayInsideArray_testStrictModeFalse_shouldNotThrowJsonException(){
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(false);
+ String testCase = "[[]]";
+ JSONArray jsonArray = new JSONArray(testCase, jsonParserConfiguration);
+ assertEquals(testCase, jsonArray.toString());
+ }
+
+ @Test
+ public void givenValidEmptyArrayInsideObject_testStrictModeFalse_shouldNotThrowJsonException(){
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(false);
+ String testCase = "{\"a0\":[]}";
+ JSONObject jsonObject = new JSONObject(testCase, jsonParserConfiguration);
+ assertEquals(testCase, jsonObject.toString());
+ }
+
+ @Test
+ public void givenInvalidStringArray_testStrictModeTrue_shouldThrowJsonException() {
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(true);
+ String testCase = "[badString]";
+ JSONException je = assertThrows(JSONException.class, () -> new JSONArray(testCase, jsonParserConfiguration));
+ assertEquals("Strict mode error: Value 'badString' is not surrounded by quotes at 10 [character 11 line 1]",
+ je.getMessage());
+ }
+
+ @Test
+ public void givenInvalidStringObject_testStrictModeTrue_shouldThrowJsonException() {
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(true);
+ String testCase = "{\"a0\":badString}";
+ JSONException je = assertThrows(JSONException.class, () -> new JSONObject(testCase, jsonParserConfiguration));
+ assertEquals("Strict mode error: Value 'badString' is not surrounded by quotes at 15 [character 16 line 1]",
+ je.getMessage());
+ }
+
+ @Test
+ public void allowNullArrayInStrictMode() {
+ String expected = "[null]";
+ JSONArray jsonArray = new JSONArray(expected, new JSONParserConfiguration().withStrictMode(true));
+ assertEquals(expected, jsonArray.toString());
+ }
+
+ @Test
+ public void allowNullObjectInStrictMode() {
+ String expected = "{\"a0\":null}";
+ JSONObject jsonObject = new JSONObject(expected, new JSONParserConfiguration().withStrictMode(true));
+ assertEquals(expected, jsonObject.toString());
+ }
+
+ @Test
+ public void shouldHandleNumericArray() {
+ String expected = "[10]";
+ JSONArray jsonArray = new JSONArray(expected, new JSONParserConfiguration().withStrictMode(true));
+ assertEquals(expected, jsonArray.toString());
+ }
+
+ @Test
+ public void shouldHandleNumericObject() {
+ String expected = "{\"a0\":10}";
+ JSONObject jsonObject = new JSONObject(expected, new JSONParserConfiguration().withStrictMode(true));
+ assertEquals(expected, jsonObject.toString());
+ }
+ @Test
+ public void givenCompliantJSONArrayFile_testStrictModeTrue_shouldNotThrowAnyException() throws IOException {
+ try (Stream lines = Files.lines(Paths.get("src/test/resources/compliantJsonArray.json"))) {
+ String compliantJsonArrayAsString = lines.collect(Collectors.joining());
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(true);
+ new JSONArray(compliantJsonArrayAsString, jsonParserConfiguration);
+ }
+ }
+
+ @Test
+ public void givenCompliantJSONObjectFile_testStrictModeTrue_shouldNotThrowAnyException() throws IOException {
+ try (Stream lines = Files.lines(Paths.get("src/test/resources/compliantJsonObject.json"))) {
+ String compliantJsonObjectAsString = lines.collect(Collectors.joining());
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(true);
+
+ new JSONObject(compliantJsonObjectAsString, jsonParserConfiguration);
+ }
+ }
+
+ @Test
+ public void givenInvalidInputArrays_testStrictModeFalse_shouldNotThrowAnyException() {
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(false);
+
+ List strictModeInputTestCases = getNonCompliantJSONArrayList();
+
+ // this is a lot easier to debug when things stop working
+ for (int i = 0; i < strictModeInputTestCases.size(); ++i) {
+ String testCase = strictModeInputTestCases.get(i);
+ try {
+ JSONArray jsonArray = new JSONArray(testCase, jsonParserConfiguration);
+ } catch (Exception e) {
+ System.out.println("Unexpected exception: " + e.getMessage() + " Noncompliant Array index: " + i);
+ fail(String.format("Noncompliant array index: %d", i));
+ }
+ }
+ }
+
+ @Test
+ public void givenInvalidInputObjects_testStrictModeFalse_shouldNotThrowAnyException() {
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(false);
+
+ List strictModeInputTestCases = getNonCompliantJSONObjectList();
+
+ // this is a lot easier to debug when things stop working
+ for (int i = 0; i < strictModeInputTestCases.size(); ++i) {
+ String testCase = strictModeInputTestCases.get(i);
+ try {
+ JSONObject jsonObject = new JSONObject(testCase, jsonParserConfiguration);
+ } catch (Exception e) {
+ System.out.println("Unexpected exception: " + e.getMessage() + " Noncompliant Array index: " + i);
+ fail(String.format("Noncompliant array index: %d", i));
+ }
+ }
+ }
+
+ @Test
+ public void givenInvalidInputArray_testStrictModeTrue_shouldThrowInvalidCharacterErrorMessage() {
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(true);
+ String testCase = "[1,2];[3,4]";
+ JSONException je = assertThrows("expected non-compliant array but got instead: " + testCase,
+ JSONException.class, () -> new JSONArray(testCase, jsonParserConfiguration));
+ assertEquals("Strict mode error: Unparsed characters found at end of input text at 6 [character 7 line 1]",
+ je.getMessage());
+ }
+
+ @Test
+ public void givenInvalidInputObject_testStrictModeTrue_shouldThrowInvalidCharacterErrorMessage() {
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(true);
+ String testCase = "{\"a0\":[1,2];\"a1\":[3,4]}";
+ JSONException je = assertThrows("expected non-compliant array but got instead: " + testCase,
+ JSONException.class, () -> new JSONObject(testCase, jsonParserConfiguration));
+ assertEquals("Strict mode error: Invalid character ';' found at 12 [character 13 line 1]", je.getMessage());
+ }
+
+ @Test
+ public void givenInvalidInputArrayWithNumericStrings_testStrictModeTrue_shouldThrowInvalidCharacterErrorMessage() {
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(true);
+ String testCase = "[\"1\",\"2\"];[3,4]";
+ JSONException je = assertThrows("expected non-compliant array but got instead: " + testCase,
+ JSONException.class, () -> new JSONArray(testCase, jsonParserConfiguration));
+ assertEquals("Strict mode error: Unparsed characters found at end of input text at 10 [character 11 line 1]",
+ je.getMessage());
+ }
+
+ @Test
+ public void givenInvalidInputObjectWithNumericStrings_testStrictModeTrue_shouldThrowInvalidCharacterErrorMessage() {
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(true);
+ String testCase = "{\"a0\":[\"1\",\"2\"];\"a1\":[3,4]}";
+ JSONException je = assertThrows("expected non-compliant array but got instead: " + testCase,
+ JSONException.class, () -> new JSONObject(testCase, jsonParserConfiguration));
+ assertEquals("Strict mode error: Invalid character ';' found at 16 [character 17 line 1]", je.getMessage());
+ }
+
+ @Test
+ public void givenInvalidInputArray_testStrictModeTrue_shouldThrowValueNotSurroundedByQuotesErrorMessage() {
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(true);
+ String testCase = "[{\"test\": implied}]";
+ JSONException je = assertThrows("expected non-compliant array but got instead: " + testCase,
+ JSONException.class, () -> new JSONArray(testCase, jsonParserConfiguration));
+ assertEquals("Strict mode error: Value 'implied' is not surrounded by quotes at 17 [character 18 line 1]",
+ je.getMessage());
+ }
+
+ @Test
+ public void givenInvalidInputObject_testStrictModeTrue_shouldThrowValueNotSurroundedByQuotesErrorMessage() {
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(true);
+ String testCase = "{\"a0\":{\"test\": implied}]}";
+ JSONException je = assertThrows("expected non-compliant array but got instead: " + testCase,
+ JSONException.class, () -> new JSONObject(testCase, jsonParserConfiguration));
+ assertEquals("Strict mode error: Value 'implied' is not surrounded by quotes at 22 [character 23 line 1]",
+ je.getMessage());
+ }
+
+ @Test
+ public void givenInvalidInputArray_testStrictModeFalse_shouldNotThrowAnyException() {
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(false);
+ String testCase = "[{\"test\": implied}]";
+ new JSONArray(testCase, jsonParserConfiguration);
+ }
+
+ @Test
+ public void givenInvalidInputObject_testStrictModeFalse_shouldNotThrowAnyException() {
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(false);
+ String testCase = "{\"a0\":{\"test\": implied}}";
+ new JSONObject(testCase, jsonParserConfiguration);
+ }
+
+ @Test
+ public void givenNonCompliantQuotesArray_testStrictModeTrue_shouldThrowJsonExceptionWithConcreteErrorDescription() {
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(true);
+
+ String testCaseOne = "[\"abc', \"test\"]";
+ String testCaseTwo = "['abc\", \"test\"]";
+ String testCaseThree = "['abc']";
+ String testCaseFour = "[{'testField': \"testValue\"}]";
+
+ JSONException jeOne = assertThrows(JSONException.class,
+ () -> new JSONArray(testCaseOne, jsonParserConfiguration));
+ JSONException jeTwo = assertThrows(JSONException.class,
+ () -> new JSONArray(testCaseTwo, jsonParserConfiguration));
+ JSONException jeThree = assertThrows(JSONException.class,
+ () -> new JSONArray(testCaseThree, jsonParserConfiguration));
+ JSONException jeFour = assertThrows(JSONException.class,
+ () -> new JSONArray(testCaseFour, jsonParserConfiguration));
+
+ assertEquals(
+ "Expected a ',' or ']' at 10 [character 11 line 1]",
+ jeOne.getMessage());
+ assertEquals(
+ "Strict mode error: Single quoted strings are not allowed at 2 [character 3 line 1]",
+ jeTwo.getMessage());
+ assertEquals(
+ "Strict mode error: Single quoted strings are not allowed at 2 [character 3 line 1]",
+ jeThree.getMessage());
+ assertEquals(
+ "Strict mode error: Single quoted strings are not allowed at 3 [character 4 line 1]",
+ jeFour.getMessage());
+ }
+
+ @Test
+ public void givenNonCompliantQuotesObject_testStrictModeTrue_shouldThrowJsonExceptionWithConcreteErrorDescription() {
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(true);
+
+ String testCaseOne = "{\"abc': \"test\"}";
+ String testCaseTwo = "{'abc\": \"test\"}";
+ String testCaseThree = "{\"a\":'abc'}";
+ String testCaseFour = "{'testField': \"testValue\"}";
+
+ JSONException jeOne = assertThrows(JSONException.class,
+ () -> new JSONObject(testCaseOne, jsonParserConfiguration));
+ JSONException jeTwo = assertThrows(JSONException.class,
+ () -> new JSONObject(testCaseTwo, jsonParserConfiguration));
+ JSONException jeThree = assertThrows(JSONException.class,
+ () -> new JSONObject(testCaseThree, jsonParserConfiguration));
+ JSONException jeFour = assertThrows(JSONException.class,
+ () -> new JSONObject(testCaseFour, jsonParserConfiguration));
+
+ assertEquals(
+ "Expected a ':' after a key at 10 [character 11 line 1]",
+ jeOne.getMessage());
+ assertEquals(
+ "Strict mode error: Single quoted strings are not allowed at 2 [character 3 line 1]",
+ jeTwo.getMessage());
+ assertEquals(
+ "Strict mode error: Single quoted strings are not allowed at 6 [character 7 line 1]",
+ jeThree.getMessage());
+ assertEquals(
+ "Strict mode error: Single quoted strings are not allowed at 2 [character 3 line 1]",
+ jeFour.getMessage());
+ }
+
+ @Test
+ public void givenUnbalancedQuotesArray_testStrictModeFalse_shouldThrowJsonException() {
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(false);
+
+ String testCaseOne = "[\"abc', \"test\"]";
+ String testCaseTwo = "['abc\", \"test\"]";
+
+ JSONException jeOne = assertThrows(JSONException.class,
+ () -> new JSONArray(testCaseOne, jsonParserConfiguration));
+ JSONException jeTwo = assertThrows(JSONException.class,
+ () -> new JSONArray(testCaseTwo, jsonParserConfiguration));
+
+ assertEquals("Expected a ',' or ']' at 10 [character 11 line 1]", jeOne.getMessage());
+ assertEquals("Unterminated string. Character with int code 0 is not allowed within a quoted string. at 15 [character 16 line 1]", jeTwo.getMessage());
+ }
+
+ @Test
+ public void givenUnbalancedQuotesObject_testStrictModeFalse_shouldThrowJsonException() {
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(false);
+
+ String testCaseOne = "{\"abc': \"test\"}";
+ String testCaseTwo = "{'abc\": \"test\"}";
+
+ JSONException jeOne = assertThrows(JSONException.class,
+ () -> new JSONObject(testCaseOne, jsonParserConfiguration));
+ JSONException jeTwo = assertThrows(JSONException.class,
+ () -> new JSONObject(testCaseTwo, jsonParserConfiguration));
+
+ assertEquals("Expected a ':' after a key at 10 [character 11 line 1]", jeOne.getMessage());
+ assertEquals("Unterminated string. Character with int code 0 is not allowed within a quoted string. at 15 [character 16 line 1]", jeTwo.getMessage());
+ }
+
+ @Test
+ public void givenInvalidInputArray_testStrictModeTrue_shouldThrowKeyNotSurroundedByQuotesErrorMessage() {
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(true);
+
+ String testCase = "[{test: implied}]";
+ JSONException je = assertThrows("expected non-compliant array but got instead: " + testCase,
+ JSONException.class, () -> new JSONArray(testCase, jsonParserConfiguration));
+
+ assertEquals("Strict mode error: Value 'test' is not surrounded by quotes at 6 [character 7 line 1]",
+ je.getMessage());
+ }
+
+ @Test
+ public void givenInvalidInputObject_testStrictModeTrue_shouldThrowKeyNotSurroundedByQuotesErrorMessage() {
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+ .withStrictMode(true);
+
+ String testCase = "{test: implied}";
+ JSONException je = assertThrows("expected non-compliant json but got instead: " + testCase,
+ JSONException.class, () -> new JSONObject(testCase, jsonParserConfiguration));
+
+ assertEquals("Strict mode error: Value 'test' is not surrounded by quotes at 5 [character 6 line 1]",
+ je.getMessage());
+ }
+
+ @Test
+ public void givenInvalidInputObject_testStrictModeTrue_JSONObjectUsingJSONTokener_shouldThrowJSONException() {
+ JSONException exception = assertThrows(JSONException.class, () -> {
+ new JSONObject(new JSONTokener("{\"key\":\"value\"} invalid trailing text"), new JSONParserConfiguration().withStrictMode(true));
+ });
+
+ assertEquals("Strict mode error: Unparsed characters found at end of input text at 17 [character 18 line 1]", exception.getMessage());
+ }
+
+ @Test
+ public void givenInvalidInputObject_testStrictModeTrue_JSONObjectUsingString_shouldThrowJSONException() {
+ JSONException exception = assertThrows(JSONException.class, () -> {
+ new JSONObject("{\"key\":\"value\"} invalid trailing text", new JSONParserConfiguration().withStrictMode(true));
+ });
+ assertEquals("Strict mode error: Unparsed characters found at end of input text at 17 [character 18 line 1]", exception.getMessage());
+ }
+
+ @Test
+ public void givenInvalidInputObject_testStrictModeTrue_JSONArrayUsingJSONTokener_shouldThrowJSONException() {
+ JSONException exception = assertThrows(JSONException.class, () -> {
+ new JSONArray(new JSONTokener("[\"value\"] invalid trailing text"), new JSONParserConfiguration().withStrictMode(true));
+ });
+
+ assertEquals("Strict mode error: Unparsed characters found at end of input text at 11 [character 12 line 1]", exception.getMessage());
+ }
+
+ @Test
+ public void givenInvalidInputObject_testStrictModeTrue_JSONArrayUsingString_shouldThrowJSONException() {
+ JSONException exception = assertThrows(JSONException.class, () -> {
+ new JSONArray("[\"value\"] invalid trailing text", new JSONParserConfiguration().withStrictMode(true));
+ });
+ assertEquals("Strict mode error: Unparsed characters found at end of input text at 11 [character 12 line 1]", exception.getMessage());
+ }
+
+ /**
+ * This method contains short but focused use-case samples and is exclusively used to test strictMode unit tests in
+ * this class.
+ *
+ * @return List with JSON strings.
+ */
+ private List getNonCompliantJSONArrayList() {
+ return Arrays.asList(
+ "[1],",
+ "[1,]",
+ "[,]",
+ "[,,]",
+ "[[1],\"sa\",[2]]a",
+ "[1],\"dsa\": \"test\"",
+ "[[a]]",
+ "[]asdf",
+ "[]]",
+ "[]}",
+ "[][",
+ "[]{",
+ "[],",
+ "[]:",
+ "[],[",
+ "[],{",
+ "[1,2];[3,4]",
+ "[test]",
+ "[{'testSingleQuote': 'testSingleQuote'}]",
+ "[1, 2,3]:[4,5]",
+ "[{test: implied}]",
+ "[{\"test\": implied}]",
+ "[{\"number\":\"7990154836330\",\"color\":'c'},{\"number\":8784148854580,\"color\":RosyBrown},{\"number\":\"5875770107113\",\"color\":\"DarkSeaGreen\"}]",
+ "[{test: \"implied\"}]");
+ }
+
+ /**
+ * This method contains short but focused use-case samples and is exclusively used to test strictMode unit tests in
+ * this class.
+ *
+ * @return List with JSON strings.
+ */
+ private List getNonCompliantJSONObjectList() {
+ return Arrays.asList(
+ "{\"a\":1},",
+ "{\"a\":1,}",
+ "{\"a0\":[1],\"a1\":\"sa\",\"a2\":[2]}a",
+ "{\"a\":1},\"dsa\": \"test\"",
+ "{\"a\":[a]}",
+ "{}asdf",
+ "{}}",
+ "{}]",
+ "{}{",
+ "{}[",
+ "{},",
+ "{}:",
+ "{},{",
+ "{},[",
+ "{\"a0\":[1,2];\"a1\":[3,4]}",
+ "{\"a\":test}",
+ "{a:{'testSingleQuote': 'testSingleQuote'}}",
+ "{\"a0\":1, \"a1\":2,\"a2\":3}:{\"a3\":4,\"a4\":5}",
+ "{\"a\":{test: implied}}",
+ "{a:{\"test\": implied}}",
+ "{a:[{\"number\":\"7990154836330\",\"color\":'c'},{\"number\":8784148854580,\"color\":RosyBrown},{\"number\":\"5875770107113\",\"color\":\"DarkSeaGreen\"}]}",
+ "{a:{test: \"implied\"}}"
+ );
+ }
+
+}
diff --git a/src/test/java/org/json/junit/JSONPointerTest.java b/src/test/java/org/json/junit/JSONPointerTest.java
index 45c7dbd3d..a420b297f 100644
--- a/src/test/java/org/json/junit/JSONPointerTest.java
+++ b/src/test/java/org/json/junit/JSONPointerTest.java
@@ -384,8 +384,7 @@ public void queryFromJSONObjectUsingPointer0() {
String str = "{"+
"\"string\\\\\\\\Key\":\"hello world!\","+
- "\"\\\\\":\"slash test\"," +
- "}"+
+ "\"\\\\\":\"slash test\"" +
"}";
JSONObject jsonObject = new JSONObject(str);
//Summary of issue: When a KEY in the jsonObject is "\\\\" --> it's held
diff --git a/src/test/java/org/json/junit/JSONStringTest.java b/src/test/java/org/json/junit/JSONStringTest.java
index b4fee3eb7..235df1806 100644
--- a/src/test/java/org/json/junit/JSONStringTest.java
+++ b/src/test/java/org/json/junit/JSONStringTest.java
@@ -319,6 +319,22 @@ public void testNullStringValue() throws Exception {
}
}
+ @Test
+ public void testEnumJSONString() {
+ JSONObject jsonObject = new JSONObject();
+ jsonObject.put("key", MyEnum.MY_ENUM);
+ assertEquals("{\"key\":\"myJsonString\"}", jsonObject.toString());
+ }
+
+ private enum MyEnum implements JSONString {
+ MY_ENUM;
+
+ @Override
+ public String toJSONString() {
+ return "\"myJsonString\"";
+ }
+ }
+
/**
* A JSONString that returns a valid JSON string value.
*/
diff --git a/src/test/java/org/json/junit/JSONTokenerTest.java b/src/test/java/org/json/junit/JSONTokenerTest.java
index 59ca6d8f6..b0b45cb7c 100644
--- a/src/test/java/org/json/junit/JSONTokenerTest.java
+++ b/src/test/java/org/json/junit/JSONTokenerTest.java
@@ -16,10 +16,7 @@
import java.io.Reader;
import java.io.StringReader;
-import org.json.JSONArray;
-import org.json.JSONException;
-import org.json.JSONObject;
-import org.json.JSONTokener;
+import org.json.*;
import org.junit.Test;
/**
@@ -98,7 +95,17 @@ public void testValid() {
checkValid(" [] ",JSONArray.class);
checkValid("[1,2]",JSONArray.class);
checkValid("\n\n[1,2]\n\n",JSONArray.class);
- checkValid("1 2", String.class);
+
+ // Test should fail if default strictMode is true, pass if false
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration();
+ if (jsonParserConfiguration.isStrictMode()) {
+ try {
+ checkValid("1 2", String.class);
+ assertEquals("Expected to throw exception due to invalid string", true, false);
+ } catch (JSONException e) { }
+ } else {
+ checkValid("1 2", String.class);
+ }
}
@Test
@@ -325,4 +332,42 @@ public void testAutoClose(){
assertEquals("Stream closed", exception.getMessage());
}
}
+
+ @Test
+ public void testInvalidInput_JSONObject_withoutStrictModel_shouldParseInput() {
+ String input = "{\"invalidInput\": [],}";
+ JSONTokener tokener = new JSONTokener(input);
+
+ // Test should fail if default strictMode is true, pass if false
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration();
+ if (jsonParserConfiguration.isStrictMode()) {
+ try {
+ Object value = tokener.nextValue();
+ assertEquals(new JSONObject(input).toString(), value.toString());
+ assertEquals("Expected to throw exception due to invalid string", true, false);
+ } catch (JSONException e) { }
+ } else {
+ Object value = tokener.nextValue();
+ assertEquals(new JSONObject(input).toString(), value.toString());
+ }
+ }
+
+ @Test
+ public void testInvalidInput_JSONArray_withoutStrictModel_shouldParseInput() {
+ String input = "[\"invalidInput\",]";
+ JSONTokener tokener = new JSONTokener(input);
+
+ // Test should fail if default strictMode is true, pass if false
+ JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration();
+ if (jsonParserConfiguration.isStrictMode()) {
+ try {
+ Object value = tokener.nextValue();
+ assertEquals(new JSONArray(input).toString(), value.toString());
+ assertEquals("Expected to throw exception due to invalid string", true, false);
+ } catch (JSONException e) { }
+ } else {
+ Object value = tokener.nextValue();
+ assertEquals(new JSONArray(input).toString(), value.toString());
+ }
+ }
}
diff --git a/src/test/java/org/json/junit/StringBuilderWriterTest.java b/src/test/java/org/json/junit/StringBuilderWriterTest.java
new file mode 100644
index 000000000..b12f5db0c
--- /dev/null
+++ b/src/test/java/org/json/junit/StringBuilderWriterTest.java
@@ -0,0 +1,60 @@
+package org.json.junit;
+
+import static org.junit.Assert.assertEquals;
+
+import org.json.StringBuilderWriter;
+import org.junit.Before;
+import org.junit.Test;
+
+public class StringBuilderWriterTest {
+ private StringBuilderWriter writer;
+
+ @Before
+ public void setUp() {
+ writer = new StringBuilderWriter();
+ }
+
+ @Test
+ public void testWriteChar() {
+ writer.write('a');
+ assertEquals("a", writer.toString());
+ }
+
+ @Test
+ public void testWriteCharArray() {
+ char[] chars = {'a', 'b', 'c'};
+ writer.write(chars, 0, 3);
+ assertEquals("abc", writer.toString());
+ }
+
+ @Test
+ public void testWriteString() {
+ writer.write("hello");
+ assertEquals("hello", writer.toString());
+ }
+
+ @Test
+ public void testWriteStringWithOffsetAndLength() {
+ writer.write("hello world", 6, 5);
+ assertEquals("world", writer.toString());
+ }
+
+ @Test
+ public void testAppendCharSequence() {
+ writer.append("hello");
+ assertEquals("hello", writer.toString());
+ }
+
+ @Test
+ public void testAppendCharSequenceWithStartAndEnd() {
+ CharSequence csq = "hello world";
+ writer.append(csq, 6, 11);
+ assertEquals("world", writer.toString());
+ }
+
+ @Test
+ public void testAppendChar() {
+ writer.append('a');
+ assertEquals("a", writer.toString());
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/org/json/junit/XMLConfigurationTest.java b/src/test/java/org/json/junit/XMLConfigurationTest.java
index 21a2b595e..938c7c806 100755
--- a/src/test/java/org/json/junit/XMLConfigurationTest.java
+++ b/src/test/java/org/json/junit/XMLConfigurationTest.java
@@ -4,11 +4,6 @@
Public Domain.
*/
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
@@ -27,6 +22,8 @@
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
+import static org.junit.Assert.*;
+
/**
* Tests for JSON-Java XML.java with XMLParserConfiguration.java
@@ -273,9 +270,9 @@ public void shouldHandleSimpleXML() {
String expectedStr =
"{\"addresses\":{\"address\":{\"street\":\"[CDATA[Baker street 5]\","+
- "\"name\":\"Joe Tester\",\"NothingHere\":\"\",TrueValue:true,\n"+
+ "\"name\":\"Joe Tester\",\"NothingHere\":\"\",\"TrueValue\":true,\n"+
"\"FalseValue\":false,\"NullValue\":null,\"PositiveValue\":42,\n"+
- "\"NegativeValue\":-23,\"DoubleValue\":-23.45,\"Nan\":-23x.45,\n"+
+ "\"NegativeValue\":-23,\"DoubleValue\":-23.45,\"Nan\":\"-23x.45\",\n"+
"\"ArrayOfNum\":\"1, 2, 3, 4.1, 5.2\"\n"+
"},\"xsi:noNamespaceSchemaLocation\":"+
"\"test.xsd\",\"xmlns:xsi\":\"http://www.w3.org/2001/"+
@@ -557,6 +554,40 @@ public void shouldHandleNullNodeValue()
assertEquals(actualXML, resultXML);
}
+ @Test
+ public void shouldHandleEmptyNodeValue()
+ {
+ JSONObject inputJSON = new JSONObject();
+ inputJSON.put("Emptyness", "");
+ String expectedXmlWithoutExplicitEndTag = "01 1 00 0 True 01 1 00 0 True two two Test Whitespace String \t ";
+
+ JSONObject actualJson = XML.toJSONObject(originalXml, new XMLParserConfiguration().withShouldTrimWhitespace(false));
+ String expectedJsonString = "{\"testXml\":\" Test Whitespace String \t \"}";
+ JSONObject expectedJson = new JSONObject(expectedJsonString);
+ Util.compareActualVsExpectedJsonObjects(actualJson,expectedJson);
+ }
+ @Test
+ public void testNestedWithWhitespaceTrimmingDisabled() {
+ String originalXml =
+ "\n"+
+ "\n"+
+ " \n"+
+ " Sherlock Holmes \n"+
+ " \n"+
+ " ";
+
+ JSONObject actualJson = XML.toJSONObject(originalXml, new XMLParserConfiguration().withShouldTrimWhitespace(false));
+ String expectedJsonString = "{\"addresses\":{\"address\":{\"name\":\" Sherlock Holmes \"}}}";
+ JSONObject expectedJson = new JSONObject(expectedJsonString);
+ Util.compareActualVsExpectedJsonObjects(actualJson,expectedJson);
+ }
+ @Test
+ public void shouldTrimWhitespaceDoesNotSupportTagsEqualingCDataTagName() {
+ // When using withShouldTrimWhitespace = true, input containing tags with same name as cDataTagName is unsupported and should not be used in conjunction
+ String originalXml =
+ "\n"+
+ "\n"+
+ " \n"+
+ " Sherlock Holmes \n"+
+ " \n"+
+ " ";
+
+ JSONObject actualJson = XML.toJSONObject(originalXml, new XMLParserConfiguration().withShouldTrimWhitespace(false).withcDataTagName("content"));
+ String expectedJsonString = "{\"addresses\":{\"address\":[[\"\\n \",\" Sherlock Holmes \",\"\\n \"]]}}";
+ JSONObject expectedJson = new JSONObject(expectedJsonString);
+ Util.compareActualVsExpectedJsonObjects(actualJson,expectedJson);
+ }
+ @Test
+ public void shouldTrimWhitespaceEnabledDropsTagsEqualingCDataTagNameButValueRemains() {
+ String originalXml =
+ "\n"+
+ "\n"+
+ " \n"+
+ " Sherlock Holmes \n"+
+ " \n"+
+ " ";
+
+ JSONObject actualJson = XML.toJSONObject(originalXml, new XMLParserConfiguration().withShouldTrimWhitespace(true).withcDataTagName("content"));
+ String expectedJsonString = "{\"addresses\":{\"address\":\"Sherlock Holmes\"}}";
+ JSONObject expectedJson = new JSONObject(expectedJsonString);
+ Util.compareActualVsExpectedJsonObjects(actualJson,expectedJson);
+ }
+ @Test
+ public void testWithWhitespaceTrimmingEnabled() {
+ String originalXml = " Test Whitespace String \t ";
+
+ JSONObject actualJson = XML.toJSONObject(originalXml, new XMLParserConfiguration().withShouldTrimWhitespace(true));
+ String expectedJsonString = "{\"testXml\":\"Test Whitespace String\"}";
+ JSONObject expectedJson = new JSONObject(expectedJsonString);
+ Util.compareActualVsExpectedJsonObjects(actualJson,expectedJson);
+ }
+ @Test
+ public void testWithWhitespaceTrimmingEnabledByDefault() {
+ String originalXml = " Test Whitespace String \t ";
+
+ JSONObject actualJson = XML.toJSONObject(originalXml, new XMLParserConfiguration());
+ String expectedJsonString = "{\"testXml\":\"Test Whitespace String\"}";
+ JSONObject expectedJson = new JSONObject(expectedJsonString);
+ Util.compareActualVsExpectedJsonObjects(actualJson,expectedJson);
+ }
+
+ @Test
+ public void clarifyCurrentBehavior() {
+
+ // Behavior documented in #826
+ // After reverting the code, amount is stored as numeric, and phone is stored as string
+ String str1 =
+ " \n" +
+ " 0123456789 \n" +
+ " 0.1230 \n" +
+ " true \n" +
+ " ";
+ JSONObject jsonObject1 = XML.toJSONObject(str1,
+ new XMLParserConfiguration().withKeepStrings(false));
+ assertEquals(jsonObject1.getJSONObject("datatypes").getFloat("amount"), 0.123, .1);
+ assertEquals(jsonObject1.getJSONObject("datatypes").getString("telephone"), "0123456789");
+
+
+ // Behavior documented in #852
+ // After reverting the code, value is still stored as a number. This is due to how XML.isDecimalNotation() works
+ // and is probably a bug. JSONObject has a similar problem.
+ String str2 = " primary 008E97 ";
+ JSONObject jsonObject2 = XML.toJSONObject(str2);
+ assertEquals(jsonObject2.getJSONObject("color").getLong("value"), 0e897, .1);
+
+ // Workaround for now is to use keepStrings
+ JSONObject jsonObject3 = XML.toJSONObject(str2, new XMLParserConfiguration().withKeepStrings(true));
+ assertEquals(jsonObject3.getJSONObject("color").getString("value"), "008E97");
+ }
+
}
diff --git a/src/test/java/org/json/junit/data/GenericBean.java b/src/test/java/org/json/junit/data/GenericBean.java
index da6370d48..dd46b88e6 100644
--- a/src/test/java/org/json/junit/data/GenericBean.java
+++ b/src/test/java/org/json/junit/data/GenericBean.java
@@ -9,7 +9,7 @@
* @param
* generic number value
*/
-public class GenericBean> implements MyBean {
+public class GenericBean implements MyBean {
/**
* @param genericValue
* value to initiate with
diff --git a/src/test/java/org/json/junit/data/WeirdList.java b/src/test/java/org/json/junit/data/WeirdList.java
index 834b81e86..35605863a 100644
--- a/src/test/java/org/json/junit/data/WeirdList.java
+++ b/src/test/java/org/json/junit/data/WeirdList.java
@@ -12,7 +12,7 @@
*/
public class WeirdList {
/** */
- private final List list = new ArrayList();
+ private final List list = new ArrayList<>();
/**
* @param vals
@@ -25,14 +25,14 @@ public WeirdList(Integer... vals) {
* @return a copy of the list
*/
public List get() {
- return new ArrayList(this.list);
+ return new ArrayList<>(this.list);
}
/**
* @return a copy of the list
*/
public List getALL() {
- return new ArrayList(this.list);
+ return new ArrayList<>(this.list);
}
/**
diff --git a/src/test/resources/compliantJsonArray.json b/src/test/resources/compliantJsonArray.json
new file mode 100644
index 000000000..d68c99588
--- /dev/null
+++ b/src/test/resources/compliantJsonArray.json
@@ -0,0 +1,317 @@
+[
+ {
+ "_id": "6606c27d2ab4a0102d49420a",
+ "index": 0,
+ "guid": "441331fb-84d1-4873-a649-3814621a0370",
+ "isActive": true,
+ "balance": "$2,691.63",
+ "picture": "http://example.abc/32x32",
+ "age": 26,
+ "eyeColor": "blue",
+ "name": "abc",
+ "gender": "female",
+ "company": "example",
+ "email": "abc@def.com",
+ "phone": "+1 (123) 456-7890",
+ "address": "123 Main St",
+ "about": "Laborum magna tempor officia irure cillum nulla incididunt Lorem dolor veniam elit cupidatat amet. Veniam veniam exercitation nulla consectetur officia esse ex sunt nulla nisi ea cillum nisi reprehenderit. Qui aliquip reprehenderit aliqua aliquip aliquip anim sit magna nostrud dolore veniam velit elit aliquip.\r\n",
+ "registered": "2016-07-22T03:18:11 -01:00",
+ "latitude": -21.544934,
+ "longitude": 72.765495,
+ "tags": [
+ "consectetur",
+ "minim",
+ "sunt",
+ "in",
+ "ut",
+ "velit",
+ "anim"
+ ],
+ "friends": [
+ {
+ "id": 0,
+ "name": "abc def"
+ },
+ {
+ "id": 1,
+ "name": "ghi jkl"
+ },
+ {
+ "id": 2,
+ "name": "mno pqr"
+ }
+ ],
+ "greeting": "Hello, abc! You have 10 unread messages.",
+ "favoriteFruit": "banana"
+ },
+ {
+ "_id": "6606c27d0a45df5121fb765f",
+ "index": 1,
+ "guid": "fd774715-de85-44b9-b498-c214d8f68d9f",
+ "isActive": true,
+ "balance": "$2,713.96",
+ "picture": "http://placehold.it/32x32",
+ "age": 27,
+ "eyeColor": "green",
+ "name": "def",
+ "gender": "female",
+ "company": "sample",
+ "email": "def@abc.com",
+ "phone": "+1 (123) 456-78910",
+ "address": "1234 Main St",
+ "about": "Ea id cupidatat eiusmod culpa. Nulla consequat esse elit enim et pariatur eiusmod ipsum. Consequat eu non reprehenderit in.\r\n",
+ "registered": "2015-04-06T07:54:22 -01:00",
+ "latitude": 83.512347,
+ "longitude": -9.368739,
+ "tags": [
+ "excepteur",
+ "non",
+ "nostrud",
+ "laboris",
+ "laboris",
+ "qui",
+ "aute"
+ ],
+ "friends": [
+ {
+ "id": 0,
+ "name": "sample example"
+ },
+ {
+ "id": 1,
+ "name": "test name"
+ },
+ {
+ "id": 2,
+ "name": "aaa aaaa"
+ }
+ ],
+ "greeting": "Hello, test! You have 7 unread messages.",
+ "favoriteFruit": "apple"
+ },
+ {
+ "_id": "6606c27dfb3a0e4e7e7183d3",
+ "index": 2,
+ "guid": "688b0c36-98e0-4ee7-86b8-863638d79b5f",
+ "isActive": false,
+ "balance": "$3,514.35",
+ "picture": "http://placehold.it/32x32",
+ "age": 32,
+ "eyeColor": "green",
+ "name": "test",
+ "gender": "female",
+ "company": "test",
+ "email": "test@test.com",
+ "phone": "+1 (123) 456-7890",
+ "address": "123 Main St",
+ "about": "Mollit officia adipisicing ex nisi non Lorem sunt quis est. Irure exercitation duis ipsum qui ullamco eu ea commodo occaecat minim proident. Incididunt nostrud ex cupidatat eiusmod mollit anim irure culpa. Labore voluptate voluptate labore nisi sit eu. Dolor sit proident velit dolor deserunt labore sit ipsum incididunt eiusmod reprehenderit voluptate. Duis anim velit officia laboris consequat officia dolor sint dolor nisi ex.\r\n",
+ "registered": "2021-11-02T12:50:05 -00:00",
+ "latitude": -82.969939,
+ "longitude": 86.415645,
+ "tags": [
+ "aliquip",
+ "et",
+ "est",
+ "nulla",
+ "nulla",
+ "tempor",
+ "adipisicing"
+ ],
+ "friends": [
+ {
+ "id": 0,
+ "name": "test"
+ },
+ {
+ "id": 1,
+ "name": "sample"
+ },
+ {
+ "id": 2,
+ "name": "example"
+ }
+ ],
+ "greeting": "Hello, test! You have 1 unread messages.",
+ "favoriteFruit": "strawberry"
+ },
+ {
+ "_id": "6606c27d204bc2327fc9ba23",
+ "index": 3,
+ "guid": "be970cba-306e-4cbd-be08-c265a43a61fa",
+ "isActive": true,
+ "balance": "$3,691.63",
+ "picture": "http://placehold.it/32x32",
+ "age": 35,
+ "eyeColor": "brown",
+ "name": "another test",
+ "gender": "male",
+ "company": "TEST",
+ "email": "anothertest@anothertest.com",
+ "phone": "+1 (321) 987-6543",
+ "address": "123 Example Main St",
+ "about": "Do proident consectetur minim quis. In adipisicing culpa Lorem fugiat cillum exercitation velit velit. Non voluptate laboris deserunt veniam et sint consectetur irure aliqua quis eiusmod consectetur elit id. Ex sint do anim Lorem excepteur eu nulla.\r\n",
+ "registered": "2020-06-25T04:55:25 -01:00",
+ "latitude": 63.614955,
+ "longitude": -109.299405,
+ "tags": [
+ "irure",
+ "esse",
+ "non",
+ "mollit",
+ "laborum",
+ "adipisicing",
+ "ad"
+ ],
+ "friends": [
+ {
+ "id": 0,
+ "name": "test"
+ },
+ {
+ "id": 1,
+ "name": "sample"
+ },
+ {
+ "id": 2,
+ "name": "example"
+ }
+ ],
+ "greeting": "Hello, another test! You have 5 unread messages.",
+ "favoriteFruit": "apple"
+ },
+ {
+ "_id": "6606c27df63eb5f390cb9989",
+ "index": 4,
+ "guid": "2c3e5115-758d-468e-99c5-c9afa26e1f9f",
+ "isActive": true,
+ "balance": "$1,047.20",
+ "picture": "http://test.it/32x32",
+ "age": 30,
+ "eyeColor": "green",
+ "name": "Test Name",
+ "gender": "female",
+ "company": "test",
+ "email": "testname@testname.com",
+ "phone": "+1 (999) 999-9999",
+ "address": "999 Test Main St",
+ "about": "Voluptate exercitation tempor consectetur velit magna ea occaecat cupidatat consectetur anim aute. Aliquip est aute ipsum laboris non irure qui consectetur tempor quis do ea Lorem. Cupidatat exercitation ad culpa aliqua amet commodo mollit reprehenderit exercitation adipisicing amet et laborum pariatur.\r\n",
+ "registered": "2023-01-19T02:43:18 -00:00",
+ "latitude": 14.15208,
+ "longitude": 170.411535,
+ "tags": [
+ "dolor",
+ "qui",
+ "cupidatat",
+ "aliqua",
+ "laboris",
+ "reprehenderit",
+ "sint"
+ ],
+ "friends": [
+ {
+ "id": 0,
+ "name": "test"
+ },
+ {
+ "id": 1,
+ "name": "sample"
+ },
+ {
+ "id": 2,
+ "name": "example"
+ }
+ ],
+ "greeting": "Hello, test! You have 6 unread messages.",
+ "favoriteFruit": "apple"
+ },
+ {
+ "_id": "6606c27d01d19fa29853d59c",
+ "index": 5,
+ "guid": "816cda74-5d4b-498f-9724-20f340d5f5bf",
+ "isActive": false,
+ "balance": "$2,628.74",
+ "picture": "http://testing.it/32x32",
+ "age": 28,
+ "eyeColor": "green",
+ "name": "Testing",
+ "gender": "female",
+ "company": "test",
+ "email": "testing@testing.com",
+ "phone": "+1 (888) 888-8888",
+ "address": "123 Main St",
+ "about": "Cupidatat non ut nulla qui excepteur in minim non et nulla fugiat. Dolor quis laborum occaecat veniam dolor ullamco deserunt amet veniam dolor quis proident tempor laboris. In cillum duis ut quis. Aliqua cupidatat magna proident velit tempor veniam et consequat laborum ex dolore qui. Incididunt deserunt magna minim Lorem consectetur.\r\n",
+ "registered": "2017-10-14T11:14:08 -01:00",
+ "latitude": -5.345728,
+ "longitude": -9.706491,
+ "tags": [
+ "officia",
+ "velit",
+ "laboris",
+ "qui",
+ "cupidatat",
+ "cupidatat",
+ "ad"
+ ],
+ "friends": [
+ {
+ "id": 0,
+ "name": "test"
+ },
+ {
+ "id": 1,
+ "name": "sample"
+ },
+ {
+ "id": 2,
+ "name": "example"
+ }
+ ],
+ "greeting": "Hello, testing! You have 2 unread messages.",
+ "favoriteFruit": "strawberry"
+ },
+ {
+ "_id": "6606c27d803003cede1d6deb",
+ "index": 6,
+ "guid": "4ee550bc-0920-4104-b3ce-ebf9db6a803f",
+ "isActive": true,
+ "balance": "$1,709.31",
+ "picture": "http://sample.it/32x32",
+ "age": 31,
+ "eyeColor": "blue",
+ "name": "Sample Name",
+ "gender": "female",
+ "company": "Sample",
+ "email": "sample@sample.com",
+ "phone": "+1 (777) 777-7777",
+ "address": "123 Main St",
+ "about": "Lorem ex proident ipsum ullamco velit sit nisi eiusmod cillum. Id tempor irure culpa nisi sit non qui veniam non ut. Aliquip reprehenderit excepteur mollit quis excepteur ex sit. Quis do eu veniam do ullamco occaecat eu cupidatat nisi laborum tempor minim fugiat pariatur. Ex in nulla ex velit.\r\n",
+ "registered": "2019-04-08T03:54:36 -01:00",
+ "latitude": -70.660321,
+ "longitude": 71.547525,
+ "tags": [
+ "consequat",
+ "veniam",
+ "pariatur",
+ "aliqua",
+ "cillum",
+ "eu",
+ "officia"
+ ],
+ "friends": [
+ {
+ "id": 0,
+ "name": "Test"
+ },
+ {
+ "id": 1,
+ "name": "Sample"
+ },
+ {
+ "id": 2,
+ "name": "Example"
+ }
+ ],
+ "greeting": "Hello, Sample! You have 6 unread messages.",
+ "favoriteFruit": "apple"
+ }
+]
diff --git a/src/test/resources/compliantJsonObject.json b/src/test/resources/compliantJsonObject.json
new file mode 100644
index 000000000..cb2918d37
--- /dev/null
+++ b/src/test/resources/compliantJsonObject.json
@@ -0,0 +1,3703 @@
+{
+ "a0": [
+ {
+ "id": 0,
+ "name": "Elijah",
+ "city": "Austin",
+ "age": 78,
+ "friends": [
+ {
+ "name": "Michelle",
+ "hobbies": [
+ "Watching Sports",
+ "Reading",
+ "Skiing & Snowboarding"
+ ]
+ },
+ {
+ "name": "Robert",
+ "hobbies": [
+ "Traveling",
+ "Video Games"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 1,
+ "name": "Noah",
+ "city": "Boston",
+ "age": 97,
+ "friends": [
+ {
+ "name": "Oliver",
+ "hobbies": [
+ "Watching Sports",
+ "Skiing & Snowboarding",
+ "Collecting"
+ ]
+ },
+ {
+ "name": "Olivia",
+ "hobbies": [
+ "Running",
+ "Music",
+ "Woodworking"
+ ]
+ },
+ {
+ "name": "Robert",
+ "hobbies": [
+ "Woodworking",
+ "Calligraphy",
+ "Genealogy"
+ ]
+ },
+ {
+ "name": "Ava",
+ "hobbies": [
+ "Walking",
+ "Church Activities"
+ ]
+ },
+ {
+ "name": "Michael",
+ "hobbies": [
+ "Music",
+ "Church Activities"
+ ]
+ },
+ {
+ "name": "Michael",
+ "hobbies": [
+ "Martial Arts",
+ "Painting",
+ "Jewelry Making"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 2,
+ "name": "Evy",
+ "city": "San Diego",
+ "age": 48,
+ "friends": [
+ {
+ "name": "Joe",
+ "hobbies": [
+ "Reading",
+ "Volunteer Work"
+ ]
+ },
+ {
+ "name": "Joe",
+ "hobbies": [
+ "Genealogy",
+ "Golf"
+ ]
+ },
+ {
+ "name": "Oliver",
+ "hobbies": [
+ "Collecting",
+ "Writing",
+ "Bicycling"
+ ]
+ },
+ {
+ "name": "Liam",
+ "hobbies": [
+ "Church Activities",
+ "Jewelry Making"
+ ]
+ },
+ {
+ "name": "Amelia",
+ "hobbies": [
+ "Calligraphy",
+ "Dancing"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 3,
+ "name": "Oliver",
+ "city": "St. Louis",
+ "age": 39,
+ "friends": [
+ {
+ "name": "Mateo",
+ "hobbies": [
+ "Watching Sports",
+ "Gardening"
+ ]
+ },
+ {
+ "name": "Nora",
+ "hobbies": [
+ "Traveling",
+ "Team Sports"
+ ]
+ },
+ {
+ "name": "Ava",
+ "hobbies": [
+ "Church Activities",
+ "Running"
+ ]
+ },
+ {
+ "name": "Amelia",
+ "hobbies": [
+ "Gardening",
+ "Board Games",
+ "Watching Sports"
+ ]
+ },
+ {
+ "name": "Leo",
+ "hobbies": [
+ "Martial Arts",
+ "Video Games",
+ "Reading"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 4,
+ "name": "Michael",
+ "city": "St. Louis",
+ "age": 95,
+ "friends": [
+ {
+ "name": "Mateo",
+ "hobbies": [
+ "Movie Watching",
+ "Collecting"
+ ]
+ },
+ {
+ "name": "Chris",
+ "hobbies": [
+ "Housework",
+ "Bicycling",
+ "Collecting"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 5,
+ "name": "Michael",
+ "city": "Portland",
+ "age": 19,
+ "friends": [
+ {
+ "name": "Jack",
+ "hobbies": [
+ "Painting",
+ "Television"
+ ]
+ },
+ {
+ "name": "Oliver",
+ "hobbies": [
+ "Walking",
+ "Watching Sports",
+ "Movie Watching"
+ ]
+ },
+ {
+ "name": "Charlotte",
+ "hobbies": [
+ "Podcasts",
+ "Jewelry Making"
+ ]
+ },
+ {
+ "name": "Elijah",
+ "hobbies": [
+ "Eating Out",
+ "Painting"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 6,
+ "name": "Lucas",
+ "city": "Austin",
+ "age": 76,
+ "friends": [
+ {
+ "name": "John",
+ "hobbies": [
+ "Genealogy",
+ "Cooking"
+ ]
+ },
+ {
+ "name": "John",
+ "hobbies": [
+ "Socializing",
+ "Yoga"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 7,
+ "name": "Michelle",
+ "city": "San Antonio",
+ "age": 25,
+ "friends": [
+ {
+ "name": "Jack",
+ "hobbies": [
+ "Music",
+ "Golf"
+ ]
+ },
+ {
+ "name": "Daniel",
+ "hobbies": [
+ "Socializing",
+ "Housework",
+ "Walking"
+ ]
+ },
+ {
+ "name": "Robert",
+ "hobbies": [
+ "Collecting",
+ "Walking"
+ ]
+ },
+ {
+ "name": "Nora",
+ "hobbies": [
+ "Painting",
+ "Church Activities"
+ ]
+ },
+ {
+ "name": "Mia",
+ "hobbies": [
+ "Running",
+ "Painting"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 8,
+ "name": "Emily",
+ "city": "Austin",
+ "age": 61,
+ "friends": [
+ {
+ "name": "Nora",
+ "hobbies": [
+ "Bicycling",
+ "Skiing & Snowboarding",
+ "Watching Sports"
+ ]
+ },
+ {
+ "name": "Ava",
+ "hobbies": [
+ "Writing",
+ "Reading",
+ "Collecting"
+ ]
+ },
+ {
+ "name": "Amelia",
+ "hobbies": [
+ "Eating Out",
+ "Watching Sports"
+ ]
+ },
+ {
+ "name": "Daniel",
+ "hobbies": [
+ "Skiing & Snowboarding",
+ "Martial Arts",
+ "Writing"
+ ]
+ },
+ {
+ "name": "Zoey",
+ "hobbies": [
+ "Board Games",
+ "Tennis"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 9,
+ "name": "Liam",
+ "city": "New Orleans",
+ "age": 33,
+ "friends": [
+ {
+ "name": "Chloe",
+ "hobbies": [
+ "Traveling",
+ "Bicycling",
+ "Shopping"
+ ]
+ },
+ {
+ "name": "Evy",
+ "hobbies": [
+ "Eating Out",
+ "Watching Sports"
+ ]
+ },
+ {
+ "name": "Grace",
+ "hobbies": [
+ "Jewelry Making",
+ "Yoga",
+ "Podcasts"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 10,
+ "name": "Levi",
+ "city": "New Orleans",
+ "age": 59,
+ "friends": [
+ {
+ "name": "Noah",
+ "hobbies": [
+ "Video Games",
+ "Fishing",
+ "Shopping"
+ ]
+ },
+ {
+ "name": "Sarah",
+ "hobbies": [
+ "Woodworking",
+ "Music",
+ "Reading"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 11,
+ "name": "Lucas",
+ "city": "Portland",
+ "age": 82,
+ "friends": [
+ {
+ "name": "Luke",
+ "hobbies": [
+ "Jewelry Making",
+ "Yoga"
+ ]
+ },
+ {
+ "name": "Noah",
+ "hobbies": [
+ "Fishing",
+ "Movie Watching"
+ ]
+ },
+ {
+ "name": "Evy",
+ "hobbies": [
+ "Gardening",
+ "Church Activities",
+ "Fishing"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 12,
+ "name": "Kevin",
+ "city": "Charleston",
+ "age": 82,
+ "friends": [
+ {
+ "name": "Oliver",
+ "hobbies": [
+ "Eating Out"
+ ]
+ },
+ {
+ "name": "Michael",
+ "hobbies": [
+ "Fishing",
+ "Writing"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 13,
+ "name": "Olivia",
+ "city": "San Antonio",
+ "age": 34,
+ "friends": [
+ {
+ "name": "Daniel",
+ "hobbies": [
+ "Yoga",
+ "Traveling",
+ "Movie Watching"
+ ]
+ },
+ {
+ "name": "Zoey",
+ "hobbies": [
+ "Team Sports",
+ "Writing"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 14,
+ "name": "Robert",
+ "city": "Los Angeles",
+ "age": 49,
+ "friends": [
+ {
+ "name": "Michelle",
+ "hobbies": [
+ "Yoga",
+ "Television"
+ ]
+ },
+ {
+ "name": "Daniel",
+ "hobbies": [
+ "Fishing",
+ "Martial Arts"
+ ]
+ },
+ {
+ "name": "Chloe",
+ "hobbies": [
+ "Church Activities",
+ "Television"
+ ]
+ },
+ {
+ "name": "Sarah",
+ "hobbies": [
+ "Movie Watching",
+ "Playing Cards"
+ ]
+ },
+ {
+ "name": "Kevin",
+ "hobbies": [
+ "Golf",
+ "Running",
+ "Cooking"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 15,
+ "name": "Grace",
+ "city": "Chicago",
+ "age": 98,
+ "friends": [
+ {
+ "name": "Joe",
+ "hobbies": [
+ "Traveling",
+ "Genealogy"
+ ]
+ },
+ {
+ "name": "Mateo",
+ "hobbies": [
+ "Golf",
+ "Podcasts"
+ ]
+ },
+ {
+ "name": "Mateo",
+ "hobbies": [
+ "Reading",
+ "Cooking"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 16,
+ "name": "Michael",
+ "city": "New Orleans",
+ "age": 78,
+ "friends": [
+ {
+ "name": "Amelia",
+ "hobbies": [
+ "Running",
+ "Housework",
+ "Gardening"
+ ]
+ },
+ {
+ "name": "Michael",
+ "hobbies": [
+ "Writing",
+ "Golf"
+ ]
+ },
+ {
+ "name": "Leo",
+ "hobbies": [
+ "Running",
+ "Church Activities"
+ ]
+ },
+ {
+ "name": "Elijah",
+ "hobbies": [
+ "Volunteer Work",
+ "Eating Out"
+ ]
+ },
+ {
+ "name": "Mateo",
+ "hobbies": [
+ "Socializing",
+ "Watching Sports",
+ "Collecting"
+ ]
+ },
+ {
+ "name": "Levi",
+ "hobbies": [
+ "Eating Out",
+ "Walking"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 17,
+ "name": "Mateo",
+ "city": "Palm Springs",
+ "age": 19,
+ "friends": [
+ {
+ "name": "Emily",
+ "hobbies": [
+ "Playing Cards",
+ "Walking"
+ ]
+ },
+ {
+ "name": "Sophie",
+ "hobbies": [
+ "Gardening",
+ "Board Games",
+ "Volunteer Work"
+ ]
+ },
+ {
+ "name": "Camila",
+ "hobbies": [
+ "Board Games",
+ "Dancing"
+ ]
+ },
+ {
+ "name": "John",
+ "hobbies": [
+ "Golf",
+ "Playing Cards",
+ "Music"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 18,
+ "name": "Levi",
+ "city": "Chicago",
+ "age": 38,
+ "friends": [
+ {
+ "name": "Emma",
+ "hobbies": [
+ "Tennis",
+ "Eating Out"
+ ]
+ },
+ {
+ "name": "Emma",
+ "hobbies": [
+ "Writing",
+ "Reading",
+ "Eating Out"
+ ]
+ },
+ {
+ "name": "Daniel",
+ "hobbies": [
+ "Collecting",
+ "Video Games"
+ ]
+ },
+ {
+ "name": "Evy",
+ "hobbies": [
+ "Shopping",
+ "Walking"
+ ]
+ },
+ {
+ "name": "Sophie",
+ "hobbies": [
+ "Dancing",
+ "Volunteer Work"
+ ]
+ },
+ {
+ "name": "Mia",
+ "hobbies": [
+ "Podcasts",
+ "Woodworking",
+ "Martial Arts"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 19,
+ "name": "Luke",
+ "city": "New York City",
+ "age": 49,
+ "friends": [
+ {
+ "name": "Leo",
+ "hobbies": [
+ "Writing",
+ "Playing Cards",
+ "Housework"
+ ]
+ },
+ {
+ "name": "Emma",
+ "hobbies": [
+ "Gardening",
+ "Running"
+ ]
+ },
+ {
+ "name": "Sarah",
+ "hobbies": [
+ "Golf",
+ "Music"
+ ]
+ },
+ {
+ "name": "Jack",
+ "hobbies": [
+ "Board Games",
+ "Socializing",
+ "Writing"
+ ]
+ },
+ {
+ "name": "Jack",
+ "hobbies": [
+ "Movie Watching",
+ "Writing",
+ "Fishing"
+ ]
+ },
+ {
+ "name": "Michael",
+ "hobbies": [
+ "Golf",
+ "Jewelry Making",
+ "Yoga"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 20,
+ "name": "Camila",
+ "city": "New Orleans",
+ "age": 69,
+ "friends": [
+ {
+ "name": "Kevin",
+ "hobbies": [
+ "Video Games",
+ "Collecting",
+ "Painting"
+ ]
+ },
+ {
+ "name": "Grace",
+ "hobbies": [
+ "Reading",
+ "Volunteer Work"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 21,
+ "name": "Amelia",
+ "city": "Charleston",
+ "age": 70,
+ "friends": [
+ {
+ "name": "John",
+ "hobbies": [
+ "Quilting",
+ "Volunteer Work"
+ ]
+ },
+ {
+ "name": "Leo",
+ "hobbies": [
+ "Painting",
+ "Podcasts"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 22,
+ "name": "Victoria",
+ "city": "Miami Beach",
+ "age": 50,
+ "friends": [
+ {
+ "name": "Mia",
+ "hobbies": [
+ "Cooking",
+ "Team Sports"
+ ]
+ },
+ {
+ "name": "Lucas",
+ "hobbies": [
+ "Team Sports",
+ "Genealogy"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 23,
+ "name": "Kevin",
+ "city": "Miami Beach",
+ "age": 93,
+ "friends": [
+ {
+ "name": "Jack",
+ "hobbies": [
+ "Bicycling",
+ "Fishing"
+ ]
+ },
+ {
+ "name": "Sophie",
+ "hobbies": [
+ "Martial Arts",
+ "Genealogy",
+ "Tennis"
+ ]
+ },
+ {
+ "name": "Chloe",
+ "hobbies": [
+ "Yoga"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 24,
+ "name": "Daniel",
+ "city": "Saint Augustine",
+ "age": 43,
+ "friends": [
+ {
+ "name": "Sarah",
+ "hobbies": [
+ "Calligraphy",
+ "Martial Arts",
+ "Music"
+ ]
+ },
+ {
+ "name": "Evy",
+ "hobbies": [
+ "Walking",
+ "Bicycling"
+ ]
+ },
+ {
+ "name": "Kevin",
+ "hobbies": [
+ "Collecting",
+ "Golf"
+ ]
+ },
+ {
+ "name": "Mia",
+ "hobbies": [
+ "Podcasts",
+ "Walking"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 25,
+ "name": "Olivia",
+ "city": "Austin",
+ "age": 46,
+ "friends": [
+ {
+ "name": "Mia",
+ "hobbies": [
+ "Podcasts",
+ "Housework"
+ ]
+ },
+ {
+ "name": "Robert",
+ "hobbies": [
+ "Golf",
+ "Volunteer Work"
+ ]
+ },
+ {
+ "name": "Michelle",
+ "hobbies": [
+ "Eating Out",
+ "Music"
+ ]
+ },
+ {
+ "name": "Elijah",
+ "hobbies": [
+ "Eating Out",
+ "Genealogy",
+ "Reading"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 26,
+ "name": "Michael",
+ "city": "Palm Springs",
+ "age": 62,
+ "friends": [
+ {
+ "name": "Sarah",
+ "hobbies": [
+ "Socializing",
+ "Playing Cards"
+ ]
+ },
+ {
+ "name": "Daniel",
+ "hobbies": [
+ "Playing Cards",
+ "Shopping",
+ "Collecting"
+ ]
+ },
+ {
+ "name": "Chloe",
+ "hobbies": [
+ "Music",
+ "Movie Watching"
+ ]
+ },
+ {
+ "name": "Zoey",
+ "hobbies": [
+ "Volunteer Work",
+ "Calligraphy",
+ "Jewelry Making"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 27,
+ "name": "Kevin",
+ "city": "San Antonio",
+ "age": 97,
+ "friends": [
+ {
+ "name": "Sarah",
+ "hobbies": [
+ "Television",
+ "Quilting",
+ "Team Sports"
+ ]
+ },
+ {
+ "name": "Oliver",
+ "hobbies": [
+ "Shopping",
+ "Martial Arts"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 28,
+ "name": "Oliver",
+ "city": "Honolulu",
+ "age": 79,
+ "friends": [
+ {
+ "name": "Charlotte",
+ "hobbies": [
+ "Housework",
+ "Jewelry Making"
+ ]
+ },
+ {
+ "name": "Isabella",
+ "hobbies": [
+ "Volunteer Work",
+ "Movie Watching"
+ ]
+ },
+ {
+ "name": "Ava",
+ "hobbies": [
+ "Traveling",
+ "Bicycling"
+ ]
+ },
+ {
+ "name": "Chris",
+ "hobbies": [
+ "Shopping",
+ "Church Activities",
+ "Dancing"
+ ]
+ },
+ {
+ "name": "Sarah",
+ "hobbies": [
+ "Reading",
+ "Movie Watching"
+ ]
+ },
+ {
+ "name": "Daniel",
+ "hobbies": [
+ "Socializing",
+ "Collecting",
+ "Cooking"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 29,
+ "name": "Levi",
+ "city": "Miami Beach",
+ "age": 46,
+ "friends": [
+ {
+ "name": "Ava",
+ "hobbies": [
+ "Housework",
+ "Video Games",
+ "Walking"
+ ]
+ },
+ {
+ "name": "Elijah",
+ "hobbies": [
+ "Golf",
+ "Volunteer Work",
+ "Painting"
+ ]
+ },
+ {
+ "name": "Lucas",
+ "hobbies": [
+ "Writing",
+ "Martial Arts",
+ "Television"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 30,
+ "name": "Michael",
+ "city": "Seattle",
+ "age": 18,
+ "friends": [
+ {
+ "name": "Oliver",
+ "hobbies": [
+ "Shopping",
+ "Woodworking"
+ ]
+ },
+ {
+ "name": "Emma",
+ "hobbies": [
+ "Yoga",
+ "Genealogy",
+ "Traveling"
+ ]
+ },
+ {
+ "name": "Evy",
+ "hobbies": [
+ "Eating Out",
+ "Church Activities",
+ "Calligraphy"
+ ]
+ },
+ {
+ "name": "Noah",
+ "hobbies": [
+ "Board Games",
+ "Television"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 31,
+ "name": "Isabella",
+ "city": "Savannah",
+ "age": 65,
+ "friends": [
+ {
+ "name": "Jack",
+ "hobbies": [
+ "Church Activities",
+ "Housework",
+ "Martial Arts"
+ ]
+ },
+ {
+ "name": "Oliver",
+ "hobbies": [
+ "Calligraphy",
+ "Cooking"
+ ]
+ },
+ {
+ "name": "Grace",
+ "hobbies": [
+ "Volunteer Work",
+ "Podcasts",
+ "Tennis"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 32,
+ "name": "Chris",
+ "city": "Las Vegas",
+ "age": 31,
+ "friends": [
+ {
+ "name": "Levi",
+ "hobbies": [
+ "Shopping",
+ "Fishing"
+ ]
+ },
+ {
+ "name": "Nora",
+ "hobbies": [
+ "Dancing",
+ "Quilting"
+ ]
+ },
+ {
+ "name": "Levi",
+ "hobbies": [
+ "Reading",
+ "Eating Out"
+ ]
+ },
+ {
+ "name": "Zoey",
+ "hobbies": [
+ "Traveling",
+ "Golf",
+ "Genealogy"
+ ]
+ },
+ {
+ "name": "Mia",
+ "hobbies": [
+ "Video Games",
+ "Shopping",
+ "Walking"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 33,
+ "name": "Kevin",
+ "city": "Portland",
+ "age": 51,
+ "friends": [
+ {
+ "name": "Olivia",
+ "hobbies": [
+ "Running",
+ "Calligraphy"
+ ]
+ },
+ {
+ "name": "Amelia",
+ "hobbies": [
+ "Tennis",
+ "Genealogy"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 34,
+ "name": "Sophie",
+ "city": "New York City",
+ "age": 25,
+ "friends": [
+ {
+ "name": "Levi",
+ "hobbies": [
+ "Video Games",
+ "Board Games",
+ "Podcasts"
+ ]
+ },
+ {
+ "name": "Joe",
+ "hobbies": [
+ "Calligraphy",
+ "Video Games",
+ "Martial Arts"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 35,
+ "name": "John",
+ "city": "Orlando",
+ "age": 67,
+ "friends": [
+ {
+ "name": "Nora",
+ "hobbies": [
+ "Podcasts",
+ "Skiing & Snowboarding",
+ "Quilting"
+ ]
+ },
+ {
+ "name": "Jack",
+ "hobbies": [
+ "Tennis",
+ "Socializing",
+ "Music"
+ ]
+ },
+ {
+ "name": "Camila",
+ "hobbies": [
+ "Walking",
+ "Church Activities",
+ "Quilting"
+ ]
+ },
+ {
+ "name": "Grace",
+ "hobbies": [
+ "Team Sports",
+ "Cooking"
+ ]
+ },
+ {
+ "name": "Isabella",
+ "hobbies": [
+ "Skiing & Snowboarding",
+ "Dancing",
+ "Painting"
+ ]
+ },
+ {
+ "name": "Ava",
+ "hobbies": [
+ "Tennis",
+ "Bicycling"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 36,
+ "name": "Emily",
+ "city": "New York City",
+ "age": 82,
+ "friends": [
+ {
+ "name": "Emma",
+ "hobbies": [
+ "Church Activities",
+ "Writing"
+ ]
+ },
+ {
+ "name": "Luke",
+ "hobbies": [
+ "Running",
+ "Calligraphy",
+ "Tennis"
+ ]
+ },
+ {
+ "name": "Robert",
+ "hobbies": [
+ "Dancing",
+ "Socializing"
+ ]
+ },
+ {
+ "name": "Amelia",
+ "hobbies": [
+ "Genealogy",
+ "Calligraphy",
+ "Tennis"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 37,
+ "name": "Amelia",
+ "city": "New Orleans",
+ "age": 28,
+ "friends": [
+ {
+ "name": "Victoria",
+ "hobbies": [
+ "Traveling",
+ "Skiing & Snowboarding"
+ ]
+ },
+ {
+ "name": "Luke",
+ "hobbies": [
+ "Martial Arts",
+ "Cooking",
+ "Dancing"
+ ]
+ },
+ {
+ "name": "Olivia",
+ "hobbies": [
+ "Bicycling",
+ "Walking",
+ "Podcasts"
+ ]
+ },
+ {
+ "name": "Elijah",
+ "hobbies": [
+ "Traveling",
+ "Volunteer Work",
+ "Collecting"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 38,
+ "name": "Victoria",
+ "city": "Austin",
+ "age": 71,
+ "friends": [
+ {
+ "name": "Noah",
+ "hobbies": [
+ "Yoga",
+ "Shopping"
+ ]
+ },
+ {
+ "name": "Evy",
+ "hobbies": [
+ "Eating Out",
+ "Writing",
+ "Shopping"
+ ]
+ },
+ {
+ "name": "Camila",
+ "hobbies": [
+ "Volunteer Work",
+ "Team Sports"
+ ]
+ },
+ {
+ "name": "Lucas",
+ "hobbies": [
+ "Volunteer Work",
+ "Board Games",
+ "Running"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 39,
+ "name": "Mia",
+ "city": "Honolulu",
+ "age": 63,
+ "friends": [
+ {
+ "name": "Sophie",
+ "hobbies": [
+ "Volunteer Work",
+ "Housework",
+ "Bicycling"
+ ]
+ },
+ {
+ "name": "Evy",
+ "hobbies": [
+ "Woodworking",
+ "Golf"
+ ]
+ },
+ {
+ "name": "Ava",
+ "hobbies": [
+ "Martial Arts",
+ "Skiing & Snowboarding",
+ "Dancing"
+ ]
+ },
+ {
+ "name": "Joe",
+ "hobbies": [
+ "Collecting",
+ "Watching Sports"
+ ]
+ },
+ {
+ "name": "Camila",
+ "hobbies": [
+ "Television",
+ "Socializing",
+ "Skiing & Snowboarding"
+ ]
+ },
+ {
+ "name": "Robert",
+ "hobbies": [
+ "Martial Arts",
+ "Woodworking",
+ "Reading"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 40,
+ "name": "Daniel",
+ "city": "Las Vegas",
+ "age": 50,
+ "friends": [
+ {
+ "name": "Kevin",
+ "hobbies": [
+ "Bicycling",
+ "Housework"
+ ]
+ },
+ {
+ "name": "Evy",
+ "hobbies": [
+ "Woodworking",
+ "Collecting"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 41,
+ "name": "Luke",
+ "city": "Nashville",
+ "age": 84,
+ "friends": [
+ {
+ "name": "Lucas",
+ "hobbies": [
+ "Fishing",
+ "Shopping"
+ ]
+ },
+ {
+ "name": "Victoria",
+ "hobbies": [
+ "Church Activities",
+ "Martial Arts",
+ "Television"
+ ]
+ },
+ {
+ "name": "Charlotte",
+ "hobbies": [
+ "Church Activities",
+ "Walking"
+ ]
+ },
+ {
+ "name": "Evy",
+ "hobbies": [
+ "Calligraphy",
+ "Writing"
+ ]
+ },
+ {
+ "name": "Liam",
+ "hobbies": [
+ "Movie Watching",
+ "Board Games"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 42,
+ "name": "Joe",
+ "city": "Orlando",
+ "age": 28,
+ "friends": [
+ {
+ "name": "Sophie",
+ "hobbies": [
+ "Board Games",
+ "Music"
+ ]
+ },
+ {
+ "name": "Camila",
+ "hobbies": [
+ "Woodworking",
+ "Yoga",
+ "Music"
+ ]
+ },
+ {
+ "name": "Jack",
+ "hobbies": [
+ "Team Sports",
+ "Bicycling"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 43,
+ "name": "Robert",
+ "city": "Boston",
+ "age": 89,
+ "friends": [
+ {
+ "name": "Mia",
+ "hobbies": [
+ "Team Sports",
+ "Church Activities",
+ "Martial Arts"
+ ]
+ },
+ {
+ "name": "Elijah",
+ "hobbies": [
+ "Housework",
+ "Collecting"
+ ]
+ },
+ {
+ "name": "Zoey",
+ "hobbies": [
+ "Watching Sports",
+ "Golf",
+ "Podcasts"
+ ]
+ },
+ {
+ "name": "Sarah",
+ "hobbies": [
+ "Volunteer Work",
+ "Team Sports"
+ ]
+ },
+ {
+ "name": "Chloe",
+ "hobbies": [
+ "Yoga",
+ "Walking"
+ ]
+ },
+ {
+ "name": "Mateo",
+ "hobbies": [
+ "Running",
+ "Painting",
+ "Television"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 44,
+ "name": "Mateo",
+ "city": "Palm Springs",
+ "age": 75,
+ "friends": [
+ {
+ "name": "Sarah",
+ "hobbies": [
+ "Socializing",
+ "Walking",
+ "Painting"
+ ]
+ },
+ {
+ "name": "Sophie",
+ "hobbies": [
+ "Skiing & Snowboarding",
+ "Bicycling",
+ "Eating Out"
+ ]
+ },
+ {
+ "name": "Zoey",
+ "hobbies": [
+ "Podcasts",
+ "Socializing",
+ "Calligraphy"
+ ]
+ },
+ {
+ "name": "Olivia",
+ "hobbies": [
+ "Dancing",
+ "Volunteer Work"
+ ]
+ },
+ {
+ "name": "Mia",
+ "hobbies": [
+ "Watching Sports",
+ "Yoga",
+ "Martial Arts"
+ ]
+ },
+ {
+ "name": "Mateo",
+ "hobbies": [
+ "Housework",
+ "Genealogy"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 45,
+ "name": "Michelle",
+ "city": "Portland",
+ "age": 64,
+ "friends": [
+ {
+ "name": "Ava",
+ "hobbies": [
+ "Watching Sports",
+ "Shopping"
+ ]
+ },
+ {
+ "name": "John",
+ "hobbies": [
+ "Martial Arts",
+ "Video Games",
+ "Fishing"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 46,
+ "name": "Emma",
+ "city": "Portland",
+ "age": 47,
+ "friends": [
+ {
+ "name": "Zoey",
+ "hobbies": [
+ "Yoga",
+ "Music",
+ "Bicycling"
+ ]
+ },
+ {
+ "name": "Olivia",
+ "hobbies": [
+ "Traveling",
+ "Movie Watching",
+ "Gardening"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 47,
+ "name": "Elijah",
+ "city": "Chicago",
+ "age": 96,
+ "friends": [
+ {
+ "name": "Kevin",
+ "hobbies": [
+ "Video Games",
+ "Watching Sports",
+ "Eating Out"
+ ]
+ },
+ {
+ "name": "Kevin",
+ "hobbies": [
+ "Housework",
+ "Tennis",
+ "Playing Cards"
+ ]
+ },
+ {
+ "name": "Liam",
+ "hobbies": [
+ "Cooking"
+ ]
+ },
+ {
+ "name": "Kevin",
+ "hobbies": [
+ "Genealogy",
+ "Housework"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 48,
+ "name": "Elijah",
+ "city": "Seattle",
+ "age": 30,
+ "friends": [
+ {
+ "name": "Kevin",
+ "hobbies": [
+ "Socializing",
+ "Eating Out"
+ ]
+ },
+ {
+ "name": "Olivia",
+ "hobbies": [
+ "Martial Arts",
+ "Golf",
+ "Cooking"
+ ]
+ },
+ {
+ "name": "Daniel",
+ "hobbies": [
+ "Gardening",
+ "Bicycling",
+ "Television"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 49,
+ "name": "Sophie",
+ "city": "Palm Springs",
+ "age": 84,
+ "friends": [
+ {
+ "name": "Victoria",
+ "hobbies": [
+ "Podcasts",
+ "Martial Arts"
+ ]
+ },
+ {
+ "name": "Nora",
+ "hobbies": [
+ "Volunteer Work",
+ "Bicycling",
+ "Reading"
+ ]
+ },
+ {
+ "name": "Noah",
+ "hobbies": [
+ "Television",
+ "Watching Sports",
+ "Traveling"
+ ]
+ },
+ {
+ "name": "Victoria",
+ "hobbies": [
+ "Bicycling",
+ "Woodworking",
+ "Tennis"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 50,
+ "name": "Sophie",
+ "city": "Chicago",
+ "age": 52,
+ "friends": [
+ {
+ "name": "Chris",
+ "hobbies": [
+ "Collecting",
+ "Dancing",
+ "Cooking"
+ ]
+ },
+ {
+ "name": "Emma",
+ "hobbies": [
+ "Watching Sports",
+ "Dancing",
+ "Tennis"
+ ]
+ },
+ {
+ "name": "Joe",
+ "hobbies": [
+ "Board Games",
+ "Skiing & Snowboarding"
+ ]
+ },
+ {
+ "name": "Jack",
+ "hobbies": [
+ "Calligraphy",
+ "Running"
+ ]
+ },
+ {
+ "name": "John",
+ "hobbies": [
+ "Quilting",
+ "Golf",
+ "Gardening"
+ ]
+ },
+ {
+ "name": "John",
+ "hobbies": [
+ "Watching Sports",
+ "Jewelry Making"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 51,
+ "name": "Nora",
+ "city": "Lahaina",
+ "age": 79,
+ "friends": [
+ {
+ "name": "Elijah",
+ "hobbies": [
+ "Skiing & Snowboarding",
+ "Martial Arts"
+ ]
+ },
+ {
+ "name": "Kevin",
+ "hobbies": [
+ "Volunteer Work",
+ "Running",
+ "Tennis"
+ ]
+ },
+ {
+ "name": "Michael",
+ "hobbies": [
+ "Skiing & Snowboarding",
+ "Quilting",
+ "Fishing"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 52,
+ "name": "Chris",
+ "city": "Miami Beach",
+ "age": 59,
+ "friends": [
+ {
+ "name": "Amelia",
+ "hobbies": [
+ "Video Games",
+ "Traveling",
+ "Cooking"
+ ]
+ },
+ {
+ "name": "Kevin",
+ "hobbies": [
+ "Shopping",
+ "Calligraphy"
+ ]
+ },
+ {
+ "name": "Luke",
+ "hobbies": [
+ "Playing Cards",
+ "Housework"
+ ]
+ },
+ {
+ "name": "Chloe",
+ "hobbies": [
+ "Painting",
+ "Housework",
+ "Shopping"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 53,
+ "name": "Kevin",
+ "city": "Boston",
+ "age": 88,
+ "friends": [
+ {
+ "name": "Zoey",
+ "hobbies": [
+ "Dancing"
+ ]
+ },
+ {
+ "name": "Liam",
+ "hobbies": [
+ "Traveling",
+ "Martial Arts"
+ ]
+ },
+ {
+ "name": "Robert",
+ "hobbies": [
+ "Woodworking",
+ "Collecting"
+ ]
+ },
+ {
+ "name": "Elijah",
+ "hobbies": [
+ "Collecting",
+ "Running"
+ ]
+ },
+ {
+ "name": "Daniel",
+ "hobbies": [
+ "Dancing",
+ "Traveling"
+ ]
+ },
+ {
+ "name": "Emily",
+ "hobbies": [
+ "Fishing",
+ "Quilting",
+ "Team Sports"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 54,
+ "name": "Grace",
+ "city": "Miami Beach",
+ "age": 62,
+ "friends": [
+ {
+ "name": "Joe",
+ "hobbies": [
+ "Church Activities",
+ "Music"
+ ]
+ },
+ {
+ "name": "Emily",
+ "hobbies": [
+ "Genealogy",
+ "Watching Sports",
+ "Woodworking"
+ ]
+ },
+ {
+ "name": "Chris",
+ "hobbies": [
+ "Team Sports",
+ "Skiing & Snowboarding"
+ ]
+ },
+ {
+ "name": "Grace",
+ "hobbies": [
+ "Yoga",
+ "Music",
+ "Running"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 55,
+ "name": "Chloe",
+ "city": "Lahaina",
+ "age": 97,
+ "friends": [
+ {
+ "name": "Emily",
+ "hobbies": [
+ "Genealogy",
+ "Team Sports",
+ "Skiing & Snowboarding"
+ ]
+ },
+ {
+ "name": "Joe",
+ "hobbies": [
+ "Movie Watching",
+ "Television"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 56,
+ "name": "Zoey",
+ "city": "Saint Augustine",
+ "age": 75,
+ "friends": [
+ {
+ "name": "Luke",
+ "hobbies": [
+ "Bicycling",
+ "Martial Arts"
+ ]
+ },
+ {
+ "name": "Emma",
+ "hobbies": [
+ "Music",
+ "Cooking"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 57,
+ "name": "Sophie",
+ "city": "Boston",
+ "age": 26,
+ "friends": [
+ {
+ "name": "Levi",
+ "hobbies": [
+ "Writing",
+ "Yoga",
+ "Movie Watching"
+ ]
+ },
+ {
+ "name": "Noah",
+ "hobbies": [
+ "Board Games",
+ "Martial Arts",
+ "Shopping"
+ ]
+ },
+ {
+ "name": "Camila",
+ "hobbies": [
+ "Jewelry Making",
+ "Skiing & Snowboarding",
+ "Fishing"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 58,
+ "name": "Emma",
+ "city": "Seattle",
+ "age": 40,
+ "friends": [
+ {
+ "name": "Victoria",
+ "hobbies": [
+ "Traveling",
+ "Bicycling"
+ ]
+ },
+ {
+ "name": "Michelle",
+ "hobbies": [
+ "Skiing & Snowboarding",
+ "Bicycling",
+ "Watching Sports"
+ ]
+ },
+ {
+ "name": "Michael",
+ "hobbies": [
+ "Board Games",
+ "Watching Sports"
+ ]
+ },
+ {
+ "name": "Daniel",
+ "hobbies": [
+ "Yoga",
+ "Shopping"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 59,
+ "name": "Luke",
+ "city": "San Diego",
+ "age": 44,
+ "friends": [
+ {
+ "name": "Mia",
+ "hobbies": [
+ "Calligraphy",
+ "Writing"
+ ]
+ },
+ {
+ "name": "Michelle",
+ "hobbies": [
+ "Podcasts",
+ "Movie Watching",
+ "Playing Cards"
+ ]
+ },
+ {
+ "name": "Charlotte",
+ "hobbies": [
+ "Bicycling",
+ "Golf",
+ "Walking"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 60,
+ "name": "Chloe",
+ "city": "Austin",
+ "age": 23,
+ "friends": [
+ {
+ "name": "Camila",
+ "hobbies": [
+ "Martial Arts",
+ "Golf"
+ ]
+ },
+ {
+ "name": "Sarah",
+ "hobbies": [
+ "Writing",
+ "Martial Arts",
+ "Jewelry Making"
+ ]
+ },
+ {
+ "name": "Amelia",
+ "hobbies": [
+ "Video Games",
+ "Bicycling",
+ "Eating Out"
+ ]
+ },
+ {
+ "name": "Sophie",
+ "hobbies": [
+ "Socializing",
+ "Collecting",
+ "Traveling"
+ ]
+ },
+ {
+ "name": "Olivia",
+ "hobbies": [
+ "Team Sports",
+ "Woodworking",
+ "Collecting"
+ ]
+ },
+ {
+ "name": "Elijah",
+ "hobbies": [
+ "Yoga",
+ "Music",
+ "Skiing & Snowboarding"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 61,
+ "name": "Nora",
+ "city": "Orlando",
+ "age": 83,
+ "friends": [
+ {
+ "name": "Zoey",
+ "hobbies": [
+ "Board Games",
+ "Woodworking"
+ ]
+ },
+ {
+ "name": "Emma",
+ "hobbies": [
+ "Board Games",
+ "Traveling"
+ ]
+ },
+ {
+ "name": "Nora",
+ "hobbies": [
+ "Bicycling",
+ "Golf"
+ ]
+ },
+ {
+ "name": "Leo",
+ "hobbies": [
+ "Church Activities",
+ "Golf",
+ "Socializing"
+ ]
+ },
+ {
+ "name": "Oliver",
+ "hobbies": [
+ "Running",
+ "Dancing"
+ ]
+ },
+ {
+ "name": "Amelia",
+ "hobbies": [
+ "Board Games",
+ "Volunteer Work"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 62,
+ "name": "Kevin",
+ "city": "Saint Augustine",
+ "age": 76,
+ "friends": [
+ {
+ "name": "Lucas",
+ "hobbies": [
+ "Playing Cards",
+ "Skiing & Snowboarding"
+ ]
+ },
+ {
+ "name": "Grace",
+ "hobbies": [
+ "Movie Watching",
+ "Calligraphy",
+ "Socializing"
+ ]
+ },
+ {
+ "name": "Ava",
+ "hobbies": [
+ "Podcasts",
+ "Yoga",
+ "Quilting"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 63,
+ "name": "Amelia",
+ "city": "Honolulu",
+ "age": 84,
+ "friends": [
+ {
+ "name": "Grace",
+ "hobbies": [
+ "Golf",
+ "Reading"
+ ]
+ },
+ {
+ "name": "Luke",
+ "hobbies": [
+ "Genealogy",
+ "Martial Arts"
+ ]
+ },
+ {
+ "name": "Lucas",
+ "hobbies": [
+ "Gardening",
+ "Music"
+ ]
+ },
+ {
+ "name": "Isabella",
+ "hobbies": [
+ "Board Games",
+ "Music"
+ ]
+ },
+ {
+ "name": "Noah",
+ "hobbies": [
+ "Cooking",
+ "Eating Out",
+ "Quilting"
+ ]
+ },
+ {
+ "name": "Levi",
+ "hobbies": [
+ "Movie Watching",
+ "Church Activities",
+ "Shopping"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 64,
+ "name": "Joe",
+ "city": "San Francisco",
+ "age": 37,
+ "friends": [
+ {
+ "name": "Michelle",
+ "hobbies": [
+ "Skiing & Snowboarding",
+ "Dancing"
+ ]
+ },
+ {
+ "name": "John",
+ "hobbies": [
+ "Running",
+ "Podcasts",
+ "Woodworking"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 65,
+ "name": "Chloe",
+ "city": "Palm Springs",
+ "age": 60,
+ "friends": [
+ {
+ "name": "Lucas",
+ "hobbies": [
+ "Movie Watching",
+ "Walking"
+ ]
+ },
+ {
+ "name": "Grace",
+ "hobbies": [
+ "Volunteer Work",
+ "Socializing"
+ ]
+ },
+ {
+ "name": "Daniel",
+ "hobbies": [
+ "Church Activities",
+ "Gardening"
+ ]
+ },
+ {
+ "name": "Michael",
+ "hobbies": [
+ "Walking",
+ "Team Sports",
+ "Martial Arts"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 66,
+ "name": "Leo",
+ "city": "New Orleans",
+ "age": 97,
+ "friends": [
+ {
+ "name": "Ava",
+ "hobbies": [
+ "Martial Arts",
+ "Woodworking",
+ "Quilting"
+ ]
+ },
+ {
+ "name": "Chloe",
+ "hobbies": [
+ "Fishing",
+ "Genealogy",
+ "Writing"
+ ]
+ },
+ {
+ "name": "Nora",
+ "hobbies": [
+ "Traveling",
+ "Woodworking"
+ ]
+ },
+ {
+ "name": "Victoria",
+ "hobbies": [
+ "Church Activities",
+ "Cooking"
+ ]
+ },
+ {
+ "name": "Camila",
+ "hobbies": [
+ "Video Games",
+ "Housework"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 67,
+ "name": "Robert",
+ "city": "Austin",
+ "age": 19,
+ "friends": [
+ {
+ "name": "Joe",
+ "hobbies": [
+ "Writing",
+ "Yoga"
+ ]
+ },
+ {
+ "name": "Emma",
+ "hobbies": [
+ "Writing",
+ "Socializing"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 68,
+ "name": "Robert",
+ "city": "Orlando",
+ "age": 65,
+ "friends": [
+ {
+ "name": "Mateo",
+ "hobbies": [
+ "Board Games",
+ "Cooking"
+ ]
+ },
+ {
+ "name": "Noah",
+ "hobbies": [
+ "Collecting",
+ "Housework",
+ "Skiing & Snowboarding"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 69,
+ "name": "Mateo",
+ "city": "New Orleans",
+ "age": 95,
+ "friends": [
+ {
+ "name": "Chloe",
+ "hobbies": [
+ "Painting",
+ "Eating Out",
+ "Walking"
+ ]
+ },
+ {
+ "name": "Nora",
+ "hobbies": [
+ "Bicycling",
+ "Jewelry Making",
+ "Woodworking"
+ ]
+ },
+ {
+ "name": "Jack",
+ "hobbies": [
+ "Cooking",
+ "Gardening"
+ ]
+ },
+ {
+ "name": "Liam",
+ "hobbies": [
+ "Reading",
+ "Collecting",
+ "Podcasts"
+ ]
+ },
+ {
+ "name": "Noah",
+ "hobbies": [
+ "Housework",
+ "Team Sports"
+ ]
+ },
+ {
+ "name": "Emily",
+ "hobbies": [
+ "Dancing",
+ "Yoga"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 70,
+ "name": "Jack",
+ "city": "Boston",
+ "age": 76,
+ "friends": [
+ {
+ "name": "Ava",
+ "hobbies": [
+ "Martial Arts",
+ "Volunteer Work",
+ "Team Sports"
+ ]
+ },
+ {
+ "name": "Kevin",
+ "hobbies": [
+ "Traveling",
+ "Bicycling"
+ ]
+ },
+ {
+ "name": "Lucas",
+ "hobbies": [
+ "Podcasts",
+ "Jewelry Making",
+ "Dancing"
+ ]
+ },
+ {
+ "name": "Michelle",
+ "hobbies": [
+ "Gardening",
+ "Shopping",
+ "Genealogy"
+ ]
+ },
+ {
+ "name": "Michelle",
+ "hobbies": [
+ "Writing",
+ "Tennis"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 71,
+ "name": "Liam",
+ "city": "Savannah",
+ "age": 37,
+ "friends": [
+ {
+ "name": "Michelle",
+ "hobbies": [
+ "Painting",
+ "Volunteer Work"
+ ]
+ },
+ {
+ "name": "Kevin",
+ "hobbies": [
+ "Dancing",
+ "Fishing"
+ ]
+ },
+ {
+ "name": "Olivia",
+ "hobbies": [
+ "Television",
+ "Running"
+ ]
+ },
+ {
+ "name": "Robert",
+ "hobbies": [
+ "Fishing",
+ "Eating Out"
+ ]
+ },
+ {
+ "name": "John",
+ "hobbies": [
+ "Skiing & Snowboarding"
+ ]
+ },
+ {
+ "name": "Chloe",
+ "hobbies": [
+ "Church Activities",
+ "Calligraphy",
+ "Writing"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 72,
+ "name": "Daniel",
+ "city": "Los Angeles",
+ "age": 63,
+ "friends": [
+ {
+ "name": "Evy",
+ "hobbies": [
+ "Television",
+ "Dancing"
+ ]
+ },
+ {
+ "name": "Kevin",
+ "hobbies": [
+ "Walking",
+ "Socializing",
+ "Writing"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 73,
+ "name": "Olivia",
+ "city": "Boston",
+ "age": 89,
+ "friends": [
+ {
+ "name": "Ava",
+ "hobbies": [
+ "Fishing",
+ "Playing Cards"
+ ]
+ },
+ {
+ "name": "Noah",
+ "hobbies": [
+ "Movie Watching",
+ "Board Games"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 74,
+ "name": "Amelia",
+ "city": "Orlando",
+ "age": 40,
+ "friends": [
+ {
+ "name": "Kevin",
+ "hobbies": [
+ "Golf",
+ "Reading",
+ "Shopping"
+ ]
+ },
+ {
+ "name": "Liam",
+ "hobbies": [
+ "Writing",
+ "Woodworking"
+ ]
+ },
+ {
+ "name": "Amelia",
+ "hobbies": [
+ "Movie Watching",
+ "Music"
+ ]
+ },
+ {
+ "name": "Grace",
+ "hobbies": [
+ "Jewelry Making",
+ "Bicycling"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 75,
+ "name": "Camila",
+ "city": "New Orleans",
+ "age": 65,
+ "friends": [
+ {
+ "name": "Mateo",
+ "hobbies": [
+ "Yoga",
+ "Reading",
+ "Team Sports"
+ ]
+ },
+ {
+ "name": "Mateo",
+ "hobbies": [
+ "Board Games",
+ "Shopping"
+ ]
+ },
+ {
+ "name": "Leo",
+ "hobbies": [
+ "Woodworking",
+ "Martial Arts"
+ ]
+ },
+ {
+ "name": "Jack",
+ "hobbies": [
+ "Television",
+ "Calligraphy",
+ "Playing Cards"
+ ]
+ },
+ {
+ "name": "Liam",
+ "hobbies": [
+ "Fishing",
+ "Martial Arts"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 76,
+ "name": "Jack",
+ "city": "Orlando",
+ "age": 42,
+ "friends": [
+ {
+ "name": "Daniel",
+ "hobbies": [
+ "Podcasts",
+ "Collecting"
+ ]
+ },
+ {
+ "name": "Robert",
+ "hobbies": [
+ "Running",
+ "Shopping",
+ "Quilting"
+ ]
+ },
+ {
+ "name": "Chris",
+ "hobbies": [
+ "Martial Arts",
+ "Golf",
+ "Quilting"
+ ]
+ },
+ {
+ "name": "Amelia",
+ "hobbies": [
+ "Eating Out",
+ "Bicycling",
+ "Golf"
+ ]
+ },
+ {
+ "name": "Olivia",
+ "hobbies": [
+ "Skiing & Snowboarding",
+ "Church Activities"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 77,
+ "name": "Leo",
+ "city": "Lahaina",
+ "age": 46,
+ "friends": [
+ {
+ "name": "Robert",
+ "hobbies": [
+ "Traveling",
+ "Watching Sports"
+ ]
+ },
+ {
+ "name": "Daniel",
+ "hobbies": [
+ "Video Games",
+ "Music"
+ ]
+ },
+ {
+ "name": "Michael",
+ "hobbies": [
+ "Video Games",
+ "Gardening"
+ ]
+ },
+ {
+ "name": "Emma",
+ "hobbies": [
+ "Painting",
+ "Television"
+ ]
+ },
+ {
+ "name": "Sarah",
+ "hobbies": [
+ "Dancing",
+ "Tennis"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 78,
+ "name": "Kevin",
+ "city": "San Antonio",
+ "age": 19,
+ "friends": [
+ {
+ "name": "Leo",
+ "hobbies": [
+ "Traveling",
+ "Television"
+ ]
+ },
+ {
+ "name": "Victoria",
+ "hobbies": [
+ "Fishing",
+ "Collecting",
+ "Gardening"
+ ]
+ },
+ {
+ "name": "Mia",
+ "hobbies": [
+ "Skiing & Snowboarding",
+ "Watching Sports",
+ "Martial Arts"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 79,
+ "name": "Leo",
+ "city": "Sedona",
+ "age": 56,
+ "friends": [
+ {
+ "name": "Mateo",
+ "hobbies": [
+ "Board Games",
+ "Reading"
+ ]
+ },
+ {
+ "name": "Grace",
+ "hobbies": [
+ "Reading",
+ "Fishing",
+ "Woodworking"
+ ]
+ },
+ {
+ "name": "Mia",
+ "hobbies": [
+ "Gardening",
+ "Woodworking"
+ ]
+ },
+ {
+ "name": "Noah",
+ "hobbies": [
+ "Video Games",
+ "Television",
+ "Eating Out"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 80,
+ "name": "Charlotte",
+ "city": "Orlando",
+ "age": 73,
+ "friends": [
+ {
+ "name": "Camila",
+ "hobbies": [
+ "Golf",
+ "Collecting"
+ ]
+ },
+ {
+ "name": "Evy",
+ "hobbies": [
+ "Shopping",
+ "Yoga",
+ "Genealogy"
+ ]
+ },
+ {
+ "name": "Charlotte",
+ "hobbies": [
+ "Yoga",
+ "Volunteer Work"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 81,
+ "name": "Robert",
+ "city": "Chicago",
+ "age": 52,
+ "friends": [
+ {
+ "name": "Noah",
+ "hobbies": [
+ "Church Activities",
+ "Woodworking",
+ "Traveling"
+ ]
+ },
+ {
+ "name": "Liam",
+ "hobbies": [
+ "Board Games",
+ "Socializing"
+ ]
+ },
+ {
+ "name": "Liam",
+ "hobbies": [
+ "Housework",
+ "Music",
+ "Calligraphy"
+ ]
+ },
+ {
+ "name": "Zoey",
+ "hobbies": [
+ "Shopping",
+ "Fishing",
+ "Walking"
+ ]
+ },
+ {
+ "name": "Grace",
+ "hobbies": [
+ "Dancing",
+ "Yoga"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 82,
+ "name": "Kevin",
+ "city": "Palm Springs",
+ "age": 75,
+ "friends": [
+ {
+ "name": "Oliver",
+ "hobbies": [
+ "Running",
+ "Traveling"
+ ]
+ },
+ {
+ "name": "Luke",
+ "hobbies": [
+ "Socializing",
+ "Martial Arts",
+ "Running"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 83,
+ "name": "Evy",
+ "city": "Palm Springs",
+ "age": 51,
+ "friends": [
+ {
+ "name": "Michael",
+ "hobbies": [
+ "Writing",
+ "Podcasts"
+ ]
+ },
+ {
+ "name": "Noah",
+ "hobbies": [
+ "Yoga",
+ "Quilting",
+ "Fishing"
+ ]
+ },
+ {
+ "name": "Sophie",
+ "hobbies": [
+ "Painting"
+ ]
+ },
+ {
+ "name": "Olivia",
+ "hobbies": [
+ "Martial Arts",
+ "Shopping",
+ "Podcasts"
+ ]
+ },
+ {
+ "name": "Camila",
+ "hobbies": [
+ "Reading",
+ "Collecting"
+ ]
+ },
+ {
+ "name": "Noah",
+ "hobbies": [
+ "Socializing",
+ "Housework"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 84,
+ "name": "Daniel",
+ "city": "Saint Augustine",
+ "age": 57,
+ "friends": [
+ {
+ "name": "Emily",
+ "hobbies": [
+ "Walking",
+ "Painting",
+ "Reading"
+ ]
+ },
+ {
+ "name": "Oliver",
+ "hobbies": [
+ "Team Sports",
+ "Board Games"
+ ]
+ },
+ {
+ "name": "Levi",
+ "hobbies": [
+ "Jewelry Making",
+ "Eating Out",
+ "Volunteer Work"
+ ]
+ },
+ {
+ "name": "Zoey",
+ "hobbies": [
+ "Movie Watching",
+ "Video Games"
+ ]
+ },
+ {
+ "name": "Sophie",
+ "hobbies": [
+ "Watching Sports",
+ "Walking",
+ "Martial Arts"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 85,
+ "name": "Olivia",
+ "city": "Charleston",
+ "age": 63,
+ "friends": [
+ {
+ "name": "Oliver",
+ "hobbies": [
+ "Reading",
+ "Playing Cards"
+ ]
+ },
+ {
+ "name": "Mia",
+ "hobbies": [
+ "Running",
+ "Shopping"
+ ]
+ },
+ {
+ "name": "John",
+ "hobbies": [
+ "Writing",
+ "Walking",
+ "Tennis"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 86,
+ "name": "Amelia",
+ "city": "Seattle",
+ "age": 96,
+ "friends": [
+ {
+ "name": "Daniel",
+ "hobbies": [
+ "Dancing",
+ "Eating Out"
+ ]
+ },
+ {
+ "name": "Levi",
+ "hobbies": [
+ "Bicycling",
+ "Dancing"
+ ]
+ },
+ {
+ "name": "Daniel",
+ "hobbies": [
+ "Writing",
+ "Shopping",
+ "Tennis"
+ ]
+ },
+ {
+ "name": "Michelle",
+ "hobbies": [
+ "Board Games",
+ "Walking",
+ "Housework"
+ ]
+ },
+ {
+ "name": "Chloe",
+ "hobbies": [
+ "Genealogy",
+ "Dancing",
+ "Podcasts"
+ ]
+ },
+ {
+ "name": "Joe",
+ "hobbies": [
+ "Movie Watching",
+ "Cooking",
+ "Housework"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 87,
+ "name": "Luke",
+ "city": "Seattle",
+ "age": 26,
+ "friends": [
+ {
+ "name": "Isabella",
+ "hobbies": [
+ "Traveling",
+ "Walking",
+ "Team Sports"
+ ]
+ },
+ {
+ "name": "Amelia",
+ "hobbies": [
+ "Writing",
+ "Housework",
+ "Volunteer Work"
+ ]
+ },
+ {
+ "name": "Elijah",
+ "hobbies": [
+ "Golf",
+ "Yoga"
+ ]
+ },
+ {
+ "name": "Levi",
+ "hobbies": [
+ "Volunteer Work",
+ "Eating Out"
+ ]
+ },
+ {
+ "name": "Kevin",
+ "hobbies": [
+ "Yoga",
+ "Genealogy",
+ "Volunteer Work"
+ ]
+ },
+ {
+ "name": "Levi",
+ "hobbies": [
+ "Tennis",
+ "Television"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 88,
+ "name": "Chris",
+ "city": "Nashville",
+ "age": 34,
+ "friends": [
+ {
+ "name": "Kevin",
+ "hobbies": [
+ "Podcasts",
+ "Team Sports",
+ "Traveling"
+ ]
+ },
+ {
+ "name": "Elijah",
+ "hobbies": [
+ "Television",
+ "Woodworking",
+ "Cooking"
+ ]
+ },
+ {
+ "name": "Evy",
+ "hobbies": [
+ "Podcasts",
+ "Genealogy",
+ "Calligraphy"
+ ]
+ },
+ {
+ "name": "Victoria",
+ "hobbies": [
+ "Fishing",
+ "Church Activities",
+ "Collecting"
+ ]
+ },
+ {
+ "name": "Camila",
+ "hobbies": [
+ "Television",
+ "Writing"
+ ]
+ },
+ {
+ "name": "Michelle",
+ "hobbies": [
+ "Yoga",
+ "Running"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 89,
+ "name": "Michelle",
+ "city": "Honolulu",
+ "age": 85,
+ "friends": [
+ {
+ "name": "Isabella",
+ "hobbies": [
+ "Calligraphy",
+ "Gardening"
+ ]
+ },
+ {
+ "name": "Chloe",
+ "hobbies": [
+ "Shopping",
+ "Playing Cards",
+ "Tennis"
+ ]
+ },
+ {
+ "name": "Evy",
+ "hobbies": [
+ "Watching Sports",
+ "Cooking",
+ "Golf"
+ ]
+ },
+ {
+ "name": "Elijah",
+ "hobbies": [
+ "Writing",
+ "Tennis",
+ "Playing Cards"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 90,
+ "name": "Lucas",
+ "city": "Los Angeles",
+ "age": 78,
+ "friends": [
+ {
+ "name": "Emma",
+ "hobbies": [
+ "Woodworking",
+ "Painting",
+ "Television"
+ ]
+ },
+ {
+ "name": "Lucas",
+ "hobbies": [
+ "Bicycling",
+ "Volunteer Work"
+ ]
+ },
+ {
+ "name": "Grace",
+ "hobbies": [
+ "Dancing",
+ "Running"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 91,
+ "name": "Sophie",
+ "city": "St. Louis",
+ "age": 86,
+ "friends": [
+ {
+ "name": "Joe",
+ "hobbies": [
+ "Socializing",
+ "Music"
+ ]
+ },
+ {
+ "name": "Zoey",
+ "hobbies": [
+ "Running",
+ "Playing Cards"
+ ]
+ },
+ {
+ "name": "Elijah",
+ "hobbies": [
+ "Dancing"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 92,
+ "name": "Victoria",
+ "city": "Saint Augustine",
+ "age": 33,
+ "friends": [
+ {
+ "name": "Leo",
+ "hobbies": [
+ "Socializing",
+ "Fishing"
+ ]
+ },
+ {
+ "name": "Emily",
+ "hobbies": [
+ "Video Games",
+ "Watching Sports"
+ ]
+ },
+ {
+ "name": "Luke",
+ "hobbies": [
+ "Martial Arts"
+ ]
+ },
+ {
+ "name": "Oliver",
+ "hobbies": [
+ "Traveling",
+ "Quilting",
+ "Television"
+ ]
+ },
+ {
+ "name": "Charlotte",
+ "hobbies": [
+ "Gardening",
+ "Cooking",
+ "Housework"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 93,
+ "name": "Michael",
+ "city": "New Orleans",
+ "age": 82,
+ "friends": [
+ {
+ "name": "Jack",
+ "hobbies": [
+ "Bicycling",
+ "Board Games",
+ "Movie Watching"
+ ]
+ },
+ {
+ "name": "Liam",
+ "hobbies": [
+ "Painting",
+ "Writing",
+ "Bicycling"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 94,
+ "name": "Michael",
+ "city": "Seattle",
+ "age": 49,
+ "friends": [
+ {
+ "name": "John",
+ "hobbies": [
+ "Collecting",
+ "Playing Cards",
+ "Cooking"
+ ]
+ },
+ {
+ "name": "Sarah",
+ "hobbies": [
+ "Fishing",
+ "Walking",
+ "Movie Watching"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 95,
+ "name": "Victoria",
+ "city": "Branson",
+ "age": 48,
+ "friends": [
+ {
+ "name": "Amelia",
+ "hobbies": [
+ "Painting",
+ "Volunteer Work",
+ "Socializing"
+ ]
+ },
+ {
+ "name": "Evy",
+ "hobbies": [
+ "Skiing & Snowboarding",
+ "Volunteer Work"
+ ]
+ },
+ {
+ "name": "Amelia",
+ "hobbies": [
+ "Genealogy",
+ "Reading",
+ "Yoga"
+ ]
+ },
+ {
+ "name": "Sophie",
+ "hobbies": [
+ "Movie Watching",
+ "Golf",
+ "Television"
+ ]
+ },
+ {
+ "name": "Charlotte",
+ "hobbies": [
+ "Jewelry Making",
+ "Quilting",
+ "Playing Cards"
+ ]
+ },
+ {
+ "name": "Jack",
+ "hobbies": [
+ "Playing Cards",
+ "Golf"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 96,
+ "name": "Grace",
+ "city": "Seattle",
+ "age": 89,
+ "friends": [
+ {
+ "name": "Chris",
+ "hobbies": [
+ "Board Games",
+ "Golf",
+ "Playing Cards"
+ ]
+ },
+ {
+ "name": "Emily",
+ "hobbies": [
+ "Video Games",
+ "Golf"
+ ]
+ },
+ {
+ "name": "Victoria",
+ "hobbies": [
+ "Housework",
+ "Collecting",
+ "Woodworking"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 97,
+ "name": "Liam",
+ "city": "Nashville",
+ "age": 64,
+ "friends": [
+ {
+ "name": "Kevin",
+ "hobbies": [
+ "Collecting"
+ ]
+ },
+ {
+ "name": "Amelia",
+ "hobbies": [
+ "Golf",
+ "Playing Cards",
+ "Cooking"
+ ]
+ },
+ {
+ "name": "Charlotte",
+ "hobbies": [
+ "Reading",
+ "Board Games",
+ "Genealogy"
+ ]
+ },
+ {
+ "name": "Leo",
+ "hobbies": [
+ "Video Games",
+ "Writing"
+ ]
+ },
+ {
+ "name": "Nora",
+ "hobbies": [
+ "Jewelry Making",
+ "Volunteer Work"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 98,
+ "name": "Mia",
+ "city": "Miami Beach",
+ "age": 77,
+ "friends": [
+ {
+ "name": "Emma",
+ "hobbies": [
+ "Podcasts",
+ "Movie Watching"
+ ]
+ },
+ {
+ "name": "Oliver",
+ "hobbies": [
+ "Playing Cards",
+ "Fishing",
+ "Eating Out"
+ ]
+ },
+ {
+ "name": "Emma",
+ "hobbies": [
+ "Collecting",
+ "Yoga"
+ ]
+ },
+ {
+ "name": "Michael",
+ "hobbies": [
+ "Bicycling",
+ "Team Sports"
+ ]
+ },
+ {
+ "name": "Ava",
+ "hobbies": [
+ "Watching Sports",
+ "Jewelry Making"
+ ]
+ },
+ {
+ "name": "Joe",
+ "hobbies": [
+ "Video Games",
+ "Woodworking",
+ "Music"
+ ]
+ }
+ ]
+ },
+ {
+ "id": 99,
+ "name": "Mateo",
+ "city": "Branson",
+ "age": 66,
+ "friends": [
+ {
+ "name": "Isabella",
+ "hobbies": [
+ "Television",
+ "Skiing & Snowboarding"
+ ]
+ },
+ {
+ "name": "Noah",
+ "hobbies": [
+ "Housework",
+ "Running",
+ "Podcasts"
+ ]
+ }
+ ]
+ }
+ ]
+}
\ No newline at end of file