/*
* Copyright 2007 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.gwt.json.client;
import com.google.gwt.core.client.JsonUtils;
import com.google.gwt.junit.client.GWTTestCase;
import java.util.Set;
/**
* Test case for JSONValue and friends.
*/
public class JSONTest extends GWTTestCase {
static final String menuTest = "{\"menu\": {\n" + " \"id\": \"file\",\n"
+ " \"value\": \"File:\",\n" + " \"popup\": {\n"
+ " \"menuitem\": [\n"
+ " {\"value\": \"New\", \"onclick\": \"CreateNewDoc()\"},\n"
+ " {\"value\": \"Open\", \"onclick\": \"OpenDoc()\"},\n"
+ " {\"value\": \"Close\", \"onclick\": \"CloseDoc()\"}\n"
+ " ]\n" + " }\n" + "}}\n" + "";
static final String widgetTest = "{\"widget\": {\n"
+ " \"debug\": \"on\",\n"
+ " \"window\": {\n"
+ " \"title\": \"Sample Konfabulator Widget\", \"name\": \"main_window\", \"width\": 500, \"height\": 500\n"
+ " }, \"image\": { \n"
+ " \"src\": \"Images/Sun.png\",\n"
+ " \"name\": \"sun1\", \"hOffset\": 250, \"vOffset\": 250, \"alignment\": \"center\"\n"
+ " }, \"text\": {\n"
+ " \"data\": \"Click Here\",\n"
+ " \"size\": 36,\n"
+ " \"style\": \"bold\", \"name\": \"text1\", \"hOffset\": 250, \"vOffset\": 100, \"alignment\": \"center\",\n"
+ " \"onMouseUp\": \"sun1.opacity = (sun1.opacity / 100) * 90;\"\n"
+ " }\n" + "}} \n" + "";
// Number of unicode characters to test at once for JSON escaping
private static final int JSON_CHUNK_SIZE = 256;
private static void assertJSONArrayEquals(JSONArray expected, JSONArray actual) {
assertEquals(expected.size(), actual.size());
for (int i = 0; i < expected.size(); ++i) {
assertJSONValueEquals(expected.get(i), actual.get(i));
}
}
private static void assertJSONObjectEquals(JSONObject expected,
JSONObject actual) {
Set<String> actKeys = actual.keySet();
Set<String> expKeys = expected.keySet();
assertEquals(expKeys.size(), actKeys.size());
for (String key : expKeys) {
assertTrue(actual.containsKey(key));
JSONValue expValue = expected.get(key);
JSONValue actValue = actual.get(key);
assertJSONValueEquals(expValue, actValue);
}
}
private static void assertJSONValueEquals(JSONValue expected, JSONValue actual) {
if (expected.isArray() != null) {
JSONArray expArray = expected.isArray();
JSONArray actArray = actual.isArray();
assertJSONArrayEquals(expArray, actArray);
} else if (expected.isBoolean() != null) {
JSONBoolean expBool = expected.isBoolean();
JSONBoolean actBool = actual.isBoolean();
assertEquals(expBool.booleanValue(), actBool.booleanValue());
} else if (expected.isNull() != null) {
assertNotNull(actual.isNull());
} else if (expected.isNumber() != null) {
JSONNumber expNum = expected.isNumber();
JSONNumber actNum = actual.isNumber();
assertEquals(expNum.doubleValue(), actNum.doubleValue());
} else if (expected.isObject() != null) {
JSONObject expObj = expected.isObject();
JSONObject actObj = actual.isObject();
assertJSONObjectEquals(expObj, actObj);
} else if (expected.isString() != null) {
JSONString expStr = expected.isString();
JSONString actStr = actual.isString();
assertEquals(expStr.stringValue(), actStr.stringValue());
} else {
fail("Unknown JSONValue " + expected);
}
}
/**
* Returns the module name for GWT unit test running.
*/
public String getModuleName() {
return "com.google.gwt.json.JSON";
}
public void testArrayBasics() {
JSONArray a = new JSONArray();
JSONString s = new JSONString("s");
JSONBoolean b = JSONBoolean.getInstance(false);
JSONNumber n = new JSONNumber(4);
assertNull(a.get(3));
assertNull(a.get(-4));
a.set(3, s);
assertEquals(s, a.get(3));
a.set(-4, b);
assertEquals(b, a.get(-4));
a.set(2, b);
assertEquals(b, a.get(2));
a.set(1, n);
assertEquals(n, a.get(1));
}
/**
* Test deep recursion of arrays.
*/
public void testArrayOfArraysOfArrays() {
JSONArray array = populateRecursiveArray(3, 5);
assertEquals(
"[[[[[[],[],[]],[[],[],[]],[[],[],[]]],[[[],[],[]],[[],[],[]],[[],[],[]]],[[[],[],[]],[[],[],[]],[[],[],[]]]],[[[[],[],[]],[[],[],[]],[[],[],[]]],[[[],[],[]],[[],[],[]],[[],[],[]]],[[[],[],[]],[[],[],[]],[[],[],[]]]],[[[[],[],[]],[[],[],[]],[[],[],[]]],[[[],[],[]],[[],[],[]],[[],[],[]]],[[[],[],[]],[[],[],[]],[[],[],[]]]]],[[[[[],[],[]],[[],[],[]],[[],[],[]]],[[[],[],[]],[[],[],[]],[[],[],[]]],[[[],[],[]],[[],[],[]],[[],[],[]]]],[[[[],[],[]],[[],[],[]],[[],[],[]]],[[[],[],[]],[[],[],[]],[[],[],[]]],[[[],[],[]],[[],[],[]],[[],[],[]]]],[[[[],[],[]],[[],[],[]],[[],[],[]]],[[[],[],[]],[[],[],[]],[[],[],[]]],[[[],[],[]],[[],[],[]],[[],[],[]]]]],[[[[[],[],[]],[[],[],[]],[[],[],[]]],[[[],[],[]],[[],[],[]],[[],[],[]]],[[[],[],[]],[[],[],[]],[[],[],[]]]],[[[[],[],[]],[[],[],[]],[[],[],[]]],[[[],[],[]],[[],[],[]],[[],[],[]]],[[[],[],[]],[[],[],[]],[[],[],[]]]],[[[[],[],[]],[[],[],[]],[[],[],[]]],[[[],[],[]],[[],[],[]],[[],[],[]]],[[[],[],[]],[[],[],[]],[[],[],[]]]]]]",
array.toString());
// now to access
for (int i = 0; i < 5; i++) {
array = (JSONArray) array.get(0);
}
}
/**
* Tests an array of raw numbers, like [1,2,3].
*/
public void testArrayOfNumbers() {
JSONArray arr = new JSONArray();
for (int i = 0; i < 10; i++) {
arr.set(i, new JSONNumber(i));
}
String s = arr.toString();
JSONValue v = parseStrictVsLenient(s);
JSONArray array = v.isArray();
assertTrue("v must be an array", array != null);
assertEquals("Array size must be 10", 10, array.size());
for (int i = 0; i < 10; i++) {
assertEquals("Array value at " + i + " must be " + i,
array.get(i).isNumber().doubleValue(), i, 0.001);
}
}
public void testBooleanBasics() {
assertTrue(JSONBoolean.getInstance(true).booleanValue());
assertFalse(JSONBoolean.getInstance(false).booleanValue());
JSONValue trueVal = parseStrictVsLenient("true");
assertEquals(trueVal, trueVal.isBoolean());
assertTrue(trueVal.isBoolean().booleanValue());
JSONValue falseVal = parseStrictVsLenient("false");
assertEquals(falseVal, falseVal.isBoolean());
assertFalse(falseVal.isBoolean().booleanValue());
}
public void testEquals() {
JSONArray array = parseStrictVsLenient("[]").isArray();
assertEquals(array, new JSONArray(array.getJavaScriptObject()));
assertEquals(JSONBoolean.getInstance(false), JSONBoolean.getInstance(false));
assertEquals(JSONBoolean.getInstance(true), JSONBoolean.getInstance(true));
assertEquals(JSONNull.getInstance(), JSONNull.getInstance());
assertEquals(new JSONNumber(3.1), new JSONNumber(3.1));
JSONObject object = parseStrictVsLenient("{}").isObject();
assertEquals(object, new JSONObject(object.getJavaScriptObject()));
assertEquals(new JSONString("foo"), new JSONString("foo"));
}
// Null characters do not work in Development Mode
public void testEscaping() {
JSONObject o = new JSONObject();
char[] charsToEscape = new char[42];
for (char i = 1; i < 32; i++) {
charsToEscape[i] = i;
}
charsToEscape[32] = '"';
charsToEscape[33] = '\\';
charsToEscape[34] = '\b';
charsToEscape[35] = '\f';
charsToEscape[36] = '\n';
charsToEscape[37] = '\r';
charsToEscape[38] = '\t';
charsToEscape[39] = '/';
charsToEscape[40] = '\u2028';
charsToEscape[41] = '\u2029';
for (int i = 1; i < charsToEscape.length; i++) {
o.put("c" + i, new JSONString(new Character(charsToEscape[i]).toString()));
}
assertEquals("{\"c1\":\"\\u0001\", \"c2\":\"\\u0002\", "
+ "\"c3\":\"\\u0003\", \"c4\":\"\\u0004\", \"c5\":\"\\u0005\", "
+ "\"c6\":\"\\u0006\", \"c7\":\"\\u0007\", \"c8\":\"\\b\", "
+ "\"c9\":\"\\t\", \"c10\":\"\\n\", \"c11\":\"\\u000B\", "
+ "\"c12\":\"\\f\", \"c13\":\"\\r\", \"c14\":\"\\u000E\", "
+ "\"c15\":\"\\u000F\", \"c16\":\"\\u0010\", \"c17\":\"\\u0011\", "
+ "\"c18\":\"\\u0012\", \"c19\":\"\\u0013\", \"c20\":\"\\u0014\", "
+ "\"c21\":\"\\u0015\", \"c22\":\"\\u0016\", \"c23\":\"\\u0017\", "
+ "\"c24\":\"\\u0018\", \"c25\":\"\\u0019\", \"c26\":\"\\u001A\", "
+ "\"c27\":\"\\u001B\", \"c28\":\"\\u001C\", \"c29\":\"\\u001D\", "
+ "\"c30\":\"\\u001E\", \"c31\":\"\\u001F\", \"c32\":\"\\\"\", "
+ "\"c33\":\"\\\\\", \"c34\":\"\\b\", \"c35\":\"\\f\", "
+ "\"c36\":\"\\n\", \"c37\":\"\\r\", \"c38\":\"\\t\", "
+ "\"c39\":\"/\", \"c40\":\"\\u2028\", \"c41\":\"\\u2029\"}", o.toString());
}
public void testHashCode() {
JSONArray array = parseStrictVsLenient("[]").isArray();
assertHashCodeEquals(array, new JSONArray(array.getJavaScriptObject()));
assertHashCodeEquals(JSONBoolean.getInstance(false), JSONBoolean.getInstance(false));
assertHashCodeEquals(JSONBoolean.getInstance(true), JSONBoolean.getInstance(true));
assertHashCodeEquals(JSONNull.getInstance(), JSONNull.getInstance());
assertHashCodeEquals(new JSONNumber(3.1), new JSONNumber(3.1));
JSONObject object = parseStrictVsLenient("{}").isObject();
assertHashCodeEquals(object, new JSONObject(object.getJavaScriptObject()));
assertHashCodeEquals(new JSONString("foo"), new JSONString("foo"));
}
public void testLargeArrays() {
JSONArray arr = null;
for (int j = 1; j < 500; j *= 2) {
arr = createLargeArray(j);
assertEquals("size j" + j, j, arr.size());
}
}
public void testLenientAndStrict() {
String jsonString = "{ a:27, 'b': 'value' }";
// parseLenient should succeed
JSONValue value = JSONParser.parseLenient(jsonString);
JSONObject object = value.isObject();
assertEquals(27.0, object.get("a").isNumber().doubleValue());
assertEquals("value", object.get("b").isString().stringValue());
// parseStrict should fail
try {
parseStrictVsLenient(jsonString);
fail();
} catch (JSONException e) {
}
// Must fail even on browsers that lack JSON.parse()
jsonString = "function f() { return 5; }";
try {
parseStrictVsLenient(jsonString);
fail();
} catch (JSONException e) {
}
}
public void testMenu() {
JSONObject v = (JSONObject) parseStrictVsLenient(menuTest);
assertTrue(v.containsKey("menu"));
JSONObject menu = ((JSONObject) v.get("menu"));
assertEquals(3, menu.keySet().size());
}
public void testNested() {
JSONObject obj = new JSONObject();
nestedAux(obj, 3);
String s1 = obj.toString();
String s2 = parseStrictVsLenient(s1).toString();
assertEquals(s1, s2);
assertEquals(
"{\"string3\":\"s3\", \"Number3\":3.1, \"Boolean3\":false, "
+ "\"Null3\":null, \"object3\":{\"string2\":\"s2\", \"Number2\":2.1, "
+ "\"Boolean2\":true, \"Null2\":null, \"object2\":{\"string1\":\"s1\","
+ " \"Number1\":1.1, \"Boolean1\":false, \"Null1\":null, \"object1\":{"
+ "\"string0\":\"s0\", \"Number0\":0.1, \"Boolean0\":true, "
+ "\"Null0\":null, \"object0\":{}, "
+ "\"Array0\":[\"s0\",0.1,true,null,{}]}, "
+ "\"Array1\":[\"s1\",1.1,false,null,{\"string0\":\"s0\", "
+ "\"Number0\":0.1, \"Boolean0\":true, \"Null0\":null, \"object0\":{}, "
+ "\"Array0\":[\"s0\",0.1,true,null,{}]}]}, "
+ "\"Array2\":[\"s2\",2.1,true,null,{\"string1\":\"s1\", "
+ "\"Number1\":1.1, \"Boolean1\":false, \"Null1\":null, "
+ "\"object1\":{\"string0\":\"s0\", \"Number0\":0.1, "
+ "\"Boolean0\":true, \"Null0\":null, \"object0\":{}, "
+ "\"Array0\":[\"s0\",0.1,true,null,{}]}, "
+ "\"Array1\":[\"s1\",1.1,false,null,{\"string0\":\"s0\", "
+ "\"Number0\":0.1, \"Boolean0\":true, \"Null0\":null, "
+ "\"object0\":{}, \"Array0\":[\"s0\",0.1,true,null,{}]}]}]}, "
+ "\"Array3\":[\"s3\",3.1,false,null,{\"string2\":\"s2\", "
+ "\"Number2\":2.1, \"Boolean2\":true, \"Null2\":null, "
+ "\"object2\":{\"string1\":\"s1\", \"Number1\":1.1, "
+ "\"Boolean1\":false, \"Null1\":null, \"object1\":{\"string0\":\"s0\","
+ " \"Number0\":0.1, \"Boolean0\":true, \"Null0\":null, \"object0\":{}, "
+ "\"Array0\":[\"s0\",0.1,true,null,{}]}, "
+ "\"Array1\":[\"s1\",1.1,false,null,{\"string0\":\"s0\", "
+ "\"Number0\":0.1, \"Boolean0\":true, \"Null0\":null, "
+ "\"object0\":{}, \"Array0\":[\"s0\",0.1,true,null,{}]}]}, "
+ "\"Array2\":[\"s2\",2.1,true,null,{\"string1\":\"s1\", "
+ "\"Number1\":1.1, \"Boolean1\":false, \"Null1\":null, "
+ "\"object1\":{\"string0\":\"s0\", \"Number0\":0.1, "
+ "\"Boolean0\":true, \"Null0\":null, \"object0\":{}, "
+ "\"Array0\":[\"s0\",0.1,true,null,{}]}, "
+ "\"Array1\":[\"s1\",1.1,false,null,{\"string0\":\"s0\", "
+ "\"Number0\":0.1, \"Boolean0\":true, \"Null0\":null, \"object0\":{},"
+ " \"Array0\":[\"s0\",0.1,true,null,{}]}]}]}]}", obj.toString());
}
public void testNumberBasics() {
JSONNumber n0 = new JSONNumber(1000);
assertEquals(1000, n0.doubleValue(), .000001);
assertTrue(n0.isNumber() == n0);
assertNull(n0.isObject());
JSONNumber n1 = new JSONNumber(Integer.MAX_VALUE);
assertEquals(Integer.MAX_VALUE, n1.doubleValue(), .00001);
assertTrue(n1.isNumber() == n1);
assertNull(n1.isObject());
JSONNumber n2 = new JSONNumber(Integer.MIN_VALUE);
assertEquals(Integer.MIN_VALUE, n2.doubleValue(), .00001);
assertTrue(n2.isNumber() == n2);
assertNull(n2.isObject());
}
public void testObjectBasics() {
JSONObject s = new JSONObject();
assertNull(s.get("buba"));
s.put("a", new JSONString("A"));
s.put("a", new JSONString("AA"));
assertEquals("\"AA\"", s.get("a").toString());
}
/**
* Tests an object whose keys are filled out with numbers, like {"a":1}.
*/
public void testObjectOfNumbers() {
JSONObject obj = new JSONObject();
for (int i = 0; i < 10; i++) {
obj.put("Object " + i, new JSONNumber(i));
}
String s = obj.toString();
JSONValue v = parseStrictVsLenient(s);
JSONObject objIn = v.isObject();
assertTrue("v must be an object", objIn != null);
assertEquals("Object size must be 10", 10, objIn.keySet().size());
for (int i = 0; i < 10; i++) {
assertEquals("Object value at 'Object " + i + "' must be " + i,
objIn.get("Object " + i).isNumber().doubleValue(), i, 0.001);
}
}
/**
* Tests generic parsing.
*/
public void testParse() {
try {
new JSONString(null);
fail();
} catch (NullPointerException t) {
}
try {
parseStrictVsLenient(null);
fail();
} catch (NullPointerException t) {
}
try {
parseStrictVsLenient("");
fail();
} catch (IllegalArgumentException t) {
}
try {
parseStrictVsLenient("{\"menu\": {\n" + " \"id\": \"file\",\n");
fail();
} catch (JSONException e) {
}
assertEquals("\"null\" should be null JSONValue", JSONNull.getInstance(),
parseStrictVsLenient("null"));
assertEquals("5 should be JSONNumber 5", 5d,
parseStrictVsLenient("5").isNumber().doubleValue(), 0.001);
assertEquals("\"null\" should be null JSONValue", JSONNull.getInstance(),
parseStrictVsLenient("null"));
JSONValue somethingHello = parseStrictVsLenient("[{\"something\":\"hello\"}]");
JSONArray somethingHelloArray = somethingHello.isArray();
assertTrue("somethingHello must be a JSONArray",
somethingHelloArray != null);
assertTrue("somethingHello size must be one",
somethingHelloArray.size() == 1);
JSONObject somethingHelloObject = somethingHelloArray.get(0).isObject();
assertTrue("somethingHello element 0 must be a JSONObject",
somethingHelloObject != null);
assertTrue("somethingHello element 0 must have hello for key something",
somethingHelloObject.get("something").isString().stringValue().equals(
"hello"));
}
public void testParseUnescaped() {
for (int i = 0; i <= 0xffff; i += JSON_CHUNK_SIZE) {
doTestParseUnescaped(i, JSON_CHUNK_SIZE);
}
}
public void testRoundTripEscaping() {
JSONObject obj = new JSONObject();
obj.put("a", new JSONNumber(42));
obj.put("\\", new JSONNumber(43.5));
obj.put("\"", new JSONNumber(44));
String toString = obj.toString();
assertEquals("{\"a\":42, \"\\\\\":43.5, \"\\\"\":44}", toString.trim());
JSONValue parseResponse = parseStrictVsLenient(toString);
JSONObject obj2 = parseResponse.isObject();
assertJSONObjectEquals(obj, obj2);
}
public void testSimpleNested() {
JSONObject j1 = new JSONObject();
j1.put("test1", new JSONString(""));
JSONObject j2 = new JSONObject();
j2.put("test1", new JSONString(""));
JSONObject j22 = new JSONObject();
j22.put("test12", new JSONString(""));
j2.put("j22", j22);
JSONObject j3 = new JSONObject();
j3.put("j1", j1);
j3.put("j2", j2);
assertEquals(
"{\"j1\":{\"test1\":\"\"}, \"j2\":{\"test1\":\"\", \"j22\":{\"test12\":\"\"}}}",
j3.toString());
}
public void testStringBasics() {
JSONString arr = new JSONString("");
assertEquals("\"\"", arr.toString());
JSONString s = new JSONString(menuTest);
assertEquals(menuTest, s.stringValue());
}
public void testStringEscaping() {
checkRoundTripJsonText("\"hello\"", "hello");
checkRoundTripJsonText("\"hel\\\"lo\"", "hel\"lo");
checkRoundTripJsonText("\"hel\\\\lo\"", "hel\\lo");
checkRoundTripJsonText("\"hel\\\\\\\"lo\"", "hel\\\"lo");
}
public void testStringTypes() {
JSONObject object = parseStrictVsLenient("{\"a\":\"b\",\"null\":\"foo\"}").isObject();
assertNotNull(object);
assertEquals("b",
object.get(stringAsPrimitive("a")).isString().stringValue());
assertEquals("b", object.get(stringAsObject("a")).isString().stringValue());
assertEquals("foo",
object.get(stringAsPrimitive("null")).isString().stringValue());
assertEquals("foo",
object.get(stringAsObject("null")).isString().stringValue());
try {
assertNull(object.get(null));
fail("Expected NullPointerException");
} catch (NullPointerException expected) {
}
}
public void testUndefined() {
JSONObject o = parseStrictVsLenient("{\"foo\":\"foo\",\"bar\":null}").isObject();
assertEquals(new JSONString("foo"), o.get("foo"));
assertEquals(JSONNull.getInstance(), o.get("bar"));
assertNull(o.get("baz"));
o.put("foo", JSONNull.getInstance());
assertEquals(JSONNull.getInstance(), o.get("foo"));
o.put("foo", null);
assertNull(o.get("foo"));
JSONArray array = parseStrictVsLenient("[\"foo\",null]").isArray();
assertEquals(new JSONString("foo"), array.get(0));
assertEquals(JSONNull.getInstance(), array.get(1));
assertNull(array.get(2));
array.set(0, JSONNull.getInstance());
assertEquals(JSONNull.getInstance(), array.get(0));
array.set(0, null);
assertNull(array.get(0));
}
public void testUnicodeSeparators() {
/*
* ECMAScript 5 allows unescaped U+2028 (line separator) and U+2029
* (paragraph separator) characters to occur inside strings.
*/
String jsonString = "{ \"name\": \"miles\u2028da\u2029vis\", \"ins\u2028tru\u2029ment\": \"trumpet\" }";
try {
JSONValue parsed = parseStrictVsLenient(jsonString);
JSONObject result = parsed.isObject();
assertNotNull(result);
JSONValue nameValue = result.get("name");
assertNotNull(nameValue);
JSONString nameJsonString = nameValue.isString();
assertNotNull(nameJsonString);
String nameString = nameJsonString.stringValue();
assertEquals("miles\u2028da\u2029vis", nameString);
String nameStringQuoted = nameJsonString.toString();
assertEquals("\"miles\\u2028da\\u2029vis\"", nameStringQuoted);
JSONValue instrumentValue = result.get("ins\u2028tru\u2029ment");
assertNotNull(instrumentValue);
JSONValue instrumentValue2 = result.get("instrument");
assertNull(instrumentValue2); // check no name collision
JSONString instrumentJsonString = instrumentValue.isString();
assertNotNull(instrumentJsonString);
String instrumentString = instrumentJsonString.stringValue();
assertEquals("trumpet", instrumentString);
} catch (JSONException e) {
fail(e.getMessage());
}
// U+2028 and U+2029 should not appear outside a string
jsonString = "{ \"name\": \"miles davis\",\u2028\"instrument\": \"trumpet\" }";
try {
parseStrictVsLenient(jsonString);
fail();
} catch (JSONException e) {
}
jsonString = "{ \"name\":\u2029\"miles davis\", \"instrument\": \"trumpet\" }";
try {
parseStrictVsLenient(jsonString);
fail();
} catch (JSONException e) {
}
}
public void testUnsafeEval() {
JsonUtils.unsafeEval("{\"name\":\"value\"}");
JsonUtils.unsafeEval("[0,1,2,3,4]");
}
public void testWidget() {
JSONObject v = (JSONObject) parseStrictVsLenient(widgetTest);
JSONObject widget = (JSONObject) v.get("widget");
JSONObject window = (JSONObject) widget.get("window");
JSONValue title = window.get("title");
assertNotNull(title.isString());
JSONValue hOffSet = window.get("width");
assertNotNull(hOffSet.isNumber());
}
private void assertHashCodeEquals(Object expected, Object actual) {
assertEquals("hashCodes are not equal", expected.hashCode(),
actual.hashCode());
}
private void checkRoundTripJsonText(String jsonText, String normaltext) {
JSONString parsed = parseStrictVsLenient(jsonText).isString();
assertEquals(normaltext, parsed.stringValue());
assertEquals(jsonText, parsed.toString());
}
private JSONArray createLargeArray(int size) {
JSONArray arr = new JSONArray();
for (int i = 0; i < size; i++) {
arr.set(i, new JSONNumber(i));
}
return arr;
}
/**
* Test a chunk of Unicode code points for use in JSON keys and values.
*
* @param start starting code point
* @param len number of code points to test
*/
private void doTestParseUnescaped(int start, int len) {
StringBuilder sb = new StringBuilder();
for (int i = start; i < start + len; i++) {
// Skip control characters
if (i < 0x20) {
continue;
}
// Skip surrogate pairs
if (i >= 0xD800 && i <= 0xDFFF) {
continue;
}
char c = (char) i;
// Skip quote and backslash
if (c == '\"' || c == '\\') {
continue;
}
sb.append(c);
}
String chars = sb.toString();
if (chars.length() == 0) {
return;
}
String key = "na" + chars + "me";
String value = "miles" + chars + "davis";
String jsonString = "{ \"" + key + "\": \"" + value + "\"}";
try {
JSONValue parsed = parseStrictVsLenient(jsonString);
JSONObject result = parsed.isObject();
assertNotNull("start = " + start + ", len = " + len, result);
Set<String> keys = result.keySet();
assertTrue("start = " + start + ", len = " + len, keys.contains(key));
JSONValue nameValue = result.get(key);
assertNotNull("start = " + start + ", len = " + len, nameValue);
JSONString nameJsonString = nameValue.isString();
assertNotNull("start = " + start + ", len = " + len, nameJsonString);
String nameString = nameJsonString.stringValue();
assertEquals("start = " + start + ", len = " + len, value, nameString);
} catch (JSONException e) {
fail("start = " + start + ", len = " + len + ", e = " + e.getMessage());
}
}
private void nestedAux(JSONObject obj, int i) {
JSONArray array = new JSONArray();
JSONString str = new JSONString("s" + i);
array.set(0, str);
obj.put("string" + i, str);
JSONNumber num = new JSONNumber(i + 0.1);
array.set(1, num);
obj.put("Number" + i, num);
JSONBoolean b = JSONBoolean.getInstance((i % 2) == 0);
array.set(2, b);
obj.put("Boolean" + i, b);
JSONNull nul = JSONNull.getInstance();
array.set(3, nul);
obj.put("Null" + i, nul);
JSONObject newObj = new JSONObject();
obj.put("object" + i, newObj);
if (i != 0) {
nestedAux(newObj, i - 1);
}
array.set(4, newObj);
obj.put("Array" + i, array);
}
// Check that parseLenient produces the same results as parseStrict
private JSONValue parseStrictVsLenient(String jsonString) {
JSONValue strictValue = JSONParser.parseStrict(jsonString);
JSONValue lenientValue = JSONParser.parseLenient(jsonString);
assertJSONValueEquals(strictValue, lenientValue);
return strictValue;
}
private JSONArray populateRecursiveArray(int numElements, int recursion) {
JSONArray newArray = new JSONArray();
if (recursion <= 0) {
return newArray;
}
for (int i = 0; i < numElements; i++) {
JSONArray childArray = populateRecursiveArray(numElements, recursion - 1);
newArray.set(i, childArray);
}
return newArray;
}
private native String stringAsObject(String str) /*-{
return new String(str);
}-*/;
private native String stringAsPrimitive(String str) /*-{
return String(str);
}-*/;
}