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 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. + */ + 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/XML.java b/src/main/java/org/json/XML.java index 3eb948c77..7e4b0bb0c 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; @@ -387,8 +391,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) { @@ -447,7 +456,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())); diff --git a/src/main/java/org/json/XMLTokener.java b/src/main/java/org/json/XMLTokener.java index bc18b31c9..dad2e2897 100644 --- a/src/main/java/org/json/XMLTokener.java +++ b/src/main/java/org/json/XMLTokener.java @@ -151,33 +151,108 @@ 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: &#;"); } - return new String(new int[] {cp},0,1); - } + int cp = (e.charAt(1) == 'x' || e.charAt(1) == 'X') + ? parseHexEntity(e) + : parseDecimalEntity(e); + 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/JSONMLTest.java b/src/test/java/org/json/junit/JSONMLTest.java index 5a360dd59..93a6821d8 100644 --- a/src/test/java/org/json/junit/JSONMLTest.java +++ b/src/test/java/org/json/junit/JSONMLTest.java @@ -986,4 +986,70 @@ public void testToJSONObjectMaxNestingDepthWithValidFittingXML() { } } + /** + * Tests that malformed XML causing type mismatch throws JSONException. + * Previously threw ClassCastException when parse() returned String instead of JSONArray. + * Related to issue #1034 + */ + @Test(expected = JSONException.class) + public void testMalformedXMLThrowsJSONExceptionNotClassCast() { + // This malformed XML causes parse() to return wrong type + byte[] data = {0x3c, 0x0a, 0x2f, (byte)0xff, (byte)0xff, (byte)0xff, + (byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff, + (byte)0xff, 0x3e, 0x42}; + String xmlStr = new String(data); + JSONML.toJSONArray(xmlStr); + } + + /** + * Tests that type mismatch in toJSONObject throws JSONException. + * Validates safe type casting in toJSONObject methods. + */ + @Test + public void testToJSONObjectTypeMismatch() { + // Create XML that would cause parse() to return wrong type + String xmlStr = "<\n/\u00ff\u00ff\u00ff\u00ff\u00ff\u00ff\u00ff\u00ff>B"; + try { + JSONML.toJSONObject(xmlStr); + fail("Expected JSONException for type mismatch"); + } catch (ClassCastException e) { + fail("Should throw JSONException, not ClassCastException"); + } catch (JSONException e) { + // Expected - verify it's about type mismatch + assertTrue("Exception message should mention type error", + e.getMessage().contains("Expected") || e.getMessage().contains("got")); + } + } + + /** + * Tests that valid XML still works correctly after the fix. + * Ensures the type checking doesn't break normal operation. + */ + @Test + public void testValidXMLStillWorks() { + String xmlStr = "value"; + try { + JSONArray jsonArray = JSONML.toJSONArray(xmlStr); + assertNotNull("JSONArray should not be null", jsonArray); + assertEquals("root", jsonArray.getString(0)); + } catch (Exception e) { + fail("Valid XML should not throw exception: " + e.getMessage()); + } + } + + /** + * Tests that valid XML to JSONObject still works correctly. + */ + @Test + public void testValidXMLToJSONObjectStillWorks() { + String xmlStr = "content"; + try { + JSONObject jsonObject = JSONML.toJSONObject(xmlStr); + assertNotNull("JSONObject should not be null", jsonObject); + assertEquals("root", jsonObject.getString("tagName")); + } catch (Exception e) { + fail("Valid XML should not throw exception: " + e.getMessage()); + } + } + } diff --git a/src/test/java/org/json/junit/JSONObjectLocaleTest.java b/src/test/java/org/json/junit/JSONObjectLocaleTest.java index 1cdaf743d..e1a9dd64e 100755 --- a/src/test/java/org/json/junit/JSONObjectLocaleTest.java +++ b/src/test/java/org/json/junit/JSONObjectLocaleTest.java @@ -36,25 +36,31 @@ public void jsonObjectByLocaleBean() { MyLocaleBean myLocaleBean = new MyLocaleBean(); - /** - * This is just the control case which happens when the locale.ROOT - * lowercasing behavior is the same as the current locale. - */ - Locale.setDefault(new Locale("en")); - JSONObject jsonen = new JSONObject(myLocaleBean); - assertEquals("expected size 2, found: " +jsonen.length(), 2, jsonen.length()); - assertEquals("expected jsonen[i] == beanI", "beanI", jsonen.getString("i")); - assertEquals("expected jsonen[id] == beanId", "beanId", jsonen.getString("id")); - - /** - * Without the JSON-Java change, these keys would be stored internally as - * starting with the letter, 'ı' (dotless i), since the lowercasing of - * the getI and getId keys would be specific to the Turkish locale. - */ - Locale.setDefault(new Locale("tr")); - JSONObject jsontr = new JSONObject(myLocaleBean); - assertEquals("expected size 2, found: " +jsontr.length(), 2, jsontr.length()); - assertEquals("expected jsontr[i] == beanI", "beanI", jsontr.getString("i")); - assertEquals("expected jsontr[id] == beanId", "beanId", jsontr.getString("id")); + // save and restore the current default locale, to avoid any side effects on other executions in the same JVM + Locale defaultLocale = Locale.getDefault(); + try { + /** + * This is just the control case which happens when the locale.ROOT + * lowercasing behavior is the same as the current locale. + */ + Locale.setDefault(new Locale("en")); + JSONObject jsonen = new JSONObject(myLocaleBean); + assertEquals("expected size 2, found: " +jsonen.length(), 2, jsonen.length()); + assertEquals("expected jsonen[i] == beanI", "beanI", jsonen.getString("i")); + assertEquals("expected jsonen[id] == beanId", "beanId", jsonen.getString("id")); + + /** + * Without the JSON-Java change, these keys would be stored internally as + * starting with the letter, 'ı' (dotless i), since the lowercasing of + * the getI and getId keys would be specific to the Turkish locale. + */ + Locale.setDefault(new Locale("tr")); + JSONObject jsontr = new JSONObject(myLocaleBean); + assertEquals("expected size 2, found: " +jsontr.length(), 2, jsontr.length()); + assertEquals("expected jsontr[i] == beanI", "beanI", jsontr.getString("i")); + assertEquals("expected jsontr[id] == beanId", "beanId", jsontr.getString("id")); + } finally { + Locale.setDefault(defaultLocale); + } } } diff --git a/src/test/java/org/json/junit/JSONObjectRecordTest.java b/src/test/java/org/json/junit/JSONObjectRecordTest.java new file mode 100644 index 000000000..f1a673d28 --- /dev/null +++ b/src/test/java/org/json/junit/JSONObjectRecordTest.java @@ -0,0 +1,179 @@ +package org.json.junit; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +import java.io.StringReader; + +import org.json.JSONObject; +import org.json.junit.data.GenericBeanInt; +import org.json.junit.data.MyEnum; +import org.json.junit.data.MyNumber; +import org.json.junit.data.PersonRecord; +import org.junit.Ignore; +import org.junit.Test; + +/** + * Tests for JSONObject support of Java record types. + * + * NOTE: These tests are currently ignored because PersonRecord is not an actual Java record. + * The implementation now correctly detects actual Java records using reflection (Class.isRecord()). + * These tests will need to be enabled and run with Java 17+ where PersonRecord can be converted + * to an actual record type. + * + * This ensures backward compatibility - regular classes with lowercase method names will not + * be treated as records unless they are actual Java record types. + */ +public class JSONObjectRecordTest { + + /** + * Tests that JSONObject can be created from a record-style class. + * Record-style classes use accessor methods like name() instead of getName(). + * + * NOTE: Ignored until PersonRecord is converted to an actual Java record (requires Java 17+) + */ + @Test + @Ignore("Requires actual Java record type - PersonRecord needs to be a real record (Java 17+)") + public void jsonObjectByRecord() { + PersonRecord person = new PersonRecord("John Doe", 30, true); + JSONObject jsonObject = new JSONObject(person); + + assertEquals("Expected 3 keys in the JSONObject", 3, jsonObject.length()); + assertEquals("John Doe", jsonObject.get("name")); + assertEquals(30, jsonObject.get("age")); + assertEquals(true, jsonObject.get("active")); + } + + /** + * Test that Object methods (toString, hashCode, equals, etc.) are not included + * + * NOTE: Ignored until PersonRecord is converted to an actual Java record (requires Java 17+) + */ + @Test + @Ignore("Requires actual Java record type - PersonRecord needs to be a real record (Java 17+)") + public void recordStyleClassShouldNotIncludeObjectMethods() { + PersonRecord person = new PersonRecord("Jane Doe", 25, false); + JSONObject jsonObject = new JSONObject(person); + + // Should NOT include Object methods + assertFalse("Should not include toString", jsonObject.has("toString")); + assertFalse("Should not include hashCode", jsonObject.has("hashCode")); + assertFalse("Should not include equals", jsonObject.has("equals")); + assertFalse("Should not include clone", jsonObject.has("clone")); + assertFalse("Should not include wait", jsonObject.has("wait")); + assertFalse("Should not include notify", jsonObject.has("notify")); + assertFalse("Should not include notifyAll", jsonObject.has("notifyAll")); + + // Should only have the 3 record fields + assertEquals("Should only have 3 fields", 3, jsonObject.length()); + } + + /** + * Test that enum methods are not included when processing an enum + */ + @Test + public void enumsShouldNotIncludeEnumMethods() { + MyEnum myEnum = MyEnum.VAL1; + JSONObject jsonObject = new JSONObject(myEnum); + + // Should NOT include enum-specific methods like name(), ordinal(), values(), valueOf() + assertFalse("Should not include name method", jsonObject.has("name")); + assertFalse("Should not include ordinal method", jsonObject.has("ordinal")); + assertFalse("Should not include declaringClass", jsonObject.has("declaringClass")); + + // Enums should still work with traditional getters if they have any + // But should not pick up the built-in enum methods + } + + /** + * Test that Number subclass methods are not included + */ + @Test + public void numberSubclassesShouldNotIncludeNumberMethods() { + MyNumber myNumber = new MyNumber(); + JSONObject jsonObject = new JSONObject(myNumber); + + // Should NOT include Number methods like intValue(), longValue(), etc. + assertFalse("Should not include intValue", jsonObject.has("intValue")); + assertFalse("Should not include longValue", jsonObject.has("longValue")); + assertFalse("Should not include doubleValue", jsonObject.has("doubleValue")); + assertFalse("Should not include floatValue", jsonObject.has("floatValue")); + + // Should include the actual getter + assertTrue("Should include number", jsonObject.has("number")); + assertEquals("Should have 1 field", 1, jsonObject.length()); + } + + /** + * Test that generic bean with get() and is() methods works correctly + */ + @Test + public void genericBeanWithGetAndIsMethodsShouldNotBeIncluded() { + GenericBeanInt bean = new GenericBeanInt(42); + JSONObject jsonObject = new JSONObject(bean); + + // Should NOT include standalone get() or is() methods + assertFalse("Should not include standalone 'get' method", jsonObject.has("get")); + assertFalse("Should not include standalone 'is' method", jsonObject.has("is")); + + // Should include the actual getters + assertTrue("Should include genericValue field", jsonObject.has("genericValue")); + assertTrue("Should include a field", jsonObject.has("a")); + } + + /** + * Test that java.* classes don't have their methods picked up + */ + @Test + public void javaLibraryClassesShouldNotIncludeTheirMethods() { + StringReader reader = new StringReader("test"); + JSONObject jsonObject = new JSONObject(reader); + + // Should NOT include java.io.Reader methods like read(), reset(), etc. + assertFalse("Should not include read method", jsonObject.has("read")); + assertFalse("Should not include reset method", jsonObject.has("reset")); + assertFalse("Should not include ready method", jsonObject.has("ready")); + assertFalse("Should not include skip method", jsonObject.has("skip")); + + // Reader should produce empty JSONObject (no valid properties) + assertEquals("Reader should produce empty JSON", 0, jsonObject.length()); + } + + /** + * Test mixed case - object with both traditional getters and record-style accessors + * + * NOTE: Ignored until PersonRecord is converted to an actual Java record (requires Java 17+) + */ + @Test + @Ignore("Requires actual Java record type - PersonRecord needs to be a real record (Java 17+)") + public void mixedGettersAndRecordStyleAccessors() { + // PersonRecord has record-style accessors: name(), age(), active() + // These should all be included + PersonRecord person = new PersonRecord("Mixed Test", 40, true); + JSONObject jsonObject = new JSONObject(person); + + assertEquals("Should have all 3 record-style fields", 3, jsonObject.length()); + assertTrue("Should include name", jsonObject.has("name")); + assertTrue("Should include age", jsonObject.has("age")); + assertTrue("Should include active", jsonObject.has("active")); + } + + /** + * Test that methods starting with uppercase are not included (not valid record accessors) + * + * NOTE: Ignored until PersonRecord is converted to an actual Java record (requires Java 17+) + */ + @Test + @Ignore("Requires actual Java record type - PersonRecord needs to be a real record (Java 17+)") + public void methodsStartingWithUppercaseShouldNotBeIncluded() { + PersonRecord person = new PersonRecord("Test", 50, false); + JSONObject jsonObject = new JSONObject(person); + + // Record-style accessors must start with lowercase + // Methods like Name(), Age() (uppercase) should not be picked up + // Our PersonRecord only has lowercase accessors, which is correct + + assertEquals("Should only have lowercase accessors", 3, jsonObject.length()); + } +} diff --git a/src/test/java/org/json/junit/JSONObjectTest.java b/src/test/java/org/json/junit/JSONObjectTest.java index 88c19c7dc..6a3c9b573 100644 --- a/src/test/java/org/json/junit/JSONObjectTest.java +++ b/src/test/java/org/json/junit/JSONObjectTest.java @@ -56,6 +56,18 @@ import org.json.junit.data.Singleton; import org.json.junit.data.SingletonEnum; import org.json.junit.data.WeirdList; +import org.json.junit.data.CustomClass; +import org.json.junit.data.CustomClassA; +import org.json.junit.data.CustomClassB; +import org.json.junit.data.CustomClassC; +import org.json.junit.data.CustomClassD; +import org.json.junit.data.CustomClassE; +import org.json.junit.data.CustomClassF; +import org.json.junit.data.CustomClassG; +import org.json.junit.data.CustomClassH; +import org.json.junit.data.CustomClassI; +import org.json.junit.data.CustomClassJ; +import org.json.JSONObject; import org.junit.After; import org.junit.Ignore; import org.junit.Test; @@ -3106,12 +3118,13 @@ public void testJSONWriterException() { // test a more complex object writer = new StringWriter(); - try { - new JSONObject() + + JSONObject object = new JSONObject() .put("somethingElse", "a value") .put("someKey", new JSONArray() - .put(new JSONObject().put("key1", new BrokenToString()))) - .write(writer).toString(); + .put(new JSONObject().put("key1", new BrokenToString()))); + try { + object.write(writer).toString(); fail("Expected an exception, got a String value"); } catch (JSONException e) { assertEquals("Unable to write JSONObject value for key: someKey", e.getMessage()); @@ -3122,17 +3135,18 @@ public void testJSONWriterException() { writer.close(); } catch (Exception e) {} } - + // test a more slightly complex object writer = new StringWriter(); - try { - new JSONObject() + + object = new JSONObject() .put("somethingElse", "a value") .put("someKey", new JSONArray() .put(new JSONObject().put("key1", new BrokenToString())) .put(12345) - ) - .write(writer).toString(); + ); + try { + object.write(writer).toString(); fail("Expected an exception, got a String value"); } catch (JSONException e) { assertEquals("Unable to write JSONObject value for key: someKey", e.getMessage()); @@ -4095,4 +4109,145 @@ public void jsonObjectParseNullFieldsWithoutParserConfiguration() { assertTrue("JSONObject should be empty", jsonObject.isEmpty()); } + + @Test + public void jsonObjectParseFromJson_0() { + JSONObject object = new JSONObject(); + object.put("number", 12); + object.put("name", "Alex"); + object.put("longNumber", 1500000000L); + CustomClass customClass = object.fromJson(CustomClass.class); + CustomClass compareClass = new CustomClass(12, "Alex", 1500000000L); + assertEquals(customClass, compareClass); + } + + @Test + public void jsonObjectParseFromJson_1() { + JSONObject object = new JSONObject(); + + BigInteger largeInt = new BigInteger("123"); + object.put("largeInt", largeInt.toString()); + CustomClassA customClassA = object.fromJson(CustomClassA.class); + CustomClassA compareClassClassA = new CustomClassA(largeInt); + assertEquals(customClassA, compareClassClassA); + } + + @Test + public void jsonObjectParseFromJson_2() { + JSONObject object = new JSONObject(); + object.put("number", 12); + + JSONObject classC = new JSONObject(); + classC.put("stringName", "Alex"); + classC.put("longNumber", 123456L); + + object.put("classC", classC); + + CustomClassB customClassB = object.fromJson(CustomClassB.class); + CustomClassC classCObject = new CustomClassC("Alex", 123456L); + CustomClassB compareClassB = new CustomClassB(12, classCObject); + assertEquals(customClassB, compareClassB); + } + + @Test + public void jsonObjectParseFromJson_3() { + JSONObject object = new JSONObject(); + JSONArray array = new JSONArray(); + array.put("test1"); + array.put("test2"); + array.put("test3"); + object.put("stringList", array); + + CustomClassD customClassD = object.fromJson(CustomClassD.class); + CustomClassD compareClassD = new CustomClassD(Arrays.asList("test1", "test2", "test3")); + assertEquals(customClassD, compareClassD); + } + + @Test + public void jsonObjectParseFromJson_4() { + JSONObject object = new JSONObject(); + JSONArray array = new JSONArray(); + array.put(new CustomClassC("test1", 1L).toJSON()); + array.put(new CustomClassC("test2", 2L).toJSON()); + object.put("listClassC", array); + + CustomClassE customClassE = object.fromJson(CustomClassE.class); + CustomClassE compareClassE = new CustomClassE(java.util.Arrays.asList( + new CustomClassC("test1", 1L), + new CustomClassC("test2", 2L))); + assertEquals(customClassE, compareClassE); + } + + @Test + public void jsonObjectParseFromJson_5() { + JSONObject object = new JSONObject(); + JSONArray array = new JSONArray(); + array.put(Arrays.asList("A", "B", "C")); + array.put(Arrays.asList("D", "E")); + object.put("listOfString", array); + + CustomClassF customClassF = object.fromJson(CustomClassF.class); + List> listOfString = new ArrayList<>(); + listOfString.add(Arrays.asList("A", "B", "C")); + listOfString.add(Arrays.asList("D", "E")); + CustomClassF compareClassF = new CustomClassF(listOfString); + assertEquals(customClassF, compareClassF); + } + + @Test + public void jsonObjectParseFromJson_6() { + JSONObject object = new JSONObject(); + Map dataList = new HashMap<>(); + dataList.put("A", "Aa"); + dataList.put("B", "Bb"); + dataList.put("C", "Cc"); + object.put("dataList", dataList); + + CustomClassG customClassG = object.fromJson(CustomClassG.class); + CustomClassG compareClassG = new CustomClassG(dataList); + assertEquals(customClassG, compareClassG); + } + + @Test + public void jsonObjectParseFromJson_7() { + JSONObject object = new JSONObject(); + Map> dataList = new HashMap<>(); + dataList.put("1", Arrays.asList(1, 2, 3, 4)); + dataList.put("2", Arrays.asList(2, 3, 4, 5)); + object.put("integerMap", dataList); + + CustomClassH customClassH = object.fromJson(CustomClassH.class); + CustomClassH compareClassH = new CustomClassH(dataList); + assertEquals(customClassH.integerMap.toString(), compareClassH.integerMap.toString()); + } + + @Test + public void jsonObjectParseFromJson_8() { + JSONObject object = new JSONObject(); + Map> dataList = new HashMap<>(); + dataList.put("1", Collections.singletonMap("1", 1)); + dataList.put("2", Collections.singletonMap("2", 2)); + object.put("integerMap", dataList); + + CustomClassI customClassI = object.fromJson(CustomClassI.class); + CustomClassI compareClassI = new CustomClassI(dataList); + assertEquals(customClassI.integerMap.toString(), compareClassI.integerMap.toString()); + } + + @Test + public void jsonObjectParseFromJson_9() { + JSONObject object = new JSONObject(); + object.put("number", 12); + object.put("classState", "mutated"); + + String initialClassState = CustomClassJ.classState; + CustomClassJ.classState = "original"; + try { + CustomClassJ customClassJ = object.fromJson(CustomClassJ.class); + assertEquals(12, customClassJ.number); + assertEquals("original", CustomClassJ.classState); + } finally { + CustomClassJ.classState = initialClassState; + } + } } diff --git a/src/test/java/org/json/junit/XMLConfigurationTest.java b/src/test/java/org/json/junit/XMLConfigurationTest.java index ca1980c8a..e8ff3b60c 100755 --- a/src/test/java/org/json/junit/XMLConfigurationTest.java +++ b/src/test/java/org/json/junit/XMLConfigurationTest.java @@ -1092,7 +1092,7 @@ public void testEmptyForceList() { ""; String expectedStr = - "{\"addresses\":[]}"; + "{\"addresses\":[\"\"]}"; Set forceList = new HashSet(); forceList.add("addresses"); @@ -1130,7 +1130,7 @@ public void testEmptyTagForceList() { ""; String expectedStr = - "{\"addresses\":[]}"; + "{\"addresses\":[\"\"]}"; Set forceList = new HashSet(); forceList.add("addresses"); @@ -1144,6 +1144,157 @@ public void testEmptyTagForceList() { Util.compareActualVsExpectedJsonObjects(jsonObject, expetedJsonObject); } + @Test + public void testForceListWithLastElementAsEmptyTag(){ + final String originalXml = "1"; + final String expectedJsonString = "{\"root\":{\"id\":[1,\"\"]}}"; + + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + final JSONObject json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withKeepStrings(false) + .withcDataTagName("content") + .withForceList(forceListCandidates) + .withConvertNilAttributeToNull(true)); + assertEquals(expectedJsonString, json.toString()); + } + + @Test + public void testForceListWithFirstElementAsEmptyTag(){ + final String originalXml = "1"; + final String expectedJsonString = "{\"root\":{\"id\":[\"\",1]}}"; + + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + final JSONObject json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withKeepStrings(false) + .withcDataTagName("content") + .withForceList(forceListCandidates) + .withConvertNilAttributeToNull(true)); + assertEquals(expectedJsonString, json.toString()); + } + + @Test + public void testForceListWithMiddleElementAsEmptyTag(){ + final String originalXml = "12"; + final String expectedJsonString = "{\"root\":{\"id\":[1,\"\",2]}}"; + + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + final JSONObject json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withKeepStrings(false) + .withcDataTagName("content") + .withForceList(forceListCandidates) + .withConvertNilAttributeToNull(true)); + assertEquals(expectedJsonString, json.toString()); + } + + @Test + public void testForceListWithLastElementAsEmpty(){ + final String originalXml = "1"; + final String expectedJsonString = "{\"root\":{\"id\":[1,\"\"]}}"; + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + final JSONObject json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withKeepStrings(false) + .withForceList(forceListCandidates) + .withConvertNilAttributeToNull(true)); + assertEquals(expectedJsonString, json.toString()); + } + + @Test + public void testForceListWithFirstElementAsEmpty(){ + final String originalXml = "1"; + final String expectedJsonString = "{\"root\":{\"id\":[\"\",1]}}"; + + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + final JSONObject json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withKeepStrings(false) + .withForceList(forceListCandidates) + .withConvertNilAttributeToNull(true)); + assertEquals(expectedJsonString, json.toString()); + } + + @Test + public void testForceListWithMiddleElementAsEmpty(){ + final String originalXml = "12"; + final String expectedJsonString = "{\"root\":{\"id\":[1,\"\",2]}}"; + + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + final JSONObject json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withKeepStrings(false) + .withForceList(forceListCandidates) + .withConvertNilAttributeToNull(true)); + assertEquals(expectedJsonString, json.toString()); + } + + @Test + public void testForceListEmptyAndEmptyTagsMixed(){ + final String originalXml = "12"; + final String expectedJsonString = "{\"root\":{\"id\":[\"\",\"\",1,\"\",\"\",2]}}"; + + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + final JSONObject json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withKeepStrings(false) + .withForceList(forceListCandidates) + .withConvertNilAttributeToNull(true)); + assertEquals(expectedJsonString, json.toString()); + } + + @Test + public void testForceListConsistencyWithDefault() { + final String originalXml = "01"; + final String expectedJsonString = "{\"root\":{\"id\":[0,1,\"\",\"\"]}}"; + + // confirm expected result of default array-of-tags processing + JSONObject json = XML.toJSONObject(originalXml); + assertEquals(expectedJsonString, json.toString()); + + // confirm forceList array-of-tags processing is consistent with default processing + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withForceList(forceListCandidates)); + assertEquals(expectedJsonString, json.toString()); + } + + @Test + public void testForceListInitializesAnArrayWithAnEmptyElement(){ + final String originalXml = ""; + final String expectedJsonString = "{\"root\":{\"id\":[\"\"]}}"; + + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + JSONObject json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withForceList(forceListCandidates)); + assertEquals(expectedJsonString, json.toString()); + } + + @Test + public void testForceListInitializesAnArrayWithAnEmptyTag(){ + final String originalXml = ""; + final String expectedJsonString = "{\"root\":{\"id\":[\"\"]}}"; + + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + JSONObject json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withForceList(forceListCandidates)); + assertEquals(expectedJsonString, json.toString()); + } + @Test public void testMaxNestingDepthIsSet() { XMLParserConfiguration xmlParserConfiguration = XMLParserConfiguration.ORIGINAL; diff --git a/src/test/java/org/json/junit/XMLTest.java b/src/test/java/org/json/junit/XMLTest.java index 2fa5daeea..25b0a0e42 100644 --- a/src/test/java/org/json/junit/XMLTest.java +++ b/src/test/java/org/json/junit/XMLTest.java @@ -1426,6 +1426,81 @@ public void clarifyCurrentBehavior() { assertEquals(jsonObject3.getJSONObject("color").getString("value"), "008E97"); } + /** + * Tests that empty numeric character reference &#; throws JSONException. + * Previously threw StringIndexOutOfBoundsException. + * Related to issue #1035 + */ + @Test(expected = JSONException.class) + public void testEmptyNumericEntityThrowsJSONException() { + String xmlStr = "&#;"; + XML.toJSONObject(xmlStr); + } + + /** + * Tests that malformed decimal entity &#txx; throws JSONException. + * Previously threw NumberFormatException. + * Related to issue #1036 + */ + @Test(expected = JSONException.class) + public void testInvalidDecimalEntityThrowsJSONException() { + String xmlStr = "&#txx;"; + XML.toJSONObject(xmlStr); + } + + /** + * Tests that empty hex entity &#x; throws JSONException. + * Validates proper input validation for hex entities. + */ + @Test(expected = JSONException.class) + public void testEmptyHexEntityThrowsJSONException() { + String xmlStr = "&#x;"; + XML.toJSONObject(xmlStr); + } + + /** + * Tests that invalid hex entity &#xGGG; throws JSONException. + * Validates hex digit validation. + */ + @Test(expected = JSONException.class) + public void testInvalidHexEntityThrowsJSONException() { + String xmlStr = "&#xGGG;"; + XML.toJSONObject(xmlStr); + } + + /** + * Tests that valid decimal numeric entity A works correctly. + * Should decode to character 'A'. + */ + @Test + public void testValidDecimalEntity() { + String xmlStr = "A"; + JSONObject jsonObject = XML.toJSONObject(xmlStr); + assertEquals("A", jsonObject.getString("a")); + } + + /** + * Tests that valid hex numeric entity A works correctly. + * Should decode to character 'A'. + */ + @Test + public void testValidHexEntity() { + String xmlStr = "A"; + JSONObject jsonObject = XML.toJSONObject(xmlStr); + assertEquals("A", jsonObject.getString("a")); + } + + /** + * Tests that valid uppercase hex entity A works correctly. + * Should decode to character 'A'. + */ + @Test + public void testValidUppercaseHexEntity() { + String xmlStr = "A"; + JSONObject jsonObject = XML.toJSONObject(xmlStr); + assertEquals("A", jsonObject.getString("a")); + } + } diff --git a/src/test/java/org/json/junit/data/CustomClass.java b/src/test/java/org/json/junit/data/CustomClass.java new file mode 100644 index 000000000..9ae405597 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClass.java @@ -0,0 +1,23 @@ +package org.json.junit.data; + +public class CustomClass { + public int number; + public String name; + public Long longNumber; + + public CustomClass() {} + public CustomClass (int number, String name, Long longNumber) { + this.number = number; + this.name = name; + this.longNumber = longNumber; + } + @Override + public boolean equals(Object o) { + CustomClass customClass = (CustomClass) o; + + return (this.number == customClass.number + && this.name.equals(customClass.name) + && this.longNumber.equals(customClass.longNumber)); + } +} + diff --git a/src/test/java/org/json/junit/data/CustomClassA.java b/src/test/java/org/json/junit/data/CustomClassA.java new file mode 100644 index 000000000..08a99d333 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassA.java @@ -0,0 +1,19 @@ +package org.json.junit.data; + +import java.math.BigInteger; + +public class CustomClassA { + public BigInteger largeInt; + + public CustomClassA() {} + public CustomClassA(BigInteger largeInt) { + this.largeInt = largeInt; + } + + @Override + public boolean equals(Object o) { + CustomClassA classA = (CustomClassA) o; + return this.largeInt.equals(classA.largeInt); + } +} + diff --git a/src/test/java/org/json/junit/data/CustomClassB.java b/src/test/java/org/json/junit/data/CustomClassB.java new file mode 100644 index 000000000..688997ec4 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassB.java @@ -0,0 +1,20 @@ +package org.json.junit.data; + +public class CustomClassB { + public int number; + public CustomClassC classC; + + public CustomClassB() {} + public CustomClassB(int number, CustomClassC classC) { + this.number = number; + this.classC = classC; + } + + @Override + public boolean equals(Object o) { + CustomClassB classB = (CustomClassB) o; + return this.number == classB.number + && this.classC.equals(classB.classC); + } +} + diff --git a/src/test/java/org/json/junit/data/CustomClassC.java b/src/test/java/org/json/junit/data/CustomClassC.java new file mode 100644 index 000000000..9d20aa392 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassC.java @@ -0,0 +1,34 @@ +package org.json.junit.data; + +import org.json.JSONObject; + +public class CustomClassC { + public String stringName; + public Long longNumber; + + public CustomClassC() {} + public CustomClassC(String stringName, Long longNumber) { + this.stringName = stringName; + this.longNumber = longNumber; + } + + public JSONObject toJSON() { + JSONObject object = new JSONObject(); + object.put("stringName", this.stringName); + object.put("longNumber", this.longNumber); + return object; + } + + @Override + public boolean equals(Object o) { + CustomClassC classC = (CustomClassC) o; + return this.stringName.equals(classC.stringName) + && this.longNumber.equals(classC.longNumber); + } + + @Override + public int hashCode() { + return java.util.Objects.hash(stringName, longNumber); + } +} + diff --git a/src/test/java/org/json/junit/data/CustomClassD.java b/src/test/java/org/json/junit/data/CustomClassD.java new file mode 100644 index 000000000..4a858058c --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassD.java @@ -0,0 +1,19 @@ +package org.json.junit.data; + +import java.util.List; + +public class CustomClassD { + public List stringList; + + public CustomClassD() {} + public CustomClassD(List stringList) { + this.stringList = stringList; + } + + @Override + public boolean equals(Object o) { + CustomClassD classD = (CustomClassD) o; + return this.stringList.equals(classD.stringList); + } +} + diff --git a/src/test/java/org/json/junit/data/CustomClassE.java b/src/test/java/org/json/junit/data/CustomClassE.java new file mode 100644 index 000000000..807dc5540 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassE.java @@ -0,0 +1,18 @@ +package org.json.junit.data; + +import java.util.List; + +public class CustomClassE { + public List listClassC; + + public CustomClassE() {} + public CustomClassE(List listClassC) { + this.listClassC = listClassC; + } + + @Override + public boolean equals(Object o) { + CustomClassE classE = (CustomClassE) o; + return this.listClassC.equals(classE.listClassC); + } +} diff --git a/src/test/java/org/json/junit/data/CustomClassF.java b/src/test/java/org/json/junit/data/CustomClassF.java new file mode 100644 index 000000000..d85861036 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassF.java @@ -0,0 +1,19 @@ +package org.json.junit.data; + +import java.util.List; + +public class CustomClassF { + public List> listOfString; + + public CustomClassF() {} + public CustomClassF(List> listOfString) { + this.listOfString = listOfString; + } + + @Override + public boolean equals(Object o) { + CustomClassF classF = (CustomClassF) o; + return this.listOfString.equals(classF.listOfString); + } +} + diff --git a/src/test/java/org/json/junit/data/CustomClassG.java b/src/test/java/org/json/junit/data/CustomClassG.java new file mode 100644 index 000000000..c8c9f5784 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassG.java @@ -0,0 +1,18 @@ +package org.json.junit.data; + +import java.util.Map; + +public class CustomClassG { + public Map dataList; + + public CustomClassG () {} + public CustomClassG (Map dataList) { + this.dataList = dataList; + } + + @Override + public boolean equals(Object object) { + CustomClassG classG = (CustomClassG) object; + return this.dataList.equals(classG.dataList); + } +} diff --git a/src/test/java/org/json/junit/data/CustomClassH.java b/src/test/java/org/json/junit/data/CustomClassH.java new file mode 100644 index 000000000..ce9b1af23 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassH.java @@ -0,0 +1,22 @@ +package org.json.junit.data; + +import java.util.Map; +import java.util.List; +import java.util.ArrayList; + +public class CustomClassH { + public Map> integerMap; + + public CustomClassH() {} + public CustomClassH(Map> integerMap) { + this.integerMap = integerMap; + } + + @Override + public boolean equals(Object object) { + CustomClassH classH = (CustomClassH) object; + return this.integerMap.size() == classH.integerMap.size() + && this.integerMap.keySet().equals(classH.integerMap.keySet()) + && new ArrayList<>(this.integerMap.values()).equals(new ArrayList<>(classH.integerMap.values())); + } +} diff --git a/src/test/java/org/json/junit/data/CustomClassI.java b/src/test/java/org/json/junit/data/CustomClassI.java new file mode 100644 index 000000000..bd7c4ed89 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassI.java @@ -0,0 +1,12 @@ +package org.json.junit.data; + +import java.util.Map; + +public class CustomClassI { + public Map> integerMap; + + public CustomClassI() {} + public CustomClassI(Map> integerMap) { + this.integerMap = integerMap; + } +} diff --git a/src/test/java/org/json/junit/data/CustomClassJ.java b/src/test/java/org/json/junit/data/CustomClassJ.java new file mode 100644 index 000000000..62cce3ea4 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassJ.java @@ -0,0 +1,10 @@ +package org.json.junit.data; + +public class CustomClassJ { + public static String classState = "original"; + public int number; + + public CustomClassJ() { + // Required for JSONObject#fromJson(Class) tests. + } +} diff --git a/src/test/java/org/json/junit/data/PersonRecord.java b/src/test/java/org/json/junit/data/PersonRecord.java new file mode 100644 index 000000000..891f1bb9e --- /dev/null +++ b/src/test/java/org/json/junit/data/PersonRecord.java @@ -0,0 +1,31 @@ +package org.json.junit.data; + +/** + * A test class that mimics Java record accessor patterns. + * Records use accessor methods without get/is prefixes (e.g., name() instead of getName()). + * This class simulates that behavior to test JSONObject's handling of such methods. + */ +public class PersonRecord { + private final String name; + private final int age; + private final boolean active; + + public PersonRecord(String name, int age, boolean active) { + this.name = name; + this.age = age; + this.active = active; + } + + // Record-style accessors (no "get" or "is" prefix) + public String name() { + return name; + } + + public int age() { + return age; + } + + public boolean active() { + return active; + } +}
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. + */ + 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/XML.java b/src/main/java/org/json/XML.java index 3eb948c77..7e4b0bb0c 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; @@ -387,8 +391,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) { @@ -447,7 +456,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())); diff --git a/src/main/java/org/json/XMLTokener.java b/src/main/java/org/json/XMLTokener.java index bc18b31c9..dad2e2897 100644 --- a/src/main/java/org/json/XMLTokener.java +++ b/src/main/java/org/json/XMLTokener.java @@ -151,33 +151,108 @@ 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: &#;"); } - return new String(new int[] {cp},0,1); - } + int cp = (e.charAt(1) == 'x' || e.charAt(1) == 'X') + ? parseHexEntity(e) + : parseDecimalEntity(e); + 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/JSONMLTest.java b/src/test/java/org/json/junit/JSONMLTest.java index 5a360dd59..93a6821d8 100644 --- a/src/test/java/org/json/junit/JSONMLTest.java +++ b/src/test/java/org/json/junit/JSONMLTest.java @@ -986,4 +986,70 @@ public void testToJSONObjectMaxNestingDepthWithValidFittingXML() { } } + /** + * Tests that malformed XML causing type mismatch throws JSONException. + * Previously threw ClassCastException when parse() returned String instead of JSONArray. + * Related to issue #1034 + */ + @Test(expected = JSONException.class) + public void testMalformedXMLThrowsJSONExceptionNotClassCast() { + // This malformed XML causes parse() to return wrong type + byte[] data = {0x3c, 0x0a, 0x2f, (byte)0xff, (byte)0xff, (byte)0xff, + (byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff, + (byte)0xff, 0x3e, 0x42}; + String xmlStr = new String(data); + JSONML.toJSONArray(xmlStr); + } + + /** + * Tests that type mismatch in toJSONObject throws JSONException. + * Validates safe type casting in toJSONObject methods. + */ + @Test + public void testToJSONObjectTypeMismatch() { + // Create XML that would cause parse() to return wrong type + String xmlStr = "<\n/\u00ff\u00ff\u00ff\u00ff\u00ff\u00ff\u00ff\u00ff>B"; + try { + JSONML.toJSONObject(xmlStr); + fail("Expected JSONException for type mismatch"); + } catch (ClassCastException e) { + fail("Should throw JSONException, not ClassCastException"); + } catch (JSONException e) { + // Expected - verify it's about type mismatch + assertTrue("Exception message should mention type error", + e.getMessage().contains("Expected") || e.getMessage().contains("got")); + } + } + + /** + * Tests that valid XML still works correctly after the fix. + * Ensures the type checking doesn't break normal operation. + */ + @Test + public void testValidXMLStillWorks() { + String xmlStr = "value"; + try { + JSONArray jsonArray = JSONML.toJSONArray(xmlStr); + assertNotNull("JSONArray should not be null", jsonArray); + assertEquals("root", jsonArray.getString(0)); + } catch (Exception e) { + fail("Valid XML should not throw exception: " + e.getMessage()); + } + } + + /** + * Tests that valid XML to JSONObject still works correctly. + */ + @Test + public void testValidXMLToJSONObjectStillWorks() { + String xmlStr = "content"; + try { + JSONObject jsonObject = JSONML.toJSONObject(xmlStr); + assertNotNull("JSONObject should not be null", jsonObject); + assertEquals("root", jsonObject.getString("tagName")); + } catch (Exception e) { + fail("Valid XML should not throw exception: " + e.getMessage()); + } + } + } diff --git a/src/test/java/org/json/junit/JSONObjectLocaleTest.java b/src/test/java/org/json/junit/JSONObjectLocaleTest.java index 1cdaf743d..e1a9dd64e 100755 --- a/src/test/java/org/json/junit/JSONObjectLocaleTest.java +++ b/src/test/java/org/json/junit/JSONObjectLocaleTest.java @@ -36,25 +36,31 @@ public void jsonObjectByLocaleBean() { MyLocaleBean myLocaleBean = new MyLocaleBean(); - /** - * This is just the control case which happens when the locale.ROOT - * lowercasing behavior is the same as the current locale. - */ - Locale.setDefault(new Locale("en")); - JSONObject jsonen = new JSONObject(myLocaleBean); - assertEquals("expected size 2, found: " +jsonen.length(), 2, jsonen.length()); - assertEquals("expected jsonen[i] == beanI", "beanI", jsonen.getString("i")); - assertEquals("expected jsonen[id] == beanId", "beanId", jsonen.getString("id")); - - /** - * Without the JSON-Java change, these keys would be stored internally as - * starting with the letter, 'ı' (dotless i), since the lowercasing of - * the getI and getId keys would be specific to the Turkish locale. - */ - Locale.setDefault(new Locale("tr")); - JSONObject jsontr = new JSONObject(myLocaleBean); - assertEquals("expected size 2, found: " +jsontr.length(), 2, jsontr.length()); - assertEquals("expected jsontr[i] == beanI", "beanI", jsontr.getString("i")); - assertEquals("expected jsontr[id] == beanId", "beanId", jsontr.getString("id")); + // save and restore the current default locale, to avoid any side effects on other executions in the same JVM + Locale defaultLocale = Locale.getDefault(); + try { + /** + * This is just the control case which happens when the locale.ROOT + * lowercasing behavior is the same as the current locale. + */ + Locale.setDefault(new Locale("en")); + JSONObject jsonen = new JSONObject(myLocaleBean); + assertEquals("expected size 2, found: " +jsonen.length(), 2, jsonen.length()); + assertEquals("expected jsonen[i] == beanI", "beanI", jsonen.getString("i")); + assertEquals("expected jsonen[id] == beanId", "beanId", jsonen.getString("id")); + + /** + * Without the JSON-Java change, these keys would be stored internally as + * starting with the letter, 'ı' (dotless i), since the lowercasing of + * the getI and getId keys would be specific to the Turkish locale. + */ + Locale.setDefault(new Locale("tr")); + JSONObject jsontr = new JSONObject(myLocaleBean); + assertEquals("expected size 2, found: " +jsontr.length(), 2, jsontr.length()); + assertEquals("expected jsontr[i] == beanI", "beanI", jsontr.getString("i")); + assertEquals("expected jsontr[id] == beanId", "beanId", jsontr.getString("id")); + } finally { + Locale.setDefault(defaultLocale); + } } } diff --git a/src/test/java/org/json/junit/JSONObjectRecordTest.java b/src/test/java/org/json/junit/JSONObjectRecordTest.java new file mode 100644 index 000000000..f1a673d28 --- /dev/null +++ b/src/test/java/org/json/junit/JSONObjectRecordTest.java @@ -0,0 +1,179 @@ +package org.json.junit; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +import java.io.StringReader; + +import org.json.JSONObject; +import org.json.junit.data.GenericBeanInt; +import org.json.junit.data.MyEnum; +import org.json.junit.data.MyNumber; +import org.json.junit.data.PersonRecord; +import org.junit.Ignore; +import org.junit.Test; + +/** + * Tests for JSONObject support of Java record types. + * + * NOTE: These tests are currently ignored because PersonRecord is not an actual Java record. + * The implementation now correctly detects actual Java records using reflection (Class.isRecord()). + * These tests will need to be enabled and run with Java 17+ where PersonRecord can be converted + * to an actual record type. + * + * This ensures backward compatibility - regular classes with lowercase method names will not + * be treated as records unless they are actual Java record types. + */ +public class JSONObjectRecordTest { + + /** + * Tests that JSONObject can be created from a record-style class. + * Record-style classes use accessor methods like name() instead of getName(). + * + * NOTE: Ignored until PersonRecord is converted to an actual Java record (requires Java 17+) + */ + @Test + @Ignore("Requires actual Java record type - PersonRecord needs to be a real record (Java 17+)") + public void jsonObjectByRecord() { + PersonRecord person = new PersonRecord("John Doe", 30, true); + JSONObject jsonObject = new JSONObject(person); + + assertEquals("Expected 3 keys in the JSONObject", 3, jsonObject.length()); + assertEquals("John Doe", jsonObject.get("name")); + assertEquals(30, jsonObject.get("age")); + assertEquals(true, jsonObject.get("active")); + } + + /** + * Test that Object methods (toString, hashCode, equals, etc.) are not included + * + * NOTE: Ignored until PersonRecord is converted to an actual Java record (requires Java 17+) + */ + @Test + @Ignore("Requires actual Java record type - PersonRecord needs to be a real record (Java 17+)") + public void recordStyleClassShouldNotIncludeObjectMethods() { + PersonRecord person = new PersonRecord("Jane Doe", 25, false); + JSONObject jsonObject = new JSONObject(person); + + // Should NOT include Object methods + assertFalse("Should not include toString", jsonObject.has("toString")); + assertFalse("Should not include hashCode", jsonObject.has("hashCode")); + assertFalse("Should not include equals", jsonObject.has("equals")); + assertFalse("Should not include clone", jsonObject.has("clone")); + assertFalse("Should not include wait", jsonObject.has("wait")); + assertFalse("Should not include notify", jsonObject.has("notify")); + assertFalse("Should not include notifyAll", jsonObject.has("notifyAll")); + + // Should only have the 3 record fields + assertEquals("Should only have 3 fields", 3, jsonObject.length()); + } + + /** + * Test that enum methods are not included when processing an enum + */ + @Test + public void enumsShouldNotIncludeEnumMethods() { + MyEnum myEnum = MyEnum.VAL1; + JSONObject jsonObject = new JSONObject(myEnum); + + // Should NOT include enum-specific methods like name(), ordinal(), values(), valueOf() + assertFalse("Should not include name method", jsonObject.has("name")); + assertFalse("Should not include ordinal method", jsonObject.has("ordinal")); + assertFalse("Should not include declaringClass", jsonObject.has("declaringClass")); + + // Enums should still work with traditional getters if they have any + // But should not pick up the built-in enum methods + } + + /** + * Test that Number subclass methods are not included + */ + @Test + public void numberSubclassesShouldNotIncludeNumberMethods() { + MyNumber myNumber = new MyNumber(); + JSONObject jsonObject = new JSONObject(myNumber); + + // Should NOT include Number methods like intValue(), longValue(), etc. + assertFalse("Should not include intValue", jsonObject.has("intValue")); + assertFalse("Should not include longValue", jsonObject.has("longValue")); + assertFalse("Should not include doubleValue", jsonObject.has("doubleValue")); + assertFalse("Should not include floatValue", jsonObject.has("floatValue")); + + // Should include the actual getter + assertTrue("Should include number", jsonObject.has("number")); + assertEquals("Should have 1 field", 1, jsonObject.length()); + } + + /** + * Test that generic bean with get() and is() methods works correctly + */ + @Test + public void genericBeanWithGetAndIsMethodsShouldNotBeIncluded() { + GenericBeanInt bean = new GenericBeanInt(42); + JSONObject jsonObject = new JSONObject(bean); + + // Should NOT include standalone get() or is() methods + assertFalse("Should not include standalone 'get' method", jsonObject.has("get")); + assertFalse("Should not include standalone 'is' method", jsonObject.has("is")); + + // Should include the actual getters + assertTrue("Should include genericValue field", jsonObject.has("genericValue")); + assertTrue("Should include a field", jsonObject.has("a")); + } + + /** + * Test that java.* classes don't have their methods picked up + */ + @Test + public void javaLibraryClassesShouldNotIncludeTheirMethods() { + StringReader reader = new StringReader("test"); + JSONObject jsonObject = new JSONObject(reader); + + // Should NOT include java.io.Reader methods like read(), reset(), etc. + assertFalse("Should not include read method", jsonObject.has("read")); + assertFalse("Should not include reset method", jsonObject.has("reset")); + assertFalse("Should not include ready method", jsonObject.has("ready")); + assertFalse("Should not include skip method", jsonObject.has("skip")); + + // Reader should produce empty JSONObject (no valid properties) + assertEquals("Reader should produce empty JSON", 0, jsonObject.length()); + } + + /** + * Test mixed case - object with both traditional getters and record-style accessors + * + * NOTE: Ignored until PersonRecord is converted to an actual Java record (requires Java 17+) + */ + @Test + @Ignore("Requires actual Java record type - PersonRecord needs to be a real record (Java 17+)") + public void mixedGettersAndRecordStyleAccessors() { + // PersonRecord has record-style accessors: name(), age(), active() + // These should all be included + PersonRecord person = new PersonRecord("Mixed Test", 40, true); + JSONObject jsonObject = new JSONObject(person); + + assertEquals("Should have all 3 record-style fields", 3, jsonObject.length()); + assertTrue("Should include name", jsonObject.has("name")); + assertTrue("Should include age", jsonObject.has("age")); + assertTrue("Should include active", jsonObject.has("active")); + } + + /** + * Test that methods starting with uppercase are not included (not valid record accessors) + * + * NOTE: Ignored until PersonRecord is converted to an actual Java record (requires Java 17+) + */ + @Test + @Ignore("Requires actual Java record type - PersonRecord needs to be a real record (Java 17+)") + public void methodsStartingWithUppercaseShouldNotBeIncluded() { + PersonRecord person = new PersonRecord("Test", 50, false); + JSONObject jsonObject = new JSONObject(person); + + // Record-style accessors must start with lowercase + // Methods like Name(), Age() (uppercase) should not be picked up + // Our PersonRecord only has lowercase accessors, which is correct + + assertEquals("Should only have lowercase accessors", 3, jsonObject.length()); + } +} diff --git a/src/test/java/org/json/junit/JSONObjectTest.java b/src/test/java/org/json/junit/JSONObjectTest.java index 88c19c7dc..6a3c9b573 100644 --- a/src/test/java/org/json/junit/JSONObjectTest.java +++ b/src/test/java/org/json/junit/JSONObjectTest.java @@ -56,6 +56,18 @@ import org.json.junit.data.Singleton; import org.json.junit.data.SingletonEnum; import org.json.junit.data.WeirdList; +import org.json.junit.data.CustomClass; +import org.json.junit.data.CustomClassA; +import org.json.junit.data.CustomClassB; +import org.json.junit.data.CustomClassC; +import org.json.junit.data.CustomClassD; +import org.json.junit.data.CustomClassE; +import org.json.junit.data.CustomClassF; +import org.json.junit.data.CustomClassG; +import org.json.junit.data.CustomClassH; +import org.json.junit.data.CustomClassI; +import org.json.junit.data.CustomClassJ; +import org.json.JSONObject; import org.junit.After; import org.junit.Ignore; import org.junit.Test; @@ -3106,12 +3118,13 @@ public void testJSONWriterException() { // test a more complex object writer = new StringWriter(); - try { - new JSONObject() + + JSONObject object = new JSONObject() .put("somethingElse", "a value") .put("someKey", new JSONArray() - .put(new JSONObject().put("key1", new BrokenToString()))) - .write(writer).toString(); + .put(new JSONObject().put("key1", new BrokenToString()))); + try { + object.write(writer).toString(); fail("Expected an exception, got a String value"); } catch (JSONException e) { assertEquals("Unable to write JSONObject value for key: someKey", e.getMessage()); @@ -3122,17 +3135,18 @@ public void testJSONWriterException() { writer.close(); } catch (Exception e) {} } - + // test a more slightly complex object writer = new StringWriter(); - try { - new JSONObject() + + object = new JSONObject() .put("somethingElse", "a value") .put("someKey", new JSONArray() .put(new JSONObject().put("key1", new BrokenToString())) .put(12345) - ) - .write(writer).toString(); + ); + try { + object.write(writer).toString(); fail("Expected an exception, got a String value"); } catch (JSONException e) { assertEquals("Unable to write JSONObject value for key: someKey", e.getMessage()); @@ -4095,4 +4109,145 @@ public void jsonObjectParseNullFieldsWithoutParserConfiguration() { assertTrue("JSONObject should be empty", jsonObject.isEmpty()); } + + @Test + public void jsonObjectParseFromJson_0() { + JSONObject object = new JSONObject(); + object.put("number", 12); + object.put("name", "Alex"); + object.put("longNumber", 1500000000L); + CustomClass customClass = object.fromJson(CustomClass.class); + CustomClass compareClass = new CustomClass(12, "Alex", 1500000000L); + assertEquals(customClass, compareClass); + } + + @Test + public void jsonObjectParseFromJson_1() { + JSONObject object = new JSONObject(); + + BigInteger largeInt = new BigInteger("123"); + object.put("largeInt", largeInt.toString()); + CustomClassA customClassA = object.fromJson(CustomClassA.class); + CustomClassA compareClassClassA = new CustomClassA(largeInt); + assertEquals(customClassA, compareClassClassA); + } + + @Test + public void jsonObjectParseFromJson_2() { + JSONObject object = new JSONObject(); + object.put("number", 12); + + JSONObject classC = new JSONObject(); + classC.put("stringName", "Alex"); + classC.put("longNumber", 123456L); + + object.put("classC", classC); + + CustomClassB customClassB = object.fromJson(CustomClassB.class); + CustomClassC classCObject = new CustomClassC("Alex", 123456L); + CustomClassB compareClassB = new CustomClassB(12, classCObject); + assertEquals(customClassB, compareClassB); + } + + @Test + public void jsonObjectParseFromJson_3() { + JSONObject object = new JSONObject(); + JSONArray array = new JSONArray(); + array.put("test1"); + array.put("test2"); + array.put("test3"); + object.put("stringList", array); + + CustomClassD customClassD = object.fromJson(CustomClassD.class); + CustomClassD compareClassD = new CustomClassD(Arrays.asList("test1", "test2", "test3")); + assertEquals(customClassD, compareClassD); + } + + @Test + public void jsonObjectParseFromJson_4() { + JSONObject object = new JSONObject(); + JSONArray array = new JSONArray(); + array.put(new CustomClassC("test1", 1L).toJSON()); + array.put(new CustomClassC("test2", 2L).toJSON()); + object.put("listClassC", array); + + CustomClassE customClassE = object.fromJson(CustomClassE.class); + CustomClassE compareClassE = new CustomClassE(java.util.Arrays.asList( + new CustomClassC("test1", 1L), + new CustomClassC("test2", 2L))); + assertEquals(customClassE, compareClassE); + } + + @Test + public void jsonObjectParseFromJson_5() { + JSONObject object = new JSONObject(); + JSONArray array = new JSONArray(); + array.put(Arrays.asList("A", "B", "C")); + array.put(Arrays.asList("D", "E")); + object.put("listOfString", array); + + CustomClassF customClassF = object.fromJson(CustomClassF.class); + List> listOfString = new ArrayList<>(); + listOfString.add(Arrays.asList("A", "B", "C")); + listOfString.add(Arrays.asList("D", "E")); + CustomClassF compareClassF = new CustomClassF(listOfString); + assertEquals(customClassF, compareClassF); + } + + @Test + public void jsonObjectParseFromJson_6() { + JSONObject object = new JSONObject(); + Map dataList = new HashMap<>(); + dataList.put("A", "Aa"); + dataList.put("B", "Bb"); + dataList.put("C", "Cc"); + object.put("dataList", dataList); + + CustomClassG customClassG = object.fromJson(CustomClassG.class); + CustomClassG compareClassG = new CustomClassG(dataList); + assertEquals(customClassG, compareClassG); + } + + @Test + public void jsonObjectParseFromJson_7() { + JSONObject object = new JSONObject(); + Map> dataList = new HashMap<>(); + dataList.put("1", Arrays.asList(1, 2, 3, 4)); + dataList.put("2", Arrays.asList(2, 3, 4, 5)); + object.put("integerMap", dataList); + + CustomClassH customClassH = object.fromJson(CustomClassH.class); + CustomClassH compareClassH = new CustomClassH(dataList); + assertEquals(customClassH.integerMap.toString(), compareClassH.integerMap.toString()); + } + + @Test + public void jsonObjectParseFromJson_8() { + JSONObject object = new JSONObject(); + Map> dataList = new HashMap<>(); + dataList.put("1", Collections.singletonMap("1", 1)); + dataList.put("2", Collections.singletonMap("2", 2)); + object.put("integerMap", dataList); + + CustomClassI customClassI = object.fromJson(CustomClassI.class); + CustomClassI compareClassI = new CustomClassI(dataList); + assertEquals(customClassI.integerMap.toString(), compareClassI.integerMap.toString()); + } + + @Test + public void jsonObjectParseFromJson_9() { + JSONObject object = new JSONObject(); + object.put("number", 12); + object.put("classState", "mutated"); + + String initialClassState = CustomClassJ.classState; + CustomClassJ.classState = "original"; + try { + CustomClassJ customClassJ = object.fromJson(CustomClassJ.class); + assertEquals(12, customClassJ.number); + assertEquals("original", CustomClassJ.classState); + } finally { + CustomClassJ.classState = initialClassState; + } + } } diff --git a/src/test/java/org/json/junit/XMLConfigurationTest.java b/src/test/java/org/json/junit/XMLConfigurationTest.java index ca1980c8a..e8ff3b60c 100755 --- a/src/test/java/org/json/junit/XMLConfigurationTest.java +++ b/src/test/java/org/json/junit/XMLConfigurationTest.java @@ -1092,7 +1092,7 @@ public void testEmptyForceList() { ""; String expectedStr = - "{\"addresses\":[]}"; + "{\"addresses\":[\"\"]}"; Set forceList = new HashSet(); forceList.add("addresses"); @@ -1130,7 +1130,7 @@ public void testEmptyTagForceList() { ""; String expectedStr = - "{\"addresses\":[]}"; + "{\"addresses\":[\"\"]}"; Set forceList = new HashSet(); forceList.add("addresses"); @@ -1144,6 +1144,157 @@ public void testEmptyTagForceList() { Util.compareActualVsExpectedJsonObjects(jsonObject, expetedJsonObject); } + @Test + public void testForceListWithLastElementAsEmptyTag(){ + final String originalXml = "1"; + final String expectedJsonString = "{\"root\":{\"id\":[1,\"\"]}}"; + + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + final JSONObject json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withKeepStrings(false) + .withcDataTagName("content") + .withForceList(forceListCandidates) + .withConvertNilAttributeToNull(true)); + assertEquals(expectedJsonString, json.toString()); + } + + @Test + public void testForceListWithFirstElementAsEmptyTag(){ + final String originalXml = "1"; + final String expectedJsonString = "{\"root\":{\"id\":[\"\",1]}}"; + + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + final JSONObject json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withKeepStrings(false) + .withcDataTagName("content") + .withForceList(forceListCandidates) + .withConvertNilAttributeToNull(true)); + assertEquals(expectedJsonString, json.toString()); + } + + @Test + public void testForceListWithMiddleElementAsEmptyTag(){ + final String originalXml = "12"; + final String expectedJsonString = "{\"root\":{\"id\":[1,\"\",2]}}"; + + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + final JSONObject json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withKeepStrings(false) + .withcDataTagName("content") + .withForceList(forceListCandidates) + .withConvertNilAttributeToNull(true)); + assertEquals(expectedJsonString, json.toString()); + } + + @Test + public void testForceListWithLastElementAsEmpty(){ + final String originalXml = "1"; + final String expectedJsonString = "{\"root\":{\"id\":[1,\"\"]}}"; + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + final JSONObject json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withKeepStrings(false) + .withForceList(forceListCandidates) + .withConvertNilAttributeToNull(true)); + assertEquals(expectedJsonString, json.toString()); + } + + @Test + public void testForceListWithFirstElementAsEmpty(){ + final String originalXml = "1"; + final String expectedJsonString = "{\"root\":{\"id\":[\"\",1]}}"; + + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + final JSONObject json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withKeepStrings(false) + .withForceList(forceListCandidates) + .withConvertNilAttributeToNull(true)); + assertEquals(expectedJsonString, json.toString()); + } + + @Test + public void testForceListWithMiddleElementAsEmpty(){ + final String originalXml = "12"; + final String expectedJsonString = "{\"root\":{\"id\":[1,\"\",2]}}"; + + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + final JSONObject json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withKeepStrings(false) + .withForceList(forceListCandidates) + .withConvertNilAttributeToNull(true)); + assertEquals(expectedJsonString, json.toString()); + } + + @Test + public void testForceListEmptyAndEmptyTagsMixed(){ + final String originalXml = "12"; + final String expectedJsonString = "{\"root\":{\"id\":[\"\",\"\",1,\"\",\"\",2]}}"; + + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + final JSONObject json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withKeepStrings(false) + .withForceList(forceListCandidates) + .withConvertNilAttributeToNull(true)); + assertEquals(expectedJsonString, json.toString()); + } + + @Test + public void testForceListConsistencyWithDefault() { + final String originalXml = "01"; + final String expectedJsonString = "{\"root\":{\"id\":[0,1,\"\",\"\"]}}"; + + // confirm expected result of default array-of-tags processing + JSONObject json = XML.toJSONObject(originalXml); + assertEquals(expectedJsonString, json.toString()); + + // confirm forceList array-of-tags processing is consistent with default processing + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withForceList(forceListCandidates)); + assertEquals(expectedJsonString, json.toString()); + } + + @Test + public void testForceListInitializesAnArrayWithAnEmptyElement(){ + final String originalXml = ""; + final String expectedJsonString = "{\"root\":{\"id\":[\"\"]}}"; + + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + JSONObject json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withForceList(forceListCandidates)); + assertEquals(expectedJsonString, json.toString()); + } + + @Test + public void testForceListInitializesAnArrayWithAnEmptyTag(){ + final String originalXml = ""; + final String expectedJsonString = "{\"root\":{\"id\":[\"\"]}}"; + + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + JSONObject json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withForceList(forceListCandidates)); + assertEquals(expectedJsonString, json.toString()); + } + @Test public void testMaxNestingDepthIsSet() { XMLParserConfiguration xmlParserConfiguration = XMLParserConfiguration.ORIGINAL; diff --git a/src/test/java/org/json/junit/XMLTest.java b/src/test/java/org/json/junit/XMLTest.java index 2fa5daeea..25b0a0e42 100644 --- a/src/test/java/org/json/junit/XMLTest.java +++ b/src/test/java/org/json/junit/XMLTest.java @@ -1426,6 +1426,81 @@ public void clarifyCurrentBehavior() { assertEquals(jsonObject3.getJSONObject("color").getString("value"), "008E97"); } + /** + * Tests that empty numeric character reference &#; throws JSONException. + * Previously threw StringIndexOutOfBoundsException. + * Related to issue #1035 + */ + @Test(expected = JSONException.class) + public void testEmptyNumericEntityThrowsJSONException() { + String xmlStr = "&#;"; + XML.toJSONObject(xmlStr); + } + + /** + * Tests that malformed decimal entity &#txx; throws JSONException. + * Previously threw NumberFormatException. + * Related to issue #1036 + */ + @Test(expected = JSONException.class) + public void testInvalidDecimalEntityThrowsJSONException() { + String xmlStr = "&#txx;"; + XML.toJSONObject(xmlStr); + } + + /** + * Tests that empty hex entity &#x; throws JSONException. + * Validates proper input validation for hex entities. + */ + @Test(expected = JSONException.class) + public void testEmptyHexEntityThrowsJSONException() { + String xmlStr = "&#x;"; + XML.toJSONObject(xmlStr); + } + + /** + * Tests that invalid hex entity &#xGGG; throws JSONException. + * Validates hex digit validation. + */ + @Test(expected = JSONException.class) + public void testInvalidHexEntityThrowsJSONException() { + String xmlStr = "&#xGGG;"; + XML.toJSONObject(xmlStr); + } + + /** + * Tests that valid decimal numeric entity A works correctly. + * Should decode to character 'A'. + */ + @Test + public void testValidDecimalEntity() { + String xmlStr = "A"; + JSONObject jsonObject = XML.toJSONObject(xmlStr); + assertEquals("A", jsonObject.getString("a")); + } + + /** + * Tests that valid hex numeric entity A works correctly. + * Should decode to character 'A'. + */ + @Test + public void testValidHexEntity() { + String xmlStr = "A"; + JSONObject jsonObject = XML.toJSONObject(xmlStr); + assertEquals("A", jsonObject.getString("a")); + } + + /** + * Tests that valid uppercase hex entity A works correctly. + * Should decode to character 'A'. + */ + @Test + public void testValidUppercaseHexEntity() { + String xmlStr = "A"; + JSONObject jsonObject = XML.toJSONObject(xmlStr); + assertEquals("A", jsonObject.getString("a")); + } + } diff --git a/src/test/java/org/json/junit/data/CustomClass.java b/src/test/java/org/json/junit/data/CustomClass.java new file mode 100644 index 000000000..9ae405597 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClass.java @@ -0,0 +1,23 @@ +package org.json.junit.data; + +public class CustomClass { + public int number; + public String name; + public Long longNumber; + + public CustomClass() {} + public CustomClass (int number, String name, Long longNumber) { + this.number = number; + this.name = name; + this.longNumber = longNumber; + } + @Override + public boolean equals(Object o) { + CustomClass customClass = (CustomClass) o; + + return (this.number == customClass.number + && this.name.equals(customClass.name) + && this.longNumber.equals(customClass.longNumber)); + } +} + diff --git a/src/test/java/org/json/junit/data/CustomClassA.java b/src/test/java/org/json/junit/data/CustomClassA.java new file mode 100644 index 000000000..08a99d333 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassA.java @@ -0,0 +1,19 @@ +package org.json.junit.data; + +import java.math.BigInteger; + +public class CustomClassA { + public BigInteger largeInt; + + public CustomClassA() {} + public CustomClassA(BigInteger largeInt) { + this.largeInt = largeInt; + } + + @Override + public boolean equals(Object o) { + CustomClassA classA = (CustomClassA) o; + return this.largeInt.equals(classA.largeInt); + } +} + diff --git a/src/test/java/org/json/junit/data/CustomClassB.java b/src/test/java/org/json/junit/data/CustomClassB.java new file mode 100644 index 000000000..688997ec4 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassB.java @@ -0,0 +1,20 @@ +package org.json.junit.data; + +public class CustomClassB { + public int number; + public CustomClassC classC; + + public CustomClassB() {} + public CustomClassB(int number, CustomClassC classC) { + this.number = number; + this.classC = classC; + } + + @Override + public boolean equals(Object o) { + CustomClassB classB = (CustomClassB) o; + return this.number == classB.number + && this.classC.equals(classB.classC); + } +} + diff --git a/src/test/java/org/json/junit/data/CustomClassC.java b/src/test/java/org/json/junit/data/CustomClassC.java new file mode 100644 index 000000000..9d20aa392 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassC.java @@ -0,0 +1,34 @@ +package org.json.junit.data; + +import org.json.JSONObject; + +public class CustomClassC { + public String stringName; + public Long longNumber; + + public CustomClassC() {} + public CustomClassC(String stringName, Long longNumber) { + this.stringName = stringName; + this.longNumber = longNumber; + } + + public JSONObject toJSON() { + JSONObject object = new JSONObject(); + object.put("stringName", this.stringName); + object.put("longNumber", this.longNumber); + return object; + } + + @Override + public boolean equals(Object o) { + CustomClassC classC = (CustomClassC) o; + return this.stringName.equals(classC.stringName) + && this.longNumber.equals(classC.longNumber); + } + + @Override + public int hashCode() { + return java.util.Objects.hash(stringName, longNumber); + } +} + diff --git a/src/test/java/org/json/junit/data/CustomClassD.java b/src/test/java/org/json/junit/data/CustomClassD.java new file mode 100644 index 000000000..4a858058c --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassD.java @@ -0,0 +1,19 @@ +package org.json.junit.data; + +import java.util.List; + +public class CustomClassD { + public List stringList; + + public CustomClassD() {} + public CustomClassD(List stringList) { + this.stringList = stringList; + } + + @Override + public boolean equals(Object o) { + CustomClassD classD = (CustomClassD) o; + return this.stringList.equals(classD.stringList); + } +} + diff --git a/src/test/java/org/json/junit/data/CustomClassE.java b/src/test/java/org/json/junit/data/CustomClassE.java new file mode 100644 index 000000000..807dc5540 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassE.java @@ -0,0 +1,18 @@ +package org.json.junit.data; + +import java.util.List; + +public class CustomClassE { + public List listClassC; + + public CustomClassE() {} + public CustomClassE(List listClassC) { + this.listClassC = listClassC; + } + + @Override + public boolean equals(Object o) { + CustomClassE classE = (CustomClassE) o; + return this.listClassC.equals(classE.listClassC); + } +} diff --git a/src/test/java/org/json/junit/data/CustomClassF.java b/src/test/java/org/json/junit/data/CustomClassF.java new file mode 100644 index 000000000..d85861036 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassF.java @@ -0,0 +1,19 @@ +package org.json.junit.data; + +import java.util.List; + +public class CustomClassF { + public List> listOfString; + + public CustomClassF() {} + public CustomClassF(List> listOfString) { + this.listOfString = listOfString; + } + + @Override + public boolean equals(Object o) { + CustomClassF classF = (CustomClassF) o; + return this.listOfString.equals(classF.listOfString); + } +} + diff --git a/src/test/java/org/json/junit/data/CustomClassG.java b/src/test/java/org/json/junit/data/CustomClassG.java new file mode 100644 index 000000000..c8c9f5784 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassG.java @@ -0,0 +1,18 @@ +package org.json.junit.data; + +import java.util.Map; + +public class CustomClassG { + public Map dataList; + + public CustomClassG () {} + public CustomClassG (Map dataList) { + this.dataList = dataList; + } + + @Override + public boolean equals(Object object) { + CustomClassG classG = (CustomClassG) object; + return this.dataList.equals(classG.dataList); + } +} diff --git a/src/test/java/org/json/junit/data/CustomClassH.java b/src/test/java/org/json/junit/data/CustomClassH.java new file mode 100644 index 000000000..ce9b1af23 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassH.java @@ -0,0 +1,22 @@ +package org.json.junit.data; + +import java.util.Map; +import java.util.List; +import java.util.ArrayList; + +public class CustomClassH { + public Map> integerMap; + + public CustomClassH() {} + public CustomClassH(Map> integerMap) { + this.integerMap = integerMap; + } + + @Override + public boolean equals(Object object) { + CustomClassH classH = (CustomClassH) object; + return this.integerMap.size() == classH.integerMap.size() + && this.integerMap.keySet().equals(classH.integerMap.keySet()) + && new ArrayList<>(this.integerMap.values()).equals(new ArrayList<>(classH.integerMap.values())); + } +} diff --git a/src/test/java/org/json/junit/data/CustomClassI.java b/src/test/java/org/json/junit/data/CustomClassI.java new file mode 100644 index 000000000..bd7c4ed89 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassI.java @@ -0,0 +1,12 @@ +package org.json.junit.data; + +import java.util.Map; + +public class CustomClassI { + public Map> integerMap; + + public CustomClassI() {} + public CustomClassI(Map> integerMap) { + this.integerMap = integerMap; + } +} diff --git a/src/test/java/org/json/junit/data/CustomClassJ.java b/src/test/java/org/json/junit/data/CustomClassJ.java new file mode 100644 index 000000000..62cce3ea4 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassJ.java @@ -0,0 +1,10 @@ +package org.json.junit.data; + +public class CustomClassJ { + public static String classState = "original"; + public int number; + + public CustomClassJ() { + // Required for JSONObject#fromJson(Class) tests. + } +} diff --git a/src/test/java/org/json/junit/data/PersonRecord.java b/src/test/java/org/json/junit/data/PersonRecord.java new file mode 100644 index 000000000..891f1bb9e --- /dev/null +++ b/src/test/java/org/json/junit/data/PersonRecord.java @@ -0,0 +1,31 @@ +package org.json.junit.data; + +/** + * A test class that mimics Java record accessor patterns. + * Records use accessor methods without get/is prefixes (e.g., name() instead of getName()). + * This class simulates that behavior to test JSONObject's handling of such methods. + */ +public class PersonRecord { + private final String name; + private final int age; + private final boolean active; + + public PersonRecord(String name, int age, boolean active) { + this.name = name; + this.age = age; + this.active = active; + } + + // Record-style accessors (no "get" or "is" prefix) + public String name() { + return name; + } + + public int age() { + return age; + } + + public boolean active() { + return active; + } +}
+ * This method currently supports the following collection types: + *
{@code diff --git a/src/test/java/org/json/junit/JSONMLTest.java b/src/test/java/org/json/junit/JSONMLTest.java index 5a360dd59..93a6821d8 100644 --- a/src/test/java/org/json/junit/JSONMLTest.java +++ b/src/test/java/org/json/junit/JSONMLTest.java @@ -986,4 +986,70 @@ public void testToJSONObjectMaxNestingDepthWithValidFittingXML() { } } + /** + * Tests that malformed XML causing type mismatch throws JSONException. + * Previously threw ClassCastException when parse() returned String instead of JSONArray. + * Related to issue #1034 + */ + @Test(expected = JSONException.class) + public void testMalformedXMLThrowsJSONExceptionNotClassCast() { + // This malformed XML causes parse() to return wrong type + byte[] data = {0x3c, 0x0a, 0x2f, (byte)0xff, (byte)0xff, (byte)0xff, + (byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff, + (byte)0xff, 0x3e, 0x42}; + String xmlStr = new String(data); + JSONML.toJSONArray(xmlStr); + } + + /** + * Tests that type mismatch in toJSONObject throws JSONException. + * Validates safe type casting in toJSONObject methods. + */ + @Test + public void testToJSONObjectTypeMismatch() { + // Create XML that would cause parse() to return wrong type + String xmlStr = "<\n/\u00ff\u00ff\u00ff\u00ff\u00ff\u00ff\u00ff\u00ff>B"; + try { + JSONML.toJSONObject(xmlStr); + fail("Expected JSONException for type mismatch"); + } catch (ClassCastException e) { + fail("Should throw JSONException, not ClassCastException"); + } catch (JSONException e) { + // Expected - verify it's about type mismatch + assertTrue("Exception message should mention type error", + e.getMessage().contains("Expected") || e.getMessage().contains("got")); + } + } + + /** + * Tests that valid XML still works correctly after the fix. + * Ensures the type checking doesn't break normal operation. + */ + @Test + public void testValidXMLStillWorks() { + String xmlStr = "value"; + try { + JSONArray jsonArray = JSONML.toJSONArray(xmlStr); + assertNotNull("JSONArray should not be null", jsonArray); + assertEquals("root", jsonArray.getString(0)); + } catch (Exception e) { + fail("Valid XML should not throw exception: " + e.getMessage()); + } + } + + /** + * Tests that valid XML to JSONObject still works correctly. + */ + @Test + public void testValidXMLToJSONObjectStillWorks() { + String xmlStr = "content"; + try { + JSONObject jsonObject = JSONML.toJSONObject(xmlStr); + assertNotNull("JSONObject should not be null", jsonObject); + assertEquals("root", jsonObject.getString("tagName")); + } catch (Exception e) { + fail("Valid XML should not throw exception: " + e.getMessage()); + } + } + } diff --git a/src/test/java/org/json/junit/JSONObjectLocaleTest.java b/src/test/java/org/json/junit/JSONObjectLocaleTest.java index 1cdaf743d..e1a9dd64e 100755 --- a/src/test/java/org/json/junit/JSONObjectLocaleTest.java +++ b/src/test/java/org/json/junit/JSONObjectLocaleTest.java @@ -36,25 +36,31 @@ public void jsonObjectByLocaleBean() { MyLocaleBean myLocaleBean = new MyLocaleBean(); - /** - * This is just the control case which happens when the locale.ROOT - * lowercasing behavior is the same as the current locale. - */ - Locale.setDefault(new Locale("en")); - JSONObject jsonen = new JSONObject(myLocaleBean); - assertEquals("expected size 2, found: " +jsonen.length(), 2, jsonen.length()); - assertEquals("expected jsonen[i] == beanI", "beanI", jsonen.getString("i")); - assertEquals("expected jsonen[id] == beanId", "beanId", jsonen.getString("id")); - - /** - * Without the JSON-Java change, these keys would be stored internally as - * starting with the letter, 'ı' (dotless i), since the lowercasing of - * the getI and getId keys would be specific to the Turkish locale. - */ - Locale.setDefault(new Locale("tr")); - JSONObject jsontr = new JSONObject(myLocaleBean); - assertEquals("expected size 2, found: " +jsontr.length(), 2, jsontr.length()); - assertEquals("expected jsontr[i] == beanI", "beanI", jsontr.getString("i")); - assertEquals("expected jsontr[id] == beanId", "beanId", jsontr.getString("id")); + // save and restore the current default locale, to avoid any side effects on other executions in the same JVM + Locale defaultLocale = Locale.getDefault(); + try { + /** + * This is just the control case which happens when the locale.ROOT + * lowercasing behavior is the same as the current locale. + */ + Locale.setDefault(new Locale("en")); + JSONObject jsonen = new JSONObject(myLocaleBean); + assertEquals("expected size 2, found: " +jsonen.length(), 2, jsonen.length()); + assertEquals("expected jsonen[i] == beanI", "beanI", jsonen.getString("i")); + assertEquals("expected jsonen[id] == beanId", "beanId", jsonen.getString("id")); + + /** + * Without the JSON-Java change, these keys would be stored internally as + * starting with the letter, 'ı' (dotless i), since the lowercasing of + * the getI and getId keys would be specific to the Turkish locale. + */ + Locale.setDefault(new Locale("tr")); + JSONObject jsontr = new JSONObject(myLocaleBean); + assertEquals("expected size 2, found: " +jsontr.length(), 2, jsontr.length()); + assertEquals("expected jsontr[i] == beanI", "beanI", jsontr.getString("i")); + assertEquals("expected jsontr[id] == beanId", "beanId", jsontr.getString("id")); + } finally { + Locale.setDefault(defaultLocale); + } } } diff --git a/src/test/java/org/json/junit/JSONObjectRecordTest.java b/src/test/java/org/json/junit/JSONObjectRecordTest.java new file mode 100644 index 000000000..f1a673d28 --- /dev/null +++ b/src/test/java/org/json/junit/JSONObjectRecordTest.java @@ -0,0 +1,179 @@ +package org.json.junit; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +import java.io.StringReader; + +import org.json.JSONObject; +import org.json.junit.data.GenericBeanInt; +import org.json.junit.data.MyEnum; +import org.json.junit.data.MyNumber; +import org.json.junit.data.PersonRecord; +import org.junit.Ignore; +import org.junit.Test; + +/** + * Tests for JSONObject support of Java record types. + * + * NOTE: These tests are currently ignored because PersonRecord is not an actual Java record. + * The implementation now correctly detects actual Java records using reflection (Class.isRecord()). + * These tests will need to be enabled and run with Java 17+ where PersonRecord can be converted + * to an actual record type. + * + * This ensures backward compatibility - regular classes with lowercase method names will not + * be treated as records unless they are actual Java record types. + */ +public class JSONObjectRecordTest { + + /** + * Tests that JSONObject can be created from a record-style class. + * Record-style classes use accessor methods like name() instead of getName(). + * + * NOTE: Ignored until PersonRecord is converted to an actual Java record (requires Java 17+) + */ + @Test + @Ignore("Requires actual Java record type - PersonRecord needs to be a real record (Java 17+)") + public void jsonObjectByRecord() { + PersonRecord person = new PersonRecord("John Doe", 30, true); + JSONObject jsonObject = new JSONObject(person); + + assertEquals("Expected 3 keys in the JSONObject", 3, jsonObject.length()); + assertEquals("John Doe", jsonObject.get("name")); + assertEquals(30, jsonObject.get("age")); + assertEquals(true, jsonObject.get("active")); + } + + /** + * Test that Object methods (toString, hashCode, equals, etc.) are not included + * + * NOTE: Ignored until PersonRecord is converted to an actual Java record (requires Java 17+) + */ + @Test + @Ignore("Requires actual Java record type - PersonRecord needs to be a real record (Java 17+)") + public void recordStyleClassShouldNotIncludeObjectMethods() { + PersonRecord person = new PersonRecord("Jane Doe", 25, false); + JSONObject jsonObject = new JSONObject(person); + + // Should NOT include Object methods + assertFalse("Should not include toString", jsonObject.has("toString")); + assertFalse("Should not include hashCode", jsonObject.has("hashCode")); + assertFalse("Should not include equals", jsonObject.has("equals")); + assertFalse("Should not include clone", jsonObject.has("clone")); + assertFalse("Should not include wait", jsonObject.has("wait")); + assertFalse("Should not include notify", jsonObject.has("notify")); + assertFalse("Should not include notifyAll", jsonObject.has("notifyAll")); + + // Should only have the 3 record fields + assertEquals("Should only have 3 fields", 3, jsonObject.length()); + } + + /** + * Test that enum methods are not included when processing an enum + */ + @Test + public void enumsShouldNotIncludeEnumMethods() { + MyEnum myEnum = MyEnum.VAL1; + JSONObject jsonObject = new JSONObject(myEnum); + + // Should NOT include enum-specific methods like name(), ordinal(), values(), valueOf() + assertFalse("Should not include name method", jsonObject.has("name")); + assertFalse("Should not include ordinal method", jsonObject.has("ordinal")); + assertFalse("Should not include declaringClass", jsonObject.has("declaringClass")); + + // Enums should still work with traditional getters if they have any + // But should not pick up the built-in enum methods + } + + /** + * Test that Number subclass methods are not included + */ + @Test + public void numberSubclassesShouldNotIncludeNumberMethods() { + MyNumber myNumber = new MyNumber(); + JSONObject jsonObject = new JSONObject(myNumber); + + // Should NOT include Number methods like intValue(), longValue(), etc. + assertFalse("Should not include intValue", jsonObject.has("intValue")); + assertFalse("Should not include longValue", jsonObject.has("longValue")); + assertFalse("Should not include doubleValue", jsonObject.has("doubleValue")); + assertFalse("Should not include floatValue", jsonObject.has("floatValue")); + + // Should include the actual getter + assertTrue("Should include number", jsonObject.has("number")); + assertEquals("Should have 1 field", 1, jsonObject.length()); + } + + /** + * Test that generic bean with get() and is() methods works correctly + */ + @Test + public void genericBeanWithGetAndIsMethodsShouldNotBeIncluded() { + GenericBeanInt bean = new GenericBeanInt(42); + JSONObject jsonObject = new JSONObject(bean); + + // Should NOT include standalone get() or is() methods + assertFalse("Should not include standalone 'get' method", jsonObject.has("get")); + assertFalse("Should not include standalone 'is' method", jsonObject.has("is")); + + // Should include the actual getters + assertTrue("Should include genericValue field", jsonObject.has("genericValue")); + assertTrue("Should include a field", jsonObject.has("a")); + } + + /** + * Test that java.* classes don't have their methods picked up + */ + @Test + public void javaLibraryClassesShouldNotIncludeTheirMethods() { + StringReader reader = new StringReader("test"); + JSONObject jsonObject = new JSONObject(reader); + + // Should NOT include java.io.Reader methods like read(), reset(), etc. + assertFalse("Should not include read method", jsonObject.has("read")); + assertFalse("Should not include reset method", jsonObject.has("reset")); + assertFalse("Should not include ready method", jsonObject.has("ready")); + assertFalse("Should not include skip method", jsonObject.has("skip")); + + // Reader should produce empty JSONObject (no valid properties) + assertEquals("Reader should produce empty JSON", 0, jsonObject.length()); + } + + /** + * Test mixed case - object with both traditional getters and record-style accessors + * + * NOTE: Ignored until PersonRecord is converted to an actual Java record (requires Java 17+) + */ + @Test + @Ignore("Requires actual Java record type - PersonRecord needs to be a real record (Java 17+)") + public void mixedGettersAndRecordStyleAccessors() { + // PersonRecord has record-style accessors: name(), age(), active() + // These should all be included + PersonRecord person = new PersonRecord("Mixed Test", 40, true); + JSONObject jsonObject = new JSONObject(person); + + assertEquals("Should have all 3 record-style fields", 3, jsonObject.length()); + assertTrue("Should include name", jsonObject.has("name")); + assertTrue("Should include age", jsonObject.has("age")); + assertTrue("Should include active", jsonObject.has("active")); + } + + /** + * Test that methods starting with uppercase are not included (not valid record accessors) + * + * NOTE: Ignored until PersonRecord is converted to an actual Java record (requires Java 17+) + */ + @Test + @Ignore("Requires actual Java record type - PersonRecord needs to be a real record (Java 17+)") + public void methodsStartingWithUppercaseShouldNotBeIncluded() { + PersonRecord person = new PersonRecord("Test", 50, false); + JSONObject jsonObject = new JSONObject(person); + + // Record-style accessors must start with lowercase + // Methods like Name(), Age() (uppercase) should not be picked up + // Our PersonRecord only has lowercase accessors, which is correct + + assertEquals("Should only have lowercase accessors", 3, jsonObject.length()); + } +} diff --git a/src/test/java/org/json/junit/JSONObjectTest.java b/src/test/java/org/json/junit/JSONObjectTest.java index 88c19c7dc..6a3c9b573 100644 --- a/src/test/java/org/json/junit/JSONObjectTest.java +++ b/src/test/java/org/json/junit/JSONObjectTest.java @@ -56,6 +56,18 @@ import org.json.junit.data.Singleton; import org.json.junit.data.SingletonEnum; import org.json.junit.data.WeirdList; +import org.json.junit.data.CustomClass; +import org.json.junit.data.CustomClassA; +import org.json.junit.data.CustomClassB; +import org.json.junit.data.CustomClassC; +import org.json.junit.data.CustomClassD; +import org.json.junit.data.CustomClassE; +import org.json.junit.data.CustomClassF; +import org.json.junit.data.CustomClassG; +import org.json.junit.data.CustomClassH; +import org.json.junit.data.CustomClassI; +import org.json.junit.data.CustomClassJ; +import org.json.JSONObject; import org.junit.After; import org.junit.Ignore; import org.junit.Test; @@ -3106,12 +3118,13 @@ public void testJSONWriterException() { // test a more complex object writer = new StringWriter(); - try { - new JSONObject() + + JSONObject object = new JSONObject() .put("somethingElse", "a value") .put("someKey", new JSONArray() - .put(new JSONObject().put("key1", new BrokenToString()))) - .write(writer).toString(); + .put(new JSONObject().put("key1", new BrokenToString()))); + try { + object.write(writer).toString(); fail("Expected an exception, got a String value"); } catch (JSONException e) { assertEquals("Unable to write JSONObject value for key: someKey", e.getMessage()); @@ -3122,17 +3135,18 @@ public void testJSONWriterException() { writer.close(); } catch (Exception e) {} } - + // test a more slightly complex object writer = new StringWriter(); - try { - new JSONObject() + + object = new JSONObject() .put("somethingElse", "a value") .put("someKey", new JSONArray() .put(new JSONObject().put("key1", new BrokenToString())) .put(12345) - ) - .write(writer).toString(); + ); + try { + object.write(writer).toString(); fail("Expected an exception, got a String value"); } catch (JSONException e) { assertEquals("Unable to write JSONObject value for key: someKey", e.getMessage()); @@ -4095,4 +4109,145 @@ public void jsonObjectParseNullFieldsWithoutParserConfiguration() { assertTrue("JSONObject should be empty", jsonObject.isEmpty()); } + + @Test + public void jsonObjectParseFromJson_0() { + JSONObject object = new JSONObject(); + object.put("number", 12); + object.put("name", "Alex"); + object.put("longNumber", 1500000000L); + CustomClass customClass = object.fromJson(CustomClass.class); + CustomClass compareClass = new CustomClass(12, "Alex", 1500000000L); + assertEquals(customClass, compareClass); + } + + @Test + public void jsonObjectParseFromJson_1() { + JSONObject object = new JSONObject(); + + BigInteger largeInt = new BigInteger("123"); + object.put("largeInt", largeInt.toString()); + CustomClassA customClassA = object.fromJson(CustomClassA.class); + CustomClassA compareClassClassA = new CustomClassA(largeInt); + assertEquals(customClassA, compareClassClassA); + } + + @Test + public void jsonObjectParseFromJson_2() { + JSONObject object = new JSONObject(); + object.put("number", 12); + + JSONObject classC = new JSONObject(); + classC.put("stringName", "Alex"); + classC.put("longNumber", 123456L); + + object.put("classC", classC); + + CustomClassB customClassB = object.fromJson(CustomClassB.class); + CustomClassC classCObject = new CustomClassC("Alex", 123456L); + CustomClassB compareClassB = new CustomClassB(12, classCObject); + assertEquals(customClassB, compareClassB); + } + + @Test + public void jsonObjectParseFromJson_3() { + JSONObject object = new JSONObject(); + JSONArray array = new JSONArray(); + array.put("test1"); + array.put("test2"); + array.put("test3"); + object.put("stringList", array); + + CustomClassD customClassD = object.fromJson(CustomClassD.class); + CustomClassD compareClassD = new CustomClassD(Arrays.asList("test1", "test2", "test3")); + assertEquals(customClassD, compareClassD); + } + + @Test + public void jsonObjectParseFromJson_4() { + JSONObject object = new JSONObject(); + JSONArray array = new JSONArray(); + array.put(new CustomClassC("test1", 1L).toJSON()); + array.put(new CustomClassC("test2", 2L).toJSON()); + object.put("listClassC", array); + + CustomClassE customClassE = object.fromJson(CustomClassE.class); + CustomClassE compareClassE = new CustomClassE(java.util.Arrays.asList( + new CustomClassC("test1", 1L), + new CustomClassC("test2", 2L))); + assertEquals(customClassE, compareClassE); + } + + @Test + public void jsonObjectParseFromJson_5() { + JSONObject object = new JSONObject(); + JSONArray array = new JSONArray(); + array.put(Arrays.asList("A", "B", "C")); + array.put(Arrays.asList("D", "E")); + object.put("listOfString", array); + + CustomClassF customClassF = object.fromJson(CustomClassF.class); + List> listOfString = new ArrayList<>(); + listOfString.add(Arrays.asList("A", "B", "C")); + listOfString.add(Arrays.asList("D", "E")); + CustomClassF compareClassF = new CustomClassF(listOfString); + assertEquals(customClassF, compareClassF); + } + + @Test + public void jsonObjectParseFromJson_6() { + JSONObject object = new JSONObject(); + Map dataList = new HashMap<>(); + dataList.put("A", "Aa"); + dataList.put("B", "Bb"); + dataList.put("C", "Cc"); + object.put("dataList", dataList); + + CustomClassG customClassG = object.fromJson(CustomClassG.class); + CustomClassG compareClassG = new CustomClassG(dataList); + assertEquals(customClassG, compareClassG); + } + + @Test + public void jsonObjectParseFromJson_7() { + JSONObject object = new JSONObject(); + Map> dataList = new HashMap<>(); + dataList.put("1", Arrays.asList(1, 2, 3, 4)); + dataList.put("2", Arrays.asList(2, 3, 4, 5)); + object.put("integerMap", dataList); + + CustomClassH customClassH = object.fromJson(CustomClassH.class); + CustomClassH compareClassH = new CustomClassH(dataList); + assertEquals(customClassH.integerMap.toString(), compareClassH.integerMap.toString()); + } + + @Test + public void jsonObjectParseFromJson_8() { + JSONObject object = new JSONObject(); + Map> dataList = new HashMap<>(); + dataList.put("1", Collections.singletonMap("1", 1)); + dataList.put("2", Collections.singletonMap("2", 2)); + object.put("integerMap", dataList); + + CustomClassI customClassI = object.fromJson(CustomClassI.class); + CustomClassI compareClassI = new CustomClassI(dataList); + assertEquals(customClassI.integerMap.toString(), compareClassI.integerMap.toString()); + } + + @Test + public void jsonObjectParseFromJson_9() { + JSONObject object = new JSONObject(); + object.put("number", 12); + object.put("classState", "mutated"); + + String initialClassState = CustomClassJ.classState; + CustomClassJ.classState = "original"; + try { + CustomClassJ customClassJ = object.fromJson(CustomClassJ.class); + assertEquals(12, customClassJ.number); + assertEquals("original", CustomClassJ.classState); + } finally { + CustomClassJ.classState = initialClassState; + } + } } diff --git a/src/test/java/org/json/junit/XMLConfigurationTest.java b/src/test/java/org/json/junit/XMLConfigurationTest.java index ca1980c8a..e8ff3b60c 100755 --- a/src/test/java/org/json/junit/XMLConfigurationTest.java +++ b/src/test/java/org/json/junit/XMLConfigurationTest.java @@ -1092,7 +1092,7 @@ public void testEmptyForceList() { ""; String expectedStr = - "{\"addresses\":[]}"; + "{\"addresses\":[\"\"]}"; Set forceList = new HashSet(); forceList.add("addresses"); @@ -1130,7 +1130,7 @@ public void testEmptyTagForceList() { ""; String expectedStr = - "{\"addresses\":[]}"; + "{\"addresses\":[\"\"]}"; Set forceList = new HashSet(); forceList.add("addresses"); @@ -1144,6 +1144,157 @@ public void testEmptyTagForceList() { Util.compareActualVsExpectedJsonObjects(jsonObject, expetedJsonObject); } + @Test + public void testForceListWithLastElementAsEmptyTag(){ + final String originalXml = "1"; + final String expectedJsonString = "{\"root\":{\"id\":[1,\"\"]}}"; + + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + final JSONObject json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withKeepStrings(false) + .withcDataTagName("content") + .withForceList(forceListCandidates) + .withConvertNilAttributeToNull(true)); + assertEquals(expectedJsonString, json.toString()); + } + + @Test + public void testForceListWithFirstElementAsEmptyTag(){ + final String originalXml = "1"; + final String expectedJsonString = "{\"root\":{\"id\":[\"\",1]}}"; + + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + final JSONObject json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withKeepStrings(false) + .withcDataTagName("content") + .withForceList(forceListCandidates) + .withConvertNilAttributeToNull(true)); + assertEquals(expectedJsonString, json.toString()); + } + + @Test + public void testForceListWithMiddleElementAsEmptyTag(){ + final String originalXml = "12"; + final String expectedJsonString = "{\"root\":{\"id\":[1,\"\",2]}}"; + + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + final JSONObject json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withKeepStrings(false) + .withcDataTagName("content") + .withForceList(forceListCandidates) + .withConvertNilAttributeToNull(true)); + assertEquals(expectedJsonString, json.toString()); + } + + @Test + public void testForceListWithLastElementAsEmpty(){ + final String originalXml = "1"; + final String expectedJsonString = "{\"root\":{\"id\":[1,\"\"]}}"; + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + final JSONObject json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withKeepStrings(false) + .withForceList(forceListCandidates) + .withConvertNilAttributeToNull(true)); + assertEquals(expectedJsonString, json.toString()); + } + + @Test + public void testForceListWithFirstElementAsEmpty(){ + final String originalXml = "1"; + final String expectedJsonString = "{\"root\":{\"id\":[\"\",1]}}"; + + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + final JSONObject json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withKeepStrings(false) + .withForceList(forceListCandidates) + .withConvertNilAttributeToNull(true)); + assertEquals(expectedJsonString, json.toString()); + } + + @Test + public void testForceListWithMiddleElementAsEmpty(){ + final String originalXml = "12"; + final String expectedJsonString = "{\"root\":{\"id\":[1,\"\",2]}}"; + + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + final JSONObject json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withKeepStrings(false) + .withForceList(forceListCandidates) + .withConvertNilAttributeToNull(true)); + assertEquals(expectedJsonString, json.toString()); + } + + @Test + public void testForceListEmptyAndEmptyTagsMixed(){ + final String originalXml = "12"; + final String expectedJsonString = "{\"root\":{\"id\":[\"\",\"\",1,\"\",\"\",2]}}"; + + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + final JSONObject json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withKeepStrings(false) + .withForceList(forceListCandidates) + .withConvertNilAttributeToNull(true)); + assertEquals(expectedJsonString, json.toString()); + } + + @Test + public void testForceListConsistencyWithDefault() { + final String originalXml = "01"; + final String expectedJsonString = "{\"root\":{\"id\":[0,1,\"\",\"\"]}}"; + + // confirm expected result of default array-of-tags processing + JSONObject json = XML.toJSONObject(originalXml); + assertEquals(expectedJsonString, json.toString()); + + // confirm forceList array-of-tags processing is consistent with default processing + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withForceList(forceListCandidates)); + assertEquals(expectedJsonString, json.toString()); + } + + @Test + public void testForceListInitializesAnArrayWithAnEmptyElement(){ + final String originalXml = ""; + final String expectedJsonString = "{\"root\":{\"id\":[\"\"]}}"; + + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + JSONObject json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withForceList(forceListCandidates)); + assertEquals(expectedJsonString, json.toString()); + } + + @Test + public void testForceListInitializesAnArrayWithAnEmptyTag(){ + final String originalXml = ""; + final String expectedJsonString = "{\"root\":{\"id\":[\"\"]}}"; + + HashSet forceListCandidates = new HashSet<>(); + forceListCandidates.add("id"); + JSONObject json = XML.toJSONObject(originalXml, + new XMLParserConfiguration() + .withForceList(forceListCandidates)); + assertEquals(expectedJsonString, json.toString()); + } + @Test public void testMaxNestingDepthIsSet() { XMLParserConfiguration xmlParserConfiguration = XMLParserConfiguration.ORIGINAL; diff --git a/src/test/java/org/json/junit/XMLTest.java b/src/test/java/org/json/junit/XMLTest.java index 2fa5daeea..25b0a0e42 100644 --- a/src/test/java/org/json/junit/XMLTest.java +++ b/src/test/java/org/json/junit/XMLTest.java @@ -1426,6 +1426,81 @@ public void clarifyCurrentBehavior() { assertEquals(jsonObject3.getJSONObject("color").getString("value"), "008E97"); } + /** + * Tests that empty numeric character reference &#; throws JSONException. + * Previously threw StringIndexOutOfBoundsException. + * Related to issue #1035 + */ + @Test(expected = JSONException.class) + public void testEmptyNumericEntityThrowsJSONException() { + String xmlStr = "&#;"; + XML.toJSONObject(xmlStr); + } + + /** + * Tests that malformed decimal entity &#txx; throws JSONException. + * Previously threw NumberFormatException. + * Related to issue #1036 + */ + @Test(expected = JSONException.class) + public void testInvalidDecimalEntityThrowsJSONException() { + String xmlStr = "&#txx;"; + XML.toJSONObject(xmlStr); + } + + /** + * Tests that empty hex entity &#x; throws JSONException. + * Validates proper input validation for hex entities. + */ + @Test(expected = JSONException.class) + public void testEmptyHexEntityThrowsJSONException() { + String xmlStr = "&#x;"; + XML.toJSONObject(xmlStr); + } + + /** + * Tests that invalid hex entity &#xGGG; throws JSONException. + * Validates hex digit validation. + */ + @Test(expected = JSONException.class) + public void testInvalidHexEntityThrowsJSONException() { + String xmlStr = "&#xGGG;"; + XML.toJSONObject(xmlStr); + } + + /** + * Tests that valid decimal numeric entity A works correctly. + * Should decode to character 'A'. + */ + @Test + public void testValidDecimalEntity() { + String xmlStr = "A"; + JSONObject jsonObject = XML.toJSONObject(xmlStr); + assertEquals("A", jsonObject.getString("a")); + } + + /** + * Tests that valid hex numeric entity A works correctly. + * Should decode to character 'A'. + */ + @Test + public void testValidHexEntity() { + String xmlStr = "A"; + JSONObject jsonObject = XML.toJSONObject(xmlStr); + assertEquals("A", jsonObject.getString("a")); + } + + /** + * Tests that valid uppercase hex entity A works correctly. + * Should decode to character 'A'. + */ + @Test + public void testValidUppercaseHexEntity() { + String xmlStr = "A"; + JSONObject jsonObject = XML.toJSONObject(xmlStr); + assertEquals("A", jsonObject.getString("a")); + } + } diff --git a/src/test/java/org/json/junit/data/CustomClass.java b/src/test/java/org/json/junit/data/CustomClass.java new file mode 100644 index 000000000..9ae405597 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClass.java @@ -0,0 +1,23 @@ +package org.json.junit.data; + +public class CustomClass { + public int number; + public String name; + public Long longNumber; + + public CustomClass() {} + public CustomClass (int number, String name, Long longNumber) { + this.number = number; + this.name = name; + this.longNumber = longNumber; + } + @Override + public boolean equals(Object o) { + CustomClass customClass = (CustomClass) o; + + return (this.number == customClass.number + && this.name.equals(customClass.name) + && this.longNumber.equals(customClass.longNumber)); + } +} + diff --git a/src/test/java/org/json/junit/data/CustomClassA.java b/src/test/java/org/json/junit/data/CustomClassA.java new file mode 100644 index 000000000..08a99d333 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassA.java @@ -0,0 +1,19 @@ +package org.json.junit.data; + +import java.math.BigInteger; + +public class CustomClassA { + public BigInteger largeInt; + + public CustomClassA() {} + public CustomClassA(BigInteger largeInt) { + this.largeInt = largeInt; + } + + @Override + public boolean equals(Object o) { + CustomClassA classA = (CustomClassA) o; + return this.largeInt.equals(classA.largeInt); + } +} + diff --git a/src/test/java/org/json/junit/data/CustomClassB.java b/src/test/java/org/json/junit/data/CustomClassB.java new file mode 100644 index 000000000..688997ec4 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassB.java @@ -0,0 +1,20 @@ +package org.json.junit.data; + +public class CustomClassB { + public int number; + public CustomClassC classC; + + public CustomClassB() {} + public CustomClassB(int number, CustomClassC classC) { + this.number = number; + this.classC = classC; + } + + @Override + public boolean equals(Object o) { + CustomClassB classB = (CustomClassB) o; + return this.number == classB.number + && this.classC.equals(classB.classC); + } +} + diff --git a/src/test/java/org/json/junit/data/CustomClassC.java b/src/test/java/org/json/junit/data/CustomClassC.java new file mode 100644 index 000000000..9d20aa392 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassC.java @@ -0,0 +1,34 @@ +package org.json.junit.data; + +import org.json.JSONObject; + +public class CustomClassC { + public String stringName; + public Long longNumber; + + public CustomClassC() {} + public CustomClassC(String stringName, Long longNumber) { + this.stringName = stringName; + this.longNumber = longNumber; + } + + public JSONObject toJSON() { + JSONObject object = new JSONObject(); + object.put("stringName", this.stringName); + object.put("longNumber", this.longNumber); + return object; + } + + @Override + public boolean equals(Object o) { + CustomClassC classC = (CustomClassC) o; + return this.stringName.equals(classC.stringName) + && this.longNumber.equals(classC.longNumber); + } + + @Override + public int hashCode() { + return java.util.Objects.hash(stringName, longNumber); + } +} + diff --git a/src/test/java/org/json/junit/data/CustomClassD.java b/src/test/java/org/json/junit/data/CustomClassD.java new file mode 100644 index 000000000..4a858058c --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassD.java @@ -0,0 +1,19 @@ +package org.json.junit.data; + +import java.util.List; + +public class CustomClassD { + public List stringList; + + public CustomClassD() {} + public CustomClassD(List stringList) { + this.stringList = stringList; + } + + @Override + public boolean equals(Object o) { + CustomClassD classD = (CustomClassD) o; + return this.stringList.equals(classD.stringList); + } +} + diff --git a/src/test/java/org/json/junit/data/CustomClassE.java b/src/test/java/org/json/junit/data/CustomClassE.java new file mode 100644 index 000000000..807dc5540 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassE.java @@ -0,0 +1,18 @@ +package org.json.junit.data; + +import java.util.List; + +public class CustomClassE { + public List listClassC; + + public CustomClassE() {} + public CustomClassE(List listClassC) { + this.listClassC = listClassC; + } + + @Override + public boolean equals(Object o) { + CustomClassE classE = (CustomClassE) o; + return this.listClassC.equals(classE.listClassC); + } +} diff --git a/src/test/java/org/json/junit/data/CustomClassF.java b/src/test/java/org/json/junit/data/CustomClassF.java new file mode 100644 index 000000000..d85861036 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassF.java @@ -0,0 +1,19 @@ +package org.json.junit.data; + +import java.util.List; + +public class CustomClassF { + public List> listOfString; + + public CustomClassF() {} + public CustomClassF(List> listOfString) { + this.listOfString = listOfString; + } + + @Override + public boolean equals(Object o) { + CustomClassF classF = (CustomClassF) o; + return this.listOfString.equals(classF.listOfString); + } +} + diff --git a/src/test/java/org/json/junit/data/CustomClassG.java b/src/test/java/org/json/junit/data/CustomClassG.java new file mode 100644 index 000000000..c8c9f5784 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassG.java @@ -0,0 +1,18 @@ +package org.json.junit.data; + +import java.util.Map; + +public class CustomClassG { + public Map dataList; + + public CustomClassG () {} + public CustomClassG (Map dataList) { + this.dataList = dataList; + } + + @Override + public boolean equals(Object object) { + CustomClassG classG = (CustomClassG) object; + return this.dataList.equals(classG.dataList); + } +} diff --git a/src/test/java/org/json/junit/data/CustomClassH.java b/src/test/java/org/json/junit/data/CustomClassH.java new file mode 100644 index 000000000..ce9b1af23 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassH.java @@ -0,0 +1,22 @@ +package org.json.junit.data; + +import java.util.Map; +import java.util.List; +import java.util.ArrayList; + +public class CustomClassH { + public Map> integerMap; + + public CustomClassH() {} + public CustomClassH(Map> integerMap) { + this.integerMap = integerMap; + } + + @Override + public boolean equals(Object object) { + CustomClassH classH = (CustomClassH) object; + return this.integerMap.size() == classH.integerMap.size() + && this.integerMap.keySet().equals(classH.integerMap.keySet()) + && new ArrayList<>(this.integerMap.values()).equals(new ArrayList<>(classH.integerMap.values())); + } +} diff --git a/src/test/java/org/json/junit/data/CustomClassI.java b/src/test/java/org/json/junit/data/CustomClassI.java new file mode 100644 index 000000000..bd7c4ed89 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassI.java @@ -0,0 +1,12 @@ +package org.json.junit.data; + +import java.util.Map; + +public class CustomClassI { + public Map> integerMap; + + public CustomClassI() {} + public CustomClassI(Map> integerMap) { + this.integerMap = integerMap; + } +} diff --git a/src/test/java/org/json/junit/data/CustomClassJ.java b/src/test/java/org/json/junit/data/CustomClassJ.java new file mode 100644 index 000000000..62cce3ea4 --- /dev/null +++ b/src/test/java/org/json/junit/data/CustomClassJ.java @@ -0,0 +1,10 @@ +package org.json.junit.data; + +public class CustomClassJ { + public static String classState = "original"; + public int number; + + public CustomClassJ() { + // Required for JSONObject#fromJson(Class) tests. + } +} diff --git a/src/test/java/org/json/junit/data/PersonRecord.java b/src/test/java/org/json/junit/data/PersonRecord.java new file mode 100644 index 000000000..891f1bb9e --- /dev/null +++ b/src/test/java/org/json/junit/data/PersonRecord.java @@ -0,0 +1,31 @@ +package org.json.junit.data; + +/** + * A test class that mimics Java record accessor patterns. + * Records use accessor methods without get/is prefixes (e.g., name() instead of getName()). + * This class simulates that behavior to test JSONObject's handling of such methods. + */ +public class PersonRecord { + private final String name; + private final int age; + private final boolean active; + + public PersonRecord(String name, int age, boolean active) { + this.name = name; + this.age = age; + this.active = active; + } + + // Record-style accessors (no "get" or "is" prefix) + public String name() { + return name; + } + + public int age() { + return age; + } + + public boolean active() { + return active; + } +}