From 20f520000014ac6e65d0de5b7f7dad93c0e706ba Mon Sep 17 00:00:00 2001 From: AbhineshJha Date: Sat, 25 Oct 2025 14:16:55 +0530 Subject: [PATCH 1/5] Fix: Support Java record accessors in JSONObject --- src/main/java/org/json/JSONObject.java | 29 ++++++++++++++++- .../java/org/json/junit/JSONObjectTest.java | 20 ++++++++++++ .../org/json/junit/data/PersonRecord.java | 31 +++++++++++++++++++ 3 files changed, 79 insertions(+), 1 deletion(-) create mode 100644 src/test/java/org/json/junit/data/PersonRecord.java diff --git a/src/main/java/org/json/JSONObject.java b/src/main/java/org/json/JSONObject.java index 4e8b42c97..72c8453a1 100644 --- a/src/main/java/org/json/JSONObject.java +++ b/src/main/java/org/json/JSONObject.java @@ -1885,7 +1885,8 @@ private static Method[] getMethods(Class klass) { } private static boolean isValidMethodName(String name) { - return !"getClass".equals(name) && !"getDeclaringClass".equals(name); + return !"getClass".equals(name) + && !"getDeclaringClass".equals(name); } private static String getKeyNameFromMethod(Method method) { @@ -1909,6 +1910,32 @@ private static String getKeyNameFromMethod(Method method) { } else if (name.startsWith("is") && name.length() > 2) { key = name.substring(2); } else { + // Check if this is a record-style accessor (no prefix) + // Record accessors are simple method names that match field names + // They must start with a lowercase letter and should be declared in the class itself + // (not inherited from Object, Enum, Number, or any java.* class) + // Also exclude common Object/bean method names + Class declaringClass = method.getDeclaringClass(); + if (name.length() > 0 && Character.isLowerCase(name.charAt(0)) + && !"get".equals(name) + && !"is".equals(name) + && !"set".equals(name) + && !"toString".equals(name) + && !"hashCode".equals(name) + && !"equals".equals(name) + && !"clone".equals(name) + && !"notify".equals(name) + && !"notifyAll".equals(name) + && !"wait".equals(name) + && declaringClass != null + && declaringClass != Object.class + && !Enum.class.isAssignableFrom(declaringClass) + && !Number.class.isAssignableFrom(declaringClass) + && !declaringClass.getName().startsWith("java.") + && !declaringClass.getName().startsWith("javax.")) { + // This is a record-style accessor - return the method name as-is + return name; + } return null; } // if the first letter in the key is not uppercase, then skip. diff --git a/src/test/java/org/json/junit/JSONObjectTest.java b/src/test/java/org/json/junit/JSONObjectTest.java index 7ca6093b7..59a287448 100644 --- a/src/test/java/org/json/junit/JSONObjectTest.java +++ b/src/test/java/org/json/junit/JSONObjectTest.java @@ -51,6 +51,7 @@ import org.json.junit.data.MyNumber; import org.json.junit.data.MyNumberContainer; import org.json.junit.data.MyPublicClass; +import org.json.junit.data.PersonRecord; import org.json.junit.data.RecursiveBean; import org.json.junit.data.RecursiveBeanEquals; import org.json.junit.data.Singleton; @@ -796,6 +797,25 @@ public void jsonObjectByBean3() { Util.checkJSONObjectMaps(jsonObject); } + /** + * JSONObject built from a Java record. + * Records use accessor methods without get/is prefixes (e.g., name() instead of getName()). + * This test verifies that JSONObject correctly handles record types. + */ + @Test + public void jsonObjectByRecord() { + PersonRecord person = new PersonRecord("John Doe", 30, true); + JSONObject jsonObject = new JSONObject(person); + + // validate JSON + Object doc = Configuration.defaultConfiguration().jsonProvider().parse(jsonObject.toString()); + assertTrue("expected 3 top level items", ((Map)(JsonPath.read(doc, "$"))).size() == 3); + assertTrue("expected name field", "John Doe".equals(jsonObject.query("/name"))); + assertTrue("expected age field", Integer.valueOf(30).equals(jsonObject.query("/age"))); + assertTrue("expected active field", Boolean.TRUE.equals(jsonObject.query("/active"))); + Util.checkJSONObjectMaps(jsonObject); + } + /** * A bean is also an object. But in order to test the JSONObject * ctor that takes an object and a list of names, 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; + } +} From 2550c692cfe32d840431434f531a7735d438c17a Mon Sep 17 00:00:00 2001 From: AbhineshJha Date: Sat, 25 Oct 2025 14:30:25 +0530 Subject: [PATCH 2/5] Refactor: Extract isRecordStyleAccessor helper method --- src/main/java/org/json/JSONObject.java | 55 +++++++++++++++++--------- 1 file changed, 36 insertions(+), 19 deletions(-) diff --git a/src/main/java/org/json/JSONObject.java b/src/main/java/org/json/JSONObject.java index 72c8453a1..6b5c7b011 100644 --- a/src/main/java/org/json/JSONObject.java +++ b/src/main/java/org/json/JSONObject.java @@ -1915,25 +1915,7 @@ private static String getKeyNameFromMethod(Method method) { // They must start with a lowercase letter and should be declared in the class itself // (not inherited from Object, Enum, Number, or any java.* class) // Also exclude common Object/bean method names - Class declaringClass = method.getDeclaringClass(); - if (name.length() > 0 && Character.isLowerCase(name.charAt(0)) - && !"get".equals(name) - && !"is".equals(name) - && !"set".equals(name) - && !"toString".equals(name) - && !"hashCode".equals(name) - && !"equals".equals(name) - && !"clone".equals(name) - && !"notify".equals(name) - && !"notifyAll".equals(name) - && !"wait".equals(name) - && declaringClass != null - && declaringClass != Object.class - && !Enum.class.isAssignableFrom(declaringClass) - && !Number.class.isAssignableFrom(declaringClass) - && !declaringClass.getName().startsWith("java.") - && !declaringClass.getName().startsWith("javax.")) { - // This is a record-style accessor - return the method name as-is + if (isRecordStyleAccessor(name, method)) { return name; } return null; @@ -1952,6 +1934,41 @@ private static String getKeyNameFromMethod(Method method) { return key; } + /** + * Checks if a method is a record-style accessor. + * Record accessors have lowercase names without get/is prefixes and are not inherited from standard Java classes. + * + * @param methodName the name of the method + * @param method the method to check + * @return true if this is a record-style accessor, false otherwise + */ + private static boolean isRecordStyleAccessor(String methodName, Method method) { + if (methodName.isEmpty() || !Character.isLowerCase(methodName.charAt(0))) { + return false; + } + + // Exclude common bean/Object method names + if ("get".equals(methodName) || "is".equals(methodName) || "set".equals(methodName) + || "toString".equals(methodName) || "hashCode".equals(methodName) + || "equals".equals(methodName) || "clone".equals(methodName) + || "notify".equals(methodName) || "notifyAll".equals(methodName) + || "wait".equals(methodName)) { + return false; + } + + Class declaringClass = method.getDeclaringClass(); + if (declaringClass == null || declaringClass == Object.class) { + return false; + } + + if (Enum.class.isAssignableFrom(declaringClass) || Number.class.isAssignableFrom(declaringClass)) { + return false; + } + + String className = declaringClass.getName(); + return !className.startsWith("java.") && !className.startsWith("javax."); + } + /** * checks if the annotation is not null and the {@link JSONPropertyName#value()} is not null and is not empty. * @param annotation the annotation to check From fd1eee9c3bd20f4ce63b6a1daae58f1c03b5e695 Mon Sep 17 00:00:00 2001 From: AbhineshJha Date: Sat, 25 Oct 2025 14:43:09 +0530 Subject: [PATCH 3/5] Add comprehensive edge case tests for record support --- .../org/json/junit/JSONObjectRecordTest.java | 160 ++++++++++++++++++ .../java/org/json/junit/JSONObjectTest.java | 20 --- 2 files changed, 160 insertions(+), 20 deletions(-) create mode 100644 src/test/java/org/json/junit/JSONObjectRecordTest.java 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..84bd749f5 --- /dev/null +++ b/src/test/java/org/json/junit/JSONObjectRecordTest.java @@ -0,0 +1,160 @@ +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.Test; + +/** + * Tests for JSONObject support of Java record-style classes. + * These tests verify that classes with accessor methods without get/is prefixes + * (like Java records) can be properly converted to JSONObject. + */ +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(). + */ + @Test + 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 + */ + @Test + 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 + */ + @Test + 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) + */ + @Test + 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 59a287448..7ca6093b7 100644 --- a/src/test/java/org/json/junit/JSONObjectTest.java +++ b/src/test/java/org/json/junit/JSONObjectTest.java @@ -51,7 +51,6 @@ import org.json.junit.data.MyNumber; import org.json.junit.data.MyNumberContainer; import org.json.junit.data.MyPublicClass; -import org.json.junit.data.PersonRecord; import org.json.junit.data.RecursiveBean; import org.json.junit.data.RecursiveBeanEquals; import org.json.junit.data.Singleton; @@ -797,25 +796,6 @@ public void jsonObjectByBean3() { Util.checkJSONObjectMaps(jsonObject); } - /** - * JSONObject built from a Java record. - * Records use accessor methods without get/is prefixes (e.g., name() instead of getName()). - * This test verifies that JSONObject correctly handles record types. - */ - @Test - public void jsonObjectByRecord() { - PersonRecord person = new PersonRecord("John Doe", 30, true); - JSONObject jsonObject = new JSONObject(person); - - // validate JSON - Object doc = Configuration.defaultConfiguration().jsonProvider().parse(jsonObject.toString()); - assertTrue("expected 3 top level items", ((Map)(JsonPath.read(doc, "$"))).size() == 3); - assertTrue("expected name field", "John Doe".equals(jsonObject.query("/name"))); - assertTrue("expected age field", Integer.valueOf(30).equals(jsonObject.query("/age"))); - assertTrue("expected active field", Boolean.TRUE.equals(jsonObject.query("/active"))); - Util.checkJSONObjectMaps(jsonObject); - } - /** * A bean is also an object. But in order to test the JSONObject * ctor that takes an object and a list of names, From f2acf8af6932ad8a46339b8024ee009919c1b7cf Mon Sep 17 00:00:00 2001 From: AbhineshJha Date: Thu, 30 Oct 2025 20:15:42 +0530 Subject: [PATCH 4/5] Optimize method name exclusion using Set lookup instead of multiple equals checks --- src/main/java/org/json/JSONObject.java | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) diff --git a/src/main/java/org/json/JSONObject.java b/src/main/java/org/json/JSONObject.java index 6b5c7b011..3e3778d4b 100644 --- a/src/main/java/org/json/JSONObject.java +++ b/src/main/java/org/json/JSONObject.java @@ -144,6 +144,18 @@ public Class getMapType() { */ public static final Object NULL = new Null(); + /** + * Set of method names that should be excluded when identifying record-style accessors. + * These are common bean/Object method names that are not property accessors. + */ + private static final Set EXCLUDED_RECORD_METHOD_NAMES = Collections.unmodifiableSet( + new HashSet(Arrays.asList( + "get", "is", "set", + "toString", "hashCode", "equals", "clone", + "notify", "notifyAll", "wait" + )) + ); + /** * Construct an empty JSONObject. */ @@ -1948,11 +1960,7 @@ private static boolean isRecordStyleAccessor(String methodName, Method method) { } // Exclude common bean/Object method names - if ("get".equals(methodName) || "is".equals(methodName) || "set".equals(methodName) - || "toString".equals(methodName) || "hashCode".equals(methodName) - || "equals".equals(methodName) || "clone".equals(methodName) - || "notify".equals(methodName) || "notifyAll".equals(methodName) - || "wait".equals(methodName)) { + if (EXCLUDED_RECORD_METHOD_NAMES.contains(methodName)) { return false; } From 8f3b0f1c139ded2180261f200f33bd2e40f65c27 Mon Sep 17 00:00:00 2001 From: AbhineshJha Date: Sun, 2 Nov 2025 22:32:44 +0530 Subject: [PATCH 5/5] Add runtime record detection for backward compatibility --- src/main/java/org/json/JSONObject.java | 39 +++++++++++++++---- .../org/json/junit/JSONObjectRecordTest.java | 25 ++++++++++-- 2 files changed, 53 insertions(+), 11 deletions(-) diff --git a/src/main/java/org/json/JSONObject.java b/src/main/java/org/json/JSONObject.java index 3e3778d4b..db2c2aac7 100644 --- a/src/main/java/org/json/JSONObject.java +++ b/src/main/java/org/json/JSONObject.java @@ -1835,11 +1835,14 @@ private void populateMap(Object bean, Set objectsRecord, JSONParserConfi Class klass = bean.getClass(); // If klass is a System class then set includeSuperClass to false. + + // Check if this is a Java record type + boolean isRecord = isRecordType(klass); Method[] methods = getMethods(klass); for (final Method method : methods) { if (isValidMethod(method)) { - final String key = getKeyNameFromMethod(method); + final String key = getKeyNameFromMethod(method, isRecord); if (key != null && !key.isEmpty()) { processMethod(bean, objectsRecord, jsonParserConfiguration, method, key); } @@ -1885,6 +1888,29 @@ private void processMethod(Object bean, Set objectsRecord, JSONParserCon } } + /** + * Checks if a class is a Java record type. + * This uses reflection to check for the isRecord() method which was introduced in Java 16. + * This approach works even when running on Java 6+ JVM. + * + * @param klass the class to check + * @return true if the class is a record type, false otherwise + */ + private static boolean isRecordType(Class klass) { + try { + // Use reflection to check if Class has an isRecord() method (Java 16+) + // This allows the code to compile on Java 6 while still detecting records at runtime + Method isRecordMethod = Class.class.getMethod("isRecord"); + return (Boolean) isRecordMethod.invoke(klass); + } catch (NoSuchMethodException e) { + // isRecord() method doesn't exist - we're on Java < 16 + return false; + } catch (Exception e) { + // Any other reflection error - assume not a record + return false; + } + } + /** * This is a convenience method to simplify populate maps * @param klass the name of the object being checked @@ -1901,7 +1927,7 @@ private static boolean isValidMethodName(String name) { && !"getDeclaringClass".equals(name); } - private static String getKeyNameFromMethod(Method method) { + private static String getKeyNameFromMethod(Method method, boolean isRecordType) { final int ignoreDepth = getAnnotationDepth(method, JSONPropertyIgnore.class); if (ignoreDepth > 0) { final int forcedNameDepth = getAnnotationDepth(method, JSONPropertyName.class); @@ -1922,12 +1948,9 @@ private static String getKeyNameFromMethod(Method method) { } else if (name.startsWith("is") && name.length() > 2) { key = name.substring(2); } else { - // Check if this is a record-style accessor (no prefix) - // Record accessors are simple method names that match field names - // They must start with a lowercase letter and should be declared in the class itself - // (not inherited from Object, Enum, Number, or any java.* class) - // Also exclude common Object/bean method names - if (isRecordStyleAccessor(name, method)) { + // Only check for record-style accessors if this is actually a record type + // This maintains backward compatibility - classes with lowercase methods won't be affected + if (isRecordType && isRecordStyleAccessor(name, method)) { return name; } return null; diff --git a/src/test/java/org/json/junit/JSONObjectRecordTest.java b/src/test/java/org/json/junit/JSONObjectRecordTest.java index 84bd749f5..f1a673d28 100644 --- a/src/test/java/org/json/junit/JSONObjectRecordTest.java +++ b/src/test/java/org/json/junit/JSONObjectRecordTest.java @@ -11,20 +11,30 @@ 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-style classes. - * These tests verify that classes with accessor methods without get/is prefixes - * (like Java records) can be properly converted to JSONObject. + * 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); @@ -37,8 +47,11 @@ public void jsonObjectByRecord() { /** * 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); @@ -129,8 +142,11 @@ public void javaLibraryClassesShouldNotIncludeTheirMethods() { /** * 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 @@ -145,8 +161,11 @@ public void mixedGettersAndRecordStyleAccessors() { /** * 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);