erik/JSON-java
erik/JSON-java
1
0
Fork 0
mirror of https://github.com/ethauvin/JSON-java.git synced 2025-06-18 00:10:51 -07:00
Code Releases Activity

Merge pull request #71 from johnjaylward/OptimizeOpt

Browse source 
Adjustments to tests for https://github.com/stleary/JSON-java/pull/337
This commit is contained in:
Sean Leary 2017-05-22 22:59:37 -05:00 • committed by GitHub
commit 93ca7b176f
2 changed files with 152 additions and 38 deletions
Download patch file Download diff file Expand all files Collapse all files

14
src/test/java/org/json/junit/JSONArrayTest.java
View file

@ -393,6 +393,20 @@ public class JSONArrayTest {
assertTrue("Array opt double default implicit",
new Double(jsonArray.optDouble(99)).isNaN());
assertTrue("Array opt float",
new Float(23.45e-4).equals(jsonArray.optFloat(5)));
assertTrue("Array opt float default",
new Float(1).equals(jsonArray.optFloat(0, 1)));
assertTrue("Array opt float default implicit",
new Float(jsonArray.optFloat(99)).isNaN());
assertTrue("Array opt Number",
new Double(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",
new Double(jsonArray.optNumber(99,Double.NaN).doubleValue()).isNaN());
assertTrue("Array opt int",
new Integer(42).equals(jsonArray.optInt(7)));
assertTrue("Array opt int default",

176
src/test/java/org/json/junit/JSONObjectTest.java
View file

@ -2,8 +2,10 @@ package org.json.junit;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@ -513,7 +515,7 @@ public class JSONObjectTest {
// include an unsupported object for coverage
try {
jsonObject.accumulate("myArray", Double.NaN);
assertTrue("Expected exception", false);
fail("Expected exception");
} catch (JSONException ignored) {}
// validate JSON
@ -544,7 +546,7 @@ public class JSONObjectTest {
// include an unsupported object for coverage
try {
jsonObject.append("myArray", Double.NaN);
assertTrue("Expected exception", false);
fail("Expected exception");
} catch (JSONException ignored) {}
// validate JSON
@ -594,6 +596,9 @@ public class JSONObjectTest {
"\"longStrKey\":\"987654321098765432\","+
"\"doubleKey\":-23.45e7,"+
"\"doubleStrKey\":\"00001.000\","+
"\"BigDecimalStrKey\":\"19007199254740993.35481234487103587486413587843213584\","+
"\"negZeroKey\":-0.0,"+
"\"negZeroStrKey\":\"-0.0\","+
"\"arrayKey\":[0,1,2],"+
"\"objectKey\":{\"myKey\":\"myVal\"}"+
"}";
@ -610,10 +615,30 @@ public class JSONObjectTest {
jsonObject.getDouble("doubleKey") == -23.45e7);
assertTrue("doubleStrKey should be double",
jsonObject.getDouble("doubleStrKey") == 1);
assertTrue("doubleKey can be float",
jsonObject.getFloat("doubleKey") == -23.45e7f);
assertTrue("doubleStrKey can be float",
jsonObject.getFloat("doubleStrKey") == 1f);
assertTrue("opt doubleKey should be double",
jsonObject.optDouble("doubleKey") == -23.45e7);
assertTrue("opt doubleKey with Default should be double",
jsonObject.optDouble("doubleStrKey", Double.NaN) == 1);
assertTrue("opt negZeroKey should be double",
Double.compare(jsonObject.optDouble("negZeroKey"), -0.0d) == 0);
assertTrue("opt negZeroStrKey with Default should be double",
Double.compare(jsonObject.optDouble("negZeroStrKey"), -0.0d) == 0);
assertTrue("optNumber negZeroKey should return Double",
jsonObject.optNumber("negZeroKey") instanceof Double);
assertTrue("optNumber negZeroStrKey should return Double",
jsonObject.optNumber("negZeroStrKey") instanceof Double);
assertTrue("optNumber negZeroKey should be -0.0",
Double.compare(jsonObject.optNumber("negZeroKey").doubleValue(), -0.0d) == 0);
assertTrue("optNumber negZeroStrKey should be -0.0",
Double.compare(jsonObject.optNumber("negZeroStrKey").doubleValue(), -0.0d) == 0);
assertTrue("optFloat doubleKey should be float",
jsonObject.optFloat("doubleKey") == -23.45e7f);
assertTrue("optFloat doubleKey with Default should be float",
jsonObject.optFloat("doubleStrKey", Float.NaN) == 1f);
assertTrue("intKey should be int",
jsonObject.optInt("intKey") == 42);
assertTrue("opt intKey should be int",
@ -630,6 +655,20 @@ public class JSONObjectTest {
jsonObject.optLong("longKey", 0) == 1234567890123456789L);
assertTrue("longStrKey should be long",
jsonObject.getLong("longStrKey") == 987654321098765432L);
assertTrue("optNumber int should return Integer",
jsonObject.optNumber("intKey") instanceof Integer);
assertTrue("optNumber long should return Long",
jsonObject.optNumber("longKey") instanceof Long);
assertTrue("optNumber double should return Double",
jsonObject.optNumber("doubleKey") instanceof Double);
assertTrue("optNumber Str int should return Integer",
jsonObject.optNumber("intStrKey") instanceof Integer);
assertTrue("optNumber Str long should return Long",
jsonObject.optNumber("longStrKey") instanceof Long);
assertTrue("optNumber Str double should return Double",
jsonObject.optNumber("doubleStrKey") instanceof Double);
assertTrue("optNumber BigDecimalStrKey should return BigDecimal",
jsonObject.optNumber("BigDecimalStrKey") instanceof BigDecimal);
assertTrue("xKey should not exist",
jsonObject.isNull("xKey"));
assertTrue("stringKey should exist",
@ -669,7 +708,7 @@ public class JSONObjectTest {
* This test documents a need for BigDecimal conversion.
*/
Object obj = JSONObject.stringToValue( "299792.457999999984" );
assertTrue( "evaluates to 299792.458 doubld instead of 299792.457999999984 BigDecimal!",
assertTrue( "evaluates to 299792.458 double instead of 299792.457999999984 BigDecimal!",
obj.equals(new Double(299792.458)) );
assertTrue( "1 should be an Integer!",
JSONObject.stringToValue( "1" ) instanceof Integer );
@ -787,14 +826,14 @@ public class JSONObjectTest {
JSONObject jsonObject = new JSONObject(str);
try {
jsonObject.getBoolean("nonKey");
assertTrue("Expected an exception", false);
fail("Expected an exception");
} catch (JSONException e) {
assertTrue("expecting an exception message",
"JSONObject[\"nonKey\"] not found.".equals(e.getMessage()));
}
try {
jsonObject.getBoolean("stringKey");
assertTrue("Expected an exception", false);
fail("Expected an exception");
} catch (JSONException e) {
assertTrue("Expecting an exception message",
"JSONObject[\"stringKey\"] is not a Boolean.".
@ -802,7 +841,7 @@ public class JSONObjectTest {
}
try {
jsonObject.getString("nonKey");
assertTrue("Expected an exception", false);
fail("Expected an exception");
} catch (JSONException e) {
assertTrue("Expecting an exception message",
"JSONObject[\"nonKey\"] not found.".
@ -810,7 +849,7 @@ public class JSONObjectTest {
}
try {
jsonObject.getString("trueKey");
assertTrue("Expected an exception", false);
fail("Expected an exception");
} catch (JSONException e) {
assertTrue("Expecting an exception message",
"JSONObject[\"trueKey\"] not a string.".
@ -818,7 +857,7 @@ public class JSONObjectTest {
}
try {
jsonObject.getDouble("nonKey");
assertTrue("Expected an exception", false);
fail("Expected an exception");
} catch (JSONException e) {
assertTrue("Expecting an exception message",
"JSONObject[\"nonKey\"] not found.".
@ -826,7 +865,23 @@ public class JSONObjectTest {
}
try {
jsonObject.getDouble("stringKey");
assertTrue("Expected an exception", false);
fail("Expected an exception");
} catch (JSONException e) {
assertTrue("Expecting an exception message",
"JSONObject[\"stringKey\"] is not a number.".
equals(e.getMessage()));
}
try {
jsonObject.getFloat("nonKey");
fail("Expected an exception");
} catch (JSONException e) {
assertTrue("Expecting an exception message",
"JSONObject[\"nonKey\"] not found.".
equals(e.getMessage()));
}
try {
jsonObject.getFloat("stringKey");
fail("Expected an exception");
} catch (JSONException e) {
assertTrue("Expecting an exception message",
"JSONObject[\"stringKey\"] is not a number.".
@ -834,7 +889,7 @@ public class JSONObjectTest {
}
try {
jsonObject.getInt("nonKey");
assertTrue("Expected an exception", false);
fail("Expected an exception");
} catch (JSONException e) {
assertTrue("Expecting an exception message",
"JSONObject[\"nonKey\"] not found.".
@ -842,7 +897,7 @@ public class JSONObjectTest {
}
try {
jsonObject.getInt("stringKey");
assertTrue("Expected an exception", false);
fail("Expected an exception");
} catch (JSONException e) {
assertTrue("Expecting an exception message",
"JSONObject[\"stringKey\"] is not an int.".
@ -850,7 +905,7 @@ public class JSONObjectTest {
}
try {
jsonObject.getLong("nonKey");
assertTrue("Expected an exception", false);
fail("Expected an exception");
} catch (JSONException e) {
assertTrue("Expecting an exception message",
"JSONObject[\"nonKey\"] not found.".
@ -858,7 +913,7 @@ public class JSONObjectTest {
}
try {
jsonObject.getLong("stringKey");
assertTrue("Expected an exception", false);
fail("Expected an exception");
} catch (JSONException e) {
assertTrue("Expecting an exception message",
"JSONObject[\"stringKey\"] is not a long.".
@ -866,7 +921,7 @@ public class JSONObjectTest {
}
try {
jsonObject.getJSONArray("nonKey");
assertTrue("Expected an exception", false);
fail("Expected an exception");
} catch (JSONException e) {
assertTrue("Expecting an exception message",
"JSONObject[\"nonKey\"] not found.".
@ -874,7 +929,7 @@ public class JSONObjectTest {
}
try {
jsonObject.getJSONArray("stringKey");
assertTrue("Expected an exception", false);
fail("Expected an exception");
} catch (JSONException e) {
assertTrue("Expecting an exception message",
"JSONObject[\"stringKey\"] is not a JSONArray.".
@ -882,7 +937,7 @@ public class JSONObjectTest {
}
try {
jsonObject.getJSONObject("nonKey");
assertTrue("Expected an exception", false);
fail("Expected an exception");
} catch (JSONException e) {
assertTrue("Expecting an exception message",
"JSONObject[\"nonKey\"] not found.".
@ -890,7 +945,7 @@ public class JSONObjectTest {
}
try {
jsonObject.getJSONObject("stringKey");
assertTrue("Expected an exception", false);
fail("Expected an exception");
} catch (JSONException e) {
assertTrue("Expecting an exception message",
"JSONObject[\"stringKey\"] is not a JSONObject.".
@ -987,21 +1042,22 @@ public class JSONObjectTest {
*/
try {
jsonObject.getBigDecimal("bigInt");
assertTrue("expected an exeption", false);
fail("expected an exeption");
} catch (JSONException ignored) {}
obj = jsonObject.optBigDecimal("bigInt", BigDecimal.ONE);
assertTrue("expected BigDecimal", obj.equals(BigDecimal.ONE));
try {
jsonObject.getBigInteger("bigDec");
assertTrue("expected an exeption", false);
fail("expected an exeption");
} catch (JSONException ignored) {}
jsonObject.put("stringKey", "abc");
try {
jsonObject.getBigDecimal("stringKey");
assertTrue("expected an exeption", false);
fail("expected an exeption");
} catch (JSONException ignored) {}
obj = jsonObject.optBigInteger("bigDec", BigInteger.ONE);
assertTrue("expected BigInteger", obj.equals(BigInteger.ONE));
assertTrue("expected BigInteger", obj instanceof BigInteger);
assertEquals(bigDecimal.toBigInteger(), obj);
/**
* JSONObject.numberToString() works correctly, nothing to change.
@ -1074,11 +1130,11 @@ public class JSONObjectTest {
jsonArray.put(Boolean.TRUE);
try {
jsonArray.getBigInteger(2);
assertTrue("should not be able to get big int", false);
fail("should not be able to get big int");
} catch (Exception ignored) {}
try {
jsonArray.getBigDecimal(2);
assertTrue("should not be able to get big dec", false);
fail("should not be able to get big dec");
} catch (Exception ignored) {}
assertTrue("optBigInt is default", jsonArray.optBigInteger(2, BigInteger.ONE).equals(BigInteger.ONE));
assertTrue("optBigDec is default", jsonArray.optBigDecimal(2, BigDecimal.ONE).equals(BigDecimal.ONE));
@ -1833,7 +1889,7 @@ public class JSONObjectTest {
String str = "{\"myKey\":true, \"myOtherKey\":false}";
JSONObject jsonObject = new JSONObject(str);
jsonObject.append("myKey", "hello");
assertTrue("Expected an exception", false);
fail("Expected an exception");
} catch (JSONException e) {
assertTrue("Expecting an exception message",
"JSONObject[myKey] is not a JSONArray.".
@ -1844,7 +1900,7 @@ public class JSONObjectTest {
String str = "{\"myKey\":true, \"myOtherKey\":false}";
JSONObject jsonObject = new JSONObject(str);
jsonObject.increment("myKey");
assertTrue("Expected an exception", false);
fail("Expected an exception");
} catch (JSONException e) {
assertTrue("Expecting an exception message",
"Unable to increment [\"myKey\"].".
@ -1855,7 +1911,7 @@ public class JSONObjectTest {
String str = "{\"myKey\":true, \"myOtherKey\":false}";
JSONObject jsonObject = new JSONObject(str);
jsonObject.get(null);
assertTrue("Expected an exception", false);
fail("Expected an exception");
} catch (JSONException e) {
assertTrue("Expecting an exception message",
"Null key.".
@ -1864,7 +1920,7 @@ public class JSONObjectTest {
try {
// invalid numberToString()
JSONObject.numberToString((Number)null);
assertTrue("Expected an exception", false);
fail("Expected an exception");
} catch (JSONException e) {
assertTrue("Expecting an exception message",
"Null pointer".
@ -1874,7 +1930,7 @@ public class JSONObjectTest {
// null put key
JSONObject jsonObject = new JSONObject("{}");
jsonObject.put(null, 0);
assertTrue("Expected an exception", false);
fail("Expected an exception");
} catch (NullPointerException ignored) {
}
try {
@ -1882,21 +1938,21 @@ public class JSONObjectTest {
JSONObject jsonObject = new JSONObject("{}");
jsonObject.putOnce("hello", "world");
jsonObject.putOnce("hello", "world!");
assertTrue("Expected an exception", false);
fail("Expected an exception");
} catch (JSONException e) {
assertTrue("", true);
}
try {
// test validity of invalid double
JSONObject.testValidity(Double.NaN);
assertTrue("Expected an exception", false);
fail("Expected an exception");
} catch (JSONException e) {
assertTrue("", true);
}
try {
// test validity of invalid float
JSONObject.testValidity(Float.NEGATIVE_INFINITY);
assertTrue("Expected an exception", false);
fail("Expected an exception");
} catch (JSONException e) {
assertTrue("", true);
}
@ -1936,9 +1992,13 @@ public class JSONObjectTest {
assertTrue("optJSONObject() should return null ",
null==jsonObject.optJSONObject("myKey"));
assertTrue("optLong() should return default long",
42 == jsonObject.optLong("myKey", 42));
42l == jsonObject.optLong("myKey", 42l));
assertTrue("optDouble() should return default double",
42.3 == jsonObject.optDouble("myKey", 42.3));
42.3d == jsonObject.optDouble("myKey", 42.3d));
assertTrue("optFloat() should return default float",
42.3f == jsonObject.optFloat("myKey", 42.3f));
assertTrue("optNumber() should return default Number",
42l == jsonObject.optNumber("myKey", Long.valueOf(42)).longValue());
assertTrue("optString() should return default string",
"hi".equals(jsonObject.optString("hiKey", "hi")));
}
@ -1966,9 +2026,13 @@ public class JSONObjectTest {
assertTrue("optJSONObject() should return null ",
null==jsonObject.optJSONObject("myKey"));
assertTrue("optLong() should return default long",
42 == jsonObject.optLong("myKey", 42));
42l == jsonObject.optLong("myKey", 42l));
assertTrue("optDouble() should return default double",
42.3 == jsonObject.optDouble("myKey", 42.3));
42.3d == jsonObject.optDouble("myKey", 42.3d));
assertTrue("optFloat() should return default float",
42.3f == jsonObject.optFloat("myKey", 42.3f));
assertTrue("optNumber() should return default Number",
42l == jsonObject.optNumber("myKey", Long.valueOf(42)).longValue());
assertTrue("optString() should return default string",
"hi".equals(jsonObject.optString("hiKey", "hi")));
}
@ -1982,11 +2046,47 @@ public class JSONObjectTest {
assertTrue("unexpected optBoolean value",jo.optBoolean("true",false)==true);
assertTrue("unexpected optBoolean value",jo.optBoolean("false",true)==false);
assertTrue("unexpected optInt value",jo.optInt("int",0)==123);
assertTrue("unexpected optLong value",jo.optLong("int",0)==123);
assertTrue("unexpected optDouble value",jo.optDouble("int",0.0)==123.0);
assertTrue("unexpected optLong value",jo.optLong("int",0)==123l);
assertTrue("unexpected optDouble value",jo.optDouble("int",0.0d)==123.0d);
assertTrue("unexpected optFloat value",jo.optFloat("int",0.0f)==123.0f);
assertTrue("unexpected optBigInteger value",jo.optBigInteger("int",BigInteger.ZERO).compareTo(new BigInteger("123"))==0);
assertTrue("unexpected optBigDecimal value",jo.optBigDecimal("int",BigDecimal.ZERO).compareTo(new BigDecimal("123"))==0);
assertTrue("unexpected optBigDecimal value",jo.optBigDecimal("int",BigDecimal.ZERO).compareTo(new BigDecimal("123"))==0);
assertTrue("unexpected optNumber value",jo.optNumber("int",BigInteger.ZERO).longValue()==123l);
}
/**
* Verifies that the opt methods properly convert string values to numbers and coerce them consistently.
*/
@Test
public void jsonObjectOptCoercion() {
JSONObject jo = new JSONObject("{\"largeNumberStr\":\"19007199254740993.35481234487103587486413587843213584\"}");
// currently the parser doesn't recognize BigDecimal, to we have to put it manually
jo.put("largeNumber", new BigDecimal("19007199254740993.35481234487103587486413587843213584"));
// Test type coercion from larger to smaller
assertEquals(new BigDecimal("19007199254740993.35481234487103587486413587843213584"), jo.optBigDecimal("largeNumber",null));
assertEquals(new BigInteger("19007199254740993"), jo.optBigInteger("largeNumber",null));
assertEquals(1.9007199254740992E16, jo.optDouble("largeNumber"),0.0);
assertEquals(1.90071995E16f, jo.optFloat("largeNumber"),0.0f);
assertEquals(19007199254740993l, jo.optLong("largeNumber"));
assertEquals(1874919425, jo.optInt("largeNumber"));
// conversion from a string
assertEquals(new BigDecimal("19007199254740993.35481234487103587486413587843213584"), jo.optBigDecimal("largeNumberStr",null));
assertEquals(new BigInteger("19007199254740993"), jo.optBigInteger("largeNumberStr",null));
assertEquals(1.9007199254740992E16, jo.optDouble("largeNumberStr"),0.0);
assertEquals(1.90071995E16f, jo.optFloat("largeNumberStr"),0.0f);
assertEquals(19007199254740993l, jo.optLong("largeNumberStr"));
assertEquals(1874919425, jo.optInt("largeNumberStr"));
// the integer portion of the actual value is larger than a double can hold.
assertNotEquals((long)Double.parseDouble("19007199254740993.35481234487103587486413587843213584"), jo.optLong("largeNumber"));
assertNotEquals((int)Double.parseDouble("19007199254740993.35481234487103587486413587843213584"), jo.optInt("largeNumber"));
assertNotEquals((long)Double.parseDouble("19007199254740993.35481234487103587486413587843213584"), jo.optLong("largeNumberStr"));
assertNotEquals((int)Double.parseDouble("19007199254740993.35481234487103587486413587843213584"), jo.optInt("largeNumberStr"));
assertEquals(19007199254740992l, (long)Double.parseDouble("19007199254740993.35481234487103587486413587843213584"));
assertEquals(2147483647, (int)Double.parseDouble("19007199254740993.35481234487103587486413587843213584"));
}
/**
@ -2253,7 +2353,7 @@ public class JSONObjectTest {
// assertTrue("should convert null to empty string", "".equals(string));
try {
value = jsonObjectNull.get("key");
assertTrue("get() null should throw exception", false);
fail("get() null should throw exception");
} catch (Exception ignored) {}
/**