entry, String key) {
+ try{
+ writeValue(writer, entry.getValue(), indentFactor, indent);
+ } catch (Exception e) {
+ throw new JSONException("Unable to write JSONObject value for key: " + key, e);
+ }
+ }
+
/**
* Returns a java.util.Map containing all of the entries in this object.
* If an entry in the object is a JSONArray or JSONObject it will also
@@ -3012,22 +3403,257 @@ private static JSONException recursivelyDefinedObjectException(String key) {
}
/**
- * For a prospective number, remove the leading zeros
- * @param value prospective number
- * @return number without leading zeros
+ * Helper method to extract the raw Class from Type.
+ */
+ private Class getRawType(Type type) {
+ if (type instanceof Class) {
+ return (Class) type;
+ } else if (type instanceof ParameterizedType) {
+ return (Class) ((ParameterizedType) type).getRawType();
+ } else if (type instanceof GenericArrayType) {
+ return Object[].class; // Simplified handling for arrays
+ }
+ return Object.class; // Fallback
+ }
+
+ /**
+ * Extracts the element Type for a Collection Type.
+ */
+ private Type getElementType(Type type) {
+ if (type instanceof ParameterizedType) {
+ Type[] args = ((ParameterizedType) type).getActualTypeArguments();
+ return args.length > 0 ? args[0] : Object.class;
+ }
+ return Object.class;
+ }
+
+ /**
+ * Extracts the key and value Types for a Map Type.
*/
- 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);
+ private Type[] getMapTypes(Type type) {
+ if (type instanceof ParameterizedType) {
+ Type[] args = ((ParameterizedType) type).getActualTypeArguments();
+ if (args.length == 2) {
+ return args;
}
- ++counter;
}
- if (negativeFirstChar) {return "-0";}
- return "0";
+ return new Type[]{Object.class, Object.class}; // Default: String keys, Object values
+ }
+
+ /**
+ * Deserializes a JSON string into an instance of the specified class.
+ *
+ * This method attempts to map JSON key-value pairs to the corresponding fields
+ * of the given class. It supports basic data types including int, double, float,
+ * long, and boolean (as well as their boxed counterparts). The class must have a
+ * no-argument constructor, and the field names in the class must match the keys
+ * in the JSON string.
+ *
+ * @param the type of the object to return
+ * @param jsonString json in string format
+ * @param clazz the class of the object to be returned
+ * @return an instance of Object T with fields populated from the JSON string
+ */
+ public static T fromJson(String jsonString, Class clazz) {
+ JSONObject jsonObject = new JSONObject(jsonString);
+ return jsonObject.fromJson(clazz);
+ }
+
+ /**
+ * Deserializes a JSON string into an instance of the specified class.
+ *
+ * This method attempts to map JSON key-value pairs to the corresponding fields
+ * of the given class. It supports basic data types including {@code int}, {@code double},
+ * {@code float}, {@code long}, and {@code boolean}, as well as their boxed counterparts.
+ * The target class must have a no-argument constructor, and its field names must match
+ * the keys in the JSON string. Static fields are ignored.
+ *
+ *
Note: Only classes that are explicitly supported and registered within
+ * the {@code JSONObject} context can be deserialized. If the provided class is not among those,
+ * this method will not be able to deserialize it. This ensures that only a limited and
+ * controlled set of types can be instantiated from JSON for safety and predictability.
+ *
+ * @param clazz the class of the object to be returned
+ * @param the type of the object
+ * @return an instance of type {@code T} with fields populated from the JSON string
+ * @throws IllegalArgumentException if the class is not supported for deserialization
+ */
+ @SuppressWarnings("unchecked")
+ public T fromJson(Class clazz) {
+ try {
+ T obj = clazz.getDeclaredConstructor().newInstance();
+ for (Field field : clazz.getDeclaredFields()) {
+ if (Modifier.isStatic(field.getModifiers())) {
+ continue;
+ }
+ field.setAccessible(true);
+ String fieldName = field.getName();
+ if (has(fieldName)) {
+ Object value = get(fieldName);
+ Type fieldType = field.getGenericType();
+ Object convertedValue = convertValue(value, fieldType);
+ field.set(obj, convertedValue);
+ }
+ }
+ return obj;
+ } catch (NoSuchMethodException e) {
+ throw new JSONException("No no-arg constructor for class: " + clazz.getName(), e);
+ } catch (Exception e) {
+ throw new JSONException("Failed to instantiate or set field for class: " + clazz.getName(), e);
+ }
+ }
+
+ /**
+ * Recursively converts a value to the target Type, handling nested generics for Collections and Maps.
+ */
+ private Object convertValue(Object value, Type targetType) throws JSONException {
+ if (value == null) {
+ return null;
+ }
+
+ Class rawType = getRawType(targetType);
+
+ // Direct assignment
+ if (rawType.isAssignableFrom(value.getClass())) {
+ return value;
+ }
+
+ if (rawType == int.class || rawType == Integer.class) {
+ return ((Number) value).intValue();
+ } else if (rawType == double.class || rawType == Double.class) {
+ return ((Number) value).doubleValue();
+ } else if (rawType == float.class || rawType == Float.class) {
+ return ((Number) value).floatValue();
+ } else if (rawType == long.class || rawType == Long.class) {
+ return ((Number) value).longValue();
+ } else if (rawType == boolean.class || rawType == Boolean.class) {
+ return value;
+ } else if (rawType == String.class) {
+ return value;
+ } else if (rawType == BigDecimal.class) {
+ return new BigDecimal((String) value);
+ } else if (rawType == BigInteger.class) {
+ return new BigInteger((String) value);
+ }
+
+ // Enum conversion
+ if (rawType.isEnum() && value instanceof String) {
+ return stringToEnum(rawType, (String) value);
+ }
+
+ // Collection handling (e.g., List>>)
+ if (Collection.class.isAssignableFrom(rawType)) {
+ if (value instanceof JSONArray) {
+ Type elementType = getElementType(targetType);
+ return fromJsonArray((JSONArray) value, rawType, elementType);
+ }
+ }
+ // Map handling (e.g., Map>)
+ else if (Map.class.isAssignableFrom(rawType) && value instanceof JSONObject) {
+ Type[] mapTypes = getMapTypes(targetType);
+ Type keyType = mapTypes[0];
+ Type valueType = mapTypes[1];
+ return convertToMap((JSONObject) value, keyType, valueType, rawType);
+ }
+ // POJO handling (including custom classes like Tuple)
+ else if (!rawType.isPrimitive() && !rawType.isEnum() && value instanceof JSONObject) {
+ // Recurse with the raw class for POJO deserialization
+ return ((JSONObject) value).fromJson(rawType);
+ }
+
+ // Fallback
+ return value.toString();
+ }
+
+ /**
+ * Converts a JSONObject to a Map with the specified generic key and value Types.
+ * Supports nested types via recursive convertValue.
+ */
+ private Map convertToMap(JSONObject jsonMap, Type keyType, Type valueType, Class mapType) throws JSONException {
+ try {
+ @SuppressWarnings("unchecked")
+ Map createdMap = new HashMap();
+
+ for (Object keyObj : jsonMap.keySet()) {
+ String keyStr = (String) keyObj;
+ Object mapValue = jsonMap.get(keyStr);
+ // Convert key (e.g., String to Integer for Map)
+ Object convertedKey = convertValue(keyStr, keyType);
+ // Convert value recursively (handles nesting)
+ Object convertedValue = convertValue(mapValue, valueType);
+ createdMap.put(convertedKey, convertedValue);
+ }
+ return createdMap;
+ } catch (Exception e) {
+ throw new JSONException("Failed to convert JSONObject to Map: " + mapType.getName(), e);
+ }
+ }
+
+ /**
+ * Converts a String to an Enum value.
+ * The unchecked warning is suppressed when casting valueOf() to E
+ * @param enumClass enum class
+ * @param value value of enum
+ * @param type of enum
+ */
+ @SuppressWarnings("unchecked")
+ private E stringToEnum(Class enumClass, String value) throws JSONException {
+ try {
+ @SuppressWarnings("unchecked")
+ Class enumType = (Class) enumClass;
+ Method valueOfMethod = enumType.getMethod("valueOf", String.class);
+ return (E) valueOfMethod.invoke(null, value);
+ } catch (Exception e) {
+ throw new JSONException("Failed to convert string to enum: " + value + " for " + enumClass.getName(), e);
+ }
+ }
+
+ /**
+ * Deserializes a JSONArray into a Collection, supporting nested generics.
+ * Uses recursive convertValue for elements.
+ */
+ @SuppressWarnings("unchecked")
+ private Collection fromJsonArray(JSONArray jsonArray, Class collectionType, Type elementType) throws JSONException {
+ try {
+ Collection collection = getCollection(collectionType);
+
+ for (int i = 0; i < jsonArray.length(); i++) {
+ Object jsonElement = jsonArray.get(i);
+ // Recursively convert each element using the full element Type (handles nesting)
+ Object convertedValue = convertValue(jsonElement, elementType);
+ collection.add((T) convertedValue);
+ }
+ return collection;
+ } catch (Exception e) {
+ throw new JSONException("Failed to convert JSONArray to Collection: " + collectionType.getName(), e);
+ }
+ }
+
+ /**
+ * Creates and returns a new instance of a supported {@link Collection} implementation
+ * based on the specified collection type.
+ *
+ * This method currently supports the following collection types:
+ *
+ * - {@code List.class}
+ * - {@code ArrayList.class}
+ * - {@code Set.class}
+ * - {@code HashSet.class}
+ *
+ * If the provided type does not match any of the supported types, a {@link JSONException}
+ * is thrown.
+ *
+ * @param collectionType the {@link Class} object representing the desired collection type
+ * @return a new empty instance of the specified collection type
+ * @throws JSONException if the specified type is not a supported collection type
+ */
+ private Collection getCollection(Class collectionType) throws JSONException {
+ if (collectionType == List.class || collectionType == ArrayList.class) {
+ return new ArrayList();
+ } else if (collectionType == Set.class || collectionType == HashSet.class) {
+ return new HashSet();
+ } else {
+ throw new JSONException("Unsupported Collection type: " + collectionType.getName());
+ }
}
}
diff --git a/src/main/java/org/json/JSONPointer.java b/src/main/java/org/json/JSONPointer.java
index 859e1e644..34066c1aa 100644
--- a/src/main/java/org/json/JSONPointer.java
+++ b/src/main/java/org/json/JSONPointer.java
@@ -127,7 +127,7 @@ public JSONPointer(final String pointer) {
if (pointer == null) {
throw new NullPointerException("pointer cannot be null");
}
- if (pointer.isEmpty() || pointer.equals("#")) {
+ if (pointer.isEmpty() || "#".equals(pointer)) {
this.refTokens = Collections.emptyList();
return;
}
@@ -246,7 +246,7 @@ private static Object readByIndexToken(Object current, String indexToken) throws
*/
@Override
public String toString() {
- StringBuilder rval = new StringBuilder("");
+ StringBuilder rval = new StringBuilder();
for (String token: this.refTokens) {
rval.append('/').append(escape(token));
}
diff --git a/src/main/java/org/json/JSONTokener.java b/src/main/java/org/json/JSONTokener.java
index a90d51ae3..3726856d3 100644
--- a/src/main/java/org/json/JSONTokener.java
+++ b/src/main/java/org/json/JSONTokener.java
@@ -509,13 +509,26 @@ Object nextSimpleValue(char c) {
string = sb.toString().trim();
if ("".equals(string)) {
throw this.syntaxError("Missing value");
+ } else if (jsonParserConfiguration != null &&
+ jsonParserConfiguration.isStrictMode() && string.endsWith(".")) {
+ throw this.syntaxError(String.format("Strict mode error: Value '%s' ends with dot", string));
}
- Object obj = JSONObject.stringToValue(string);
- // Strict mode only allows strings with explicit double quotes
+ Object obj = JSONObject.stringToValue(string, jsonParserConfiguration);
+ // if obj is a boolean, look at string
if (jsonParserConfiguration != null &&
- jsonParserConfiguration.isStrictMode() &&
- obj instanceof String) {
- throw this.syntaxError(String.format("Strict mode error: Value '%s' is not surrounded by quotes", obj));
+ jsonParserConfiguration.isStrictMode()) {
+ if (obj instanceof Boolean && !"true".equals(string) && !"false".equals(string)) {
+ // Strict mode only allows lowercase true or false
+ throw this.syntaxError(String.format("Strict mode error: Value '%s' is not lowercase boolean", obj));
+ }
+ else if (obj == JSONObject.NULL && !"null".equals(string)) {
+ // Strint mode only allows lowercase null
+ throw this.syntaxError(String.format("Strict mode error: Value '%s' is not lowercase null", obj));
+ }
+ else if (obj instanceof String) {
+ // Strict mode only allows strings with explicit double quotes
+ throw this.syntaxError(String.format("Strict mode error: Value '%s' is not surrounded by quotes", obj));
+ }
}
return obj;
}
diff --git a/src/main/java/org/json/ParserConfiguration.java b/src/main/java/org/json/ParserConfiguration.java
index 06cc44366..e80093cac 100644
--- a/src/main/java/org/json/ParserConfiguration.java
+++ b/src/main/java/org/json/ParserConfiguration.java
@@ -13,11 +13,21 @@ public class ParserConfiguration {
*/
public static final int UNDEFINED_MAXIMUM_NESTING_DEPTH = -1;
+ /**
+ * Used to indicate there's no defined limit to the maximum number length
+ */
+ public static final int UNDEFINED_MAXIMUM_NUMBER_LENGTH = -1;
+
/**
* The default maximum nesting depth when parsing a document.
*/
public static final int DEFAULT_MAXIMUM_NESTING_DEPTH = 512;
+ /**
+ * The default max number length
+ */
+ public static final int DEFAULT_MAX_NUMBER_LENGTH = 1000;
+
/**
* Specifies if values should be kept as strings (true), or if
* they should try to be guessed into JSON values (numeric, boolean, string).
@@ -29,23 +39,32 @@ public class ParserConfiguration {
*/
protected int maxNestingDepth;
+ /**
+ * The max number of chars for any number. Exceeding this limit will cause the value to be converted to a string
+ */
+ protected int maxNumberLength;
+
/**
* Constructs a new ParserConfiguration with default settings.
*/
public ParserConfiguration() {
this.keepStrings = false;
this.maxNestingDepth = DEFAULT_MAXIMUM_NESTING_DEPTH;
+ this.maxNumberLength = DEFAULT_MAX_NUMBER_LENGTH;
}
/**
- * Constructs a new ParserConfiguration with the specified settings.
+ * Constructs a new ParserConfiguration with the specified settings. Use the with* methods instead of calling this ctor.
*
* @param keepStrings A boolean indicating whether to preserve strings during parsing.
* @param maxNestingDepth An integer representing the maximum allowed nesting depth.
+ * @deprecated Use the with*() methods instead
*/
+ @Deprecated
protected ParserConfiguration(final boolean keepStrings, final int maxNestingDepth) {
this.keepStrings = keepStrings;
this.maxNestingDepth = maxNestingDepth;
+ this.maxNumberLength = DEFAULT_MAX_NUMBER_LENGTH;
}
/**
@@ -58,10 +77,11 @@ protected ParserConfiguration 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 ParserConfiguration(
- this.keepStrings,
- this.maxNestingDepth
- );
+ ParserConfiguration parserConfiguration = new ParserConfiguration();
+ parserConfiguration.keepStrings = this.keepStrings;
+ parserConfiguration.maxNestingDepth = this.maxNestingDepth;
+ parserConfiguration.maxNumberLength = this.maxNumberLength;
+ return parserConfiguration;
}
/**
@@ -123,4 +143,37 @@ public T withMaxNestingDepth(int maxNestingDepth
return newConfig;
}
+
+
+ /**
+ * The maximum number length that the parser will allow
+ *
+ * @return the maximum number lengtj set for this configuration
+ */
+ public int getMaxNumberLength() {
+ return maxNumberLength;
+ }
+
+ /**
+ * Defines the maximum number length that the parser will allow
+ * Using any negative value as a parameter is equivalent to setting no limit to the length
+ * which means any size number is allowed
+ *
+ * @param maxNumberLength the maximum number length allowed
+ * @param the type of the configuration object
+ * @return The existing configuration will not be modified. A new configuration is returned.
+ */
+ @SuppressWarnings("unchecked")
+ public T withMaxNumberLength(int maxNumberLength) {
+ T newConfig = (T) this.clone();
+
+ if (maxNumberLength > UNDEFINED_MAXIMUM_NUMBER_LENGTH) {
+ newConfig.maxNumberLength = maxNumberLength;
+ } else {
+ newConfig.maxNumberLength = UNDEFINED_MAXIMUM_NUMBER_LENGTH;
+ }
+
+ return newConfig;
+ }
+
}
diff --git a/src/main/java/org/json/XML.java b/src/main/java/org/json/XML.java
index e59ec7a4a..f5846cc1e 100644
--- a/src/main/java/org/json/XML.java
+++ b/src/main/java/org/json/XML.java
@@ -9,6 +9,7 @@
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Iterator;
+import java.util.NoSuchElementException;
/**
* This provides static methods to convert an XML text into a JSONObject, and to
@@ -80,7 +81,7 @@ private static Iterable codePointIterator(final String string) {
public Iterator iterator() {
return new Iterator() {
private int nextIndex = 0;
- private int length = string.length();
+ private final int length = string.length();
@Override
public boolean hasNext() {
@@ -89,6 +90,9 @@ public boolean hasNext() {
@Override
public Integer next() {
+ if (!hasNext()) {
+ throw new NoSuchElementException();
+ }
int result = string.codePointAt(this.nextIndex);
this.nextIndex += Character.charCount(result);
return result;
@@ -154,7 +158,7 @@ public static String escape(String string) {
* @param cp code point to test
* @return true if the code point is not valid for an XML
*/
- private static boolean mustEscape(int cp) {
+ static boolean mustEscape(int cp) {
/* Valid range from https://www.w3.org/TR/REC-xml/#charsets
*
* #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]
@@ -168,8 +172,14 @@ private static boolean mustEscape(int cp) {
&& cp != 0xA
&& cp != 0xD
) || !(
- // valid the range of acceptable characters that aren't control
- (cp >= 0x20 && cp <= 0xD7FF)
+ // Valid character range per W3C XML 1.0 spec:
+ // #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]
+ // Previously omitted #x9/#xA/#xD, causing unescape("
") etc.
+ // to reject valid LF/TAB/CR as illegal (see #1059)
+ cp == 0x9
+ || cp == 0xA
+ || cp == 0xD
+ || (cp >= 0x20 && cp <= 0xD7FF)
|| (cp >= 0xE000 && cp <= 0xFFFD)
|| (cp >= 0x10000 && cp <= 0x10FFFF)
)
@@ -355,10 +365,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 {
@@ -377,8 +397,13 @@ private static boolean parse(XMLTokener x, JSONObject context, String name, XMLP
context.append(tagName, JSONObject.NULL);
} else if (jsonObject.length() > 0) {
context.append(tagName, jsonObject);
- } else {
+ } else if(context.isEmpty()) { //avoids resetting the array in case of an empty tag in the middle or end
context.put(tagName, new JSONArray());
+ if (jsonObject.isEmpty()){
+ context.append(tagName, "");
+ }
+ } else {
+ context.append(tagName, "");
}
} else {
if (nilAttributeFound) {
@@ -407,8 +432,23 @@ 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 if (obj == JSONObject.NULL) {
+ jsonObject.accumulate(config.getcDataTagName(),
+ config.isKeepStrings() ? ((String) token) : obj);
+ } else {
+ jsonObject.accumulate(config.getcDataTagName(), stringToValue((String) token));
+ }
}
}
@@ -422,7 +462,11 @@ private static boolean parse(XMLTokener x, JSONObject context, String name, XMLP
if (config.getForceList().contains(tagName)) {
// Force the value to be an array
if (jsonObject.length() == 0) {
- context.put(tagName, new JSONArray());
+ //avoids resetting the array in case of an empty element in the middle or end
+ if(context.isEmpty()) {
+ context.put(tagName, new JSONArray());
+ }
+ context.append(tagName, "");
} else if (jsonObject.length() == 1
&& jsonObject.opt(config.getcDataTagName()) != null) {
context.append(tagName, jsonObject.opt(config.getcDataTagName()));
@@ -579,16 +623,32 @@ public static Object stringToValue(String string, XMLXsiTypeConverter typeCon
return stringToValue(string);
}
+ /**
+ * This method is the same as {@link JSONObject#stringToValue(String)}.
+ * Warning! stringToValue(String) uses the default max number length. If you want to override it,
+ * use a suitable initialized XMLParserConfiguration and the method: stringToValue(String, XMLParserConfiguration).
+ * @param str 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 str) {
+ return stringToValue(str, new XMLParserConfiguration());
+ }
+
/**
* This method is the same as {@link JSONObject#stringToValue(String)}.
*
* @param string String to convert
- * @return JSON value of this string or the string
+ * @param xmlParserConfiguration the XML parser config object
+ * @return JSON value of this string or the string. If the string represents a number that is too large,
+ * a string will be returned.
*/
// 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) {
+ public static Object stringToValue(String string, XMLParserConfiguration xmlParserConfiguration) {
if ("".equals(string)) {
return string;
}
@@ -612,7 +672,13 @@ public static Object stringToValue(String string) {
char initial = string.charAt(0);
if ((initial >= '0' && initial <= '9') || initial == '-') {
try {
- return stringToNumber(string);
+ // user declines max number checking
+ if (xmlParserConfiguration.getMaxNumberLength() == ParserConfiguration.UNDEFINED_MAXIMUM_NUMBER_LENGTH) {
+ return stringToNumber(string);
+ }
+ if(string.length() <= xmlParserConfiguration.getMaxNumberLength()) {
+ return stringToNumber(string);
+ }
} catch (Exception ignore) {
}
}
@@ -688,6 +754,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
@@ -746,6 +850,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
diff --git a/src/main/java/org/json/XMLParserConfiguration.java b/src/main/java/org/json/XMLParserConfiguration.java
index bc4a80074..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();
@@ -142,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;
}
@@ -163,8 +175,10 @@ public XMLParserConfiguration (final boolean keepStrings, final String cDataTagN
*/
private XMLParserConfiguration (final boolean keepStrings, final String cDataTagName,
final boolean convertNilAttributeToNull, final Map> xsiTypeMap, final Set forceList,
- final int maxNestingDepth, final boolean closeEmptyTag) {
- 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);
@@ -189,7 +203,9 @@ protected XMLParserConfiguration clone() {
this.xsiTypeMap,
this.forceList,
this.maxNestingDepth,
- this.closeEmptyTag
+ this.closeEmptyTag,
+ this.keepNumberAsString,
+ this.keepBooleanAsString
);
config.shouldTrimWhiteSpace = this.shouldTrimWhiteSpace;
return config;
@@ -207,7 +223,43 @@ protected XMLParserConfiguration clone() {
@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;
}
/**
@@ -221,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
diff --git a/src/main/java/org/json/XMLTokener.java b/src/main/java/org/json/XMLTokener.java
index bc18b31c9..dc90f84d4 100644
--- a/src/main/java/org/json/XMLTokener.java
+++ b/src/main/java/org/json/XMLTokener.java
@@ -151,33 +151,111 @@ public Object nextEntity(@SuppressWarnings("unused") char ampersand) throws JSON
/**
* Unescape an XML entity encoding;
* @param e entity (only the actual entity value, not the preceding & or ending ;
- * @return
+ * @return the unescaped entity string
+ * @throws JSONException if the entity is malformed
*/
- static String unescapeEntity(String e) {
+ static String unescapeEntity(String e) throws JSONException {
// validate
if (e == null || e.isEmpty()) {
return "";
}
// if our entity is an encoded unicode point, parse it.
if (e.charAt(0) == '#') {
- int cp;
- if (e.charAt(1) == 'x' || e.charAt(1) == 'X') {
- // hex encoded unicode
- cp = Integer.parseInt(e.substring(2), 16);
- } else {
- // decimal encoded unicode
- cp = Integer.parseInt(e.substring(1));
+ if (e.length() < 2) {
+ throw new JSONException("Invalid numeric character reference: &#;");
+ }
+ int cp = (e.charAt(1) == 'x' || e.charAt(1) == 'X')
+ ? parseHexEntity(e)
+ : parseDecimalEntity(e);
+ if (XML.mustEscape(cp)) {
+ throw new JSONException("Invalid numeric character reference: &#" + e.substring(1) + ";");
}
- return new String(new int[] {cp},0,1);
- }
+ return new String(new int[] {cp}, 0, 1);
+ }
Character knownEntity = entity.get(e);
- if(knownEntity==null) {
+ if (knownEntity == null) {
// we don't know the entity so keep it encoded
return '&' + e + ';';
}
return knownEntity.toString();
}
+ /**
+ * Parse a hexadecimal numeric character reference (e.g., "઼").
+ * @param e entity string starting with '#' (e.g., "#x1F4A9")
+ * @return the Unicode code point
+ * @throws JSONException if the format is invalid
+ */
+ private static int parseHexEntity(String e) throws JSONException {
+ // hex encoded unicode - need at least one hex digit after #x
+ if (e.length() < 3) {
+ throw new JSONException("Invalid hex character reference: missing hex digits in &#" + e.substring(1) + ";");
+ }
+ String hex = e.substring(2);
+ if (!isValidHex(hex)) {
+ throw new JSONException("Invalid hex character reference: &#" + e.substring(1) + ";");
+ }
+ try {
+ return Integer.parseInt(hex, 16);
+ } catch (NumberFormatException nfe) {
+ throw new JSONException("Invalid hex character reference: &#" + e.substring(1) + ";", nfe);
+ }
+ }
+
+ /**
+ * Parse a decimal numeric character reference (e.g., "{").
+ * @param e entity string starting with '#' (e.g., "#123")
+ * @return the Unicode code point
+ * @throws JSONException if the format is invalid
+ */
+ private static int parseDecimalEntity(String e) throws JSONException {
+ String decimal = e.substring(1);
+ if (!isValidDecimal(decimal)) {
+ throw new JSONException("Invalid decimal character reference: &#" + decimal + ";");
+ }
+ try {
+ return Integer.parseInt(decimal);
+ } catch (NumberFormatException nfe) {
+ throw new JSONException("Invalid decimal character reference: &#" + decimal + ";", nfe);
+ }
+ }
+
+ /**
+ * Check if a string contains only valid hexadecimal digits.
+ * @param s the string to check
+ * @return true if s is non-empty and contains only hex digits (0-9, a-f, A-F)
+ */
+ private static boolean isValidHex(String s) {
+ if (s == null || s.isEmpty()) {
+ return false;
+ }
+ for (int i = 0; i < s.length(); i++) {
+ char c = s.charAt(i);
+ if (!((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Check if a string contains only valid decimal digits.
+ * @param s the string to check
+ * @return true if s is non-empty and contains only digits (0-9)
+ */
+ private static boolean isValidDecimal(String s) {
+ if (s == null || s.isEmpty()) {
+ return false;
+ }
+ for (int i = 0; i < s.length(); i++) {
+ char c = s.charAt(i);
+ if (c < '0' || c > '9') {
+ return false;
+ }
+ }
+ return true;
+ }
+
/**
* {@code
diff --git a/src/test/java/org/json/junit/CDLTest.java b/src/test/java/org/json/junit/CDLTest.java
index 0e3668bf7..e5eb9eda8 100644
--- a/src/test/java/org/json/junit/CDLTest.java
+++ b/src/test/java/org/json/junit/CDLTest.java
@@ -168,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.
*/
diff --git a/src/test/java/org/json/junit/HTTPTokenerTest.java b/src/test/java/org/json/junit/HTTPTokenerTest.java
new file mode 100644
index 000000000..28dd40353
--- /dev/null
+++ b/src/test/java/org/json/junit/HTTPTokenerTest.java
@@ -0,0 +1,107 @@
+package org.json.junit;
+
+import org.json.HTTPTokener;
+import org.json.JSONException;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+/**
+ * Tests for JSON-Java HTTPTokener.java
+ */
+public class HTTPTokenerTest {
+
+ /**
+ * Test parsing a simple unquoted token.
+ */
+ @Test
+ public void parseSimpleToken() {
+ HTTPTokener tokener = new HTTPTokener("Content-Type");
+ String token = tokener.nextToken();
+ assertEquals("Content-Type", token);
+ }
+
+ /**
+ * Test parsing multiple tokens separated by whitespace.
+ */
+ @Test
+ public void parseMultipleTokens() {
+ HTTPTokener tokener = new HTTPTokener("Content-Type application/json");
+ String token1 = tokener.nextToken();
+ String token2 = tokener.nextToken();
+ assertEquals("Content-Type", token1);
+ assertEquals("application/json", token2);
+ }
+
+ /**
+ * Test parsing a double-quoted token.
+ */
+ @Test
+ public void parseDoubleQuotedToken() {
+ HTTPTokener tokener = new HTTPTokener("\"application/json\"");
+ String token = tokener.nextToken();
+ assertEquals("application/json", token);
+ }
+
+ /**
+ * Test parsing a single-quoted token.
+ */
+ @Test
+ public void parseSingleQuotedToken() {
+ HTTPTokener tokener = new HTTPTokener("'application/json'");
+ String token = tokener.nextToken();
+ assertEquals("application/json", token);
+ }
+
+ /**
+ * Test parsing a quoted token that includes spaces and semicolons.
+ */
+ @Test
+ public void parseQuotedTokenWithSpaces() {
+ HTTPTokener tokener = new HTTPTokener("\"text/html; charset=UTF-8\"");
+ String token = tokener.nextToken();
+ assertEquals("text/html; charset=UTF-8", token);
+ }
+
+ /**
+ * Test that unterminated quoted strings throw a JSONException.
+ */
+ @Test
+ public void throwExceptionOnUnterminatedString() {
+ HTTPTokener tokener = new HTTPTokener("\"incomplete");
+ JSONException exception = assertThrows(JSONException.class, tokener::nextToken);
+ assertTrue(exception.getMessage().contains("Unterminated string"));
+ }
+
+ /**
+ * Test behavior with empty input string.
+ */
+ @Test
+ public void parseEmptyInput() {
+ HTTPTokener tokener = new HTTPTokener("");
+ String token = tokener.nextToken();
+ assertEquals("", token);
+ }
+
+ /**
+ * Test behavior with input consisting only of whitespace.
+ */
+ @Test
+ public void parseWhitespaceOnly() {
+ HTTPTokener tokener = new HTTPTokener(" \t \n ");
+ String token = tokener.nextToken();
+ assertEquals("", token);
+ }
+
+ /**
+ * Test parsing tokens separated by multiple whitespace characters.
+ */
+ @Test
+ public void parseTokensWithMultipleWhitespace() {
+ HTTPTokener tokener = new HTTPTokener("GET /index.html");
+ String method = tokener.nextToken();
+ String path = tokener.nextToken();
+ assertEquals("GET", method);
+ assertEquals("/index.html", path);
+ }
+
+}
\ No newline at end of file
diff --git a/src/test/java/org/json/junit/JSONArrayTest.java b/src/test/java/org/json/junit/JSONArrayTest.java
index 429620396..c54b61795 100644
--- a/src/test/java/org/json/junit/JSONArrayTest.java
+++ b/src/test/java/org/json/junit/JSONArrayTest.java
@@ -1502,19 +1502,23 @@ public void testRecursiveDepthArrayForDefaultLevels() {
}
@Test
- public void testRecursiveDepthArrayFor1000Levels() {
+ /**
+ * This test was originally for 1000 levels, which passes in test builds, but fails on my laptop.
+ * The current value of 900 seems to work.
+ */
+ public void testRecursiveDepthArrayFor900Levels() {
try {
- ArrayList