package com.fasterxml.jackson.databind.deser;
import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.URL;
import java.net.URI;
import java.util.*;
import org.junit.Assert;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.util.TokenBuffer;
/**
* Unit tests for verifying handling of simple basic non-structured
* types; primitives (and/or their wrappers), Strings.
*/
public class TestSimpleTypes
extends BaseMapTest
{
final static String NAN_STRING = "NaN";
final static class BooleanBean {
boolean _v;
void setV(boolean v) { _v = v; }
}
static class IntBean {
int _v;
void setV(int v) { _v = v; }
}
final static class DoubleBean {
double _v;
void setV(double v) { _v = v; }
}
final static class FloatBean {
float _v;
void setV(float v) { _v = v; }
}
final static class CharacterBean {
char _v;
void setV(char v) { _v = v; }
char getV() { return _v; }
}
final static class CharacterWrapperBean {
Character _v;
void setV(Character v) { _v = v; }
Character getV() { return _v; }
}
/**
* Also, let's ensure that it's ok to override methods.
*/
static class IntBean2
extends IntBean
{
@Override
void setV(int v2) { super.setV(v2+1); }
}
/*
/**********************************************************
/* Then tests for primitives
/**********************************************************
*/
private final ObjectMapper MAPPER = new ObjectMapper();
public void testBooleanPrimitive() throws Exception
{
// first, simple case:
BooleanBean result = MAPPER.readValue(new StringReader("{\"v\":true}"), BooleanBean.class);
assertTrue(result._v);
// then [JACKSON-79]:
result = MAPPER.readValue(new StringReader("{\"v\":null}"), BooleanBean.class);
assertNotNull(result);
assertFalse(result._v);
// should work with arrays too..
boolean[] array = MAPPER.readValue(new StringReader("[ null ]"), boolean[].class);
assertNotNull(array);
assertEquals(1, array.length);
assertFalse(array[0]);
// [Issue#381]
final ObjectMapper mapper = new ObjectMapper();
mapper.enable(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS);
result = mapper.readValue(new StringReader("{\"v\":[true]}"), BooleanBean.class);
assertTrue(result._v);
try {
mapper.readValue(new StringReader("[{\"v\":[true,true]}]"), BooleanBean.class);
fail("Did not throw exception while reading a value from a multi value array with UNWRAP_SINGLE_VALUE_ARRAY feature enabled");
} catch (JsonMappingException exp) {
//threw exception as required
}
result = mapper.readValue(new StringReader("{\"v\":[null]}"), BooleanBean.class);
assertNotNull(result);
assertFalse(result._v);
result = mapper.readValue(new StringReader("[{\"v\":[null]}]"), BooleanBean.class);
assertNotNull(result);
assertFalse(result._v);
array = mapper.readValue(new StringReader("[ [ null ] ]"), boolean[].class);
assertNotNull(array);
assertEquals(1, array.length);
assertFalse(array[0]);
}
public void testIntPrimitive() throws Exception
{
// first, simple case:
IntBean result = MAPPER.readValue(new StringReader("{\"v\":3}"), IntBean.class);
assertEquals(3, result._v);
// then [JACKSON-79]:
result = MAPPER.readValue(new StringReader("{\"v\":null}"), IntBean.class);
assertNotNull(result);
assertEquals(0, result._v);
// should work with arrays too..
int[] array = MAPPER.readValue(new StringReader("[ null ]"), int[].class);
assertNotNull(array);
assertEquals(1, array.length);
assertEquals(0, array[0]);
// [Issue#381]
final ObjectMapper mapper = new ObjectMapper();
mapper.disable(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS);
try {
mapper.readValue(new StringReader("{\"v\":[3]}"), IntBean.class);
fail("Did not throw exception when reading a value from a single value array with the UNWRAP_SINGLE_VALUE_ARRAYS feature disabled");
} catch (JsonMappingException exp) {
//Correctly threw exception
}
mapper.enable(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS);
result = mapper.readValue(new StringReader("{\"v\":[3]}"), IntBean.class);
assertEquals(3, result._v);
result = mapper.readValue(new StringReader("[{\"v\":[3]}]"), IntBean.class);
assertEquals(3, result._v);
try {
mapper.readValue(new StringReader("[{\"v\":[3,3]}]"), IntBean.class);
fail("Did not throw exception while reading a value from a multi value array with UNWRAP_SINGLE_VALUE_ARRAY feature enabled");
} catch (JsonMappingException exp) {
//threw exception as required
}
result = mapper.readValue(new StringReader("{\"v\":[null]}"), IntBean.class);
assertNotNull(result);
assertEquals(0, result._v);
array = mapper.readValue(new StringReader("[ [ null ] ]"), int[].class);
assertNotNull(array);
assertEquals(1, array.length);
assertEquals(0, array[0]);
}
public void testDoublePrimitive() throws Exception
{
// first, simple case:
// bit tricky with binary fps but...
double value = 0.016;
DoubleBean result = MAPPER.readValue(new StringReader("{\"v\":"+value+"}"), DoubleBean.class);
assertEquals(value, result._v);
// then [JACKSON-79]:
result = MAPPER.readValue(new StringReader("{\"v\":null}"), DoubleBean.class);
assertNotNull(result);
assertEquals(0.0, result._v);
// should work with arrays too..
double[] array = MAPPER.readValue(new StringReader("[ null ]"), double[].class);
assertNotNull(array);
assertEquals(1, array.length);
assertEquals(0.0, array[0]);
// [Issue#381]
final ObjectMapper mapper = new ObjectMapper();
mapper.disable(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS);
try {
mapper.readValue(new StringReader("{\"v\":[" + value + "]}"), DoubleBean.class);
fail("Did not throw exception when reading a value from a single value array with the UNWRAP_SINGLE_VALUE_ARRAYS feature disabled");
} catch (JsonMappingException exp) {
//Correctly threw exception
}
mapper.enable(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS);
result = mapper.readValue(new StringReader("{\"v\":[" + value + "]}"), DoubleBean.class);
assertEquals(value, result._v);
result = mapper.readValue(new StringReader("[{\"v\":[" + value + "]}]"), DoubleBean.class);
assertEquals(value, result._v);
try {
mapper.readValue(new StringReader("[{\"v\":[" + value + "," + value + "]}]"), DoubleBean.class);
fail("Did not throw exception while reading a value from a multi value array with UNWRAP_SINGLE_VALUE_ARRAY feature enabled");
} catch (JsonMappingException exp) {
//threw exception as required
}
result = mapper.readValue(new StringReader("{\"v\":[null]}"), DoubleBean.class);
assertNotNull(result);
assertEquals(0d, result._v);
array = mapper.readValue(new StringReader("[ [ null ] ]"), double[].class);
assertNotNull(array);
assertEquals(1, array.length);
assertEquals(0d, array[0]);
}
public void testDoublePrimitiveNonNumeric() throws Exception
{
// first, simple case:
// bit tricky with binary fps but...
double value = Double.POSITIVE_INFINITY;
DoubleBean result = MAPPER.readValue(new StringReader("{\"v\":\""+value+"\"}"), DoubleBean.class);
assertEquals(value, result._v);
// should work with arrays too..
double[] array = MAPPER.readValue(new StringReader("[ \"Infinity\" ]"), double[].class);
assertNotNull(array);
assertEquals(1, array.length);
assertEquals(Double.POSITIVE_INFINITY, array[0]);
}
public void testFloatPrimitiveNonNumeric() throws Exception
{
// bit tricky with binary fps but...
float value = Float.POSITIVE_INFINITY;
FloatBean result = MAPPER.readValue(new StringReader("{\"v\":\""+value+"\"}"), FloatBean.class);
assertEquals(value, result._v);
// should work with arrays too..
float[] array = MAPPER.readValue(new StringReader("[ \"Infinity\" ]"), float[].class);
assertNotNull(array);
assertEquals(1, array.length);
assertEquals(Float.POSITIVE_INFINITY, array[0]);
}
/**
* Beyond simple case, let's also ensure that method overriding works as
* expected.
*/
public void testIntWithOverride() throws Exception
{
IntBean2 result = MAPPER.readValue(new StringReader("{\"v\":8}"), IntBean2.class);
assertEquals(9, result._v);
}
/*
/**********************************************************
/* Then tests for wrappers
/**********************************************************
*/
/**
* Simple unit test to verify that we can map boolean values to
* java.lang.Boolean.
*/
public void testBooleanWrapper() throws Exception
{
Boolean result = MAPPER.readValue(new StringReader("true"), Boolean.class);
assertEquals(Boolean.TRUE, result);
result = MAPPER.readValue(new StringReader("false"), Boolean.class);
assertEquals(Boolean.FALSE, result);
// [JACKSON-78]: should accept ints too, (0 == false, otherwise true)
result = MAPPER.readValue(new StringReader("0"), Boolean.class);
assertEquals(Boolean.FALSE, result);
result = MAPPER.readValue(new StringReader("1"), Boolean.class);
assertEquals(Boolean.TRUE, result);
}
public void testByteWrapper() throws Exception
{
Byte result = MAPPER.readValue(new StringReader(" -42\t"), Byte.class);
assertEquals(Byte.valueOf((byte)-42), result);
// Also: should be able to coerce floats, strings:
result = MAPPER.readValue(new StringReader(" \"-12\""), Byte.class);
assertEquals(Byte.valueOf((byte)-12), result);
result = MAPPER.readValue(new StringReader(" 39.07"), Byte.class);
assertEquals(Byte.valueOf((byte)39), result);
}
public void testShortWrapper() throws Exception
{
Short result = MAPPER.readValue(new StringReader("37"), Short.class);
assertEquals(Short.valueOf((short)37), result);
// Also: should be able to coerce floats, strings:
result = MAPPER.readValue(new StringReader(" \"-1009\""), Short.class);
assertEquals(Short.valueOf((short)-1009), result);
result = MAPPER.readValue(new StringReader("-12.9"), Short.class);
assertEquals(Short.valueOf((short)-12), result);
}
public void testCharacterWrapper() throws Exception
{
// First: canonical value is 1-char string
Character result = MAPPER.readValue(new StringReader("\"a\""), Character.class);
assertEquals(Character.valueOf('a'), result);
// But can also pass in ascii code
result = MAPPER.readValue(new StringReader(" "+((int) 'X')), Character.class);
assertEquals(Character.valueOf('X'), result);
final CharacterWrapperBean wrapper = MAPPER.readValue(new StringReader("{\"v\":null}"), CharacterWrapperBean.class);
assertNotNull(wrapper);
assertNull(wrapper.getV());
final ObjectMapper mapper = new ObjectMapper();
try {
mapper.enable(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES);
mapper.readValue("{\"v\":null}", CharacterBean.class);
fail("Attempting to deserialize a 'null' JSON reference into a 'char' property did not throw an exception");
} catch (JsonMappingException exp) {
//Exception thrown as required
}
mapper.disable(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES);
final CharacterBean charBean = MAPPER.readValue(new StringReader("{\"v\":null}"), CharacterBean.class);
assertNotNull(wrapper);
assertEquals('\u0000', charBean.getV());
}
public void testIntWrapper() throws Exception
{
Integer result = MAPPER.readValue(new StringReader(" -42\t"), Integer.class);
assertEquals(Integer.valueOf(-42), result);
// Also: should be able to coerce floats, strings:
result = MAPPER.readValue(new StringReader(" \"-1200\""), Integer.class);
assertEquals(Integer.valueOf(-1200), result);
result = MAPPER.readValue(new StringReader(" 39.07"), Integer.class);
assertEquals(Integer.valueOf(39), result);
}
public void testLongWrapper() throws Exception
{
Long result = MAPPER.readValue(new StringReader("12345678901"), Long.class);
assertEquals(Long.valueOf(12345678901L), result);
// Also: should be able to coerce floats, strings:
result = MAPPER.readValue(new StringReader(" \"-9876\""), Long.class);
assertEquals(Long.valueOf(-9876), result);
result = MAPPER.readValue(new StringReader("1918.3"), Long.class);
assertEquals(Long.valueOf(1918), result);
}
/* Note: dealing with floating-point values is tricky; not sure if
* we can really use equality tests here... JDK does have decent
* conversions though, to retain accuracy and round-trippability.
* But still...
*/
public void testFloatWrapper() throws Exception
{
// Also: should be able to coerce floats, strings:
String[] STRS = new String[] {
"1.0", "0.0", "-0.3", "0.7", "42.012", "-999.0", NAN_STRING
};
for (String str : STRS) {
Float exp = Float.valueOf(str);
Float result;
if (NAN_STRING != str) {
// First, as regular floating point value
result = MAPPER.readValue(new StringReader(str), Float.class);
assertEquals(exp, result);
}
// and then as coerced String:
result = MAPPER.readValue(new StringReader(" \""+str+"\""), Float.class);
assertEquals(exp, result);
}
}
public void testDoubleWrapper() throws Exception
{
// Also: should be able to coerce doubles, strings:
String[] STRS = new String[] {
"1.0", "0.0", "-0.3", "0.7", "42.012", "-999.0", NAN_STRING
};
for (String str : STRS) {
Double exp = Double.valueOf(str);
Double result;
// First, as regular double value
if (NAN_STRING != str) {
result = MAPPER.readValue(str, Double.class);
assertEquals(exp, result);
}
// and then as coerced String:
result = MAPPER.readValue(new StringReader(" \""+str+"\""), Double.class);
assertEquals(exp, result);
}
}
// as per [Issue#42], allow Base64 variant use as well
public void testBase64Variants() throws Exception
{
final byte[] INPUT = "abcdefghijklmnopqrstuvwxyz1234567890abcdefghijklmnopqrstuvwxyz1234567890X".getBytes("UTF-8");
// default encoding is "MIME, no linefeeds", so:
Assert.assertArrayEquals(INPUT, MAPPER.readValue(
quote("YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXoxMjM0NTY3ODkwYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXoxMjM0NTY3ODkwWA=="),
byte[].class));
ObjectReader reader = MAPPER.reader(byte[].class);
Assert.assertArrayEquals(INPUT, (byte[]) reader.with(Base64Variants.MIME_NO_LINEFEEDS).readValue(
quote("YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXoxMjM0NTY3ODkwYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXoxMjM0NTY3ODkwWA=="
)));
// but others should be slightly different
Assert.assertArrayEquals(INPUT, (byte[]) reader.with(Base64Variants.MIME).readValue(
quote("YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXoxMjM0NTY3ODkwYWJjZGVmZ2hpamtsbW5vcHFyc3R1\\ndnd4eXoxMjM0NTY3ODkwWA=="
)));
Assert.assertArrayEquals(INPUT, (byte[]) reader.with(Base64Variants.MODIFIED_FOR_URL).readValue(
quote("YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXoxMjM0NTY3ODkwYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXoxMjM0NTY3ODkwWA"
)));
// PEM mandates 64 char lines:
Assert.assertArrayEquals(INPUT, (byte[]) reader.with(Base64Variants.PEM).readValue(
quote("YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXoxMjM0NTY3ODkwYWJjZGVmZ2hpamts\\nbW5vcHFyc3R1dnd4eXoxMjM0NTY3ODkwWA=="
)));
}
/*
/**********************************************************
/* Simple non-primitive types
/**********************************************************
*/
public void testSingleString() throws Exception
{
String value = "FOO!";
String result = MAPPER.readValue(new StringReader("\""+value+"\""), String.class);
assertEquals(value, result);
}
public void testSingleStringWrapped() throws Exception
{
final ObjectMapper mapper = new ObjectMapper();
mapper.disable(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS);
String value = "FOO!";
try {
mapper.readValue(new StringReader("[\""+value+"\"]"), String.class);
fail("Exception not thrown when attempting to unwrap a single value 'String' array into a simple String");
} catch (JsonMappingException exp) {
//exception thrown correctly
}
mapper.enable(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS);
try {
mapper.readValue(new StringReader("[\""+value+"\",\""+value+"\"]"), String.class);
fail("Exception not thrown when attempting to unwrap a single value 'String' array that contained more than one value into a simple String");
} catch (JsonMappingException exp) {
//exception thrown correctly
}
String result = mapper.readValue(new StringReader("[\""+value+"\"]"), String.class);
assertEquals(value, result);
}
public void testNull() throws Exception
{
// null doesn't really have a type, fake by assuming Object
Object result = MAPPER.readValue(" null", Object.class);
assertNull(result);
}
public void testClass() throws Exception
{
final ObjectMapper mapper = new ObjectMapper();
mapper.disable(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS);
Class<?> result = mapper.readValue(quote(String.class.getName()), Class.class);
assertEquals(String.class, result);
//[Issue#381]
try {
mapper.readValue("[" + quote(String.class.getName()) + "]", Class.class);
fail("Did not throw exception when UNWRAP_SINGLE_VALUE_ARRAYS feature was disabled and attempted to read a Class array containing one element");
} catch (JsonMappingException exp) {
}
mapper.enable(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS);
try {
mapper.readValue("[" + quote(Object.class.getName()) + "," + quote(Object.class.getName()) +"]", Class.class);
fail("Did not throw exception when UNWRAP_SINGLE_VALUE_ARRAYS feature was enabled and attempted to read a Class array containing two elements");
} catch (JsonMappingException exp) {
}
result = mapper.readValue("[" + quote(String.class.getName()) + "]", Class.class);
assertEquals(String.class, result);
}
public void testBigDecimal() throws Exception
{
final ObjectMapper mapper = objectMapper();
mapper.disable(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS);
BigDecimal value = new BigDecimal("0.001");
BigDecimal result = mapper.readValue(value.toString(), BigDecimal.class);
assertEquals(value, result);
//Issue#381
try {
mapper.readValue("[" + value.toString() + "]", BigDecimal.class);
fail("Exception was not thrown when attempting to read a single value array of BigDecimal when UNWRAP_SINGLE_VALUE_ARRAYS feature is disabled");
} catch (JsonMappingException exp) {
//Exception was thrown correctly
}
mapper.enable(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS);
result = mapper.readValue("[" + value.toString() + "]", BigDecimal.class);
assertEquals(value, result);
try {
mapper.readValue("[" + value.toString() + "," + value.toString() + "]", BigDecimal.class);
fail("Exception was not thrown when attempting to read a muti value array of BigDecimal when UNWRAP_SINGLE_VALUE_ARRAYS feature is enabled");
} catch (JsonMappingException exp) {
//Exception was thrown correctly
}
}
public void testBigInteger() throws Exception
{
final ObjectMapper mapper = objectMapper();
mapper.disable(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS);
BigInteger value = new BigInteger("-1234567890123456789012345567809");
BigInteger result = mapper.readValue(new StringReader(value.toString()), BigInteger.class);
assertEquals(value, result);
//Issue#381
try {
mapper.readValue("[" + value.toString() + "]", BigInteger.class);
fail("Exception was not thrown when attempting to read a single value array of BigInteger when UNWRAP_SINGLE_VALUE_ARRAYS feature is disabled");
} catch (JsonMappingException exp) {
//Exception was thrown correctly
}
mapper.enable(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS);
result = mapper.readValue("[" + value.toString() + "]", BigInteger.class);
assertEquals(value, result);
try {
mapper.readValue("[" + value.toString() + "," + value.toString() + "]", BigInteger.class);
fail("Exception was not thrown when attempting to read a muti value array of BigInteger when UNWRAP_SINGLE_VALUE_ARRAYS feature is enabled");
} catch (JsonMappingException exp) {
//Exception was thrown correctly
}
}
public void testUUID() throws Exception
{
final ObjectMapper mapper = objectMapper();
final String NULL_UUID = "00000000-0000-0000-0000-000000000000";
// first, couple of generated UUIDs:
for (String value : new String[] {
"76e6d183-5f68-4afa-b94a-922c1fdb83f8",
"540a88d1-e2d8-4fb1-9396-9212280d0a7f",
"2c9e441d-1cd0-472d-9bab-69838f877574",
"591b2869-146e-41d7-8048-e8131f1fdec5",
"82994ac2-7b23-49f2-8cc5-e24cf6ed77be",
"00000007-0000-0000-0000-000000000000"
}) {
mapper.disable(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS);
UUID uuid = UUID.fromString(value);
assertEquals(uuid,
mapper.readValue(quote(value), UUID.class));
try {
mapper.readValue("[" + quote(value) + "]", UUID.class);
fail("Exception was not thrown when UNWRAP_SINGLE_VALUE_ARRAYS is disabled and attempted to read a single value array as a single element");
} catch (JsonMappingException exp) {
//Exception thrown successfully
}
mapper.enable(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS);
assertEquals(uuid,
mapper.readValue("[" + quote(value) + "]", UUID.class));
try {
mapper.readValue("[" + quote(value) + "," + quote(value) + "]", UUID.class);
fail("Exception was not thrown when UNWRAP_SINGLE_VALUE_ARRAYS is enabled and attempted to read a multi value array as a single element");
} catch (JsonMappingException exp) {
//Exception thrown successfully
}
}
// then use templating; note that these are not exactly valid UUIDs
// wrt spec (type bits etc), but JDK UUID should deal ok
final String TEMPL = NULL_UUID;
final String chars = "123456789abcdefABCDEF";
for (int i = 0; i < chars.length(); ++i) {
String value = TEMPL.replace('0', chars.charAt(i));
assertEquals(UUID.fromString(value).toString(),
mapper.readValue(quote(value), UUID.class).toString());
}
// also: see if base64 encoding works as expected
String base64 = Base64Variants.getDefaultVariant().encode(new byte[16]);
assertEquals(UUID.fromString(NULL_UUID),
mapper.readValue(quote(base64), UUID.class));
}
public void testUUIDAux() throws Exception
{
// [JACKSON-393] fix:
final UUID value = UUID.fromString("76e6d183-5f68-4afa-b94a-922c1fdb83f8");
// first, null should come as null
TokenBuffer buf = new TokenBuffer(null, false);
buf.writeObject(null);
assertNull(MAPPER.readValue(buf.asParser(), UUID.class));
buf.close();
// then, UUID itself come as is:
buf = new TokenBuffer(null, false);
buf.writeObject(value);
assertSame(value, MAPPER.readValue(buf.asParser(), UUID.class));
// and finally from byte[]
// oh crap; JDK UUID just... sucks. Not even byte[] accessors or constructors? Huh?
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
DataOutputStream out = new DataOutputStream(bytes);
out.writeLong(value.getMostSignificantBits());
out.writeLong(value.getLeastSignificantBits());
byte[] data = bytes.toByteArray();
assertEquals(16, data.length);
buf.writeObject(data);
UUID value2 = MAPPER.readValue(buf.asParser(), UUID.class);
assertEquals(value, value2);
buf.close();
}
public void testURL() throws Exception
{
URL value = new URL("http://foo.com");
assertEquals(value, MAPPER.readValue("\""+value.toString()+"\"", URL.class));
// trivial case; null to null, embedded URL to URL
TokenBuffer buf = new TokenBuffer(null, false);
buf.writeObject(null);
assertNull(MAPPER.readValue(buf.asParser(), URL.class));
buf.close();
// then, URLitself come as is:
buf = new TokenBuffer(null, false);
buf.writeObject(value);
assertSame(value, MAPPER.readValue(buf.asParser(), URL.class));
buf.close();
}
public void testURI() throws Exception
{
final ObjectMapper mapper = new ObjectMapper();
URI value = new URI("http://foo.com");
assertEquals(value, mapper.readValue("\""+value.toString()+"\"", URI.class));
//[Issue#381]
mapper.disable(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS);
try {
assertEquals(value, mapper.readValue("[\""+value.toString()+"\"]", URI.class));
fail("Did not throw exception for single value array when UNWRAP_SINGLE_VALUE_ARRAYS is disabled");
} catch (JsonMappingException exp) {
//exception thrown successfully
}
try {
assertEquals(value, mapper.readValue("[\""+value.toString()+"\",\""+value.toString()+"\"]", URI.class));
fail("Did not throw exception for single value array when there were multiple values");
} catch (JsonMappingException exp) {
//exception thrown successfully
}
mapper.enable(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS);
assertEquals(value, mapper.readValue("[\""+value.toString()+"\"]", URI.class));
// [#398]
value = mapper.readValue(quote(""), URI.class);
assertNotNull(value);
assertEquals(URI.create(""), value);
}
/*
/**********************************************************
/* Sequence tests
/**********************************************************
*/
/**
* Then a unit test to verify that we can conveniently bind sequence of
* space-separate simple values
*/
public void testSequenceOfInts() throws Exception
{
final int NR_OF_INTS = 100;
StringBuilder sb = new StringBuilder();
for (int i = 0; i < NR_OF_INTS; ++i) {
sb.append(" ");
sb.append(i);
}
JsonParser jp = MAPPER.getFactory().createParser(sb.toString());
for (int i = 0; i < NR_OF_INTS; ++i) {
Integer result = MAPPER.readValue(jp, Integer.class);
assertEquals(Integer.valueOf(i), result);
}
jp.close();
}
}