Moar test coverage, now 74%/66%, similar to jackson-databind's
diff --git a/src/main/java/com/fasterxml/jackson/core/json/ReaderBasedJsonParser.java b/src/main/java/com/fasterxml/jackson/core/json/ReaderBasedJsonParser.java
index 4c45a07..dd338e5 100644
--- a/src/main/java/com/fasterxml/jackson/core/json/ReaderBasedJsonParser.java
+++ b/src/main/java/com/fasterxml/jackson/core/json/ReaderBasedJsonParser.java
@@ -445,13 +445,13 @@
@Override
public byte[] getBinaryValue(Base64Variant b64variant) throws IOException
{
- if (_currToken != JsonToken.VALUE_STRING &&
- (_currToken != JsonToken.VALUE_EMBEDDED_OBJECT || _binaryValue == null)) {
+ if ((_currToken == JsonToken.VALUE_EMBEDDED_OBJECT) && (_binaryValue != null)) {
+ return _binaryValue;
+ }
+ if (_currToken != JsonToken.VALUE_STRING) {
_reportError("Current token ("+_currToken+") not VALUE_STRING or VALUE_EMBEDDED_OBJECT, can not access as binary");
}
- /* To ensure that we won't see inconsistent data, better clear up
- * state...
- */
+ // To ensure that we won't see inconsistent data, better clear up state
if (_tokenIncomplete) {
try {
_binaryValue = _decodeBase64(b64variant);
diff --git a/src/test/java/com/fasterxml/jackson/core/base64/Base64BinaryParsingTest.java b/src/test/java/com/fasterxml/jackson/core/base64/Base64BinaryParsingTest.java
index 8693bb9..24b53ea 100644
--- a/src/test/java/com/fasterxml/jackson/core/base64/Base64BinaryParsingTest.java
+++ b/src/test/java/com/fasterxml/jackson/core/base64/Base64BinaryParsingTest.java
@@ -49,6 +49,63 @@
}
}
+ public void testInvalidTokenForBase64() throws IOException
+ {
+ for (int mode : ALL_MODES) {
+
+ // First: illegal padding
+ JsonParser p = createParser(mode, "[ ]");
+ assertToken(JsonToken.START_ARRAY, p.nextToken());
+ try {
+ p.getBinaryValue();
+ fail("Should not pass");
+ } catch (JsonParseException e) {
+ verifyException(e, "current token");
+ verifyException(e, "can not access as binary");
+ }
+ p.close();
+ }
+ }
+
+ public void testInvalidChar() throws IOException
+ {
+ for (int mode : ALL_MODES) {
+
+ // First: illegal padding
+ JsonParser p = createParser(mode, quote("a==="));
+ assertToken(JsonToken.VALUE_STRING, p.nextToken());
+ try {
+ p.getBinaryValue(Base64Variants.MIME);
+ fail("Should not pass");
+ } catch (JsonParseException e) {
+ verifyException(e, "padding only legal");
+ }
+ p.close();
+
+ // second: invalid space within
+ p = createParser(mode, quote("ab de"));
+ assertToken(JsonToken.VALUE_STRING, p.nextToken());
+ try {
+ p.getBinaryValue(Base64Variants.MIME);
+ fail("Should not pass");
+ } catch (JsonParseException e) {
+ verifyException(e, "illegal white space");
+ }
+ p.close();
+
+ // third: something else
+ p = createParser(mode, quote("ab#?"));
+ assertToken(JsonToken.VALUE_STRING, p.nextToken());
+ try {
+ p.getBinaryValue(Base64Variants.MIME);
+ fail("Should not pass");
+ } catch (JsonParseException e) {
+ verifyException(e, "illegal character '#'");
+ }
+ p.close();
+ }
+ }
+
/*
/**********************************************************
/* Test helper methods
diff --git a/src/test/java/com/fasterxml/jackson/core/read/NumberCoercionTest.java b/src/test/java/com/fasterxml/jackson/core/read/NumberCoercionTest.java
new file mode 100644
index 0000000..8b83f09
--- /dev/null
+++ b/src/test/java/com/fasterxml/jackson/core/read/NumberCoercionTest.java
@@ -0,0 +1,284 @@
+package com.fasterxml.jackson.core.read;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+
+import com.fasterxml.jackson.core.BaseTest;
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonParser.NumberType;
+import com.fasterxml.jackson.core.JsonToken;
+
+public class NumberCoercionTest extends BaseTest
+{
+ /*
+ /**********************************************************
+ /* Numeric coercions, integral
+ /**********************************************************
+ */
+
+ public void testToIntCoercion() throws Exception
+ {
+ for (int mode : ALL_STREAMING_MODES) {
+ JsonParser p;
+
+ // long->int
+ p = createParser(mode, "1");
+ assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken());
+ assertEquals(1L, p.getLongValue());
+ assertEquals(1, p.getIntValue());
+ p.close();
+
+ // BigInteger->int
+ p = createParser(mode, "10");
+ assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken());
+ assertEquals(BigInteger.TEN, p.getBigIntegerValue());
+ assertEquals(10, p.getIntValue());
+ p.close();
+
+ // double->int
+ p = createParser(mode, "2");
+ assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken());
+ assertEquals(2.0, p.getDoubleValue());
+ assertEquals(2, p.getIntValue());
+ p.close();
+
+ // BigDecimal->int
+ p = createParser(mode, "10");
+ assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken());
+ assertEquals(BigDecimal.TEN, p.getDecimalValue());
+ assertEquals(10, p.getIntValue());
+ p.close();
+ }
+ }
+
+ @SuppressWarnings("resource")
+ public void testToIntFailing() throws Exception
+ {
+ for (int mode : ALL_STREAMING_MODES) {
+ JsonParser p;
+
+ // long -> error
+ long big = 1L + Integer.MAX_VALUE;
+ p = createParser(mode, String.valueOf(big));
+ assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken());
+ assertEquals(big, p.getLongValue());
+ try {
+ p.getIntValue();
+ fail("Should not pass");
+ } catch (JsonParseException e) {
+ verifyException(e, "out of range of int");
+ }
+ long small = -1L + Integer.MIN_VALUE;
+ p = createParser(mode, String.valueOf(small));
+ assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken());
+ assertEquals(Long.valueOf(small), p.getNumberValue());
+ assertEquals(small, p.getLongValue());
+ try {
+ p.getIntValue();
+ fail("Should not pass");
+ } catch (JsonParseException e) {
+ verifyException(e, "out of range of int");
+ }
+
+ // double -> error
+ p = createParser(mode, String.valueOf(big)+".0");
+ assertToken(JsonToken.VALUE_NUMBER_FLOAT, p.nextToken());
+ assertEquals((double) big, p.getDoubleValue());
+ try {
+ p.getIntValue();
+ fail("Should not pass");
+ } catch (JsonParseException e) {
+ verifyException(e, "out of range of int");
+ }
+ p = createParser(mode, String.valueOf(small)+".0");
+ assertToken(JsonToken.VALUE_NUMBER_FLOAT, p.nextToken());
+ assertEquals((double) small, p.getDoubleValue());
+ try {
+ p.getIntValue();
+ fail("Should not pass");
+ } catch (JsonParseException e) {
+ verifyException(e, "out of range of int");
+ }
+
+ // BigInteger -> error
+ p = createParser(mode, String.valueOf(big));
+ assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken());
+ assertEquals(BigInteger.valueOf(big), p.getBigIntegerValue());
+ try {
+ p.getIntValue();
+ fail("Should not pass");
+ } catch (JsonParseException e) {
+ verifyException(e, "out of range of int");
+ }
+ p = createParser(mode, String.valueOf(small));
+ assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken());
+ assertEquals(BigInteger.valueOf(small), p.getBigIntegerValue());
+ try {
+ p.getIntValue();
+ fail("Should not pass");
+ } catch (JsonParseException e) {
+ verifyException(e, "out of range of int");
+ }
+ }
+ }
+
+ public void testToLongCoercion() throws Exception
+ {
+ for (int mode : ALL_STREAMING_MODES) {
+ JsonParser p;
+
+ // int->long
+ p = createParser(mode, "1");
+ assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken());
+ assertEquals(1, p.getIntValue());
+ assertEquals(1L, p.getLongValue());
+ p.close();
+
+ // BigInteger->long
+ long biggish = 12345678901L;
+ p = createParser(mode, String.valueOf(biggish));
+ assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken());
+ assertEquals(BigInteger.valueOf(biggish), p.getBigIntegerValue());
+ assertEquals(biggish, p.getLongValue());
+ p.close();
+
+ // double->long
+ p = createParser(mode, "2");
+ assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken());
+ assertEquals(2.0, p.getDoubleValue());
+ assertEquals(2L, p.getLongValue());
+ p.close();
+
+ // BigDecimal->long
+ p = createParser(mode, "10");
+ assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken());
+ assertEquals(BigDecimal.TEN, p.getDecimalValue());
+ assertEquals(10, p.getLongValue());
+ p.close();
+ }
+ }
+
+ @SuppressWarnings("resource")
+ public void testToLongFailing() throws Exception
+ {
+ for (int mode : ALL_STREAMING_MODES) {
+ JsonParser p;
+
+ // BigInteger -> error
+ BigInteger big = BigInteger.valueOf(Long.MAX_VALUE).add(BigInteger.TEN);
+ p = createParser(mode, String.valueOf(big));
+ assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken());
+ assertEquals(NumberType.BIG_INTEGER, p.getNumberType());
+ assertEquals(big, p.getBigIntegerValue());
+ assertEquals(big, p.getNumberValue());
+ try {
+ p.getLongValue();
+ fail("Should not pass");
+ } catch (JsonParseException e) {
+ verifyException(e, "out of range of long");
+ }
+ BigInteger small = BigInteger.valueOf(Long.MIN_VALUE).subtract(BigInteger.TEN);
+ p = createParser(mode, String.valueOf(small));
+ assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken());
+ assertEquals(small, p.getBigIntegerValue());
+ try {
+ p.getLongValue();
+ fail("Should not pass");
+ } catch (JsonParseException e) {
+ verifyException(e, "out of range of long");
+ }
+ }
+ }
+
+ public void testToBigIntegerCoercion() throws Exception
+ {
+ for (int mode : ALL_STREAMING_MODES) {
+ JsonParser p;
+
+ p = createParser(mode, "1");
+ assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken());
+ // int to BigInteger
+ assertEquals(1, p.getIntValue());
+ assertEquals(BigInteger.ONE, p.getBigIntegerValue());
+ p.close();
+
+ p = createParser(mode, "2.0");
+ assertToken(JsonToken.VALUE_NUMBER_FLOAT, p.nextToken());
+ // double to BigInteger
+ assertEquals(2.0, p.getDoubleValue());
+ assertEquals(BigInteger.valueOf(2L), p.getBigIntegerValue());
+ p.close();
+
+ p = createParser(mode, String.valueOf(Long.MAX_VALUE));
+ assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken());
+ // long to BigInteger
+ assertEquals(Long.MAX_VALUE, p.getLongValue());
+ assertEquals(BigInteger.valueOf(Long.MAX_VALUE), p.getBigIntegerValue());
+ p.close();
+
+ p = createParser(mode, " 200.0");
+ assertToken(JsonToken.VALUE_NUMBER_FLOAT, p.nextToken());
+ // BigDecimal to BigInteger
+ assertEquals(new BigDecimal("200.0"), p.getDecimalValue());
+ assertEquals(BigInteger.valueOf(200L), p.getBigIntegerValue());
+ p.close();
+ }
+ }
+
+ /*
+ /**********************************************************
+ /* Numeric coercions, floating point
+ /**********************************************************
+ */
+
+ public void testToDoubleCoercion() throws Exception
+ {
+ for (int mode : ALL_STREAMING_MODES) {
+ JsonParser p;
+
+ // BigDecimal->double
+ p = createParser(mode, "100.5");
+ assertToken(JsonToken.VALUE_NUMBER_FLOAT, p.nextToken());
+ assertEquals(new BigDecimal("100.5"), p.getDecimalValue());
+ assertEquals(100.5, p.getDoubleValue());
+ p.close();
+
+ p = createParser(mode, "10");
+ assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken());
+ assertEquals(BigInteger.TEN, p.getBigIntegerValue());
+ assertEquals(10.0, p.getDoubleValue());
+ p.close();
+ }
+ }
+
+ public void testToBigDecimalCoercion() throws Exception
+ {
+ for (int mode : ALL_STREAMING_MODES) {
+ JsonParser p;
+
+ p = createParser(mode, "1");
+ assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken());
+ // int to BigDecimal
+ assertEquals(1, p.getIntValue());
+ assertEquals(BigDecimal.ONE, p.getDecimalValue());
+ p.close();
+
+ p = createParser(mode, String.valueOf(Long.MAX_VALUE));
+ assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken());
+ // long to BigDecimal
+ assertEquals(Long.MAX_VALUE, p.getLongValue());
+ assertEquals(BigDecimal.valueOf(Long.MAX_VALUE), p.getDecimalValue());
+ p.close();
+
+ BigInteger biggie = BigInteger.valueOf(Long.MAX_VALUE).multiply(BigInteger.TEN);
+ p = createParser(mode, String.valueOf(biggie));
+ assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken());
+ // BigInteger to BigDecimal
+ assertEquals(biggie, p.getBigIntegerValue());
+ assertEquals(new BigDecimal(biggie), p.getDecimalValue());
+ p.close();
+
+ }
+ }
+}
diff --git a/src/test/java/com/fasterxml/jackson/core/read/NumberParsingTest.java b/src/test/java/com/fasterxml/jackson/core/read/NumberParsingTest.java
index 6c8da43..dab984b 100644
--- a/src/test/java/com/fasterxml/jackson/core/read/NumberParsingTest.java
+++ b/src/test/java/com/fasterxml/jackson/core/read/NumberParsingTest.java
@@ -496,6 +496,7 @@
}
}
+
/*
/**********************************************************
/* Tests for invalid access
@@ -594,6 +595,19 @@
assertNull(p.nextToken());
}
+ public void testInvalidNumber() throws Exception {
+ for (int mode : ALL_MODES) {
+ JsonParser p = createParser(mode, " -foo ");
+ try {
+ p.nextToken();
+ fail("Should not pass");
+ } catch (JsonParseException e) {
+ verifyException(e, "Unexpected character ('f'");
+ }
+ p.close();
+ }
+ }
+
/*
/**********************************************************
/* Helper methods