changes number parsing to use BigDecimal as the backing type

* updated tests to support BigDecimal as the backing type for numbers
* updated some test resource handling to java7 try-with-resources format
* cleaned up some other minor compiler warnings

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

@@ -33,7 +33,14 @@ import java.io.IOException;
 import java.io.StringWriter;
 import java.math.BigDecimal;
 import java.math.BigInteger;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
 
 import org.json.JSONArray;
 import org.json.JSONException;
@@ -424,7 +431,7 @@ public class JSONArrayTest {
         assertTrue("expected \"true\"", "true".equals(jsonArray.query("/2")));
         assertTrue("expected \"false\"", "false".equals(jsonArray.query("/3")));
         assertTrue("expected hello", "hello".equals(jsonArray.query("/4")));
-        assertTrue("expected 0.002345", Double.valueOf(0.002345).equals(jsonArray.query("/5")));
+        assertTrue("expected 0.002345", BigDecimal.valueOf(0.002345).equals(jsonArray.query("/5")));
         assertTrue("expected \"23.45\"", "23.45".equals(jsonArray.query("/6")));
         assertTrue("expected 42", Integer.valueOf(42).equals(jsonArray.query("/7")));
         assertTrue("expected \"43\"", "43".equals(jsonArray.query("/8")));
@@ -491,7 +498,7 @@ public class JSONArrayTest {
            new Float(jsonArray.optFloat(99)).isNaN());
 
         assertTrue("Array opt Number",
-                new Double(23.45e-4).equals(jsonArray.optNumber(5)));
+                BigDecimal.valueOf(23.45e-4).equals(jsonArray.optNumber(5)));
         assertTrue("Array opt Number default",
                 new Double(1).equals(jsonArray.optNumber(0, 1d)));
         assertTrue("Array opt Number default implicit",
@@ -832,13 +839,6 @@ public class JSONArrayTest {
         for (String s : jsonArray4Strs) {
             list.contains(s);
         }
-
-        //        assertEquals("Expected same number of lines", actualStrArray.length, 
-//                jsonArray0Strs.length);
-//        assertEquals(jsonArray0Str, jsonArray.toString());
-//        assertEquals(jsonArray0Str, jsonArray.toString(0));
-//        assertEquals(jsonArray1Str, jsonArray.toString(1));
-//        assertEquals(jsonArray4Str, jsonArray.toString(4));
     }
 
     /**
@@ -878,7 +878,7 @@ public class JSONArrayTest {
      */
     @SuppressWarnings("boxing")
     @Test
-    public void iterator() {
+    public void iteratorTest() {
         JSONArray jsonArray = new JSONArray(this.arrayStr);
         Iterator<Object> it = jsonArray.iterator();
         assertTrue("Array true",
@@ -892,8 +892,8 @@ public class JSONArrayTest {
         assertTrue("Array string",
                 "hello".equals(it.next()));
 
-        assertTrue("Array double",
-                new Double(23.45e-4).equals(it.next()));
+        assertTrue("Array double [23.45e-4]",
+                new BigDecimal("0.002345").equals(it.next()));
         assertTrue("Array string double",
                 new Double(23.45).equals(Double.parseDouble((String)it.next())));
 
@@ -939,24 +939,18 @@ public class JSONArrayTest {
         String str = "[\"value1\",\"value2\",{\"key1\":1,\"key2\":2,\"key3\":3}]";
         JSONArray jsonArray = new JSONArray(str);
         String expectedStr = str;
-        StringWriter stringWriter = new StringWriter();
-        try {
+        try (StringWriter stringWriter = new StringWriter();) {
             jsonArray.write(stringWriter);
             String actualStr = stringWriter.toString();
             JSONArray finalArray = new JSONArray(actualStr);
             Util.compareActualVsExpectedJsonArrays(jsonArray, finalArray);
             assertTrue("write() expected " + expectedStr +
-                            " but found " + actualStr,
-                    actualStr.contains("value1") &&
-                    actualStr.contains("value2") &&
-                    actualStr.contains("key1") &&
-                    actualStr.contains("1") &&
-                    actualStr.contains("key2") &&
-                    actualStr.contains("2") &&
-                    actualStr.contains("key3") &&
-                    actualStr.contains("3"));
-        } finally {
-            stringWriter.close();
+                " but found " + actualStr,
+                actualStr.startsWith("[\"value1\",\"value2\",{")
+                && actualStr.contains("\"key1\":1")
+                && actualStr.contains("\"key2\":2")
+                && actualStr.contains("\"key3\":3")
+                );
         }
     }
 
@@ -986,41 +980,33 @@ public class JSONArrayTest {
         String str0 = "[\"value1\",\"value2\",{\"key1\":1,\"key2\":false,\"key3\":3.14}]";
         JSONArray jsonArray = new JSONArray(str0);
         String expectedStr = str0;
-        StringWriter stringWriter = new StringWriter();
-        try {
+        try (StringWriter stringWriter = new StringWriter();) {
             String actualStr = jsonArray.write(stringWriter, 0, 0).toString();
             JSONArray finalArray = new JSONArray(actualStr);
             Util.compareActualVsExpectedJsonArrays(jsonArray, finalArray);
             assertTrue("write() expected " + expectedStr +
-                            " but found " + actualStr,
-                    actualStr.contains("value1") &&
-                    actualStr.contains("value2") &&
-                    actualStr.contains("key1") &&
-                    actualStr.contains("1") &&
-                    actualStr.contains("key2") &&
-                    actualStr.contains("false") &&
-                    actualStr.contains("key3") &&
-                    actualStr.contains("3.14"));
-        } finally {
-            stringWriter.close();
+                " but found " + actualStr,
+                actualStr.startsWith("[\"value1\",\"value2\",{")
+                && actualStr.contains("\"key1\":1")
+                && actualStr.contains("\"key2\":false")
+                && actualStr.contains("\"key3\":3.14")
+            );
         }
-        stringWriter = new StringWriter();
-        try {
+        
+        try (StringWriter stringWriter = new StringWriter();) {
             String actualStr = jsonArray.write(stringWriter, 2, 1).toString();
             JSONArray finalArray = new JSONArray(actualStr);
             Util.compareActualVsExpectedJsonArrays(jsonArray, finalArray);
             assertTrue("write() expected " + expectedStr +
-                            " but found " + actualStr,
-                    actualStr.contains("value1") &&
-                    actualStr.contains("value2") &&
-                    actualStr.contains("key1") &&
-                    actualStr.contains("1") &&
-                    actualStr.contains("key2") &&
-                    actualStr.contains("false") &&
-                    actualStr.contains("key3") &&
-                    actualStr.contains("3.14"));
-        } finally {
-            stringWriter.close();
+                " but found " + actualStr,
+                actualStr.startsWith("[\n" + 
+                        "   \"value1\",\n" + 
+                        "   \"value2\",\n" + 
+                        "   {")
+                && actualStr.contains("\"key1\": 1")
+                && actualStr.contains("\"key2\": false")
+                && actualStr.contains("\"key3\": 3.14")
+            );
         }
     }
 
@@ -1118,7 +1104,7 @@ public class JSONArrayTest {
         assertTrue("val3 list val 1 should not be null", val3Val1List != null);
         assertTrue("val3 list val 1 should have 2 elements", val3Val1List.size() == 2);
         assertTrue("val3 list val 1 list element 1 should be value1", val3Val1List.get(0).equals("value1"));
-        assertTrue("val3 list val 1 list element 2 should be 2.1", val3Val1List.get(1).equals(Double.valueOf("2.1")));
+        assertTrue("val3 list val 1 list element 2 should be 2.1", val3Val1List.get(1).equals(new BigDecimal("2.1")));
 
         List<?> val3Val2List = (List<?>)val3List.get(1);
         assertTrue("val3 list val 2 should not be null", val3Val2List != null);