20240303-pre-release-updates updates for release

Deployment and Pipeline action updates

.github/workflows/deployment.yml

@@ -1,82 +0,0 @@
-# For more information see:
-#  * https://docs.github.com/en/actions/learn-github-actions
-#  * https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions
-#  * https://github.com/actions/setup-java/blob/v3.13.0/docs/advanced-usage.md#Publishing-using-Apache-Maven
-#
-
-name: Deployment workflow
-
-on:
-    release:
-      types: [published]
-  
-jobs:
-  # old-school build and jar method. No tests run or compiled.
-  publish-1_6: 
-    name: Publish Java 1.6 to GitHub Release
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup java
-        uses: actions/setup-java@v1
-        with:
-          java-version: 1.6
-      - name: Compile Java 1.6
-        run: |
-          mkdir -p target/classes
-          javac -version
-          javac -source 1.6 -target 1.6 -d target/classes/ src/main/java/org/json/*.java
-      - name: Create JAR 1.6
-        run: |
-          jar cvf "target/org.json-1.6-${{ github.ref_name }}.jar" -C target/classes .
-      - name: Add 1.6 Jar To Release
-        uses: softprops/action-gh-release@v1
-        with:
-          append_body: true
-          files: |
-            target/*.jar
-  publish:
-    name: Publish Java 8 to Maven Central and GitHub Release
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      packages: write
-    steps:
-      - uses: actions/checkout@v4
-      - name: Set up Java for publishing to Maven Central Repository
-        uses: actions/setup-java@v3
-        with:
-          # Use lowest supported LTS Java version
-          java-version: '8'
-          distribution: 'temurin'
-          server-id: ossrh  # Value of the distributionManagement/repository/id field of the pom.xml
-          server-username: MAVEN_USERNAME # env variable for username in deploy
-          server-password: MAVEN_PASSWORD # env variable for token in deploy
-          gpg-private-key: ${{ secrets.MAVEN_GPG_PRIVATE_KEY }} # Value of the GPG private key to import
-          gpg-passphrase: MAVEN_GPG_PASSPHRASE # env variable for GPG private key passphrase
-  
-      - name: Publish to the Maven Central Repository
-        run: mvn --batch-mode deploy
-        env:
-          MAVEN_USERNAME: ${{ secrets.OSSRH_USERNAME }}
-          MAVEN_PASSWORD: ${{ secrets.OSSRH_TOKEN }}
-          MAVEN_GPG_PASSPHRASE: ${{ secrets.MAVEN_GPG_PASSPHRASE }}
-          
-      - name: Add Jar To Release
-        uses: softprops/action-gh-release@v1
-        with:
-          append_body: true
-          files: |
-            target/*.jar
-      # - name: Set up Java for publishing to GitHub Packages
-      #   uses: actions/setup-java@v3
-      #   with:
-      #     # Use lowest supported LTS Java version
-      #     java-version: '8'
-      #     distribution: 'temurin'
-      # - name: Publish to GitHub Packages
-      #   run: mvn --batch-mode deploy
-      #   env:
-      #     GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/pipeline.yml

@@ -34,14 +34,159 @@ jobs:
         with:
           name: Create java 1.6 JAR
           path: target/*.jar
-  build:
+
+  build-8:
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false
-      max-parallel: 2
+      max-parallel: 1
       matrix:
         # build against supported Java LTS versions:
-        java: [ 8, 11, 17, 21 ]
+        java: [ 8 ]
+    name: Java ${{ matrix.java }}
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up JDK ${{ matrix.java }}
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'temurin'
+          java-version: ${{ matrix.java }}
+          cache: 'maven'
+      - name: Compile Java ${{ matrix.java }}
+        run: mvn clean compile -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }} -D maven.test.skip=true -D maven.site.skip=true -D maven.javadoc.skip=true
+      - name: Run Tests ${{ matrix.java }}
+        run: |
+          mvn test -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }}
+      - name: Build Test Report ${{ matrix.java }}
+        if: ${{ always() }}
+        run: |
+          mvn surefire-report:report-only -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }}
+          mvn site -D generateReports=false -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }}
+      - name: Upload Test Results ${{ matrix.java }}
+        if: ${{ always() }}
+        uses: actions/upload-artifact@v3
+        with:
+          name: Test Results ${{ matrix.java }}
+          path: target/surefire-reports/
+      - name: Upload Test Report ${{ matrix.java }}
+        if: ${{ always() }}
+        uses: actions/upload-artifact@v3
+        with:
+          name: Test Report ${{ matrix.java }}
+          path: target/site/
+      - name: Package Jar ${{ matrix.java }}
+        run: mvn clean package -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }} -D maven.test.skip=true -D maven.site.skip=true
+      - name: Upload Package Results ${{ matrix.java }}
+        if: ${{ always() }}
+        uses: actions/upload-artifact@v3
+        with:
+          name: Package Jar ${{ matrix.java }}
+          path: target/*.jar
+
+  build-11:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      max-parallel: 1
+      matrix:
+        # build against supported Java LTS versions:
+        java: [ 11 ]
+    name: Java ${{ matrix.java }}
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up JDK ${{ matrix.java }}
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'temurin'
+          java-version: ${{ matrix.java }}
+          cache: 'maven'
+      - name: Compile Java ${{ matrix.java }}
+        run: mvn clean compile -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }} -D maven.test.skip=true -D maven.site.skip=true -D maven.javadoc.skip=true
+      - name: Run Tests ${{ matrix.java }}
+        run: |
+          mvn test -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }}
+      - name: Build Test Report ${{ matrix.java }}
+        if: ${{ always() }}
+        run: |
+          mvn surefire-report:report-only -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }}
+          mvn site -D generateReports=false -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }}
+      - name: Upload Test Results ${{ matrix.java }}
+        if: ${{ always() }}
+        uses: actions/upload-artifact@v3
+        with:
+          name: Test Results ${{ matrix.java }}
+          path: target/surefire-reports/
+      - name: Upload Test Report ${{ matrix.java }}
+        if: ${{ always() }}
+        uses: actions/upload-artifact@v3
+        with:
+          name: Test Report ${{ matrix.java }}
+          path: target/site/
+      - name: Package Jar ${{ matrix.java }}
+        run: mvn clean package -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }} -D maven.test.skip=true -D maven.site.skip=true
+      - name: Upload Package Results ${{ matrix.java }}
+        if: ${{ always() }}
+        uses: actions/upload-artifact@v3
+        with:
+          name: Package Jar ${{ matrix.java }}
+          path: target/*.jar
+
+  build-17:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      max-parallel: 1
+      matrix:
+        # build against supported Java LTS versions:
+        java: [ 17 ]
+    name: Java ${{ matrix.java }}
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up JDK ${{ matrix.java }}
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'temurin'
+          java-version: ${{ matrix.java }}
+          cache: 'maven'
+      - name: Compile Java ${{ matrix.java }}
+        run: mvn clean compile -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }} -D maven.test.skip=true -D maven.site.skip=true -D maven.javadoc.skip=true
+      - name: Run Tests ${{ matrix.java }}
+        run: |
+          mvn test -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }}
+      - name: Build Test Report ${{ matrix.java }}
+        if: ${{ always() }}
+        run: |
+          mvn surefire-report:report-only -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }}
+          mvn site -D generateReports=false -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }}
+      - name: Upload Test Results ${{ matrix.java }}
+        if: ${{ always() }}
+        uses: actions/upload-artifact@v3
+        with:
+          name: Test Results ${{ matrix.java }}
+          path: target/surefire-reports/
+      - name: Upload Test Report ${{ matrix.java }}
+        if: ${{ always() }}
+        uses: actions/upload-artifact@v3
+        with:
+          name: Test Report ${{ matrix.java }}
+          path: target/site/
+      - name: Package Jar ${{ matrix.java }}
+        run: mvn clean package -D maven.compiler.source=${{ matrix.java }} -D maven.compiler.target=${{ matrix.java }} -D maven.test.skip=true -D maven.site.skip=true
+      - name: Upload Package Results ${{ matrix.java }}
+        if: ${{ always() }}
+        uses: actions/upload-artifact@v3
+        with:
+          name: Package Jar ${{ matrix.java }}
+          path: target/*.jar
+
+  build-21:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      max-parallel: 1
+      matrix:
+        # build against supported Java LTS versions:
+        java: [ 21 ]
     name: Java ${{ matrix.java }}
     steps:
       - uses: actions/checkout@v3

README.md

@@ -10,7 +10,7 @@ JSON in Java [package org.json]
 [![Java CI with Maven](https://github.com/stleary/JSON-java/actions/workflows/pipeline.yml/badge.svg)](https://github.com/stleary/JSON-java/actions/workflows/pipeline.yml)
 [![CodeQL](https://github.com/stleary/JSON-java/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/stleary/JSON-java/actions/workflows/codeql-analysis.yml)
 
-**[Click here if you just want the latest release jar file.](https://search.maven.org/remotecontent?filepath=org/json/json/20240205/json-20240205.jar)**
+**[Click here if you just want the latest release jar file.](https://search.maven.org/remotecontent?filepath=org/json/json/20240205/json-20240303.jar)**
 
 
 # Overview

docs/RELEASES.md

@@ -5,6 +5,8 @@ and artifactId "json". For example:
 [https://search.maven.org/search?q=g:org.json%20AND%20a:json&core=gav](https://search.maven.org/search?q=g:org.json%20AND%20a:json&core=gav)
 
 ~~~
+20240303    Revert optLong/getLong changes, and recent commits.
+
 20240205    Recent commits.
 
 20231013    First release with minimum Java version 1.8. Recent commits, including fixes for CVE-2023-5072.

pom.xml

@@ -3,7 +3,7 @@
 
     <groupId>org.json</groupId>
     <artifactId>json</artifactId>
-    <version>20240205</version>
+    <version>20240303</version>
     <packaging>bundle</packaging>
 
     <name>JSON in Java</name>

src/main/java/org/json/CDL.java

@@ -5,15 +5,15 @@ Public Domain.
  */
 
 /**
- * This provides static methods to convert comma delimited text into a
- * JSONArray, and to convert a JSONArray into comma delimited text. Comma
+ * This provides static methods to convert comma (or otherwise) delimited text into a
+ * JSONArray, and to convert a JSONArray into comma (or otherwise) delimited text. Comma
  * delimited text is a very popular format for data interchange. It is
  * understood by most database, spreadsheet, and organizer programs.
  * <p>
  * Each row of text represents a row in a table or a data record. Each row
  * ends with a NEWLINE character. Each row contains one or more values.
  * Values are separated by commas. A value can contain any character except
- * for comma, unless is is wrapped in single quotes or double quotes.
+ * for comma, unless it is wrapped in single quotes or double quotes.
  * <p>
  * The first row usually contains the names of the columns.
  * <p>
@@ -25,25 +25,30 @@ Public Domain.
  */
 public class CDL {
 
+    /**
+     * Constructs a new CDL object.
+     */
+    public CDL() {
+    }
+
     /**
      * Get the next value. The value can be wrapped in quotes. The value can
      * be empty.
      * @param x A JSONTokener of the source text.
+     * @param delimiter used in the file
      * @return The value string, or null if empty.
      * @throws JSONException if the quoted string is badly formed.
      */
-    private static String getValue(JSONTokener x) throws JSONException {
+    private static String getValue(JSONTokener x, char delimiter) throws JSONException {
         char c;
         char q;
         StringBuilder sb;
         do {
             c = x.next();
         } while (c == ' ' || c == '\t');
-        switch (c) {
-        case 0:
+        if (c == 0) {
             return null;
-        case '"':
-        case '\'':
+        } else if (c == '"' || c == '\'') {
             q = c;
             sb = new StringBuilder();
             for (;;) {
@@ -51,9 +56,9 @@ public class CDL {
                 if (c == q) {
                     //Handle escaped double-quote
                     char nextC = x.next();
-                    if(nextC != '\"') {
+                    if (nextC != '\"') {
                         // if our quote was the end of the file, don't step
-                        if(nextC > 0) {
+                        if (nextC > 0) {
                             x.back();
                         }
                         break;
@@ -65,13 +70,12 @@ public class CDL {
                 sb.append(c);
             }
             return sb.toString();
-        case ',':
+        } else if (c == delimiter) {
             x.back();
             return "";
-        default:
-            x.back();
-            return x.nextTo(',');
         }
+        x.back();
+        return x.nextTo(delimiter);
     }
 
     /**
@@ -81,17 +85,28 @@ public class CDL {
      * @throws JSONException if a called function fails
      */
     public static JSONArray rowToJSONArray(JSONTokener x) throws JSONException {
+        return rowToJSONArray(x, ',');
+    }
+
+    /**
+     * Produce a JSONArray of strings from a row of comma delimited values.
+     * @param x A JSONTokener of the source text.
+     * @param delimiter custom delimiter char
+     * @return A JSONArray of strings.
+     * @throws JSONException if a called function fails
+     */
+    public static JSONArray rowToJSONArray(JSONTokener x, char delimiter) throws JSONException {
         JSONArray ja = new JSONArray();
         for (;;) {
-            String value = getValue(x);
+            String value = getValue(x,delimiter);
             char c = x.next();
             if (value == null ||
-                    (ja.length() == 0 && value.length() == 0 && c != ',')) {
+                    (ja.length() == 0 && value.length() == 0 && c != delimiter)) {
                 return null;
             }
             ja.put(value);
             for (;;) {
-                if (c == ',') {
+                if (c == delimiter) {
                     break;
                 }
                 if (c != ' ') {
@@ -116,9 +131,23 @@ public class CDL {
      * @return A JSONObject combining the names and values.
      * @throws JSONException if a called function fails
      */
-    public static JSONObject rowToJSONObject(JSONArray names, JSONTokener x)
-            throws JSONException {
-        JSONArray ja = rowToJSONArray(x);
+    public static JSONObject rowToJSONObject(JSONArray names, JSONTokener x) throws JSONException {
+        return rowToJSONObject(names, x, ',');
+    }
+
+    /**
+     * Produce a JSONObject from a row of comma delimited text, using a
+     * parallel JSONArray of strings to provides the names of the elements.
+     * @param names A JSONArray of names. This is commonly obtained from the
+     *  first row of a comma delimited text file using the rowToJSONArray
+     *  method.
+     * @param x A JSONTokener of the source text.
+     * @param delimiter custom delimiter char
+     * @return A JSONObject combining the names and values.
+     * @throws JSONException if a called function fails
+     */
+    public static JSONObject rowToJSONObject(JSONArray names, JSONTokener x, char delimiter) throws JSONException {
+        JSONArray ja = rowToJSONArray(x, delimiter);
         return ja != null ? ja.toJSONObject(names) :  null;
     }
 
@@ -130,15 +159,27 @@ public class CDL {
      * @return A string ending in NEWLINE.
      */
     public static String rowToString(JSONArray ja) {
+        return rowToString(ja, ',');
+    }
+
+    /**
+     * Produce a comma delimited text row from a JSONArray. Values containing
+     * the comma character will be quoted. Troublesome characters may be
+     * removed.
+     * @param ja A JSONArray of strings.
+     * @param delimiter custom delimiter char
+     * @return A string ending in NEWLINE.
+     */
+    public static String rowToString(JSONArray ja, char delimiter) {
         StringBuilder sb = new StringBuilder();
         for (int i = 0; i < ja.length(); i += 1) {
             if (i > 0) {
-                sb.append(',');
+                sb.append(delimiter);
             }
             Object object = ja.opt(i);
             if (object != null) {
                 String string = object.toString();
-                if (string.length() > 0 && (string.indexOf(',') >= 0 ||
+                if (string.length() > 0 && (string.indexOf(delimiter) >= 0 ||
                         string.indexOf('\n') >= 0 || string.indexOf('\r') >= 0 ||
                         string.indexOf(0) >= 0 || string.charAt(0) == '"')) {
                     sb.append('"');
@@ -167,7 +208,19 @@ public class CDL {
      * @throws JSONException if a called function fails
      */
     public static JSONArray toJSONArray(String string) throws JSONException {
-        return toJSONArray(new JSONTokener(string));
+        return toJSONArray(string, ',');
+    }
+
+    /**
+     * Produce a JSONArray of JSONObjects from a comma delimited text string,
+     * using the first row as a source of names.
+     * @param string The comma delimited text.
+     * @param delimiter custom delimiter char
+     * @return A JSONArray of JSONObjects.
+     * @throws JSONException if a called function fails
+     */
+    public static JSONArray toJSONArray(String string, char delimiter) throws JSONException {
+        return toJSONArray(new JSONTokener(string), delimiter);
     }
 
     /**
@@ -178,7 +231,19 @@ public class CDL {
      * @throws JSONException if a called function fails
      */
     public static JSONArray toJSONArray(JSONTokener x) throws JSONException {
-        return toJSONArray(rowToJSONArray(x), x);
+        return toJSONArray(x, ',');
+    }
+
+    /**
+     * Produce a JSONArray of JSONObjects from a comma delimited text string,
+     * using the first row as a source of names.
+     * @param x The JSONTokener containing the comma delimited text.
+     * @param delimiter custom delimiter char
+     * @return A JSONArray of JSONObjects.
+     * @throws JSONException if a called function fails
+     */
+    public static JSONArray toJSONArray(JSONTokener x, char delimiter) throws JSONException {
+        return toJSONArray(rowToJSONArray(x, delimiter), x, delimiter);
     }
 
     /**
@@ -189,9 +254,21 @@ public class CDL {
      * @return A JSONArray of JSONObjects.
      * @throws JSONException if a called function fails
      */
-    public static JSONArray toJSONArray(JSONArray names, String string)
-            throws JSONException {
-        return toJSONArray(names, new JSONTokener(string));
+    public static JSONArray toJSONArray(JSONArray names, String string) throws JSONException {
+        return toJSONArray(names, string, ',');
+    }
+
+    /**
+     * Produce a JSONArray of JSONObjects from a comma delimited text string
+     * using a supplied JSONArray as the source of element names.
+     * @param names A JSONArray of strings.
+     * @param string The comma delimited text.
+     * @param delimiter custom delimiter char
+     * @return A JSONArray of JSONObjects.
+     * @throws JSONException if a called function fails
+     */
+    public static JSONArray toJSONArray(JSONArray names, String string, char delimiter) throws JSONException {
+        return toJSONArray(names, new JSONTokener(string), delimiter);
     }
 
     /**
@@ -202,14 +279,26 @@ public class CDL {
      * @return A JSONArray of JSONObjects.
      * @throws JSONException if a called function fails
      */
-    public static JSONArray toJSONArray(JSONArray names, JSONTokener x)
-            throws JSONException {
+    public static JSONArray toJSONArray(JSONArray names, JSONTokener x) throws JSONException {
+        return toJSONArray(names, x, ',');
+    }
+
+    /**
+     * Produce a JSONArray of JSONObjects from a comma delimited text string
+     * using a supplied JSONArray as the source of element names.
+     * @param names A JSONArray of strings.
+     * @param x A JSONTokener of the source text.
+     * @param delimiter custom delimiter char
+     * @return A JSONArray of JSONObjects.
+     * @throws JSONException if a called function fails
+     */
+    public static JSONArray toJSONArray(JSONArray names, JSONTokener x, char delimiter) throws JSONException {
         if (names == null || names.length() == 0) {
             return null;
         }
         JSONArray ja = new JSONArray();
         for (;;) {
-            JSONObject jo = rowToJSONObject(names, x);
+            JSONObject jo = rowToJSONObject(names, x, delimiter);
             if (jo == null) {
                 break;
             }
@@ -231,11 +320,24 @@ public class CDL {
      * @throws JSONException if a called function fails
      */
     public static String toString(JSONArray ja) throws JSONException {
+        return toString(ja, ',');
+    }
+
+    /**
+     * Produce a comma delimited text from a JSONArray of JSONObjects. The
+     * first row will be a list of names obtained by inspecting the first
+     * JSONObject.
+     * @param ja A JSONArray of JSONObjects.
+     * @param delimiter custom delimiter char
+     * @return A comma delimited text.
+     * @throws JSONException if a called function fails
+     */
+    public static String toString(JSONArray ja, char delimiter) throws JSONException {
         JSONObject jo = ja.optJSONObject(0);
         if (jo != null) {
             JSONArray names = jo.names();
             if (names != null) {
-                return rowToString(names) + toString(names, ja);
+                return rowToString(names, delimiter) + toString(names, ja, delimiter);
             }
         }
         return null;
@@ -250,8 +352,21 @@ public class CDL {
      * @return A comma delimited text.
      * @throws JSONException if a called function fails
      */
-    public static String toString(JSONArray names, JSONArray ja)
-            throws JSONException {
+    public static String toString(JSONArray names, JSONArray ja) throws JSONException {
+        return toString(names, ja, ',');
+    }
+
+    /**
+     * Produce a comma delimited text from a JSONArray of JSONObjects using
+     * a provided list of names. The list of names is not included in the
+     * output.
+     * @param names A JSONArray of strings.
+     * @param ja A JSONArray of JSONObjects.
+     * @param delimiter custom delimiter char
+     * @return A comma delimited text.
+     * @throws JSONException if a called function fails
+     */
+    public static String toString(JSONArray names, JSONArray ja, char delimiter) throws JSONException {
         if (names == null || names.length() == 0) {
             return null;
         }
@@ -259,7 +374,7 @@ public class CDL {
         for (int i = 0; i < ja.length(); i += 1) {
             JSONObject jo = ja.optJSONObject(i);
             if (jo != null) {
-                sb.append(rowToString(jo.toJSONArray(names)));
+                sb.append(rowToString(jo.toJSONArray(names), delimiter));
             }
         }
         return sb.toString();

src/main/java/org/json/Cookie.java

@@ -15,6 +15,12 @@ Public Domain.
  */
 public class Cookie {
 
+    /**
+     * Constructs a new Cookie object.
+     */
+    public Cookie() {
+    }
+
     /**
      * Produce a copy of a string in which the characters '+', '%', '=', ';'
      * and control characters are replaced with "%hh". This is a gentle form

src/main/java/org/json/CookieList.java

@@ -11,6 +11,12 @@ Public Domain.
  */
 public class CookieList {
 
+    /**
+     * Constructs a new CookieList object.
+     */
+    public CookieList() {
+    }
+ 
     /**
      * Convert a cookie list into a JSONObject. A cookie list is a sequence
      * of name/value pairs. The names are separated from the values by '='.

src/main/java/org/json/HTTP.java

@@ -13,6 +13,12 @@ import java.util.Locale;
  */
 public class HTTP {
 
+    /**
+     * Constructs a new HTTP object.
+     */
+    public HTTP() {
+    }
+
     /** Carriage return/line feed. */
     public static final String CRLF = "\r\n";
 

src/main/java/org/json/JSONArray.java

@@ -360,7 +360,7 @@ public class JSONArray implements Iterable<Object> {
             if (object instanceof Number) {
                 return (Number)object;
             }
-            return NumberConversionUtil.stringToNumber(object.toString());
+            return JSONObject.stringToNumber(object.toString());
         } catch (Exception e) {
             throw wrongValueFormatException(index, "number", object, e);
         }
@@ -1107,7 +1107,7 @@ public class JSONArray implements Iterable<Object> {
         
         if (val instanceof String) {
             try {
-                return NumberConversionUtil.stringToNumber((String) val);
+                return JSONObject.stringToNumber((String) val);
             } catch (Exception e) {
                 return defaultValue;
             }

src/main/java/org/json/JSONML.java

@@ -13,6 +13,13 @@ Public Domain.
  * @version 2016-01-30
  */
 public class JSONML {
+
+    /**
+     * Constructs a new JSONML object.
+     */
+    public JSONML() {
+    }
+
     /**
      * Parse XML values and store them in a JSONArray.
      * @param x       The XMLTokener containing the source string.

src/main/java/org/json/JSONObject.java

@@ -28,9 +28,6 @@ import java.util.ResourceBundle;
 import java.util.Set;
 import java.util.regex.Pattern;
 
-import static org.json.NumberConversionUtil.potentialNumber;
-import static org.json.NumberConversionUtil.stringToNumber;
-
 /**
  * A JSONObject is an unordered collection of name/value pairs. Its external
  * form is a string wrapped in curly braces with colons between the names and
@@ -148,6 +145,11 @@ public class JSONObject {
      */
     private final Map<String, Object> map;
 
+    /**
+     * Retrieves the type of the underlying Map in this class.
+     *
+     * @return The class object representing the type of the underlying Map.
+     */
     public Class<? extends Map> getMapType() {
         return map.getClass();
     }
@@ -369,7 +371,6 @@ public class JSONObject {
      * &#64;JSONPropertyIgnore
      * public String getName() { return this.name; }
      * </pre>
-     * <p>
      *
      * @param bean
      *            An object that has getter methods that should be used to make
@@ -2232,6 +2233,14 @@ public class JSONObject {
         }
     }
 
+    /**
+     * Quotes a string and appends the result to a given Writer.
+     *
+     * @param string The input string to be quoted.
+     * @param w      The Writer to which the quoted string will be appended.
+     * @return The same Writer instance after appending the quoted string.
+     * @throws IOException If an I/O error occurs while writing to the Writer.
+     */
     public static Writer quote(String string, Writer w) throws IOException {
         if (string == null || string.isEmpty()) {
             w.write("\"\"");
@@ -2448,7 +2457,8 @@ public class JSONObject {
          * produced, then the value will just be a string.
          */
 
-        if (potentialNumber(string)) {
+        char initial = string.charAt(0);
+        if ((initial >= '0' && initial <= '9') || initial == '-') {
             try {
                 return stringToNumber(string);
             } catch (Exception ignore) {
@@ -2457,8 +2467,75 @@ public class JSONObject {
         return string;
     }
 
+    /**
+     * Converts a string to a number using the narrowest possible type. Possible
+     * returns for this function are BigDecimal, Double, BigInteger, Long, and Integer.
+     * When a Double is returned, it should always be a valid Double and not NaN or +-infinity.
+     *
+     * @param val value to convert
+     * @return Number representation of the value.
+     * @throws NumberFormatException thrown if the value is not a valid number. A public
+     *      caller should catch this and wrap it in a {@link JSONException} if applicable.
+     */
+    protected static Number stringToNumber(final String val) throws NumberFormatException {
+        char initial = val.charAt(0);
+        if ((initial >= '0' && initial <= '9') || initial == '-') {
+            // decimal representation
+            if (isDecimalNotation(val)) {
+                // Use a BigDecimal all the time so we keep the original
+                // representation. BigDecimal doesn't support -0.0, ensure we
+                // keep that by forcing a decimal.
+                try {
+                    BigDecimal bd = new BigDecimal(val);
+                    if(initial == '-' && BigDecimal.ZERO.compareTo(bd)==0) {
+                        return Double.valueOf(-0.0);
+                    }
+                    return bd;
+                } catch (NumberFormatException retryAsDouble) {
+                    // this is to support "Hex Floats" like this: 0x1.0P-1074
+                    try {
+                        Double d = Double.valueOf(val);
+                        if(d.isNaN() || d.isInfinite()) {
+                            throw new NumberFormatException("val ["+val+"] is not a valid number.");
+                        }
+                        return d;
+                    } catch (NumberFormatException ignore) {
+                        throw new NumberFormatException("val ["+val+"] is not a valid number.");
+                    }
+                }
+            }
+            // block items like 00 01 etc. Java number parsers treat these as Octal.
+            if(initial == '0' && val.length() > 1) {
+                char at1 = val.charAt(1);
+                if(at1 >= '0' && at1 <= '9') {
+                    throw new NumberFormatException("val ["+val+"] is not a valid number.");
+                }
+            } else if (initial == '-' && val.length() > 2) {
+                char at1 = val.charAt(1);
+                char at2 = val.charAt(2);
+                if(at1 == '0' && at2 >= '0' && at2 <= '9') {
+                    throw new NumberFormatException("val ["+val+"] is not a valid number.");
+                }
+            }
+            // integer representation.
+            // This will narrow any values to the smallest reasonable Object representation
+            // (Integer, Long, or BigInteger)
 
-
+            // BigInteger down conversion: We use a similar bitLength compare as
+            // BigInteger#intValueExact uses. Increases GC, but objects hold
+            // only what they need. i.e. Less runtime overhead if the value is
+            // long lived.
+            BigInteger bi = new BigInteger(val);
+            if(bi.bitLength() <= 31){
+                return Integer.valueOf(bi.intValue());
+            }
+            if(bi.bitLength() <= 63){
+                return Long.valueOf(bi.longValue());
+            }
+            return bi;
+        }
+        throw new NumberFormatException("val ["+val+"] is not a valid number.");
+    }
 
     /**
      * Throw an exception if the object is a NaN or infinite number.
@@ -2884,5 +2961,23 @@ public class JSONObject {
         );
     }
 
-
+    /**
+     * For a prospective number, remove the leading zeros
+     * @param value prospective number
+     * @return number without leading zeros
+     */
+    private static String removeLeadingZerosOfNumber(String value){
+        if (value.equals("-")){return value;}
+        boolean negativeFirstChar = (value.charAt(0) == '-');
+        int counter = negativeFirstChar ? 1:0;
+        while (counter < value.length()){
+            if (value.charAt(counter) != '0'){
+                if (negativeFirstChar) {return "-".concat(value.substring(counter));}
+                return value.substring(counter);
+            }
+            ++counter;
+        }
+        if (negativeFirstChar) {return "-0";}
+        return "0";
+    }
 }

src/main/java/org/json/JSONPointer.java

@@ -42,6 +42,12 @@ public class JSONPointer {
      */
     public static class Builder {
 
+        /**
+         * Constructs a new Builder object.
+         */
+        public Builder() {
+        }
+
         // Segments for the eventual JSONPointer string
         private final List<String> refTokens = new ArrayList<String>();
 
@@ -163,6 +169,12 @@ public class JSONPointer {
         //}
     }
 
+    /**
+     * Constructs a new JSONPointer instance with the provided list of reference tokens.
+     *
+     * @param refTokens A list of strings representing the reference tokens for the JSON Pointer.
+     *                  Each token identifies a step in the path to the targeted value.
+     */
     public JSONPointer(List<String> refTokens) {
         this.refTokens = new ArrayList<String>(refTokens);
     }

src/main/java/org/json/JSONPointerException.java

@@ -14,10 +14,21 @@ Public Domain.
 public class JSONPointerException extends JSONException {
     private static final long serialVersionUID = 8872944667561856751L;
 
+    /**
+     * Constructs a new JSONPointerException with the specified error message.
+     *
+     * @param message The detail message describing the reason for the exception.
+     */
     public JSONPointerException(String message) {
         super(message);
     }
 
+    /**
+     * Constructs a new JSONPointerException with the specified error message and cause.
+     *
+     * @param message The detail message describing the reason for the exception.
+     * @param cause   The cause of the exception.
+     */
     public JSONPointerException(String message, Throwable cause) {
         super(message, cause);
     }

src/main/java/org/json/JSONPropertyName.java

@@ -21,6 +21,7 @@ import java.lang.annotation.Target;
 @Target({METHOD})
 public @interface JSONPropertyName {
     /**
+     * The value of the JSON property.
      * @return The name of the property as to be used in the JSON Object.
      */
     String value();

src/main/java/org/json/JSONTokener.java

@@ -525,6 +525,11 @@ public class JSONTokener {
                 this.line + "]";
     }
 
+    /**
+     * Closes the underlying reader, releasing any resources associated with it.
+     *
+     * @throws IOException If an I/O error occurs while closing the reader.
+     */
     public void close() throws IOException {
         if(reader!=null){
             reader.close();

src/main/java/org/json/NumberConversionUtil.java

@@ -1,152 +0,0 @@
-package org.json;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-
-class NumberConversionUtil {
-
-    /**
-     * Converts a string to a number using the narrowest possible type. Possible
-     * returns for this function are BigDecimal, Double, BigInteger, Long, and Integer.
-     * When a Double is returned, it should always be a valid Double and not NaN or +-infinity.
-     *
-     * @param input value to convert
-     * @return Number representation of the value.
-     * @throws NumberFormatException thrown if the value is not a valid number. A public
-     *      caller should catch this and wrap it in a {@link JSONException} if applicable.
-     */
-    static Number stringToNumber(final String input) throws NumberFormatException {
-        String val = input;
-        if (val.startsWith(".")){
-            val = "0"+val;
-        }
-        if (val.startsWith("-.")){
-            val = "-0."+val.substring(2);
-        }
-        char initial = val.charAt(0);
-        if ( isNumericChar(initial) || initial == '-' ) {
-            // decimal representation
-            if (isDecimalNotation(val)) {
-                // Use a BigDecimal all the time so we keep the original
-                // representation. BigDecimal doesn't support -0.0, ensure we
-                // keep that by forcing a decimal.
-                try {
-                    BigDecimal bd = new BigDecimal(val);
-                    if(initial == '-' && BigDecimal.ZERO.compareTo(bd)==0) {
-                        return Double.valueOf(-0.0);
-                    }
-                    return bd;
-                } catch (NumberFormatException retryAsDouble) {
-                    // this is to support "Hex Floats" like this: 0x1.0P-1074
-                    try {
-                        Double d = Double.valueOf(val);
-                        if(d.isNaN() || d.isInfinite()) {
-                            throw new NumberFormatException("val ["+input+"] is not a valid number.");
-                        }
-                        return d;
-                    } catch (NumberFormatException ignore) {
-                        throw new NumberFormatException("val ["+input+"] is not a valid number.");
-                    }
-                }
-            }
-            val = removeLeadingZerosOfNumber(input);
-            initial = val.charAt(0);
-            if(initial == '0' && val.length() > 1) {
-                char at1 = val.charAt(1);
-                if(isNumericChar(at1)) {
-                    throw new NumberFormatException("val ["+input+"] is not a valid number.");
-                }
-            } else if (initial == '-' && val.length() > 2) {
-                char at1 = val.charAt(1);
-                char at2 = val.charAt(2);
-                if(at1 == '0' && isNumericChar(at2)) {
-                    throw new NumberFormatException("val ["+input+"] is not a valid number.");
-                }
-            }
-            // integer representation.
-            // This will narrow any values to the smallest reasonable Object representation
-            // (Integer, Long, or BigInteger)
-
-            // BigInteger down conversion: We use a similar bitLength compare as
-            // BigInteger#intValueExact uses. Increases GC, but objects hold
-            // only what they need. i.e. Less runtime overhead if the value is
-            // long lived.
-            BigInteger bi = new BigInteger(val);
-            if(bi.bitLength() <= 31){
-                return Integer.valueOf(bi.intValue());
-            }
-            if(bi.bitLength() <= 63){
-                return Long.valueOf(bi.longValue());
-            }
-            return bi;
-        }
-        throw new NumberFormatException("val ["+input+"] is not a valid number.");
-    }
-
-    /**
-     * Checks if the character is a numeric digit ('0' to '9').
-     *
-     * @param c The character to be checked.
-     * @return true if the character is a numeric digit, false otherwise.
-     */
-    private static boolean isNumericChar(char c) {
-        return (c <= '9' && c >= '0');
-    }
-
-    /**
-     * Checks if the value could be considered a number in decimal number system.
-     * @param value
-     * @return
-     */
-    static boolean potentialNumber(String value){
-        if (value == null || value.isEmpty()){
-            return false;
-        }
-        return potentialPositiveNumberStartingAtIndex(value, (value.charAt(0)=='-'?1:0));
-    }
-
-    /**
-     * Tests if the value should be tried as a decimal. It makes no test if there are actual digits.
-     *
-     * @param val value to test
-     * @return true if the string is "-0" or if it contains '.', 'e', or 'E', false otherwise.
-     */
-    private static boolean isDecimalNotation(final String val) {
-        return val.indexOf('.') > -1 || val.indexOf('e') > -1
-                || val.indexOf('E') > -1 || "-0".equals(val);
-    }
-
-    private static boolean potentialPositiveNumberStartingAtIndex(String value,int index){
-        if (index >= value.length()){
-            return false;
-        }
-        return digitAtIndex(value, (value.charAt(index)=='.'?index+1:index));
-    }
-
-    private static boolean digitAtIndex(String value, int index){
-        if (index >= value.length()){
-            return false;
-        }
-        return value.charAt(index) >= '0' && value.charAt(index) <= '9';
-    }
-
-    /**
-     * For a prospective number, remove the leading zeros
-     * @param value prospective number
-     * @return number without leading zeros
-     */
-    private static String removeLeadingZerosOfNumber(String value){
-        if (value.equals("-")){return value;}
-        boolean negativeFirstChar = (value.charAt(0) == '-');
-        int counter = negativeFirstChar ? 1:0;
-        while (counter < value.length()){
-            if (value.charAt(counter) != '0'){
-                if (negativeFirstChar) {return "-".concat(value.substring(counter));}
-                return value.substring(counter);
-            }
-            ++counter;
-        }
-        if (negativeFirstChar) {return "-0";}
-        return "0";
-    }
-}

src/main/java/org/json/ParserConfiguration.java

@@ -29,11 +29,20 @@ public class ParserConfiguration {
      */
     protected int maxNestingDepth;
 
+    /**
+     * Constructs a new ParserConfiguration with default settings.
+     */
     public ParserConfiguration() {
         this.keepStrings = false;
         this.maxNestingDepth = DEFAULT_MAXIMUM_NESTING_DEPTH;
     }
 
+    /**
+     * Constructs a new ParserConfiguration with the specified settings.
+     *
+     * @param keepStrings     A boolean indicating whether to preserve strings during parsing.
+     * @param maxNestingDepth An integer representing the maximum allowed nesting depth.
+     */
     protected ParserConfiguration(final boolean keepStrings, final int maxNestingDepth) {
         this.keepStrings = keepStrings;
         this.maxNestingDepth = maxNestingDepth;

src/main/java/org/json/Property.java

@@ -13,6 +13,13 @@ import java.util.Properties;
  * @version 2015-05-05
  */
 public class Property {
+
+    /**
+     * Constructs a new Property object.
+     */
+    public Property() {
+    }
+
     /**
      * Converts a property file object into a JSONObject. The property file object is a table of name value pairs.
      * @param properties java.util.Properties

src/main/java/org/json/XML.java

@@ -10,10 +10,6 @@ import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.util.Iterator;
 
-import static org.json.NumberConversionUtil.potentialNumber;
-import static org.json.NumberConversionUtil.stringToNumber;
-
-
 /**
  * This provides static methods to convert an XML text into a JSONObject, and to
  * covert a JSONObject into an XML text.
@@ -24,6 +20,12 @@ import static org.json.NumberConversionUtil.stringToNumber;
 @SuppressWarnings("boxing")
 public class XML {
 
+    /**
+     * Constructs a new XML object.
+     */
+    public XML() {
+    }
+
     /** The Character '&'. */
     public static final Character AMP = '&';
 
@@ -56,6 +58,9 @@ public class XML {
      */
     public static final String NULL_ATTR = "xsi:nil";
 
+    /**
+     * Represents the XML attribute name for specifying type information.
+     */
     public static final String TYPE_ATTR = "xsi:type";
 
     /**
@@ -490,6 +495,76 @@ public class XML {
         return true;
     }
 
+    /**
+     * direct copy of {@link JSONObject#stringToNumber(String)} to maintain Android support.
+     */
+    private static Number stringToNumber(final String val) throws NumberFormatException {
+        char initial = val.charAt(0);
+        if ((initial >= '0' && initial <= '9') || initial == '-') {
+            // decimal representation
+            if (isDecimalNotation(val)) {
+                // Use a BigDecimal all the time so we keep the original
+                // representation. BigDecimal doesn't support -0.0, ensure we
+                // keep that by forcing a decimal.
+                try {
+                    BigDecimal bd = new BigDecimal(val);
+                    if(initial == '-' && BigDecimal.ZERO.compareTo(bd)==0) {
+                        return Double.valueOf(-0.0);
+                    }
+                    return bd;
+                } catch (NumberFormatException retryAsDouble) {
+                    // this is to support "Hex Floats" like this: 0x1.0P-1074
+                    try {
+                        Double d = Double.valueOf(val);
+                        if(d.isNaN() || d.isInfinite()) {
+                            throw new NumberFormatException("val ["+val+"] is not a valid number.");
+                        }
+                        return d;
+                    } catch (NumberFormatException ignore) {
+                        throw new NumberFormatException("val ["+val+"] is not a valid number.");
+                    }
+                }
+            }
+            // block items like 00 01 etc. Java number parsers treat these as Octal.
+            if(initial == '0' && val.length() > 1) {
+                char at1 = val.charAt(1);
+                if(at1 >= '0' && at1 <= '9') {
+                    throw new NumberFormatException("val ["+val+"] is not a valid number.");
+                }
+            } else if (initial == '-' && val.length() > 2) {
+                char at1 = val.charAt(1);
+                char at2 = val.charAt(2);
+                if(at1 == '0' && at2 >= '0' && at2 <= '9') {
+                    throw new NumberFormatException("val ["+val+"] is not a valid number.");
+                }
+            }
+            // integer representation.
+            // This will narrow any values to the smallest reasonable Object representation
+            // (Integer, Long, or BigInteger)
+
+            // BigInteger down conversion: We use a similar bitLength compare as
+            // BigInteger#intValueExact uses. Increases GC, but objects hold
+            // only what they need. i.e. Less runtime overhead if the value is
+            // long lived.
+            BigInteger bi = new BigInteger(val);
+            if(bi.bitLength() <= 31){
+                return Integer.valueOf(bi.intValue());
+            }
+            if(bi.bitLength() <= 63){
+                return Long.valueOf(bi.longValue());
+            }
+            return bi;
+        }
+        throw new NumberFormatException("val ["+val+"] is not a valid number.");
+    }
+
+    /**
+     * direct copy of {@link JSONObject#isDecimalNotation(String)} to maintain Android support.
+     */
+    private static boolean isDecimalNotation(final String val) {
+        return val.indexOf('.') > -1 || val.indexOf('e') > -1
+                || val.indexOf('E') > -1 || "-0".equals(val);
+    }
 
     /**
      * This method tries to convert the given string value to the target object
@@ -534,7 +609,8 @@ public class XML {
          * produced, then the value will just be a string.
          */
 
-        if (potentialNumber(string)) {
+        char initial = string.charAt(0);
+        if ((initial >= '0' && initial <= '9') || initial == '-') {
             try {
                 return stringToNumber(string);
             } catch (Exception ignore) {
@@ -543,11 +619,6 @@ public class XML {
         return string;
     }
 
-
-
-
-
-
     /**
      * Convert a well-formed (but not necessarily valid) XML string into a
      * JSONObject. Some information may be lost in this transformation because
@@ -966,5 +1037,4 @@ public class XML {
         }
         return sb.toString();
     }
-
 }

src/main/java/org/json/XMLParserConfiguration.java

@@ -352,9 +352,20 @@ public class XMLParserConfiguration extends ParserConfiguration {
         return clonedConfiguration;
     }
 
+    /**
+     * Checks if the parser should automatically close empty XML tags.
+     *
+     * @return {@code true} if empty XML tags should be automatically closed, {@code false} otherwise.
+     */
     public boolean isCloseEmptyTag() {
         return this.closeEmptyTag;
     }
+
+    /**
+     * Checks if the parser should trim white spaces from XML content.
+     *
+     * @return {@code true} if white spaces should be trimmed, {@code false} otherwise.
+     */
     public boolean shouldTrimWhiteSpace() {
         return this.shouldTrimWhiteSpace;
     }

src/main/java/org/json/XMLXsiTypeConverter.java

@@ -42,5 +42,12 @@ Public Domain.
  * @param <T> return type of convert method
  */
 public interface XMLXsiTypeConverter<T> {
+
+    /**
+     * Converts an XML xsi:type attribute value to the specified type {@code T}.
+     *
+     * @param value The string representation of the XML xsi:type attribute value to be converted.
+     * @return An object of type {@code T} representing the converted value.
+     */
     T convert(String value);
 }

src/test/java/org/json/NumberConversionUtilTest.java

@@ -1,174 +0,0 @@
-package org.json;
-
-import org.junit.Test;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-
-import static org.junit.Assert.*;
-
-public class NumberConversionUtilTest {
-
-    @Test
-    public void shouldParseDecimalFractionNumbersWithMultipleLeadingZeros(){
-        Number number = NumberConversionUtil.stringToNumber("00.10d");
-        assertEquals("Do not match",  0.10d, number.doubleValue(),0.0d);
-        assertEquals("Do not match",  0.10f, number.floatValue(),0.0f);
-        assertEquals("Do not match",  0, number.longValue(),0);
-        assertEquals("Do not match",  0, number.intValue(),0);
-    }
-
-    @Test
-    public void shouldParseDecimalFractionNumbersWithSingleLeadingZero(){
-        Number number = NumberConversionUtil.stringToNumber("0.10d");
-        assertEquals("Do not match",  0.10d, number.doubleValue(),0.0d);
-        assertEquals("Do not match",  0.10f, number.floatValue(),0.0f);
-        assertEquals("Do not match",  0, number.longValue(),0);
-        assertEquals("Do not match",  0, number.intValue(),0);
-    }
-
-
-    @Test
-    public void shouldParseDecimalFractionNumbersWithZerosAfterDecimalPoint(){
-        Number number = NumberConversionUtil.stringToNumber("0.010d");
-        assertEquals("Do not match",  0.010d, number.doubleValue(),0.0d);
-        assertEquals("Do not match",  0.010f, number.floatValue(),0.0f);
-        assertEquals("Do not match",  0, number.longValue(),0);
-        assertEquals("Do not match",  0, number.intValue(),0);
-    }
-
-    @Test
-    public void shouldParseMixedDecimalFractionNumbersWithMultipleLeadingZeros(){
-        Number number = NumberConversionUtil.stringToNumber("00200.10d");
-        assertEquals("Do not match",  200.10d, number.doubleValue(),0.0d);
-        assertEquals("Do not match",  200.10f, number.floatValue(),0.0f);
-        assertEquals("Do not match",  200, number.longValue(),0);
-        assertEquals("Do not match",  200, number.intValue(),0);
-    }
-
-    @Test
-    public void shouldParseMixedDecimalFractionNumbersWithoutLeadingZero(){
-        Number number = NumberConversionUtil.stringToNumber("200.10d");
-        assertEquals("Do not match",  200.10d, number.doubleValue(),0.0d);
-        assertEquals("Do not match",  200.10f, number.floatValue(),0.0f);
-        assertEquals("Do not match",  200, number.longValue(),0);
-        assertEquals("Do not match",  200, number.intValue(),0);
-    }
-
-
-    @Test
-    public void shouldParseMixedDecimalFractionNumbersWithZerosAfterDecimalPoint(){
-        Number number = NumberConversionUtil.stringToNumber("200.010d");
-        assertEquals("Do not match",  200.010d, number.doubleValue(),0.0d);
-        assertEquals("Do not match",  200.010f, number.floatValue(),0.0f);
-        assertEquals("Do not match",  200, number.longValue(),0);
-        assertEquals("Do not match",  200, number.intValue(),0);
-    }
-
-
-    @Test
-    public void shouldParseNegativeDecimalFractionNumbersWithMultipleLeadingZeros(){
-        Number number = NumberConversionUtil.stringToNumber("-00.10d");
-        assertEquals("Do not match",  -0.10d, number.doubleValue(),0.0d);
-        assertEquals("Do not match",  -0.10f, number.floatValue(),0.0f);
-        assertEquals("Do not match",  -0, number.longValue(),0);
-        assertEquals("Do not match",  -0, number.intValue(),0);
-    }
-
-    @Test
-    public void shouldParseNegativeDecimalFractionNumbersWithSingleLeadingZero(){
-        Number number = NumberConversionUtil.stringToNumber("-0.10d");
-        assertEquals("Do not match",  -0.10d, number.doubleValue(),0.0d);
-        assertEquals("Do not match",  -0.10f, number.floatValue(),0.0f);
-        assertEquals("Do not match",  -0, number.longValue(),0);
-        assertEquals("Do not match",  -0, number.intValue(),0);
-    }
-
-
-    @Test
-    public void shouldParseNegativeDecimalFractionNumbersWithZerosAfterDecimalPoint(){
-        Number number = NumberConversionUtil.stringToNumber("-0.010d");
-        assertEquals("Do not match",  -0.010d, number.doubleValue(),0.0d);
-        assertEquals("Do not match",  -0.010f, number.floatValue(),0.0f);
-        assertEquals("Do not match",  -0, number.longValue(),0);
-        assertEquals("Do not match",  -0, number.intValue(),0);
-    }
-
-    @Test
-    public void shouldParseNegativeMixedDecimalFractionNumbersWithMultipleLeadingZeros(){
-        Number number = NumberConversionUtil.stringToNumber("-00200.10d");
-        assertEquals("Do not match",  -200.10d, number.doubleValue(),0.0d);
-        assertEquals("Do not match",  -200.10f, number.floatValue(),0.0f);
-        assertEquals("Do not match",  -200, number.longValue(),0);
-        assertEquals("Do not match",  -200, number.intValue(),0);
-    }
-
-    @Test
-    public void shouldParseNegativeMixedDecimalFractionNumbersWithoutLeadingZero(){
-        Number number = NumberConversionUtil.stringToNumber("-200.10d");
-        assertEquals("Do not match",  -200.10d, number.doubleValue(),0.0d);
-        assertEquals("Do not match",  -200.10f, number.floatValue(),0.0f);
-        assertEquals("Do not match",  -200, number.longValue(),0);
-        assertEquals("Do not match",  -200, number.intValue(),0);
-    }
-
-
-    @Test
-    public void shouldParseNegativeMixedDecimalFractionNumbersWithZerosAfterDecimalPoint(){
-        Number number = NumberConversionUtil.stringToNumber("-200.010d");
-        assertEquals("Do not match",  -200.010d, number.doubleValue(),0.0d);
-        assertEquals("Do not match",  -200.010f, number.floatValue(),0.0f);
-        assertEquals("Do not match",  -200, number.longValue(),0);
-        assertEquals("Do not match",  -200, number.intValue(),0);
-    }
-
-    @Test
-    public void shouldParseNumbersWithExponents(){
-        Number number = NumberConversionUtil.stringToNumber("23.45e7");
-        assertEquals("Do not match",  23.45e7d, number.doubleValue(),0.0d);
-        assertEquals("Do not match",  23.45e7f, number.floatValue(),0.0f);
-        assertEquals("Do not match",  2.345E8, number.longValue(),0);
-        assertEquals("Do not match",  2.345E8, number.intValue(),0);
-    }
-
-
-    @Test
-    public void shouldParseNegativeNumbersWithExponents(){
-        Number number = NumberConversionUtil.stringToNumber("-23.45e7");
-        assertEquals("Do not match",  -23.45e7d, number.doubleValue(),0.0d);
-        assertEquals("Do not match",  -23.45e7f, number.floatValue(),0.0f);
-        assertEquals("Do not match",  -2.345E8, number.longValue(),0);
-        assertEquals("Do not match",  -2.345E8, number.intValue(),0);
-    }
-
-    @Test
-    public void shouldParseBigDecimal(){
-        Number number = NumberConversionUtil.stringToNumber("19007199254740993.35481234487103587486413587843213584");
-        assertTrue(number instanceof BigDecimal);
-    }
-
-    @Test
-    public void shouldParseBigInteger(){
-        Number number = NumberConversionUtil.stringToNumber("1900719925474099335481234487103587486413587843213584");
-        assertTrue(number instanceof BigInteger);
-    }
-
-    @Test
-    public void shouldIdentifyPotentialNumber(){
-        assertTrue("Does not identify as number", NumberConversionUtil.potentialNumber("112.123"));
-        assertTrue("Does not identify as number", NumberConversionUtil.potentialNumber("112e123"));
-        assertTrue("Does not identify as number", NumberConversionUtil.potentialNumber("-112.123"));
-        assertTrue("Does not identify as number", NumberConversionUtil.potentialNumber("-112e23"));
-        assertFalse("Does not identify as not number", NumberConversionUtil.potentialNumber("--112.123"));
-        assertFalse("Does not identify as not number", NumberConversionUtil.potentialNumber("-a112.123"));
-        assertFalse("Does not identify as not number", NumberConversionUtil.potentialNumber("a112.123"));
-        assertFalse("Does not identify as not number", NumberConversionUtil.potentialNumber("e112.123"));
-    }
-
-    @Test(expected = NumberFormatException.class)
-    public void shouldExpectExceptionWhenNumberIsNotFormatted(){
-        NumberConversionUtil.stringToNumber("112.aa123");
-    }
-
-
-}

src/test/java/org/json/junit/CDLTest.java

@@ -24,14 +24,13 @@ public class CDLTest {
      * String of lines where the column names are in the first row,
      * and all subsequent rows are values. All keys and values should be legal.
      */
-    String lines = new String(
-            "Col 1, Col 2,  \tCol 3, Col 4, Col 5, Col 6, Col 7\n" +
-            "val1, val2, val3, val4, val5, val6, val7\n" +
-            "1, 2, 3, 4\t, 5, 6, 7\n" +
-            "true, false, true, true, false, false, false\n" +
-            "0.23, 57.42, 5e27, -234.879, 2.34e5, 0.0, 9e-3\n" +
-            "\"va\tl1\", \"v\bal2\", \"val3\", \"val\f4\", \"val5\", va\'l6, val7\n"
-    );
+    private static final String LINES = "Col 1, Col 2,  \tCol 3, Col 4, Col 5, Col 6, Col 7\n" +
+			"val1, val2, val3, val4, val5, val6, val7\n" +
+			"1, 2, 3, 4\t, 5, 6, 7\n" +
+			"true, false, true, true, false, false, false\n" +
+			"0.23, 57.42, 5e27, -234.879, 2.34e5, 0.0, 9e-3\n" +
+			"\"va\tl1\", \"v\bal2\", \"val3\", \"val\f4\", \"val5\", va'l6, val7\n";
+
 
     /**
      * CDL.toJSONArray() adds all values as strings, with no filtering or 
@@ -39,12 +38,11 @@ public class CDLTest {
      * values all must be quoted in the cases where the JSONObject parsing 
      * might normally convert the value into a non-string. 
      */
-    String expectedLines = new String(
-            "[{Col 1:val1, Col 2:val2, Col 3:val3, Col 4:val4, Col 5:val5, Col 6:val6, Col 7:val7}, "+
-            "{Col 1:\"1\", Col 2:\"2\", Col 3:\"3\", Col 4:\"4\", Col 5:\"5\", Col 6:\"6\", Col 7:\"7\"}, "+
-            "{Col 1:\"true\", Col 2:\"false\", Col 3:\"true\", Col 4:\"true\", Col 5:\"false\", Col 6:\"false\", Col 7:\"false\"}, "+
-            "{Col 1:\"0.23\", Col 2:\"57.42\", Col 3:\"5e27\", Col 4:\"-234.879\", Col 5:\"2.34e5\", Col 6:\"0.0\", Col 7:\"9e-3\"}, "+
-            "{Col 1:\"va\tl1\", Col 2:\"v\bal2\", Col 3:val3, Col 4:\"val\f4\", Col 5:val5, Col 6:va\'l6, Col 7:val7}]");
+    private static final String EXPECTED_LINES = "[{Col 1:val1, Col 2:val2, Col 3:val3, Col 4:val4, Col 5:val5, Col 6:val6, Col 7:val7}, " +
+			"{Col 1:\"1\", Col 2:\"2\", Col 3:\"3\", Col 4:\"4\", Col 5:\"5\", Col 6:\"6\", Col 7:\"7\"}, " +
+			"{Col 1:\"true\", Col 2:\"false\", Col 3:\"true\", Col 4:\"true\", Col 5:\"false\", Col 6:\"false\", Col 7:\"false\"}, " +
+			"{Col 1:\"0.23\", Col 2:\"57.42\", Col 3:\"5e27\", Col 4:\"-234.879\", Col 5:\"2.34e5\", Col 6:\"0.0\", Col 7:\"9e-3\"}, " +
+			"{Col 1:\"va\tl1\", Col 2:\"v\bal2\", Col 3:val3, Col 4:\"val\f4\", Col 5:val5, Col 6:va'l6, Col 7:val7}]";
 
     /**
      * Attempts to create a JSONArray from a null string.
@@ -194,8 +192,7 @@ public class CDLTest {
     public void emptyString() {
         String emptyStr = "";
         JSONArray jsonArray = CDL.toJSONArray(emptyStr);
-        assertTrue("CDL should return null when the input string is empty",
-                jsonArray == null);
+		assertNull("CDL should return null when the input string is empty", jsonArray);
     }
 
     /**
@@ -254,7 +251,7 @@ public class CDLTest {
         jsonObject.put("Col \r1", "V1");
         // \r will be filtered from value
         jsonObject.put("Col 2", "V2\r");
-        assertTrue("expected length should be 1",jsonArray.length() == 1);
+		assertEquals("expected length should be 1", 1, jsonArray.length());
         String cdlStr = CDL.toString(jsonArray);
         jsonObject = jsonArray.getJSONObject(0);
         assertTrue(cdlStr.contains("\"Col 1\""));
@@ -268,8 +265,15 @@ public class CDLTest {
      */
     @Test
     public void textToJSONArray() {
-        JSONArray jsonArray = CDL.toJSONArray(this.lines);
-        JSONArray expectedJsonArray = new JSONArray(this.expectedLines);
+        JSONArray jsonArray = CDL.toJSONArray(LINES);
+        JSONArray expectedJsonArray = new JSONArray(EXPECTED_LINES);
+        Util.compareActualVsExpectedJsonArrays(jsonArray, expectedJsonArray);
+    }
+    @Test
+    public void textToJSONArrayPipeDelimited() {
+        char delimiter = '|';
+        JSONArray jsonArray = CDL.toJSONArray(LINES.replaceAll(",", String.valueOf(delimiter)), delimiter);
+        JSONArray expectedJsonArray = new JSONArray(EXPECTED_LINES);
         Util.compareActualVsExpectedJsonArrays(jsonArray, expectedJsonArray);
     }
 
@@ -293,10 +297,24 @@ public class CDLTest {
      */
     @Test
     public void textToJSONArrayAndBackToString() {
-        JSONArray jsonArray = CDL.toJSONArray(this.lines);
+        JSONArray jsonArray = CDL.toJSONArray(LINES);
         String jsonStr = CDL.toString(jsonArray);
         JSONArray finalJsonArray = CDL.toJSONArray(jsonStr);
-        JSONArray expectedJsonArray = new JSONArray(this.expectedLines);
+        JSONArray expectedJsonArray = new JSONArray(EXPECTED_LINES);
+        Util.compareActualVsExpectedJsonArrays(finalJsonArray, expectedJsonArray);
+    }
+
+    /**
+     * Create a JSONArray from a string of lines,
+     * then convert to string and then back to JSONArray
+     * with a custom delimiter
+     */
+    @Test
+    public void textToJSONArrayAndBackToStringCustomDelimiter() {
+        JSONArray jsonArray = CDL.toJSONArray(LINES, ',');
+        String jsonStr = CDL.toString(jsonArray, ';');
+        JSONArray finalJsonArray = CDL.toJSONArray(jsonStr, ';');
+        JSONArray expectedJsonArray = new JSONArray(EXPECTED_LINES);
         Util.compareActualVsExpectedJsonArrays(finalJsonArray, expectedJsonArray);
     }
     

src/test/java/org/json/junit/JSONMLTest.java

@@ -709,7 +709,7 @@ public class JSONMLTest {
     @Test
     public void testToJSONArray_jsonOutput() {
         final String originalXml = "<root><id>01</id><id>1</id><id>00</id><id>0</id><item id=\"01\"/><title>True</title></root>";
-        final String expectedJsonString = "[\"root\",[\"id\",1],[\"id\",1],[\"id\",0],[\"id\",0],[\"item\",{\"id\":1}],[\"title\",true]]";
+        final String expectedJsonString = "[\"root\",[\"id\",\"01\"],[\"id\",1],[\"id\",\"00\"],[\"id\",0],[\"item\",{\"id\":\"01\"}],[\"title\",true]]";
         final JSONArray actualJsonOutput = JSONML.toJSONArray(originalXml, false);
         assertEquals(expectedJsonString, actualJsonOutput.toString());
     }

src/test/java/org/json/junit/JSONObjectDecimalTest.java

@@ -1,100 +0,0 @@
-package org.json.junit;
-
-import org.json.JSONObject;
-import org.junit.Test;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-
-import static org.junit.Assert.assertEquals;
-
-public class JSONObjectDecimalTest {
-
-    @Test
-    public void shouldParseDecimalNumberThatStartsWithDecimalPoint(){
-        JSONObject jsonObject = new JSONObject("{value:0.50}");
-        assertEquals("Float not recognized", 0.5f, jsonObject.getFloat("value"), 0.0f);
-        assertEquals("Float not recognized", 0.5f, jsonObject.optFloat("value"), 0.0f);
-        assertEquals("Float not recognized", 0.5f, jsonObject.optFloatObject("value"), 0.0f);
-        assertEquals("Double not recognized", 0.5d, jsonObject.optDouble("value"), 0.0f);
-        assertEquals("Double not recognized", 0.5d, jsonObject.optDoubleObject("value"), 0.0f);
-        assertEquals("Double not recognized", 0.5d, jsonObject.getDouble("value"), 0.0f);
-        assertEquals("Long not recognized", 0, jsonObject.optLong("value"), 0);
-        assertEquals("Long not recognized", 0, jsonObject.getLong("value"), 0);
-        assertEquals("Long not recognized", 0, jsonObject.optLongObject("value"), 0);
-        assertEquals("Integer not recognized", 0, jsonObject.optInt("value"), 0);
-        assertEquals("Integer not recognized", 0, jsonObject.getInt("value"), 0);
-        assertEquals("Integer not recognized", 0, jsonObject.optIntegerObject("value"), 0);
-        assertEquals("Number not recognized", 0, jsonObject.getNumber("value").intValue(), 0);
-        assertEquals("Number not recognized", 0, jsonObject.getNumber("value").longValue(), 0);
-        assertEquals("BigDecimal not recognized", 0, BigDecimal.valueOf(.5).compareTo(jsonObject.getBigDecimal("value")));
-        assertEquals("BigInteger not recognized",0, BigInteger.valueOf(0).compareTo(jsonObject.getBigInteger("value")));
-    }
-
-
-
-    @Test
-    public void shouldParseNegativeDecimalNumberThatStartsWithDecimalPoint(){
-        JSONObject jsonObject = new JSONObject("{value:-.50}");
-        assertEquals("Float not recognized", -0.5f, jsonObject.getFloat("value"), 0.0f);
-        assertEquals("Float not recognized", -0.5f, jsonObject.optFloat("value"), 0.0f);
-        assertEquals("Float not recognized", -0.5f, jsonObject.optFloatObject("value"), 0.0f);
-        assertEquals("Double not recognized", -0.5d, jsonObject.optDouble("value"), 0.0f);
-        assertEquals("Double not recognized", -0.5d, jsonObject.optDoubleObject("value"), 0.0f);
-        assertEquals("Double not recognized", -0.5d, jsonObject.getDouble("value"), 0.0f);
-        assertEquals("Long not recognized", 0, jsonObject.optLong("value"), 0);
-        assertEquals("Long not recognized", 0, jsonObject.getLong("value"), 0);
-        assertEquals("Long not recognized", 0, jsonObject.optLongObject("value"), 0);
-        assertEquals("Integer not recognized", 0, jsonObject.optInt("value"), 0);
-        assertEquals("Integer not recognized", 0, jsonObject.getInt("value"), 0);
-        assertEquals("Integer not recognized", 0, jsonObject.optIntegerObject("value"), 0);
-        assertEquals("Number not recognized", 0, jsonObject.getNumber("value").intValue(), 0);
-        assertEquals("Number not recognized", 0, jsonObject.getNumber("value").longValue(), 0);
-        assertEquals("BigDecimal not recognized", 0, BigDecimal.valueOf(-.5).compareTo(jsonObject.getBigDecimal("value")));
-        assertEquals("BigInteger not recognized",0, BigInteger.valueOf(0).compareTo(jsonObject.getBigInteger("value")));
-    }
-
-    @Test
-    public void shouldParseDecimalNumberThatHasZeroBeforeWithDecimalPoint(){
-        JSONObject jsonObject = new JSONObject("{value:00.050}");
-        assertEquals("Float not recognized", 0.05f, jsonObject.getFloat("value"), 0.0f);
-        assertEquals("Float not recognized", 0.05f, jsonObject.optFloat("value"), 0.0f);
-        assertEquals("Float not recognized", 0.05f, jsonObject.optFloatObject("value"), 0.0f);
-        assertEquals("Double not recognized", 0.05d, jsonObject.optDouble("value"), 0.0f);
-        assertEquals("Double not recognized", 0.05d, jsonObject.optDoubleObject("value"), 0.0f);
-        assertEquals("Double not recognized", 0.05d, jsonObject.getDouble("value"), 0.0f);
-        assertEquals("Long not recognized", 0, jsonObject.optLong("value"), 0);
-        assertEquals("Long not recognized", 0, jsonObject.getLong("value"), 0);
-        assertEquals("Long not recognized", 0, jsonObject.optLongObject("value"), 0);
-        assertEquals("Integer not recognized", 0, jsonObject.optInt("value"), 0);
-        assertEquals("Integer not recognized", 0, jsonObject.getInt("value"), 0);
-        assertEquals("Integer not recognized", 0, jsonObject.optIntegerObject("value"), 0);
-        assertEquals("Number not recognized", 0, jsonObject.getNumber("value").intValue(), 0);
-        assertEquals("Number not recognized", 0, jsonObject.getNumber("value").longValue(), 0);
-        assertEquals("BigDecimal not recognized", 0, BigDecimal.valueOf(.05).compareTo(jsonObject.getBigDecimal("value")));
-        assertEquals("BigInteger not recognized",0, BigInteger.valueOf(0).compareTo(jsonObject.getBigInteger("value")));
-    }
-
-    @Test
-    public void shouldParseNegativeDecimalNumberThatHasZeroBeforeWithDecimalPoint(){
-        JSONObject jsonObject = new JSONObject("{value:-00.050}");
-        assertEquals("Float not recognized", -0.05f, jsonObject.getFloat("value"), 0.0f);
-        assertEquals("Float not recognized", -0.05f, jsonObject.optFloat("value"), 0.0f);
-        assertEquals("Float not recognized", -0.05f, jsonObject.optFloatObject("value"), 0.0f);
-        assertEquals("Double not recognized", -0.05d, jsonObject.optDouble("value"), 0.0f);
-        assertEquals("Double not recognized", -0.05d, jsonObject.optDoubleObject("value"), 0.0f);
-        assertEquals("Double not recognized", -0.05d, jsonObject.getDouble("value"), 0.0f);
-        assertEquals("Long not recognized", 0, jsonObject.optLong("value"), 0);
-        assertEquals("Long not recognized", 0, jsonObject.getLong("value"), 0);
-        assertEquals("Long not recognized", 0, jsonObject.optLongObject("value"), 0);
-        assertEquals("Integer not recognized", 0, jsonObject.optInt("value"), 0);
-        assertEquals("Integer not recognized", 0, jsonObject.getInt("value"), 0);
-        assertEquals("Integer not recognized", 0, jsonObject.optIntegerObject("value"), 0);
-        assertEquals("Number not recognized", 0, jsonObject.getNumber("value").intValue(), 0);
-        assertEquals("Number not recognized", 0, jsonObject.getNumber("value").longValue(), 0);
-        assertEquals("BigDecimal not recognized", 0, BigDecimal.valueOf(-.05).compareTo(jsonObject.getBigDecimal("value")));
-        assertEquals("BigInteger not recognized",0, BigInteger.valueOf(0).compareTo(jsonObject.getBigInteger("value")));
-    }
-
-
-}

src/test/java/org/json/junit/JSONObjectNumberTest.java

@@ -23,10 +23,7 @@ public class JSONObjectNumberTest {
     @Parameters(name = "{index}: {0}")
     public static Collection<Object[]> data() {
         return Arrays.asList(new Object[][]{
-            {"{value:0050}", 1},
-            {"{value:0050.0000}", 1},
-            {"{value:-0050}", -1},
-            {"{value:-0050.0000}", -1},
+            {"{value:50}", 1},
             {"{value:50.0}", 1},
             {"{value:5e1}", 1},
             {"{value:5E1}", 1},
@@ -35,7 +32,6 @@ public class JSONObjectNumberTest {
             {"{value:-50}", -1},
             {"{value:-50.0}", -1},
             {"{value:-5e1}", -1},
-            {"{value:-0005e1}", -1},
             {"{value:-5E1}", -1},
             {"{value:-5e1}", -1},
             {"{value:'-50'}", -1}

src/test/java/org/json/junit/JSONObjectTest.java

@@ -4,7 +4,6 @@ package org.json.junit;
 Public Domain.
 */
 
-import static java.lang.Double.NaN;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotEquals;
@@ -786,7 +785,7 @@ public class JSONObjectTest {
         jsonObject.accumulate("myArray", -23.45e7);
         // include an unsupported object for coverage
         try {
-            jsonObject.accumulate("myArray", NaN);
+            jsonObject.accumulate("myArray", Double.NaN);
             fail("Expected exception");
         } catch (JSONException ignored) {}
 
@@ -818,7 +817,7 @@ public class JSONObjectTest {
         jsonObject.append("myArray", -23.45e7);
         // include an unsupported object for coverage
         try {
-            jsonObject.append("myArray", NaN);
+            jsonObject.append("myArray", Double.NaN);
             fail("Expected exception");
         } catch (JSONException ignored) {}
 
@@ -843,7 +842,7 @@ public class JSONObjectTest {
     public void jsonObjectDoubleToString() {
         String [] expectedStrs = {"1", "1", "-23.4", "-2.345E68", "null", "null" };
         Double [] doubles = { 1.0, 00001.00000, -23.4, -23.45e67, 
-                NaN, Double.NEGATIVE_INFINITY };
+                Double.NaN, Double.NEGATIVE_INFINITY };
         for (int i = 0; i < expectedStrs.length; ++i) {
             String actualStr = JSONObject.doubleToString(doubles[i]);
             assertTrue("value expected ["+expectedStrs[i]+
@@ -898,11 +897,11 @@ public class JSONObjectTest {
         assertTrue("opt doubleKey should be double", 
                 jsonObject.optDouble("doubleKey") == -23.45e7);
         assertTrue("opt doubleKey with Default should be double", 
-                jsonObject.optDouble("doubleStrKey", NaN) == 1);
+                jsonObject.optDouble("doubleStrKey", Double.NaN) == 1);
         assertTrue("opt doubleKey should be Double",
                 Double.valueOf(-23.45e7).equals(jsonObject.optDoubleObject("doubleKey")));
         assertTrue("opt doubleKey with Default should be Double",
-                Double.valueOf(1).equals(jsonObject.optDoubleObject("doubleStrKey", NaN)));
+                Double.valueOf(1).equals(jsonObject.optDoubleObject("doubleStrKey", Double.NaN)));
         assertTrue("opt negZeroKey should be a Double", 
                 jsonObject.opt("negZeroKey") instanceof Double);
         assertTrue("get negZeroKey should be a Double", 
@@ -1068,21 +1067,12 @@ public class JSONObjectTest {
                 "\"tooManyZeros\":00,"+
                 "\"negativeInfinite\":-Infinity,"+
                 "\"negativeNaN\":-NaN,"+
-                "\"negativeNaNWithLeadingZeros\":-00NaN,"+
                 "\"negativeFraction\":-.01,"+
                 "\"tooManyZerosFraction\":00.001,"+
                 "\"negativeHexFloat\":-0x1.fffp1,"+
                 "\"hexFloat\":0x1.0P-1074,"+
                 "\"floatIdentifier\":0.1f,"+
-                "\"doubleIdentifier\":0.1d,"+
-                "\"doubleIdentifierWithMultipleLeadingZerosBeforeDecimal\":0000000.1d,"+
-                "\"negativeDoubleIdentifierWithMultipleLeadingZerosBeforeDecimal\":-0000000.1d,"+
-                "\"doubleIdentifierWithMultipleLeadingZerosAfterDecimal\":0000000.0001d,"+
-                "\"negativeDoubleIdentifierWithMultipleLeadingZerosAfterDecimal\":-0000000.0001d,"+
-                "\"integerWithLeadingZeros\":000900,"+
-                "\"integerWithAllZeros\":00000,"+
-                "\"compositeWithLeadingZeros\":00800.90d,"+
-                "\"decimalPositiveWithoutNumberBeforeDecimalPoint\":.90,"+
+                "\"doubleIdentifier\":0.1d"+
             "}";
         JSONObject jsonObject = new JSONObject(str);
         Object obj;
@@ -1092,22 +1082,15 @@ public class JSONObjectTest {
         assertTrue("hexNumber currently evaluates to string",
                 obj.equals("-0x123"));
         assertTrue( "tooManyZeros currently evaluates to string",
-                jsonObject.get( "tooManyZeros" ).equals(0));
+                jsonObject.get( "tooManyZeros" ).equals("00"));
         obj = jsonObject.get("negativeInfinite");
         assertTrue( "negativeInfinite currently evaluates to string",
                 obj.equals("-Infinity"));
         obj = jsonObject.get("negativeNaN");
         assertTrue( "negativeNaN currently evaluates to string",
                 obj.equals("-NaN"));
-        obj = jsonObject.get("negativeNaNWithLeadingZeros");
-        assertTrue( "negativeNaNWithLeadingZeros currently evaluates to string",
-                obj.equals("-00NaN"));
         assertTrue( "negativeFraction currently evaluates to double -0.01",
                 jsonObject.get( "negativeFraction" ).equals(BigDecimal.valueOf(-0.01)));
-        assertTrue( "tooManyZerosFraction currently evaluates to double 0.001",
-                jsonObject.get( "tooManyZerosFraction" ).equals(BigDecimal.valueOf(0.001)));
-        assertTrue( "tooManyZerosFraction currently evaluates to double 0.001",
-                jsonObject.getLong( "tooManyZerosFraction" )==0);
         assertTrue( "tooManyZerosFraction currently evaluates to double 0.001",
                 jsonObject.optLong( "tooManyZerosFraction" )==0);
         assertTrue( "negativeHexFloat currently evaluates to double -3.99951171875",
@@ -1118,53 +1101,6 @@ public class JSONObjectTest {
                 jsonObject.get("floatIdentifier").equals(Double.valueOf(0.1)));
         assertTrue("doubleIdentifier currently evaluates to double 0.1",
                 jsonObject.get("doubleIdentifier").equals(Double.valueOf(0.1)));
-        assertTrue("doubleIdentifierWithMultipleLeadingZerosBeforeDecimal currently evaluates to double 0.1",
-                jsonObject.get("doubleIdentifierWithMultipleLeadingZerosBeforeDecimal").equals(Double.valueOf(0.1)));
-        assertTrue("negativeDoubleIdentifierWithMultipleLeadingZerosBeforeDecimal currently evaluates to double -0.1",
-                jsonObject.get("negativeDoubleIdentifierWithMultipleLeadingZerosBeforeDecimal").equals(Double.valueOf(-0.1)));
-        assertTrue("doubleIdentifierWithMultipleLeadingZerosAfterDecimal currently evaluates to double 0.0001",
-                jsonObject.get("doubleIdentifierWithMultipleLeadingZerosAfterDecimal").equals(Double.valueOf(0.0001)));
-        assertTrue("doubleIdentifierWithMultipleLeadingZerosAfterDecimal currently evaluates to double 0.0001",
-                jsonObject.get("doubleIdentifierWithMultipleLeadingZerosAfterDecimal").equals(Double.valueOf(0.0001)));
-        assertTrue("negativeDoubleIdentifierWithMultipleLeadingZerosAfterDecimal currently evaluates to double -0.0001",
-                jsonObject.get("negativeDoubleIdentifierWithMultipleLeadingZerosAfterDecimal").equals(Double.valueOf(-0.0001)));
-        assertTrue("Integer does not evaluate to 900",
-                jsonObject.get("integerWithLeadingZeros").equals(900));
-        assertTrue("Integer does not evaluate to 900",
-                jsonObject.getInt("integerWithLeadingZeros")==900);
-        assertTrue("Integer does not evaluate to 900",
-                jsonObject.optInt("integerWithLeadingZeros")==900);
-        assertTrue("Integer does not evaluate to 0",
-                jsonObject.get("integerWithAllZeros").equals(0));
-        assertTrue("Integer does not evaluate to 0",
-                jsonObject.getInt("integerWithAllZeros")==0);
-        assertTrue("Integer does not evaluate to 0",
-                jsonObject.optInt("integerWithAllZeros")==0);
-        assertTrue("Double does not evaluate to 800.90",
-                jsonObject.get("compositeWithLeadingZeros").equals(800.90));
-        assertTrue("Double does not evaluate to 800.90",
-                jsonObject.getDouble("compositeWithLeadingZeros")==800.9d);
-        assertTrue("Integer does not evaluate to 800",
-                jsonObject.optInt("compositeWithLeadingZeros")==800);
-        assertTrue("Long does not evaluate to 800.90",
-                jsonObject.getLong("compositeWithLeadingZeros")==800);
-        assertTrue("Long does not evaluate to 800.90",
-                jsonObject.optLong("compositeWithLeadingZeros")==800);
-        assertEquals("Get long of decimalPositiveWithoutNumberBeforeDecimalPoint does not match",
-                0.9d,jsonObject.getDouble("decimalPositiveWithoutNumberBeforeDecimalPoint"),  0.0d);
-        assertEquals("Get long of decimalPositiveWithoutNumberBeforeDecimalPoint does not match",
-                0.9d,jsonObject.optDouble("decimalPositiveWithoutNumberBeforeDecimalPoint"),  0.0d);
-        assertEquals("Get long of decimalPositiveWithoutNumberBeforeDecimalPoint does not match",
-                0.0d,jsonObject.optLong("decimalPositiveWithoutNumberBeforeDecimalPoint"),  0.0d);
-
-        assertEquals("Get long of doubleIdentifierWithMultipleLeadingZerosAfterDecimal does not match",
-                0.0001d,jsonObject.getDouble("doubleIdentifierWithMultipleLeadingZerosAfterDecimal"),  0.0d);
-        assertEquals("Get long of doubleIdentifierWithMultipleLeadingZerosAfterDecimal does not match",
-                0.0001d,jsonObject.optDouble("doubleIdentifierWithMultipleLeadingZerosAfterDecimal"),  0.0d);
-        assertEquals("Get long of doubleIdentifierWithMultipleLeadingZerosAfterDecimal does not match",
-                0.0d, jsonObject.getLong("doubleIdentifierWithMultipleLeadingZerosAfterDecimal") , 0.0d);
-        assertEquals("Get long of doubleIdentifierWithMultipleLeadingZerosAfterDecimal does not match",
-                0.0d,jsonObject.optLong("doubleIdentifierWithMultipleLeadingZerosAfterDecimal"),  0.0d);
         Util.checkJSONObjectMaps(jsonObject);
     }
 
@@ -2398,7 +2334,7 @@ public class JSONObjectTest {
         }
         try {
             // test validity of invalid double 
-            JSONObject.testValidity(NaN);
+            JSONObject.testValidity(Double.NaN);
             fail("Expected an exception");
         } catch (JSONException e) { 
             assertTrue("", true);
@@ -3802,6 +3738,43 @@ public class JSONObjectTest {
         new JSONObject(map1);
     }
 
+    @Test
+    public void clarifyCurrentBehavior() {
+        // Behavior documented in #653 optLong vs getLong inconsistencies
+        // This problem still exists.
+        // Internally, both number_1 and number_2 are stored as strings. This is reasonable since they are parsed as strings.
+        // However, getLong and optLong should return similar results
+        JSONObject json = new JSONObject("{\"number_1\":\"01234\", \"number_2\": \"332211\"}");
+        assertEquals(json.getLong("number_1"), 1234L);
+        assertEquals(json.optLong("number_1"), 0); //THIS VALUE IS NOT RETURNED AS A NUMBER
+        assertEquals(json.getLong("number_2"), 332211L);
+        assertEquals(json.optLong("number_2"), 332211L);
+
+        // Behavior documented in #826 JSONObject parsing 0-led numeric strings as ints
+        // After reverting the code, personId is stored as a string, and the behavior is as expected
+        String personId = "0123";
+        JSONObject j1 = new JSONObject("{personId: " + personId + "}");
+        assertEquals(j1.getString("personId"), "0123");
+
+        // Also #826. Here is input with missing quotes. Because of the leading zero, it should not be parsed as a number.
+        // This example was mentioned in the same ticket
+        // After reverting the code, personId is stored as a string, and the behavior is as expected
+        JSONObject j2 = new JSONObject("{\"personId\":0123}");
+        assertEquals(j2.getString("personId"), "0123");
+
+        // Behavior uncovered while working on the code
+        // All of the values are stored as strings except for hex4, which is stored as a number. This is probably incorrect
+        JSONObject j3 = new JSONObject("{ " +
+                "\"hex1\": \"010e4\", \"hex2\": \"00f0\", \"hex3\": \"0011\", " +
+                "\"hex4\": 00e0, \"hex5\": 00f0, \"hex6\": 0011 }");
+        assertEquals(j3.getString("hex1"), "010e4");
+        assertEquals(j3.getString("hex2"), "00f0");
+        assertEquals(j3.getString("hex3"), "0011");
+        assertEquals(j3.getLong("hex4"), 0, .1);
+        assertEquals(j3.getString("hex5"), "00f0");
+        assertEquals(j3.getString("hex6"), "0011");
+    }
+
     /**
      * Method to build nested map of max maxDepth
      *

src/test/java/org/json/junit/JsonNumberZeroTest.java

@@ -1,55 +0,0 @@
-package org.json.junit;
-
-import org.json.JSONObject;
-import org.junit.Test;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-
-import static org.junit.Assert.assertEquals;
-
-public class JsonNumberZeroTest {
-
-    @Test
-    public void shouldParseNegativeZeroValueWithMultipleZeroDigit(){
-        JSONObject jsonObject = new JSONObject("{value:-0000}");
-        assertEquals("Float not recognized", -0f, jsonObject.getFloat("value"), 0.0f);
-        assertEquals("Float not recognized", -0f, jsonObject.optFloat("value"), 0.0f);
-        assertEquals("Float not recognized", -0f, jsonObject.optFloatObject("value"), 0.0f);
-        assertEquals("Double not recognized", -0d, jsonObject.optDouble("value"), 0.0f);
-        assertEquals("Double not recognized", -0.0d, jsonObject.optDoubleObject("value"), 0.0f);
-        assertEquals("Double not recognized", -0.0d, jsonObject.getDouble("value"), 0.0f);
-        assertEquals("Long not recognized", 0, jsonObject.optLong("value"), 0);
-        assertEquals("Long not recognized", 0, jsonObject.getLong("value"), 0);
-        assertEquals("Long not recognized", 0, jsonObject.optLongObject("value"), 0);
-        assertEquals("Integer not recognized", 0, jsonObject.optInt("value"), 0);
-        assertEquals("Integer not recognized", 0, jsonObject.getInt("value"), 0);
-        assertEquals("Integer not recognized", 0, jsonObject.optIntegerObject("value"), 0);
-        assertEquals("Number not recognized", 0, jsonObject.getNumber("value").intValue(), 0);
-        assertEquals("Number not recognized", 0, jsonObject.getNumber("value").longValue(), 0);
-        assertEquals("BigDecimal not recognized", 0, BigDecimal.valueOf(-0).compareTo(jsonObject.getBigDecimal("value")));
-        assertEquals("BigInteger not recognized",0, BigInteger.valueOf(0).compareTo(jsonObject.getBigInteger("value")));
-    }
-
-    @Test
-    public void shouldParseZeroValueWithMultipleZeroDigit(){
-        JSONObject jsonObject = new JSONObject("{value:0000}");
-        assertEquals("Float not recognized", 0f, jsonObject.getFloat("value"), 0.0f);
-        assertEquals("Float not recognized", 0f, jsonObject.optFloat("value"), 0.0f);
-        assertEquals("Float not recognized", 0f, jsonObject.optFloatObject("value"), 0.0f);
-        assertEquals("Double not recognized", 0d, jsonObject.optDouble("value"), 0.0f);
-        assertEquals("Double not recognized", 0.0d, jsonObject.optDoubleObject("value"), 0.0f);
-        assertEquals("Double not recognized", 0.0d, jsonObject.getDouble("value"), 0.0f);
-        assertEquals("Long not recognized", 0, jsonObject.optLong("value"), 0);
-        assertEquals("Long not recognized", 0, jsonObject.getLong("value"), 0);
-        assertEquals("Long not recognized", 0, jsonObject.optLongObject("value"), 0);
-        assertEquals("Integer not recognized", 0, jsonObject.optInt("value"), 0);
-        assertEquals("Integer not recognized", 0, jsonObject.getInt("value"), 0);
-        assertEquals("Integer not recognized", 0, jsonObject.optIntegerObject("value"), 0);
-        assertEquals("Number not recognized", 0, jsonObject.getNumber("value").intValue(), 0);
-        assertEquals("Number not recognized", 0, jsonObject.getNumber("value").longValue(), 0);
-        assertEquals("BigDecimal not recognized", 0, BigDecimal.valueOf(-0).compareTo(jsonObject.getBigDecimal("value")));
-        assertEquals("BigInteger not recognized",0, BigInteger.valueOf(0).compareTo(jsonObject.getBigInteger("value")));
-    }
-
-}

src/test/java/org/json/junit/XMLConfigurationTest.java

@@ -761,7 +761,7 @@ public class XMLConfigurationTest {
     @Test
     public void testToJSONArray_jsonOutput() {
         final String originalXml = "<root><id>01</id><id>1</id><id>00</id><id>0</id><item id=\"01\"/><title>True</title></root>";
-        final JSONObject expected = new JSONObject("{\"root\":{\"item\":{\"id\":1},\"id\":[1,1,0,0],\"title\":true}}");
+        final JSONObject expected = new JSONObject("{\"root\":{\"item\":{\"id\":\"01\"},\"id\":[\"01\",1,\"00\",0],\"title\":true}}");
         final JSONObject actualJsonOutput = XML.toJSONObject(originalXml, 
                 new XMLParserConfiguration().withKeepStrings(false));
         Util.compareActualVsExpectedJsonObjects(actualJsonOutput,expected);

src/test/java/org/json/junit/XMLTest.java

@@ -791,7 +791,7 @@ public class XMLTest {
     @Test
     public void testToJSONArray_jsonOutput() {
         final String originalXml = "<root><id>01</id><id>1</id><id>00</id><id>0</id><item id=\"01\"/><title>True</title></root>";
-        final JSONObject expectedJson = new JSONObject("{\"root\":{\"item\":{\"id\":1},\"id\":[1,1,0,0],\"title\":true}}");
+        final JSONObject expectedJson = new JSONObject("{\"root\":{\"item\":{\"id\":\"01\"},\"id\":[\"01\",1,\"00\",0],\"title\":true}}");
         final JSONObject actualJsonOutput = XML.toJSONObject(originalXml, false);
 
         Util.compareActualVsExpectedJsonObjects(actualJsonOutput,expectedJson);
@@ -1397,6 +1397,35 @@ public class XMLTest {
         Util.compareActualVsExpectedJsonObjects(actualJson,expectedJson);
     }
 
+    @Test
+    public void clarifyCurrentBehavior() {
+
+        // Behavior documented in #826
+        // After reverting the code, amount is stored as numeric, and phone is stored as string
+        String str1 =
+                "    <datatypes>\n" +
+                "        <telephone>0123456789</telephone>\n" +
+                "        <amount>0.1230</amount>\n" +
+                "        <boolean>true</boolean>\n" +
+                "    </datatypes>";
+        JSONObject jsonObject1 = XML.toJSONObject(str1,
+                new XMLParserConfiguration().withKeepStrings(false));
+        assertEquals(jsonObject1.getJSONObject("datatypes").getFloat("amount"), 0.123, .1);
+        assertEquals(jsonObject1.getJSONObject("datatypes").getString("telephone"), "0123456789");
+
+
+        // Behavior documented in #852
+        // After reverting the code, value is still stored as a number. This is due to how XML.isDecimalNotation() works
+        // and is probably a bug. JSONObject has a similar problem.
+        String str2 = "<color> <color_type>primary</color_type> <value>008E97</value> </color>";
+        JSONObject jsonObject2 = XML.toJSONObject(str2);
+        assertEquals(jsonObject2.getJSONObject("color").getLong("value"), 0e897, .1);
+
+        // Workaround for now is to use keepStrings
+        JSONObject jsonObject3 = XML.toJSONObject(str2, new XMLParserConfiguration().withKeepStrings(true));
+        assertEquals(jsonObject3.getJSONObject("color").getString("value"), "008E97");
+    }
+
 }