2010-08-26 10:44:02 +02:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2010 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.gson.stream;
|
|
|
|
|
2012-02-11 21:15:39 +01:00
|
|
|
import java.io.EOFException;
|
2010-08-26 10:44:02 +02:00
|
|
|
import java.io.IOException;
|
|
|
|
import java.io.StringReader;
|
2011-07-18 21:26:02 +02:00
|
|
|
import java.util.Arrays;
|
2011-02-10 02:36:27 +01:00
|
|
|
import junit.framework.TestCase;
|
2010-08-26 10:44:02 +02:00
|
|
|
|
2012-08-26 21:31:06 +02:00
|
|
|
import static com.google.gson.stream.JsonToken.BEGIN_ARRAY;
|
|
|
|
import static com.google.gson.stream.JsonToken.BEGIN_OBJECT;
|
|
|
|
import static com.google.gson.stream.JsonToken.BOOLEAN;
|
|
|
|
import static com.google.gson.stream.JsonToken.END_ARRAY;
|
|
|
|
import static com.google.gson.stream.JsonToken.END_OBJECT;
|
|
|
|
import static com.google.gson.stream.JsonToken.NAME;
|
|
|
|
import static com.google.gson.stream.JsonToken.NULL;
|
|
|
|
import static com.google.gson.stream.JsonToken.NUMBER;
|
|
|
|
import static com.google.gson.stream.JsonToken.STRING;
|
2010-08-26 10:44:02 +02:00
|
|
|
|
2012-08-26 21:31:06 +02:00
|
|
|
public final class JsonReaderTest extends TestCase {
|
2010-08-26 10:44:02 +02:00
|
|
|
public void testReadArray() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[true, true]"));
|
|
|
|
reader.beginArray();
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
reader.endArray();
|
|
|
|
assertEquals(JsonToken.END_DOCUMENT, reader.peek());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testReadEmptyArray() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[]"));
|
|
|
|
reader.beginArray();
|
|
|
|
assertFalse(reader.hasNext());
|
|
|
|
reader.endArray();
|
|
|
|
assertEquals(JsonToken.END_DOCUMENT, reader.peek());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testReadObject() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(
|
|
|
|
"{\"a\": \"android\", \"b\": \"banana\"}"));
|
|
|
|
reader.beginObject();
|
|
|
|
assertEquals("a", reader.nextName());
|
|
|
|
assertEquals("android", reader.nextString());
|
|
|
|
assertEquals("b", reader.nextName());
|
|
|
|
assertEquals("banana", reader.nextString());
|
|
|
|
reader.endObject();
|
|
|
|
assertEquals(JsonToken.END_DOCUMENT, reader.peek());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testReadEmptyObject() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("{}"));
|
|
|
|
reader.beginObject();
|
|
|
|
assertFalse(reader.hasNext());
|
|
|
|
reader.endObject();
|
|
|
|
assertEquals(JsonToken.END_DOCUMENT, reader.peek());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testSkipObject() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(
|
|
|
|
"{\"a\": { \"c\": [], \"d\": [true, true, {}] }, \"b\": \"banana\"}"));
|
|
|
|
reader.beginObject();
|
|
|
|
assertEquals("a", reader.nextName());
|
|
|
|
reader.skipValue();
|
|
|
|
assertEquals("b", reader.nextName());
|
|
|
|
reader.skipValue();
|
|
|
|
reader.endObject();
|
|
|
|
assertEquals(JsonToken.END_DOCUMENT, reader.peek());
|
|
|
|
}
|
|
|
|
|
2012-08-25 06:31:56 +02:00
|
|
|
public void testSkipInteger() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(
|
|
|
|
"{\"a\":123456789,\"b\":-123456789}"));
|
|
|
|
reader.beginObject();
|
|
|
|
assertEquals("a", reader.nextName());
|
|
|
|
reader.skipValue();
|
|
|
|
assertEquals("b", reader.nextName());
|
|
|
|
reader.skipValue();
|
|
|
|
reader.endObject();
|
|
|
|
assertEquals(JsonToken.END_DOCUMENT, reader.peek());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testSkipDouble() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(
|
|
|
|
"{\"a\":-123.456e-789,\"b\":123456789.0}"));
|
|
|
|
reader.beginObject();
|
|
|
|
assertEquals("a", reader.nextName());
|
|
|
|
reader.skipValue();
|
|
|
|
assertEquals("b", reader.nextName());
|
|
|
|
reader.skipValue();
|
|
|
|
reader.endObject();
|
|
|
|
assertEquals(JsonToken.END_DOCUMENT, reader.peek());
|
|
|
|
}
|
|
|
|
|
2010-08-26 10:44:02 +02:00
|
|
|
public void testHelloWorld() throws IOException {
|
|
|
|
String json = "{\n" +
|
|
|
|
" \"hello\": true,\n" +
|
|
|
|
" \"foo\": [\"world\"]\n" +
|
|
|
|
"}";
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(json));
|
|
|
|
reader.beginObject();
|
|
|
|
assertEquals("hello", reader.nextName());
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
assertEquals("foo", reader.nextName());
|
|
|
|
reader.beginArray();
|
|
|
|
assertEquals("world", reader.nextString());
|
|
|
|
reader.endArray();
|
|
|
|
reader.endObject();
|
|
|
|
assertEquals(JsonToken.END_DOCUMENT, reader.peek());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testNulls() {
|
|
|
|
try {
|
|
|
|
new JsonReader(null);
|
|
|
|
fail();
|
|
|
|
} catch (NullPointerException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-04 00:14:42 +01:00
|
|
|
public void testEmptyString() {
|
2010-08-26 10:44:02 +02:00
|
|
|
try {
|
|
|
|
new JsonReader(new StringReader("")).beginArray();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
try {
|
|
|
|
new JsonReader(new StringReader("")).beginObject();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-04 00:14:42 +01:00
|
|
|
public void testNoTopLevelObject() {
|
2010-08-26 10:44:02 +02:00
|
|
|
try {
|
|
|
|
new JsonReader(new StringReader("true")).nextBoolean();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testCharacterUnescaping() throws IOException {
|
|
|
|
String json = "[\"a\","
|
|
|
|
+ "\"a\\\"\","
|
|
|
|
+ "\"\\\"\","
|
|
|
|
+ "\":\","
|
|
|
|
+ "\",\","
|
|
|
|
+ "\"\\b\","
|
|
|
|
+ "\"\\f\","
|
|
|
|
+ "\"\\n\","
|
|
|
|
+ "\"\\r\","
|
|
|
|
+ "\"\\t\","
|
|
|
|
+ "\" \","
|
|
|
|
+ "\"\\\\\","
|
|
|
|
+ "\"{\","
|
|
|
|
+ "\"}\","
|
|
|
|
+ "\"[\","
|
|
|
|
+ "\"]\","
|
|
|
|
+ "\"\\u0000\","
|
|
|
|
+ "\"\\u0019\","
|
|
|
|
+ "\"\\u20AC\""
|
|
|
|
+ "]";
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(json));
|
|
|
|
reader.beginArray();
|
|
|
|
assertEquals("a", reader.nextString());
|
|
|
|
assertEquals("a\"", reader.nextString());
|
|
|
|
assertEquals("\"", reader.nextString());
|
|
|
|
assertEquals(":", reader.nextString());
|
|
|
|
assertEquals(",", reader.nextString());
|
|
|
|
assertEquals("\b", reader.nextString());
|
|
|
|
assertEquals("\f", reader.nextString());
|
|
|
|
assertEquals("\n", reader.nextString());
|
|
|
|
assertEquals("\r", reader.nextString());
|
|
|
|
assertEquals("\t", reader.nextString());
|
|
|
|
assertEquals(" ", reader.nextString());
|
|
|
|
assertEquals("\\", reader.nextString());
|
|
|
|
assertEquals("{", reader.nextString());
|
|
|
|
assertEquals("}", reader.nextString());
|
|
|
|
assertEquals("[", reader.nextString());
|
|
|
|
assertEquals("]", reader.nextString());
|
|
|
|
assertEquals("\0", reader.nextString());
|
|
|
|
assertEquals("\u0019", reader.nextString());
|
|
|
|
assertEquals("\u20AC", reader.nextString());
|
|
|
|
reader.endArray();
|
|
|
|
assertEquals(JsonToken.END_DOCUMENT, reader.peek());
|
|
|
|
}
|
|
|
|
|
2011-12-25 08:09:46 +01:00
|
|
|
public void testUnescapingInvalidCharacters() throws IOException {
|
|
|
|
String json = "[\"\\u000g\"]";
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(json));
|
|
|
|
reader.beginArray();
|
|
|
|
try {
|
|
|
|
reader.nextString();
|
|
|
|
fail();
|
|
|
|
} catch (NumberFormatException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testUnescapingTruncatedCharacters() throws IOException {
|
|
|
|
String json = "[\"\\u000";
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(json));
|
|
|
|
reader.beginArray();
|
|
|
|
try {
|
|
|
|
reader.nextString();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-02-11 21:15:39 +01:00
|
|
|
public void testUnescapingTruncatedSequence() throws IOException {
|
|
|
|
String json = "[\"\\";
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(json));
|
|
|
|
reader.beginArray();
|
|
|
|
try {
|
|
|
|
reader.nextString();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-26 10:44:02 +02:00
|
|
|
public void testIntegersWithFractionalPartSpecified() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[1.0,1.0,1.0]"));
|
|
|
|
reader.beginArray();
|
|
|
|
assertEquals(1.0, reader.nextDouble());
|
|
|
|
assertEquals(1, reader.nextInt());
|
|
|
|
assertEquals(1L, reader.nextLong());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testDoubles() throws IOException {
|
|
|
|
String json = "[-0.0,"
|
|
|
|
+ "1.0,"
|
|
|
|
+ "1.7976931348623157E308,"
|
|
|
|
+ "4.9E-324,"
|
|
|
|
+ "0.0,"
|
|
|
|
+ "-0.5,"
|
|
|
|
+ "2.2250738585072014E-308,"
|
|
|
|
+ "3.141592653589793,"
|
|
|
|
+ "2.718281828459045]";
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(json));
|
|
|
|
reader.beginArray();
|
|
|
|
assertEquals(-0.0, reader.nextDouble());
|
|
|
|
assertEquals(1.0, reader.nextDouble());
|
|
|
|
assertEquals(1.7976931348623157E308, reader.nextDouble());
|
|
|
|
assertEquals(4.9E-324, reader.nextDouble());
|
|
|
|
assertEquals(0.0, reader.nextDouble());
|
|
|
|
assertEquals(-0.5, reader.nextDouble());
|
|
|
|
assertEquals(2.2250738585072014E-308, reader.nextDouble());
|
|
|
|
assertEquals(3.141592653589793, reader.nextDouble());
|
|
|
|
assertEquals(2.718281828459045, reader.nextDouble());
|
|
|
|
reader.endArray();
|
|
|
|
assertEquals(JsonToken.END_DOCUMENT, reader.peek());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testStrictNonFiniteDoubles() throws IOException {
|
|
|
|
String json = "[NaN]";
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(json));
|
|
|
|
reader.beginArray();
|
|
|
|
try {
|
|
|
|
reader.nextDouble();
|
|
|
|
fail();
|
2011-11-27 17:50:45 +01:00
|
|
|
} catch (MalformedJsonException expected) {
|
2010-08-26 10:44:02 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-02-11 21:15:39 +01:00
|
|
|
public void testStrictQuotedNonFiniteDoubles() throws IOException {
|
|
|
|
String json = "[\"NaN\"]";
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(json));
|
|
|
|
reader.beginArray();
|
|
|
|
try {
|
|
|
|
reader.nextDouble();
|
|
|
|
fail();
|
|
|
|
} catch (MalformedJsonException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-26 10:44:02 +02:00
|
|
|
public void testLenientNonFiniteDoubles() throws IOException {
|
|
|
|
String json = "[NaN, -Infinity, Infinity]";
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(json));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
|
|
|
assertTrue(Double.isNaN(reader.nextDouble()));
|
|
|
|
assertEquals(Double.NEGATIVE_INFINITY, reader.nextDouble());
|
|
|
|
assertEquals(Double.POSITIVE_INFINITY, reader.nextDouble());
|
|
|
|
reader.endArray();
|
|
|
|
}
|
|
|
|
|
2012-02-11 21:15:39 +01:00
|
|
|
public void testLenientQuotedNonFiniteDoubles() throws IOException {
|
|
|
|
String json = "[\"NaN\", \"-Infinity\", \"Infinity\"]";
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(json));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
|
|
|
assertTrue(Double.isNaN(reader.nextDouble()));
|
|
|
|
assertEquals(Double.NEGATIVE_INFINITY, reader.nextDouble());
|
|
|
|
assertEquals(Double.POSITIVE_INFINITY, reader.nextDouble());
|
|
|
|
reader.endArray();
|
|
|
|
}
|
|
|
|
|
2011-12-21 22:43:55 +01:00
|
|
|
public void testStrictNonFiniteDoublesWithSkipValue() throws IOException {
|
|
|
|
String json = "[NaN]";
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(json));
|
|
|
|
reader.beginArray();
|
|
|
|
try {
|
|
|
|
reader.skipValue();
|
|
|
|
fail();
|
|
|
|
} catch (MalformedJsonException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-26 10:44:02 +02:00
|
|
|
public void testLongs() throws IOException {
|
|
|
|
String json = "[0,0,0,"
|
|
|
|
+ "1,1,1,"
|
|
|
|
+ "-1,-1,-1,"
|
|
|
|
+ "-9223372036854775808,"
|
|
|
|
+ "9223372036854775807]";
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(json));
|
|
|
|
reader.beginArray();
|
|
|
|
assertEquals(0L, reader.nextLong());
|
|
|
|
assertEquals(0, reader.nextInt());
|
|
|
|
assertEquals(0.0, reader.nextDouble());
|
|
|
|
assertEquals(1L, reader.nextLong());
|
|
|
|
assertEquals(1, reader.nextInt());
|
|
|
|
assertEquals(1.0, reader.nextDouble());
|
|
|
|
assertEquals(-1L, reader.nextLong());
|
|
|
|
assertEquals(-1, reader.nextInt());
|
|
|
|
assertEquals(-1.0, reader.nextDouble());
|
|
|
|
try {
|
|
|
|
reader.nextInt();
|
|
|
|
fail();
|
|
|
|
} catch (NumberFormatException expected) {
|
|
|
|
}
|
|
|
|
assertEquals(Long.MIN_VALUE, reader.nextLong());
|
|
|
|
try {
|
|
|
|
reader.nextInt();
|
|
|
|
fail();
|
|
|
|
} catch (NumberFormatException expected) {
|
|
|
|
}
|
|
|
|
assertEquals(Long.MAX_VALUE, reader.nextLong());
|
|
|
|
reader.endArray();
|
|
|
|
assertEquals(JsonToken.END_DOCUMENT, reader.peek());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testNumberWithOctalPrefix() throws IOException {
|
|
|
|
String json = "[01]";
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(json));
|
|
|
|
reader.beginArray();
|
2011-11-27 17:50:45 +01:00
|
|
|
try {
|
|
|
|
reader.peek();
|
|
|
|
fail();
|
|
|
|
} catch (MalformedJsonException expected) {
|
|
|
|
}
|
2010-08-26 10:44:02 +02:00
|
|
|
try {
|
|
|
|
reader.nextInt();
|
|
|
|
fail();
|
2011-11-27 17:50:45 +01:00
|
|
|
} catch (MalformedJsonException expected) {
|
2010-08-26 10:44:02 +02:00
|
|
|
}
|
|
|
|
try {
|
|
|
|
reader.nextLong();
|
|
|
|
fail();
|
2011-11-27 17:50:45 +01:00
|
|
|
} catch (MalformedJsonException expected) {
|
2010-08-26 10:44:02 +02:00
|
|
|
}
|
|
|
|
try {
|
|
|
|
reader.nextDouble();
|
|
|
|
fail();
|
2011-11-27 17:50:45 +01:00
|
|
|
} catch (MalformedJsonException expected) {
|
2010-08-26 10:44:02 +02:00
|
|
|
}
|
|
|
|
assertEquals("01", reader.nextString());
|
|
|
|
reader.endArray();
|
|
|
|
assertEquals(JsonToken.END_DOCUMENT, reader.peek());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testBooleans() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[true,false]"));
|
|
|
|
reader.beginArray();
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
assertEquals(false, reader.nextBoolean());
|
|
|
|
reader.endArray();
|
|
|
|
assertEquals(JsonToken.END_DOCUMENT, reader.peek());
|
|
|
|
}
|
|
|
|
|
2012-08-25 06:31:56 +02:00
|
|
|
public void testPeekingUnquotedStringsPrefixedWithBooleans() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[truey]"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
2012-08-26 21:31:06 +02:00
|
|
|
assertEquals(STRING, reader.peek());
|
2012-08-25 06:31:56 +02:00
|
|
|
try {
|
|
|
|
reader.nextBoolean();
|
|
|
|
fail();
|
|
|
|
} catch (IllegalStateException expected) {
|
|
|
|
}
|
|
|
|
assertEquals("truey", reader.nextString());
|
|
|
|
reader.endArray();
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testPeekingUnquotedStringsPrefixedWithIntegers() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[12.34e5x]"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
2012-08-26 21:31:06 +02:00
|
|
|
assertEquals(STRING, reader.peek());
|
2012-08-25 06:31:56 +02:00
|
|
|
try {
|
|
|
|
reader.nextInt();
|
|
|
|
fail();
|
|
|
|
} catch (IllegalStateException expected) {
|
|
|
|
}
|
|
|
|
assertEquals("12.34e5x", reader.nextString());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testPeekLongMinValue() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[-9223372036854775808]"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
2012-08-26 21:31:06 +02:00
|
|
|
assertEquals(NUMBER, reader.peek());
|
2012-08-25 06:31:56 +02:00
|
|
|
assertEquals(-9223372036854775808L, reader.nextLong());
|
|
|
|
}
|
|
|
|
|
2012-08-26 06:02:09 +02:00
|
|
|
/**
|
|
|
|
* This test fails because there's no double for -9223372036854775809, and our
|
|
|
|
* long parsing uses Double.parseDouble() for fractional values.
|
|
|
|
*/
|
2012-08-27 00:06:57 +02:00
|
|
|
public void disabled_testPeekLargerThanLongMinValue() throws IOException {
|
2012-08-26 06:02:09 +02:00
|
|
|
JsonReader reader = new JsonReader(new StringReader("[-9223372036854775809]"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
2012-08-26 21:31:06 +02:00
|
|
|
assertEquals(NUMBER, reader.peek());
|
2012-08-26 06:02:09 +02:00
|
|
|
try {
|
|
|
|
reader.nextLong();
|
|
|
|
fail();
|
|
|
|
} catch (NumberFormatException expected) {
|
|
|
|
}
|
|
|
|
assertEquals(-9223372036854775809d, reader.nextDouble());
|
|
|
|
}
|
|
|
|
|
2012-08-27 00:06:57 +02:00
|
|
|
/**
|
|
|
|
* This test fails because there's no double for 9223372036854775806, and
|
|
|
|
* our long parsing uses Double.parseDouble() for fractional values.
|
|
|
|
*/
|
|
|
|
public void disabled_testHighPrecisionLong() throws IOException {
|
|
|
|
String json = "[9223372036854775806.000]";
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(json));
|
|
|
|
reader.beginArray();
|
|
|
|
assertEquals(9223372036854775806L, reader.nextLong());
|
|
|
|
reader.endArray();
|
|
|
|
}
|
|
|
|
|
2012-08-26 06:02:09 +02:00
|
|
|
public void testPeekMuchLargerThanLongMinValue() throws IOException {
|
2012-08-25 06:31:56 +02:00
|
|
|
JsonReader reader = new JsonReader(new StringReader("[-92233720368547758080]"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
2012-08-26 21:31:06 +02:00
|
|
|
assertEquals(NUMBER, reader.peek());
|
2012-08-25 06:31:56 +02:00
|
|
|
try {
|
|
|
|
reader.nextLong();
|
|
|
|
fail();
|
|
|
|
} catch (NumberFormatException expected) {
|
|
|
|
}
|
|
|
|
assertEquals(-92233720368547758080d, reader.nextDouble());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testQuotedNumberWithEscape() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[\"12\u00334\"]"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
2012-08-26 21:31:06 +02:00
|
|
|
assertEquals(STRING, reader.peek());
|
2012-08-25 06:31:56 +02:00
|
|
|
assertEquals(1234, reader.nextInt());
|
|
|
|
}
|
|
|
|
|
2010-08-26 10:44:02 +02:00
|
|
|
public void testMixedCaseLiterals() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[True,TruE,False,FALSE,NULL,nulL]"));
|
|
|
|
reader.beginArray();
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
assertEquals(false, reader.nextBoolean());
|
|
|
|
assertEquals(false, reader.nextBoolean());
|
|
|
|
reader.nextNull();
|
|
|
|
reader.nextNull();
|
|
|
|
reader.endArray();
|
|
|
|
assertEquals(JsonToken.END_DOCUMENT, reader.peek());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testMissingValue() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("{\"a\":}"));
|
|
|
|
reader.beginObject();
|
|
|
|
assertEquals("a", reader.nextName());
|
|
|
|
try {
|
|
|
|
reader.nextString();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testPrematureEndOfInput() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("{\"a\":true,"));
|
|
|
|
reader.beginObject();
|
|
|
|
assertEquals("a", reader.nextName());
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
try {
|
|
|
|
reader.nextName();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testPrematurelyClosed() throws IOException {
|
|
|
|
try {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("{\"a\":[]}"));
|
|
|
|
reader.beginObject();
|
|
|
|
reader.close();
|
|
|
|
reader.nextName();
|
|
|
|
fail();
|
|
|
|
} catch (IllegalStateException expected) {
|
|
|
|
}
|
|
|
|
|
|
|
|
try {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("{\"a\":[]}"));
|
|
|
|
reader.close();
|
|
|
|
reader.beginObject();
|
|
|
|
fail();
|
|
|
|
} catch (IllegalStateException expected) {
|
|
|
|
}
|
|
|
|
|
|
|
|
try {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("{\"a\":true}"));
|
|
|
|
reader.beginObject();
|
|
|
|
reader.nextName();
|
|
|
|
reader.peek();
|
|
|
|
reader.close();
|
|
|
|
reader.nextBoolean();
|
|
|
|
fail();
|
|
|
|
} catch (IllegalStateException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testNextFailuresDoNotAdvance() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("{\"a\":true}"));
|
|
|
|
reader.beginObject();
|
|
|
|
try {
|
|
|
|
reader.nextString();
|
|
|
|
fail();
|
|
|
|
} catch (IllegalStateException expected) {
|
|
|
|
}
|
|
|
|
assertEquals("a", reader.nextName());
|
|
|
|
try {
|
|
|
|
reader.nextName();
|
|
|
|
fail();
|
|
|
|
} catch (IllegalStateException expected) {
|
|
|
|
}
|
|
|
|
try {
|
|
|
|
reader.beginArray();
|
|
|
|
fail();
|
|
|
|
} catch (IllegalStateException expected) {
|
|
|
|
}
|
|
|
|
try {
|
|
|
|
reader.endArray();
|
|
|
|
fail();
|
|
|
|
} catch (IllegalStateException expected) {
|
|
|
|
}
|
|
|
|
try {
|
|
|
|
reader.beginObject();
|
|
|
|
fail();
|
|
|
|
} catch (IllegalStateException expected) {
|
|
|
|
}
|
|
|
|
try {
|
|
|
|
reader.endObject();
|
|
|
|
fail();
|
|
|
|
} catch (IllegalStateException expected) {
|
|
|
|
}
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
try {
|
|
|
|
reader.nextString();
|
|
|
|
fail();
|
|
|
|
} catch (IllegalStateException expected) {
|
|
|
|
}
|
|
|
|
try {
|
|
|
|
reader.nextName();
|
|
|
|
fail();
|
|
|
|
} catch (IllegalStateException expected) {
|
|
|
|
}
|
|
|
|
try {
|
|
|
|
reader.beginArray();
|
|
|
|
fail();
|
|
|
|
} catch (IllegalStateException expected) {
|
|
|
|
}
|
|
|
|
try {
|
|
|
|
reader.endArray();
|
|
|
|
fail();
|
|
|
|
} catch (IllegalStateException expected) {
|
|
|
|
}
|
|
|
|
reader.endObject();
|
|
|
|
assertEquals(JsonToken.END_DOCUMENT, reader.peek());
|
|
|
|
reader.close();
|
|
|
|
}
|
|
|
|
|
2012-08-26 06:02:09 +02:00
|
|
|
public void testIntegerMismatchFailuresDoNotAdvance() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[1.5]"));
|
|
|
|
reader.beginArray();
|
|
|
|
try {
|
|
|
|
reader.nextInt();
|
|
|
|
fail();
|
|
|
|
} catch (NumberFormatException expected) {
|
|
|
|
}
|
|
|
|
assertEquals(1.5d, reader.nextDouble());
|
|
|
|
reader.endArray();
|
|
|
|
}
|
|
|
|
|
2010-08-26 10:44:02 +02:00
|
|
|
public void testStringNullIsNotNull() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[\"null\"]"));
|
|
|
|
reader.beginArray();
|
|
|
|
try {
|
|
|
|
reader.nextNull();
|
|
|
|
fail();
|
|
|
|
} catch (IllegalStateException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testNullLiteralIsNotAString() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[null]"));
|
|
|
|
reader.beginArray();
|
|
|
|
try {
|
|
|
|
reader.nextString();
|
|
|
|
fail();
|
|
|
|
} catch (IllegalStateException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testStrictNameValueSeparator() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("{\"a\"=true}"));
|
|
|
|
reader.beginObject();
|
|
|
|
assertEquals("a", reader.nextName());
|
|
|
|
try {
|
|
|
|
reader.nextBoolean();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
|
|
|
|
reader = new JsonReader(new StringReader("{\"a\"=>true}"));
|
|
|
|
reader.beginObject();
|
|
|
|
assertEquals("a", reader.nextName());
|
|
|
|
try {
|
|
|
|
reader.nextBoolean();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testLenientNameValueSeparator() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("{\"a\"=true}"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginObject();
|
|
|
|
assertEquals("a", reader.nextName());
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
|
|
|
|
reader = new JsonReader(new StringReader("{\"a\"=>true}"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginObject();
|
|
|
|
assertEquals("a", reader.nextName());
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
}
|
|
|
|
|
2011-12-21 22:43:55 +01:00
|
|
|
public void testStrictNameValueSeparatorWithSkipValue() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("{\"a\"=true}"));
|
|
|
|
reader.beginObject();
|
|
|
|
assertEquals("a", reader.nextName());
|
|
|
|
try {
|
|
|
|
reader.skipValue();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
|
|
|
|
reader = new JsonReader(new StringReader("{\"a\"=>true}"));
|
|
|
|
reader.beginObject();
|
|
|
|
assertEquals("a", reader.nextName());
|
|
|
|
try {
|
|
|
|
reader.skipValue();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-26 10:44:02 +02:00
|
|
|
public void testStrictComments() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[// comment \n true]"));
|
|
|
|
reader.beginArray();
|
|
|
|
try {
|
|
|
|
reader.nextBoolean();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
|
|
|
|
reader = new JsonReader(new StringReader("[# comment \n true]"));
|
|
|
|
reader.beginArray();
|
|
|
|
try {
|
|
|
|
reader.nextBoolean();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
|
|
|
|
reader = new JsonReader(new StringReader("[/* comment */ true]"));
|
|
|
|
reader.beginArray();
|
|
|
|
try {
|
|
|
|
reader.nextBoolean();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testLenientComments() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[// comment \n true]"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
|
|
|
|
reader = new JsonReader(new StringReader("[# comment \n true]"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
|
|
|
|
reader = new JsonReader(new StringReader("[/* comment */ true]"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
}
|
|
|
|
|
2011-12-21 22:43:55 +01:00
|
|
|
public void testStrictCommentsWithSkipValue() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[// comment \n true]"));
|
|
|
|
reader.beginArray();
|
|
|
|
try {
|
|
|
|
reader.skipValue();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
|
|
|
|
reader = new JsonReader(new StringReader("[# comment \n true]"));
|
|
|
|
reader.beginArray();
|
|
|
|
try {
|
|
|
|
reader.skipValue();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
|
|
|
|
reader = new JsonReader(new StringReader("[/* comment */ true]"));
|
|
|
|
reader.beginArray();
|
|
|
|
try {
|
|
|
|
reader.skipValue();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-26 10:44:02 +02:00
|
|
|
public void testStrictUnquotedNames() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("{a:true}"));
|
|
|
|
reader.beginObject();
|
|
|
|
try {
|
|
|
|
reader.nextName();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testLenientUnquotedNames() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("{a:true}"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginObject();
|
|
|
|
assertEquals("a", reader.nextName());
|
|
|
|
}
|
|
|
|
|
2011-12-21 22:43:55 +01:00
|
|
|
public void testStrictUnquotedNamesWithSkipValue() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("{a:true}"));
|
|
|
|
reader.beginObject();
|
|
|
|
try {
|
|
|
|
reader.skipValue();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-26 10:44:02 +02:00
|
|
|
public void testStrictSingleQuotedNames() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("{'a':true}"));
|
|
|
|
reader.beginObject();
|
|
|
|
try {
|
|
|
|
reader.nextName();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testLenientSingleQuotedNames() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("{'a':true}"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginObject();
|
|
|
|
assertEquals("a", reader.nextName());
|
|
|
|
}
|
|
|
|
|
2011-12-21 22:43:55 +01:00
|
|
|
public void testStrictSingleQuotedNamesWithSkipValue() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("{'a':true}"));
|
|
|
|
reader.beginObject();
|
|
|
|
try {
|
|
|
|
reader.skipValue();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-26 10:44:02 +02:00
|
|
|
public void testStrictUnquotedStrings() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[a]"));
|
|
|
|
reader.beginArray();
|
|
|
|
try {
|
|
|
|
reader.nextString();
|
|
|
|
fail();
|
2010-11-16 23:14:40 +01:00
|
|
|
} catch (MalformedJsonException expected) {
|
2010-08-26 10:44:02 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-12-21 21:40:33 +01:00
|
|
|
public void testStrictUnquotedStringsWithSkipValue() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[a]"));
|
|
|
|
reader.beginArray();
|
|
|
|
try {
|
|
|
|
reader.skipValue();
|
|
|
|
fail();
|
|
|
|
} catch (MalformedJsonException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-26 10:44:02 +02:00
|
|
|
public void testLenientUnquotedStrings() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[a]"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
2011-02-10 02:36:27 +01:00
|
|
|
assertEquals("a", reader.nextString());
|
2010-08-26 10:44:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public void testStrictSingleQuotedStrings() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("['a']"));
|
|
|
|
reader.beginArray();
|
|
|
|
try {
|
|
|
|
reader.nextString();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testLenientSingleQuotedStrings() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("['a']"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
|
|
|
assertEquals("a", reader.nextString());
|
|
|
|
}
|
|
|
|
|
2011-12-21 22:43:55 +01:00
|
|
|
public void testStrictSingleQuotedStringsWithSkipValue() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("['a']"));
|
|
|
|
reader.beginArray();
|
|
|
|
try {
|
|
|
|
reader.skipValue();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-26 10:44:02 +02:00
|
|
|
public void testStrictSemicolonDelimitedArray() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[true;true]"));
|
|
|
|
reader.beginArray();
|
|
|
|
try {
|
|
|
|
reader.nextBoolean();
|
|
|
|
reader.nextBoolean();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testLenientSemicolonDelimitedArray() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[true;true]"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
}
|
|
|
|
|
2011-12-21 22:43:55 +01:00
|
|
|
public void testStrictSemicolonDelimitedArrayWithSkipValue() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[true;true]"));
|
|
|
|
reader.beginArray();
|
|
|
|
try {
|
|
|
|
reader.skipValue();
|
|
|
|
reader.skipValue();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-26 10:44:02 +02:00
|
|
|
public void testStrictSemicolonDelimitedNameValuePair() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("{\"a\":true;\"b\":true}"));
|
|
|
|
reader.beginObject();
|
|
|
|
assertEquals("a", reader.nextName());
|
|
|
|
try {
|
|
|
|
reader.nextBoolean();
|
|
|
|
reader.nextName();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testLenientSemicolonDelimitedNameValuePair() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("{\"a\":true;\"b\":true}"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginObject();
|
|
|
|
assertEquals("a", reader.nextName());
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
assertEquals("b", reader.nextName());
|
|
|
|
}
|
|
|
|
|
2011-12-21 22:43:55 +01:00
|
|
|
public void testStrictSemicolonDelimitedNameValuePairWithSkipValue() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("{\"a\":true;\"b\":true}"));
|
|
|
|
reader.beginObject();
|
|
|
|
assertEquals("a", reader.nextName());
|
|
|
|
try {
|
|
|
|
reader.skipValue();
|
|
|
|
reader.skipValue();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-26 10:44:02 +02:00
|
|
|
public void testStrictUnnecessaryArraySeparators() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[true,,true]"));
|
|
|
|
reader.beginArray();
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
try {
|
|
|
|
reader.nextNull();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
|
|
|
|
reader = new JsonReader(new StringReader("[,true]"));
|
|
|
|
reader.beginArray();
|
|
|
|
try {
|
|
|
|
reader.nextNull();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
|
|
|
|
reader = new JsonReader(new StringReader("[true,]"));
|
|
|
|
reader.beginArray();
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
try {
|
|
|
|
reader.nextNull();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
|
|
|
|
reader = new JsonReader(new StringReader("[,]"));
|
|
|
|
reader.beginArray();
|
|
|
|
try {
|
|
|
|
reader.nextNull();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testLenientUnnecessaryArraySeparators() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[true,,true]"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
reader.nextNull();
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
reader.endArray();
|
|
|
|
|
|
|
|
reader = new JsonReader(new StringReader("[,true]"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
|
|
|
reader.nextNull();
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
reader.endArray();
|
|
|
|
|
|
|
|
reader = new JsonReader(new StringReader("[true,]"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
reader.nextNull();
|
|
|
|
reader.endArray();
|
|
|
|
|
|
|
|
reader = new JsonReader(new StringReader("[,]"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
|
|
|
reader.nextNull();
|
|
|
|
reader.nextNull();
|
|
|
|
reader.endArray();
|
|
|
|
}
|
|
|
|
|
2011-12-21 22:43:55 +01:00
|
|
|
public void testStrictUnnecessaryArraySeparatorsWithSkipValue() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[true,,true]"));
|
|
|
|
reader.beginArray();
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
try {
|
|
|
|
reader.skipValue();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
|
|
|
|
reader = new JsonReader(new StringReader("[,true]"));
|
|
|
|
reader.beginArray();
|
|
|
|
try {
|
|
|
|
reader.skipValue();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
|
|
|
|
reader = new JsonReader(new StringReader("[true,]"));
|
|
|
|
reader.beginArray();
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
try {
|
|
|
|
reader.skipValue();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
|
|
|
|
reader = new JsonReader(new StringReader("[,]"));
|
|
|
|
reader.beginArray();
|
|
|
|
try {
|
|
|
|
reader.skipValue();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-26 10:44:02 +02:00
|
|
|
public void testStrictMultipleTopLevelValues() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[] []"));
|
|
|
|
reader.beginArray();
|
|
|
|
reader.endArray();
|
|
|
|
try {
|
|
|
|
reader.peek();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testLenientMultipleTopLevelValues() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[] true {}"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
|
|
|
reader.endArray();
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
reader.beginObject();
|
|
|
|
reader.endObject();
|
|
|
|
assertEquals(JsonToken.END_DOCUMENT, reader.peek());
|
|
|
|
}
|
|
|
|
|
2011-12-21 22:43:55 +01:00
|
|
|
public void testStrictMultipleTopLevelValuesWithSkipValue() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[] []"));
|
|
|
|
reader.beginArray();
|
|
|
|
reader.endArray();
|
|
|
|
try {
|
|
|
|
reader.skipValue();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-26 06:02:09 +02:00
|
|
|
public void testStrictTopLevelString() {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("\"a\""));
|
|
|
|
try {
|
2012-08-27 00:06:57 +02:00
|
|
|
reader.nextString();
|
2012-08-26 06:02:09 +02:00
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testLenientTopLevelString() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("\"a\""));
|
|
|
|
reader.setLenient(true);
|
|
|
|
assertEquals("a", reader.nextString());
|
|
|
|
assertEquals(JsonToken.END_DOCUMENT, reader.peek());
|
|
|
|
}
|
|
|
|
|
2010-08-26 10:44:02 +02:00
|
|
|
public void testStrictTopLevelValueType() {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("true"));
|
|
|
|
try {
|
|
|
|
reader.nextBoolean();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testLenientTopLevelValueType() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("true"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
}
|
|
|
|
|
2011-12-21 22:43:55 +01:00
|
|
|
public void testStrictTopLevelValueTypeWithSkipValue() {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("true"));
|
|
|
|
try {
|
|
|
|
reader.skipValue();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-26 10:44:02 +02:00
|
|
|
public void testStrictNonExecutePrefix() {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(")]}'\n []"));
|
|
|
|
try {
|
|
|
|
reader.beginArray();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-12-21 22:43:55 +01:00
|
|
|
public void testStrictNonExecutePrefixWithSkipValue() {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(")]}'\n []"));
|
|
|
|
try {
|
|
|
|
reader.skipValue();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-26 10:44:02 +02:00
|
|
|
public void testLenientNonExecutePrefix() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(")]}'\n []"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
|
|
|
reader.endArray();
|
|
|
|
assertEquals(JsonToken.END_DOCUMENT, reader.peek());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testLenientNonExecutePrefixWithLeadingWhitespace() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("\r\n \t)]}'\n []"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
|
|
|
reader.endArray();
|
|
|
|
assertEquals(JsonToken.END_DOCUMENT, reader.peek());
|
|
|
|
}
|
|
|
|
|
2010-12-06 20:47:41 +01:00
|
|
|
public void testLenientPartialNonExecutePrefix() {
|
2010-08-26 10:44:02 +02:00
|
|
|
JsonReader reader = new JsonReader(new StringReader(")]}' []"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
try {
|
2011-02-10 02:36:27 +01:00
|
|
|
assertEquals(")", reader.nextString());
|
|
|
|
reader.nextString();
|
2010-08-26 10:44:02 +02:00
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
2011-07-18 21:26:02 +02:00
|
|
|
|
2011-07-20 20:57:30 +02:00
|
|
|
public void testBomIgnoredAsFirstCharacterOfDocument() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("\ufeff[]"));
|
|
|
|
reader.beginArray();
|
|
|
|
reader.endArray();
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testBomForbiddenAsOtherCharacterInDocument() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[\ufeff]"));
|
2011-07-18 21:26:02 +02:00
|
|
|
reader.beginArray();
|
|
|
|
try {
|
2011-07-20 20:57:30 +02:00
|
|
|
reader.endArray();
|
2011-07-18 21:26:02 +02:00
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-20 20:57:30 +02:00
|
|
|
public void testFailWithPosition() throws IOException {
|
2012-08-26 06:02:09 +02:00
|
|
|
testFailWithPosition("Expected value at line 6 column 3",
|
2011-07-20 20:57:30 +02:00
|
|
|
"[\n\n\n\n\n0,}]");
|
|
|
|
}
|
|
|
|
|
2011-07-18 21:26:02 +02:00
|
|
|
public void testFailWithPositionGreaterThanBufferSize() throws IOException {
|
|
|
|
String spaces = repeat(' ', 8192);
|
2012-08-26 06:02:09 +02:00
|
|
|
testFailWithPosition("Expected value at line 6 column 3",
|
2011-07-20 20:57:30 +02:00
|
|
|
"[\n\n" + spaces + "\n\n\n0,}]");
|
|
|
|
}
|
|
|
|
|
2012-08-27 03:17:50 +02:00
|
|
|
public void disabled_testVeryLongNumber() throws IOException {
|
|
|
|
// TODO: this is a completely broken case that needs to be fixed!
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[0." + repeat('9', 8192) + "]"));
|
|
|
|
reader.beginArray();
|
|
|
|
assertEquals(1d, reader.nextDouble());
|
|
|
|
reader.endArray();
|
|
|
|
assertEquals(JsonToken.END_DOCUMENT, reader.peek());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testVeryLongUnquotedLiteral() throws IOException {
|
|
|
|
String literal = "a" + repeat('b', 8192) + "c";
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[" + literal + "]"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
|
|
|
assertEquals(literal, reader.nextString());
|
|
|
|
reader.endArray();
|
|
|
|
}
|
|
|
|
|
2011-07-20 20:57:30 +02:00
|
|
|
public void testFailWithPositionIsOffsetByBom() throws IOException {
|
2012-08-26 06:02:09 +02:00
|
|
|
testFailWithPosition("Expected value at line 1 column 4",
|
2011-07-20 20:57:30 +02:00
|
|
|
"\ufeff[0,}]");
|
|
|
|
}
|
2012-02-11 21:15:39 +01:00
|
|
|
|
2011-07-20 20:57:30 +02:00
|
|
|
private void testFailWithPosition(String message, String json) throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(json));
|
2011-07-18 21:26:02 +02:00
|
|
|
reader.beginArray();
|
|
|
|
reader.nextInt();
|
|
|
|
try {
|
|
|
|
reader.peek();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
2011-07-20 20:57:30 +02:00
|
|
|
assertEquals(message, expected.getMessage());
|
2011-07-18 21:26:02 +02:00
|
|
|
}
|
|
|
|
}
|
2012-02-11 21:15:39 +01:00
|
|
|
|
|
|
|
public void testDeeplyNestedArrays() throws IOException {
|
|
|
|
// this is nested 40 levels deep; Gson is tuned for nesting is 30 levels deep or fewer
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(
|
|
|
|
"[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]"));
|
|
|
|
for (int i = 0; i < 40; i++) {
|
|
|
|
reader.beginArray();
|
|
|
|
}
|
|
|
|
for (int i = 0; i < 40; i++) {
|
|
|
|
reader.endArray();
|
|
|
|
}
|
|
|
|
assertEquals(JsonToken.END_DOCUMENT, reader.peek());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testDeeplyNestedObjects() throws IOException {
|
|
|
|
// Build a JSON document structured like {"a":{"a":{"a":{"a":true}}}}, but 40 levels deep
|
|
|
|
String array = "{\"a\":%s}";
|
|
|
|
String json = "true";
|
|
|
|
for (int i = 0; i < 40; i++) {
|
|
|
|
json = String.format(array, json);
|
|
|
|
}
|
|
|
|
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(json));
|
|
|
|
for (int i = 0; i < 40; i++) {
|
|
|
|
reader.beginObject();
|
|
|
|
assertEquals("a", reader.nextName());
|
|
|
|
}
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
for (int i = 0; i < 40; i++) {
|
|
|
|
reader.endObject();
|
|
|
|
}
|
|
|
|
assertEquals(JsonToken.END_DOCUMENT, reader.peek());
|
|
|
|
}
|
|
|
|
|
|
|
|
// http://code.google.com/p/google-gson/issues/detail?id=409
|
|
|
|
public void testStringEndingInSlash() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("/"));
|
|
|
|
reader.setLenient(true);
|
2012-02-16 23:49:53 +01:00
|
|
|
try {
|
|
|
|
reader.peek();
|
|
|
|
fail();
|
|
|
|
} catch (MalformedJsonException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testDocumentWithCommentEndingInSlash() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("/* foo *//"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
try {
|
|
|
|
reader.peek();
|
|
|
|
fail();
|
|
|
|
} catch (MalformedJsonException expected) {
|
|
|
|
}
|
2012-02-11 21:15:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
public void testStringWithLeadingSlash() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("/x"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
try {
|
|
|
|
reader.peek();
|
|
|
|
fail();
|
|
|
|
} catch (MalformedJsonException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testUnterminatedObject() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("{\"a\":\"android\"x"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginObject();
|
|
|
|
assertEquals("a", reader.nextName());
|
|
|
|
assertEquals("android", reader.nextString());
|
|
|
|
try {
|
|
|
|
reader.peek();
|
|
|
|
fail();
|
|
|
|
} catch (MalformedJsonException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testVeryLongQuotedString() throws IOException {
|
|
|
|
char[] stringChars = new char[1024 * 16];
|
|
|
|
Arrays.fill(stringChars, 'x');
|
|
|
|
String string = new String(stringChars);
|
|
|
|
String json = "[\"" + string + "\"]";
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(json));
|
|
|
|
reader.beginArray();
|
|
|
|
assertEquals(string, reader.nextString());
|
|
|
|
reader.endArray();
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testVeryLongUnquotedString() throws IOException {
|
|
|
|
char[] stringChars = new char[1024 * 16];
|
|
|
|
Arrays.fill(stringChars, 'x');
|
|
|
|
String string = new String(stringChars);
|
|
|
|
String json = "[" + string + "]";
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(json));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
|
|
|
assertEquals(string, reader.nextString());
|
|
|
|
reader.endArray();
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testVeryLongUnterminatedString() throws IOException {
|
|
|
|
char[] stringChars = new char[1024 * 16];
|
|
|
|
Arrays.fill(stringChars, 'x');
|
|
|
|
String string = new String(stringChars);
|
|
|
|
String json = "[" + string;
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(json));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
|
|
|
assertEquals(string, reader.nextString());
|
|
|
|
try {
|
|
|
|
reader.peek();
|
|
|
|
fail();
|
|
|
|
} catch (EOFException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testSkipVeryLongUnquotedString() throws IOException {
|
2012-08-27 03:17:50 +02:00
|
|
|
JsonReader reader = new JsonReader(new StringReader("[" + repeat('x', 8192) + "]"));
|
2012-02-11 21:15:39 +01:00
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
|
|
|
reader.skipValue();
|
|
|
|
reader.endArray();
|
|
|
|
}
|
|
|
|
|
2012-08-27 03:17:50 +02:00
|
|
|
public void testSkipTopLevelUnquotedString() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(repeat('x', 8192)));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.skipValue();
|
|
|
|
assertEquals(JsonToken.END_DOCUMENT, reader.peek());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testSkipVeryLongQuotedString() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[\"" + repeat('x', 8192) + "\"]"));
|
|
|
|
reader.beginArray();
|
|
|
|
reader.skipValue();
|
|
|
|
reader.endArray();
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testSkipTopLevelQuotedString() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("\"" + repeat('x', 8192) + "\""));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.skipValue();
|
|
|
|
assertEquals(JsonToken.END_DOCUMENT, reader.peek());
|
|
|
|
}
|
|
|
|
|
2012-02-11 21:15:39 +01:00
|
|
|
public void testStringAsNumberWithTruncatedExponent() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[123e]"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
2012-08-26 21:31:06 +02:00
|
|
|
assertEquals(STRING, reader.peek());
|
2012-02-11 21:15:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
public void testStringAsNumberWithDigitAndNonDigitExponent() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[123e4b]"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
2012-08-26 21:31:06 +02:00
|
|
|
assertEquals(STRING, reader.peek());
|
2012-02-11 21:15:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
public void testStringAsNumberWithNonDigitExponent() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[123eb]"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
2012-08-26 21:31:06 +02:00
|
|
|
assertEquals(STRING, reader.peek());
|
2012-02-11 21:15:39 +01:00
|
|
|
}
|
2011-07-18 21:26:02 +02:00
|
|
|
|
2012-08-26 06:02:09 +02:00
|
|
|
public void testEmptyStringName() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("{\"\":true}"));
|
|
|
|
reader.setLenient(true);
|
2012-08-26 21:31:06 +02:00
|
|
|
assertEquals(BEGIN_OBJECT, reader.peek());
|
2012-08-26 06:02:09 +02:00
|
|
|
reader.beginObject();
|
2012-08-26 21:31:06 +02:00
|
|
|
assertEquals(NAME, reader.peek());
|
2012-08-26 06:02:09 +02:00
|
|
|
assertEquals("", reader.nextName());
|
|
|
|
assertEquals(JsonToken.BOOLEAN, reader.peek());
|
|
|
|
assertEquals(true, reader.nextBoolean());
|
|
|
|
assertEquals(JsonToken.END_OBJECT, reader.peek());
|
|
|
|
reader.endObject();
|
|
|
|
assertEquals(JsonToken.END_DOCUMENT, reader.peek());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testStrictExtraCommasInMaps() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("{\"a\":\"b\",}"));
|
|
|
|
reader.beginObject();
|
|
|
|
assertEquals("a", reader.nextName());
|
|
|
|
assertEquals("b", reader.nextString());
|
|
|
|
try {
|
|
|
|
reader.peek();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testLenientExtraCommasInMaps() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("{\"a\":\"b\",}"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginObject();
|
|
|
|
assertEquals("a", reader.nextName());
|
|
|
|
assertEquals("b", reader.nextString());
|
|
|
|
try {
|
|
|
|
reader.peek();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-18 21:26:02 +02:00
|
|
|
private String repeat(char c, int count) {
|
|
|
|
char[] array = new char[count];
|
|
|
|
Arrays.fill(array, c);
|
|
|
|
return new String(array);
|
|
|
|
}
|
2012-08-26 21:31:06 +02:00
|
|
|
|
|
|
|
public void testMalformedDocuments() throws IOException {
|
|
|
|
assertDocument("{]", BEGIN_OBJECT, IOException.class);
|
|
|
|
assertDocument("{,", BEGIN_OBJECT, IOException.class);
|
|
|
|
assertDocument("{{", BEGIN_OBJECT, IOException.class);
|
|
|
|
assertDocument("{[", BEGIN_OBJECT, IOException.class);
|
|
|
|
assertDocument("{:", BEGIN_OBJECT, IOException.class);
|
|
|
|
assertDocument("{\"name\",", BEGIN_OBJECT, NAME, IOException.class);
|
|
|
|
assertDocument("{\"name\",", BEGIN_OBJECT, NAME, IOException.class);
|
|
|
|
assertDocument("{\"name\":}", BEGIN_OBJECT, NAME, IOException.class);
|
|
|
|
assertDocument("{\"name\"::", BEGIN_OBJECT, NAME, IOException.class);
|
|
|
|
assertDocument("{\"name\":,", BEGIN_OBJECT, NAME, IOException.class);
|
|
|
|
assertDocument("{\"name\"=}", BEGIN_OBJECT, NAME, IOException.class);
|
|
|
|
assertDocument("{\"name\"=>}", BEGIN_OBJECT, NAME, IOException.class);
|
|
|
|
assertDocument("{\"name\"=>\"string\":", BEGIN_OBJECT, NAME, STRING, IOException.class);
|
|
|
|
assertDocument("{\"name\"=>\"string\"=", BEGIN_OBJECT, NAME, STRING, IOException.class);
|
|
|
|
assertDocument("{\"name\"=>\"string\"=>", BEGIN_OBJECT, NAME, STRING, IOException.class);
|
|
|
|
assertDocument("{\"name\"=>\"string\",", BEGIN_OBJECT, NAME, STRING, IOException.class);
|
|
|
|
assertDocument("{\"name\"=>\"string\",\"name\"", BEGIN_OBJECT, NAME, STRING, NAME);
|
|
|
|
assertDocument("[}", BEGIN_ARRAY, IOException.class);
|
|
|
|
assertDocument("[,]", BEGIN_ARRAY, NULL, NULL, END_ARRAY);
|
|
|
|
assertDocument("{", BEGIN_OBJECT, IOException.class);
|
|
|
|
assertDocument("{\"name\"", BEGIN_OBJECT, NAME, IOException.class);
|
|
|
|
assertDocument("{\"name\",", BEGIN_OBJECT, NAME, IOException.class);
|
|
|
|
assertDocument("{'name'", BEGIN_OBJECT, NAME, IOException.class);
|
|
|
|
assertDocument("{'name',", BEGIN_OBJECT, NAME, IOException.class);
|
|
|
|
assertDocument("{name", BEGIN_OBJECT, NAME, IOException.class);
|
|
|
|
assertDocument("[", BEGIN_ARRAY, IOException.class);
|
|
|
|
assertDocument("[string", BEGIN_ARRAY, STRING, IOException.class);
|
|
|
|
assertDocument("[\"string\"", BEGIN_ARRAY, STRING, IOException.class);
|
|
|
|
assertDocument("['string'", BEGIN_ARRAY, STRING, IOException.class);
|
|
|
|
assertDocument("[123", BEGIN_ARRAY, NUMBER, IOException.class);
|
|
|
|
assertDocument("[123,", BEGIN_ARRAY, NUMBER, IOException.class);
|
|
|
|
assertDocument("{\"name\":123", BEGIN_OBJECT, NAME, NUMBER, IOException.class);
|
|
|
|
assertDocument("{\"name\":123,", BEGIN_OBJECT, NAME, NUMBER, IOException.class);
|
|
|
|
assertDocument("{\"name\":\"string\"", BEGIN_OBJECT, NAME, STRING, IOException.class);
|
|
|
|
assertDocument("{\"name\":\"string\",", BEGIN_OBJECT, NAME, STRING, IOException.class);
|
|
|
|
assertDocument("{\"name\":'string'", BEGIN_OBJECT, NAME, STRING, IOException.class);
|
|
|
|
assertDocument("{\"name\":'string',", BEGIN_OBJECT, NAME, STRING, IOException.class);
|
|
|
|
assertDocument("{\"name\":false", BEGIN_OBJECT, NAME, BOOLEAN, IOException.class);
|
|
|
|
assertDocument("{\"name\":false,,", BEGIN_OBJECT, NAME, BOOLEAN, IOException.class);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This test behave slightly differently in Gson 2.2 and earlier. It fails
|
|
|
|
* during peek rather than during nextString().
|
|
|
|
*/
|
|
|
|
public void testUnterminatedStringFailure() throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader("[\"string"));
|
|
|
|
reader.setLenient(true);
|
|
|
|
reader.beginArray();
|
|
|
|
assertEquals(JsonToken.STRING, reader.peek());
|
|
|
|
try {
|
|
|
|
reader.nextString();
|
|
|
|
fail();
|
|
|
|
} catch (MalformedJsonException expected) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private void assertDocument(String document, Object... expectations) throws IOException {
|
|
|
|
JsonReader reader = new JsonReader(new StringReader(document));
|
|
|
|
reader.setLenient(true);
|
|
|
|
for (Object expectation : expectations) {
|
|
|
|
if (expectation == BEGIN_OBJECT) {
|
|
|
|
reader.beginObject();
|
|
|
|
} else if (expectation == BEGIN_ARRAY) {
|
|
|
|
reader.beginArray();
|
|
|
|
} else if (expectation == END_OBJECT) {
|
|
|
|
reader.endObject();
|
|
|
|
} else if (expectation == END_ARRAY) {
|
|
|
|
reader.endArray();
|
|
|
|
} else if (expectation == NAME) {
|
|
|
|
assertEquals("name", reader.nextName());
|
|
|
|
} else if (expectation == BOOLEAN) {
|
|
|
|
assertEquals(false, reader.nextBoolean());
|
|
|
|
} else if (expectation == STRING) {
|
|
|
|
assertEquals("string", reader.nextString());
|
|
|
|
} else if (expectation == NUMBER) {
|
|
|
|
assertEquals(123, reader.nextInt());
|
|
|
|
} else if (expectation == NULL) {
|
|
|
|
reader.nextNull();
|
|
|
|
} else if (expectation == IOException.class) {
|
|
|
|
try {
|
|
|
|
reader.peek();
|
|
|
|
fail();
|
|
|
|
} catch (IOException expected) {
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
throw new AssertionError();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: test character-by-character reads
|
2010-08-26 10:44:02 +02:00
|
|
|
}
|