| /* |
| * Copyright (C) 2010 The Android Open Source Project |
| * |
| * 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 org.json; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import junit.framework.TestCase; |
| |
| public class ParsingTest extends TestCase { |
| |
| public void testParsingNoObjects() { |
| try { |
| new JSONTokener("").nextValue(); |
| fail(); |
| } catch (JSONException e) { |
| } |
| } |
| |
| public void testParsingLiterals() throws JSONException { |
| assertParsed(Boolean.TRUE, "true"); |
| assertParsed(Boolean.FALSE, "false"); |
| assertParsed(JSONObject.NULL, "null"); |
| assertParsed(JSONObject.NULL, "NULL"); |
| assertParsed(Boolean.FALSE, "False"); |
| assertParsed(Boolean.TRUE, "truE"); |
| } |
| |
| public void testParsingQuotedStrings() throws JSONException { |
| assertParsed("abc", "\"abc\""); |
| assertParsed("123", "\"123\""); |
| assertParsed("foo\nbar", "\"foo\\nbar\""); |
| assertParsed("foo bar", "\"foo\\u0020bar\""); |
| assertParsed("\"{}[]/\\:,=;#", "\"\\\"{}[]/\\\\:,=;#\""); |
| } |
| |
| public void testParsingSingleQuotedStrings() throws JSONException { |
| assertParsed("abc", "'abc'"); |
| assertParsed("123", "'123'"); |
| assertParsed("foo\nbar", "'foo\\nbar'"); |
| assertParsed("foo bar", "'foo\\u0020bar'"); |
| assertParsed("\"{}[]/\\:,=;#", "'\\\"{}[]/\\\\:,=;#'"); |
| } |
| |
| public void testParsingUnquotedStrings() throws JSONException { |
| assertParsed("abc", "abc"); |
| assertParsed("123abc", "123abc"); |
| assertParsed("123e0x", "123e0x"); |
| assertParsed("123e", "123e"); |
| assertParsed("123ee21", "123ee21"); |
| assertParsed("0xFFFFFFFFFFFFFFFFF", "0xFFFFFFFFFFFFFFFFF"); |
| } |
| |
| /** |
| * Unfortunately the original implementation attempts to figure out what |
| * Java number type best suits an input value. |
| */ |
| public void testParsingNumbersThatAreBestRepresentedAsLongs() throws JSONException { |
| assertParsed(9223372036854775807L, "9223372036854775807"); |
| assertParsed(9223372036854775806L, "9223372036854775806"); |
| assertParsed(-9223372036854775808L, "-9223372036854775808"); |
| assertParsed(-9223372036854775807L, "-9223372036854775807"); |
| } |
| |
| public void testParsingNumbersThatAreBestRepresentedAsIntegers() throws JSONException { |
| assertParsed(0, "0"); |
| assertParsed(5, "5"); |
| assertParsed(-2147483648, "-2147483648"); |
| assertParsed(2147483647, "2147483647"); |
| } |
| |
| public void testParsingNegativeZero() throws JSONException { |
| assertParsed(0, "-0"); |
| } |
| |
| public void testParsingIntegersWithAdditionalPrecisionYieldDoubles() throws JSONException { |
| assertParsed(1d, "1.00"); |
| assertParsed(1d, "1.0"); |
| assertParsed(0d, "0.0"); |
| assertParsed(-0d, "-0.0"); |
| } |
| |
| public void testParsingNumbersThatAreBestRepresentedAsDoubles() throws JSONException { |
| assertParsed(9.223372036854776E18, "9223372036854775808"); |
| assertParsed(-9.223372036854776E18, "-9223372036854775809"); |
| assertParsed(1.7976931348623157E308, "1.7976931348623157e308"); |
| assertParsed(2.2250738585072014E-308, "2.2250738585072014E-308"); |
| assertParsed(4.9E-324, "4.9E-324"); |
| assertParsed(4.9E-324, "4.9e-324"); |
| } |
| |
| public void testParsingOctalNumbers() throws JSONException { |
| assertParsed(5, "05"); |
| assertParsed(8, "010"); |
| assertParsed(1046, "02026"); |
| } |
| |
| public void testParsingHexNumbers() throws JSONException { |
| assertParsed(5, "0x5"); |
| assertParsed(16, "0x10"); |
| assertParsed(8230, "0x2026"); |
| assertParsed(180150010, "0xABCDEFA"); |
| assertParsed(2077093803, "0x7BCDEFAB"); |
| } |
| |
| public void testParsingLargeHexValues() throws JSONException { |
| assertParsed(Integer.MAX_VALUE, "0x7FFFFFFF"); |
| String message = "Hex values are parsed as Strings if their signed " + |
| "value is greater than Integer.MAX_VALUE."; |
| assertParsed(message, 0x80000000L, "0x80000000"); |
| } |
| |
| public void test64BitHexValues() throws JSONException { |
| assertParsed("Large hex longs shouldn't be yield ints or strings", |
| -1L, "0xFFFFFFFFFFFFFFFF"); |
| } |
| |
| public void testParsingWithCommentsAndWhitespace() throws JSONException { |
| assertParsed("baz", " // foo bar \n baz"); |
| assertParsed("baz", " // foo bar \r baz"); |
| assertParsed("baz", " // foo bar \r\n baz"); |
| assertParsed("baz", " # foo bar \n baz"); |
| assertParsed("baz", " # foo bar \r baz"); |
| assertParsed("baz", " # foo bar \r\n baz"); |
| assertParsed(5, " /* foo bar \n baz */ 5"); |
| assertParsed(5, " /* foo bar \n baz */ 5 // quux"); |
| assertParsed(5, " 5 "); |
| assertParsed(5, " 5 \r\n\t "); |
| assertParsed(5, "\r\n\t 5 "); |
| } |
| |
| public void testParsingArrays() throws JSONException { |
| assertParsed(array(), "[]"); |
| assertParsed(array(5, 6, true), "[5,6,true]"); |
| assertParsed(array(5, 6, array()), "[5,6,[]]"); |
| assertParsed(array(5, 6, 7), "[5;6;7]"); |
| assertParsed(array(5, 6, 7), "[5 , 6 \t; \r\n 7\n]"); |
| assertParsed(array(5, 6, 7, null), "[5,6,7,]"); |
| assertParsed(array(null, null), "[,]"); |
| assertParsed(array(5, null, null, null, 5), "[5,,,,5]"); |
| assertParsed(array(null, 5), "[,5]"); |
| assertParsed(array(null, null, null), "[,,]"); |
| assertParsed(array(null, null, null, 5), "[,,,5]"); |
| } |
| |
| public void testParsingObjects() throws JSONException { |
| assertParsed(object("foo", 5), "{\"foo\": 5}"); |
| assertParsed(object("foo", 5), "{foo: 5}"); |
| assertParsed(object("foo", 5, "bar", "baz"), "{\"foo\": 5, \"bar\": \"baz\"}"); |
| assertParsed(object("foo", 5, "bar", "baz"), "{\"foo\": 5; \"bar\": \"baz\"}"); |
| assertParsed(object("foo", 5, "bar", "baz"), "{\"foo\"= 5; \"bar\"= \"baz\"}"); |
| assertParsed(object("foo", 5, "bar", "baz"), "{\"foo\"=> 5; \"bar\"=> \"baz\"}"); |
| assertParsed(object("foo", object(), "bar", array()), "{\"foo\"=> {}; \"bar\"=> []}"); |
| assertParsed(object("foo", object("foo", array(5, 6))), "{\"foo\": {\"foo\": [5, 6]}}"); |
| assertParsed(object("foo", object("foo", array(5, 6))), "{\"foo\":\n\t{\t \"foo\":[5,\r6]}}"); |
| } |
| |
| public void testSyntaxProblemUnterminatedObject() { |
| assertParseFail("{"); |
| assertParseFail("{\"foo\""); |
| assertParseFail("{\"foo\":"); |
| assertParseFail("{\"foo\":bar"); |
| assertParseFail("{\"foo\":bar,"); |
| assertParseFail("{\"foo\":bar,\"baz\""); |
| assertParseFail("{\"foo\":bar,\"baz\":"); |
| assertParseFail("{\"foo\":bar,\"baz\":true"); |
| assertParseFail("{\"foo\":bar,\"baz\":true,"); |
| } |
| |
| public void testSyntaxProblemEmptyString() { |
| assertParseFail(""); |
| } |
| |
| public void testSyntaxProblemUnterminatedArray() { |
| assertParseFail("["); |
| assertParseFail("[,"); |
| assertParseFail("[,,"); |
| assertParseFail("[true"); |
| assertParseFail("[true,"); |
| assertParseFail("[true,,"); |
| } |
| |
| public void testSyntaxProblemMalformedObject() { |
| assertParseFail("{:}"); |
| assertParseFail("{\"key\":}"); |
| assertParseFail("{:true}"); |
| assertParseFail("{\"key\":true:}"); |
| assertParseFail("{null:true}"); |
| assertParseFail("{true:true}"); |
| assertParseFail("{0xFF:true}"); |
| } |
| |
| private void assertParseFail(String malformedJson) { |
| try { |
| new JSONTokener(malformedJson).nextValue(); |
| fail("Successfully parsed: \"" + malformedJson + "\""); |
| } catch (JSONException e) { |
| } catch (StackOverflowError e) { |
| fail("Stack overflowed on input: \"" + malformedJson + "\""); |
| } |
| } |
| |
| private JSONArray array(Object... elements) { |
| return new JSONArray(Arrays.asList(elements)); |
| } |
| |
| private JSONObject object(Object... keyValuePairs) throws JSONException { |
| JSONObject result = new JSONObject(); |
| for (int i = 0; i < keyValuePairs.length; i+=2) { |
| result.put((String) keyValuePairs[i], keyValuePairs[i+1]); |
| } |
| return result; |
| } |
| |
| private void assertParsed(String message, Object expected, String json) throws JSONException { |
| Object actual = new JSONTokener(json).nextValue(); |
| actual = canonicalize(actual); |
| expected = canonicalize(expected); |
| assertEquals("For input \"" + json + "\" " + message, expected, actual); |
| } |
| |
| private void assertParsed(Object expected, String json) throws JSONException { |
| assertParsed("", expected, json); |
| } |
| |
| /** |
| * Since they don't implement equals or hashCode properly, this recursively |
| * replaces JSONObjects with an equivalent HashMap, and JSONArrays with the |
| * equivalent ArrayList. |
| */ |
| private Object canonicalize(Object input) throws JSONException { |
| if (input instanceof JSONArray) { |
| JSONArray array = (JSONArray) input; |
| List<Object> result = new ArrayList<Object>(); |
| for (int i = 0; i < array.length(); i++) { |
| result.add(canonicalize(array.opt(i))); |
| } |
| return result; |
| } else if (input instanceof JSONObject) { |
| JSONObject object = (JSONObject) input; |
| Map<String, Object> result = new HashMap<String, Object>(); |
| for (Iterator<?> i = object.keys(); i.hasNext(); ) { |
| String key = (String) i.next(); |
| result.put(key, canonicalize(object.get(key))); |
| } |
| return result; |
| } else { |
| return input; |
| } |
| } |
| } |
