| package com.fasterxml.jackson.databind.deser; |
| |
| import java.io.*; |
| import java.net.*; |
| import java.nio.ByteBuffer; |
| import java.nio.charset.Charset; |
| import java.util.Currency; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.regex.Pattern; |
| |
| import com.fasterxml.jackson.annotation.*; |
| import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility; |
| import com.fasterxml.jackson.core.JsonParser; |
| import com.fasterxml.jackson.core.JsonProcessingException; |
| import com.fasterxml.jackson.databind.*; |
| import com.fasterxml.jackson.databind.annotation.JsonDeserialize; |
| import com.fasterxml.jackson.databind.deser.std.StdDeserializer; |
| import com.fasterxml.jackson.databind.module.SimpleModule; |
| |
| public class TestJdkTypes extends BaseMapTest |
| { |
| static class PrimitivesBean |
| { |
| public boolean booleanValue = true; |
| public byte byteValue = 3; |
| public char charValue = 'a'; |
| public short shortValue = 37; |
| public int intValue = 1; |
| public long longValue = 100L; |
| public float floatValue = 0.25f; |
| public double doubleValue = -1.0; |
| } |
| |
| // for [JACKSON-616] |
| static class WrappersBean |
| { |
| public Boolean booleanValue; |
| public Byte byteValue; |
| public Character charValue; |
| public Short shortValue; |
| public Integer intValue; |
| public Long longValue; |
| public Float floatValue; |
| public Double doubleValue; |
| } |
| |
| |
| static class ParamClassBean |
| { |
| public String name = "bar"; |
| public Class<String> clazz ; |
| |
| public ParamClassBean() { } |
| public ParamClassBean(String name) { |
| this.name = name; |
| clazz = String.class; |
| } |
| } |
| |
| static class BooleanBean { |
| public Boolean wrapper; |
| public boolean primitive; |
| |
| protected Boolean ctor; |
| |
| @JsonCreator |
| public BooleanBean(@JsonProperty("ctor") Boolean foo) { |
| ctor = foo; |
| } |
| } |
| |
| // [Issue#429] |
| static class StackTraceBean { |
| public final static int NUM = 13; |
| |
| @JsonProperty("Location") |
| @JsonDeserialize(using=MyStackTraceElementDeserializer.class) |
| private StackTraceElement location; |
| } |
| |
| @SuppressWarnings("serial") |
| static class MyStackTraceElementDeserializer extends StdDeserializer<StackTraceElement> |
| { |
| public MyStackTraceElementDeserializer() { super(StackTraceElement.class); } |
| |
| @Override |
| public StackTraceElement deserialize(JsonParser jp, |
| DeserializationContext ctxt) throws IOException, JsonProcessingException { |
| jp.skipChildren(); |
| return new StackTraceElement("a", "b", "b", StackTraceBean.NUM); |
| } |
| |
| } |
| |
| /* |
| /********************************************************** |
| /* Test methods |
| /********************************************************** |
| */ |
| |
| private final ObjectMapper MAPPER = objectMapper(); |
| |
| /** |
| * Related to issues [JACKSON-155], [#170]. |
| */ |
| public void testFile() throws Exception |
| { |
| // Not portable etc... has to do: |
| File src = new File("/test").getAbsoluteFile(); |
| String abs = src.getAbsolutePath(); |
| |
| // escape backslashes (for portability with windows) |
| String json = MAPPER.writeValueAsString(abs); |
| File result = MAPPER.readValue(json, File.class); |
| assertEquals(abs, result.getAbsolutePath()); |
| |
| // Then #170 |
| final ObjectMapper mapper2 = new ObjectMapper(); |
| mapper2.setVisibility(PropertyAccessor.CREATOR, Visibility.NONE); |
| |
| result = mapper2.readValue(json, File.class); |
| assertEquals(abs, result.getAbsolutePath()); |
| } |
| |
| public void testRegexps() throws IOException |
| { |
| final String PATTERN_STR = "abc:\\s?(\\d+)"; |
| Pattern exp = Pattern.compile(PATTERN_STR); |
| /* Ok: easiest way is to just serialize first; problem |
| * is the backslash |
| */ |
| String json = MAPPER.writeValueAsString(exp); |
| Pattern result = MAPPER.readValue(json, Pattern.class); |
| assertEquals(exp.pattern(), result.pattern()); |
| } |
| |
| public void testCurrency() throws IOException |
| { |
| Currency usd = Currency.getInstance("USD"); |
| assertEquals(usd, new ObjectMapper().readValue(quote("USD"), Currency.class)); |
| } |
| |
| /** |
| * Test for [JACKSON-419] |
| */ |
| public void testLocale() throws IOException |
| { |
| assertEquals(new Locale("en"), MAPPER.readValue(quote("en"), Locale.class)); |
| assertEquals(new Locale("es", "ES"), MAPPER.readValue(quote("es_ES"), Locale.class)); |
| assertEquals(new Locale("FI", "fi", "savo"), MAPPER.readValue(quote("fi_FI_savo"), Locale.class)); |
| } |
| |
| /** |
| * Test for [JACKSON-420] (add DeserializationConfig.FAIL_ON_NULL_FOR_PRIMITIVES) |
| */ |
| public void testNullForPrimitives() throws IOException |
| { |
| // by default, ok to rely on defaults |
| PrimitivesBean bean = MAPPER.readValue("{\"intValue\":null, \"booleanValue\":null, \"doubleValue\":null}", |
| PrimitivesBean.class); |
| assertNotNull(bean); |
| assertEquals(0, bean.intValue); |
| assertEquals(false, bean.booleanValue); |
| assertEquals(0.0, bean.doubleValue); |
| |
| bean = MAPPER.readValue("{\"byteValue\":null, \"longValue\":null, \"floatValue\":null}", |
| PrimitivesBean.class); |
| assertNotNull(bean); |
| assertEquals((byte) 0, bean.byteValue); |
| assertEquals(0L, bean.longValue); |
| assertEquals(0.0f, bean.floatValue); |
| |
| // but not when enabled |
| final ObjectMapper mapper2 = new ObjectMapper(); |
| mapper2.configure(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES, true); |
| |
| // boolean |
| try { |
| mapper2.readValue("{\"booleanValue\":null}", PrimitivesBean.class); |
| fail("Expected failure for boolean + null"); |
| } catch (JsonMappingException e) { |
| verifyException(e, "Can not map JSON null into type boolean"); |
| } |
| // byte/char/short/int/long |
| try { |
| mapper2.readValue("{\"byteValue\":null}", PrimitivesBean.class); |
| fail("Expected failure for byte + null"); |
| } catch (JsonMappingException e) { |
| verifyException(e, "Can not map JSON null into type byte"); |
| } |
| try { |
| mapper2.readValue("{\"charValue\":null}", PrimitivesBean.class); |
| fail("Expected failure for char + null"); |
| } catch (JsonMappingException e) { |
| verifyException(e, "Can not map JSON null into type char"); |
| } |
| try { |
| mapper2.readValue("{\"shortValue\":null}", PrimitivesBean.class); |
| fail("Expected failure for short + null"); |
| } catch (JsonMappingException e) { |
| verifyException(e, "Can not map JSON null into type short"); |
| } |
| try { |
| mapper2.readValue("{\"intValue\":null}", PrimitivesBean.class); |
| fail("Expected failure for int + null"); |
| } catch (JsonMappingException e) { |
| verifyException(e, "Can not map JSON null into type int"); |
| } |
| try { |
| mapper2.readValue("{\"longValue\":null}", PrimitivesBean.class); |
| fail("Expected failure for long + null"); |
| } catch (JsonMappingException e) { |
| verifyException(e, "Can not map JSON null into type long"); |
| } |
| |
| // float/double |
| try { |
| mapper2.readValue("{\"floatValue\":null}", PrimitivesBean.class); |
| fail("Expected failure for float + null"); |
| } catch (JsonMappingException e) { |
| verifyException(e, "Can not map JSON null into type float"); |
| } |
| try { |
| mapper2.readValue("{\"doubleValue\":null}", PrimitivesBean.class); |
| fail("Expected failure for double + null"); |
| } catch (JsonMappingException e) { |
| verifyException(e, "Can not map JSON null into type double"); |
| } |
| } |
| |
| /** |
| * Test for [JACKSON-483], allow handling of CharSequence |
| */ |
| public void testCharSequence() throws IOException |
| { |
| CharSequence cs = MAPPER.readValue("\"abc\"", CharSequence.class); |
| assertEquals(String.class, cs.getClass()); |
| assertEquals("abc", cs.toString()); |
| } |
| |
| // [JACKSON-484] |
| public void testInetAddress() throws IOException |
| { |
| InetAddress address = MAPPER.readValue(quote("127.0.0.1"), InetAddress.class); |
| assertEquals("127.0.0.1", address.getHostAddress()); |
| |
| // should we try resolving host names? That requires connectivity... |
| final String HOST = "google.com"; |
| address = MAPPER.readValue(quote(HOST), InetAddress.class); |
| assertEquals(HOST, address.getHostName()); |
| } |
| |
| public void testInetSocketAddress() throws IOException |
| { |
| InetSocketAddress address = MAPPER.readValue(quote("127.0.0.1"), InetSocketAddress.class); |
| assertEquals("127.0.0.1", address.getAddress().getHostAddress()); |
| |
| InetSocketAddress ip6 = MAPPER.readValue( |
| quote("2001:db8:85a3:8d3:1319:8a2e:370:7348"), InetSocketAddress.class); |
| assertEquals("2001:db8:85a3:8d3:1319:8a2e:370:7348", ip6.getAddress().getHostAddress()); |
| |
| InetSocketAddress ip6port = MAPPER.readValue( |
| quote("[2001:db8:85a3:8d3:1319:8a2e:370:7348]:443"), InetSocketAddress.class); |
| assertEquals("2001:db8:85a3:8d3:1319:8a2e:370:7348", ip6port.getAddress().getHostAddress()); |
| assertEquals(443, ip6port.getPort()); |
| |
| // should we try resolving host names? That requires connectivity... |
| final String HOST = "www.google.com"; |
| address = MAPPER.readValue(quote(HOST), InetSocketAddress.class); |
| assertEquals(HOST, address.getHostName()); |
| |
| final String HOST_AND_PORT = HOST+":80"; |
| address = MAPPER.readValue(quote(HOST_AND_PORT), InetSocketAddress.class); |
| assertEquals(HOST, address.getHostName()); |
| assertEquals(80, address.getPort()); |
| } |
| |
| // [JACKSON-597] |
| public void testClass() throws IOException |
| { |
| ObjectMapper mapper = new ObjectMapper(); |
| assertSame(String.class, mapper.readValue(quote("java.lang.String"), Class.class)); |
| |
| // then primitive types |
| assertSame(Boolean.TYPE, mapper.readValue(quote("boolean"), Class.class)); |
| assertSame(Byte.TYPE, mapper.readValue(quote("byte"), Class.class)); |
| assertSame(Short.TYPE, mapper.readValue(quote("short"), Class.class)); |
| assertSame(Character.TYPE, mapper.readValue(quote("char"), Class.class)); |
| assertSame(Integer.TYPE, mapper.readValue(quote("int"), Class.class)); |
| assertSame(Long.TYPE, mapper.readValue(quote("long"), Class.class)); |
| assertSame(Float.TYPE, mapper.readValue(quote("float"), Class.class)); |
| assertSame(Double.TYPE, mapper.readValue(quote("double"), Class.class)); |
| assertSame(Void.TYPE, mapper.readValue(quote("void"), Class.class)); |
| } |
| |
| // [JACKSON-605] |
| public void testClassWithParams() throws IOException |
| { |
| String json = MAPPER.writeValueAsString(new ParamClassBean("Foobar")); |
| |
| ParamClassBean result = MAPPER.readValue(json, ParamClassBean.class); |
| assertEquals("Foobar", result.name); |
| assertSame(String.class, result.clazz); |
| } |
| |
| // by default, should return nulls, n'est pas? |
| public void testEmptyStringForWrappers() throws IOException |
| { |
| WrappersBean bean; |
| |
| // by default, ok to rely on defaults |
| bean = MAPPER.readValue("{\"booleanValue\":\"\"}", WrappersBean.class); |
| assertNull(bean.booleanValue); |
| bean = MAPPER.readValue("{\"byteValue\":\"\"}", WrappersBean.class); |
| assertNull(bean.byteValue); |
| |
| // char/Character is different... not sure if this should work or not: |
| bean = MAPPER.readValue("{\"charValue\":\"\"}", WrappersBean.class); |
| assertNull(bean.charValue); |
| |
| bean = MAPPER.readValue("{\"shortValue\":\"\"}", WrappersBean.class); |
| assertNull(bean.shortValue); |
| bean = MAPPER.readValue("{\"intValue\":\"\"}", WrappersBean.class); |
| assertNull(bean.intValue); |
| bean = MAPPER.readValue("{\"longValue\":\"\"}", WrappersBean.class); |
| assertNull(bean.longValue); |
| bean = MAPPER.readValue("{\"floatValue\":\"\"}", WrappersBean.class); |
| assertNull(bean.floatValue); |
| bean = MAPPER.readValue("{\"doubleValue\":\"\"}", WrappersBean.class); |
| assertNull(bean.doubleValue); |
| } |
| |
| // for [JACKSON-616] |
| // @since 1.9 |
| public void testEmptyStringForPrimitives() throws IOException |
| { |
| PrimitivesBean bean; |
| bean = MAPPER.readValue("{\"booleanValue\":\"\"}", PrimitivesBean.class); |
| assertFalse(bean.booleanValue); |
| bean = MAPPER.readValue("{\"byteValue\":\"\"}", PrimitivesBean.class); |
| assertEquals((byte) 0, bean.byteValue); |
| bean = MAPPER.readValue("{\"charValue\":\"\"}", PrimitivesBean.class); |
| assertEquals((char) 0, bean.charValue); |
| bean = MAPPER.readValue("{\"shortValue\":\"\"}", PrimitivesBean.class); |
| assertEquals((short) 0, bean.shortValue); |
| bean = MAPPER.readValue("{\"intValue\":\"\"}", PrimitivesBean.class); |
| assertEquals(0, bean.intValue); |
| bean = MAPPER.readValue("{\"longValue\":\"\"}", PrimitivesBean.class); |
| assertEquals(0L, bean.longValue); |
| bean = MAPPER.readValue("{\"floatValue\":\"\"}", PrimitivesBean.class); |
| assertEquals(0.0f, bean.floatValue); |
| bean = MAPPER.readValue("{\"doubleValue\":\"\"}", PrimitivesBean.class); |
| assertEquals(0.0, bean.doubleValue); |
| } |
| |
| // for [JACKSON-652] |
| // @since 1.9 |
| public void testUntypedWithJsonArrays() throws Exception |
| { |
| // by default we get: |
| Object ob = MAPPER.readValue("[1]", Object.class); |
| assertTrue(ob instanceof List<?>); |
| |
| // but can change to produce Object[]: |
| MAPPER.configure(DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY, true); |
| ob = MAPPER.readValue("[1]", Object.class); |
| assertEquals(Object[].class, ob.getClass()); |
| } |
| |
| // Test for verifying that Long values are coerced to boolean correctly as well |
| public void testLongToBoolean() throws Exception |
| { |
| long value = 1L + Integer.MAX_VALUE; |
| BooleanBean b = MAPPER.readValue("{\"primitive\" : "+value+", \"wrapper\":"+value+", \"ctor\":"+value+"}", |
| BooleanBean.class); |
| assertEquals(Boolean.TRUE, b.wrapper); |
| assertTrue(b.primitive); |
| assertEquals(Boolean.TRUE, b.ctor); |
| } |
| |
| // [JACKSON-789] |
| public void testCharset() throws Exception |
| { |
| Charset UTF8 = Charset.forName("UTF-8"); |
| assertSame(UTF8, MAPPER.readValue(quote("UTF-8"), Charset.class)); |
| } |
| |
| // [JACKSON-888] |
| public void testStackTraceElement() throws Exception |
| { |
| StackTraceElement elem = null; |
| try { |
| throw new IllegalStateException(); |
| } catch (Exception e) { |
| elem = e.getStackTrace()[0]; |
| } |
| String json = MAPPER.writeValueAsString(elem); |
| StackTraceElement back = MAPPER.readValue(json, StackTraceElement.class); |
| |
| assertEquals("testStackTraceElement", back.getMethodName()); |
| assertEquals(elem.getLineNumber(), back.getLineNumber()); |
| assertEquals(elem.getClassName(), back.getClassName()); |
| assertEquals(elem.isNativeMethod(), back.isNativeMethod()); |
| assertTrue(back.getClassName().endsWith("TestJdkTypes")); |
| assertFalse(back.isNativeMethod()); |
| } |
| |
| // [Issue#239] |
| public void testByteBuffer() throws Exception |
| { |
| byte[] INPUT = new byte[] { 1, 3, 9, -1, 6 }; |
| String exp = MAPPER.writeValueAsString(INPUT); |
| ByteBuffer result = MAPPER.readValue(exp, ByteBuffer.class); |
| assertNotNull(result); |
| assertEquals(INPUT.length, result.remaining()); |
| for (int i = 0; i < INPUT.length; ++i) { |
| assertEquals(INPUT[i], result.get()); |
| } |
| assertEquals(0, result.remaining()); |
| } |
| |
| // [Issue#429] |
| public void testStackTraceElementWithCustom() throws Exception |
| { |
| // first, via bean that contains StackTraceElement |
| StackTraceBean bean = MAPPER.readValue(aposToQuotes("{'Location':'foobar'}"), |
| StackTraceBean.class); |
| assertNotNull(bean); |
| assertNotNull(bean.location); |
| assertEquals(StackTraceBean.NUM, bean.location.getLineNumber()); |
| |
| // and then directly, iff registered |
| ObjectMapper mapper = new ObjectMapper(); |
| SimpleModule module = new SimpleModule(); |
| module.addDeserializer(StackTraceElement.class, new MyStackTraceElementDeserializer()); |
| mapper.registerModule(module); |
| |
| StackTraceElement elem = mapper.readValue("123", StackTraceElement.class); |
| assertNotNull(elem); |
| assertEquals(StackTraceBean.NUM, elem.getLineNumber()); |
| |
| // and finally, even as part of real exception |
| |
| IOException ioe = mapper.readValue(aposToQuotes("{'stackTrace':[ 123, 456 ]}"), |
| IOException.class); |
| assertNotNull(ioe); |
| StackTraceElement[] traces = ioe.getStackTrace(); |
| assertNotNull(traces); |
| assertEquals(2, traces.length); |
| assertEquals(StackTraceBean.NUM, traces[0].getLineNumber()); |
| assertEquals(StackTraceBean.NUM, traces[1].getLineNumber()); |
| } |
| |
| /* |
| /********************************************************** |
| /* Single-array handling tests |
| /********************************************************** |
| */ |
| |
| // [Issue#381] |
| public void testSingleElementArray() throws Exception { |
| final int intTest = 932832; |
| final double doubleTest = 32.3234; |
| final long longTest = 2374237428374293423L; |
| final short shortTest = (short) intTest; |
| final float floatTest = 84.3743f; |
| final byte byteTest = (byte) 43; |
| final char charTest = 'c'; |
| |
| final ObjectMapper mapper = new ObjectMapper(); |
| mapper.enable(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS); |
| |
| final int intValue = mapper.readValue(asArray(intTest), Integer.TYPE); |
| assertEquals(intTest, intValue); |
| final Integer integerWrapperValue = mapper.readValue(asArray(Integer.valueOf(intTest)), Integer.class); |
| assertEquals(Integer.valueOf(intTest), integerWrapperValue); |
| |
| final double doubleValue = mapper.readValue(asArray(doubleTest), Double.class); |
| assertEquals(doubleTest, doubleValue); |
| final Double doubleWrapperValue = mapper.readValue(asArray(Double.valueOf(doubleTest)), Double.class); |
| assertEquals(Double.valueOf(doubleTest), doubleWrapperValue); |
| |
| final long longValue = mapper.readValue(asArray(longTest), Long.TYPE); |
| assertEquals(longTest, longValue); |
| final Long longWrapperValue = mapper.readValue(asArray(Long.valueOf(longTest)), Long.class); |
| assertEquals(Long.valueOf(longTest), longWrapperValue); |
| |
| final short shortValue = mapper.readValue(asArray(shortTest), Short.TYPE); |
| assertEquals(shortTest, shortValue); |
| final Short shortWrapperValue = mapper.readValue(asArray(Short.valueOf(shortTest)), Short.class); |
| assertEquals(Short.valueOf(shortTest), shortWrapperValue); |
| |
| final float floatValue = mapper.readValue(asArray(floatTest), Float.TYPE); |
| assertEquals(floatTest, floatValue); |
| final Float floatWrapperValue = mapper.readValue(asArray(Float.valueOf(floatTest)), Float.class); |
| assertEquals(Float.valueOf(floatTest), floatWrapperValue); |
| |
| final byte byteValue = mapper.readValue(asArray(byteTest), Byte.TYPE); |
| assertEquals(byteTest, byteValue); |
| final Byte byteWrapperValue = mapper.readValue(asArray(Byte.valueOf(byteTest)), Byte.class); |
| assertEquals(Byte.valueOf(byteTest), byteWrapperValue); |
| |
| final char charValue = mapper.readValue(asArray(quote(String.valueOf(charTest))), Character.TYPE); |
| assertEquals(charTest, charValue); |
| final Character charWrapperValue = mapper.readValue(asArray(quote(String.valueOf(charTest))), Character.class); |
| assertEquals(Character.valueOf(charTest), charWrapperValue); |
| |
| final boolean booleanTrueValue = mapper.readValue(asArray(true), Boolean.TYPE); |
| assertTrue(booleanTrueValue); |
| |
| final boolean booleanFalseValue = mapper.readValue(asArray(false), Boolean.TYPE); |
| assertFalse(booleanFalseValue); |
| |
| final Boolean booleanWrapperTrueValue = mapper.readValue(asArray(Boolean.valueOf(true)), Boolean.class); |
| assertEquals(Boolean.TRUE, booleanWrapperTrueValue); |
| } |
| |
| private static String asArray(Object value) { |
| final String stringVal = value.toString(); |
| return new StringBuilder(stringVal.length() + 2).append("[").append(stringVal).append("]").toString(); |
| } |
| |
| public void testSingleElementArrayException() throws Exception { |
| final ObjectMapper mapper = new ObjectMapper(); |
| mapper.disable(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS); |
| try { |
| mapper.readValue("[42]", Integer.class); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| try { |
| mapper.readValue("[42]", Integer.TYPE); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| |
| try { |
| mapper.readValue("[42.273]", Double.class); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| try { |
| mapper.readValue("[42.2723]", Double.TYPE); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| |
| try { |
| mapper.readValue("[42342342342342]", Long.class); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| try { |
| mapper.readValue("[42342342342342342]", Long.TYPE); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| |
| try { |
| mapper.readValue("[42]", Short.class); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| try { |
| mapper.readValue("[42]", Short.TYPE); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| |
| try { |
| mapper.readValue("[327.2323]", Float.class); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| try { |
| mapper.readValue("[82.81902]", Float.TYPE); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| |
| try { |
| mapper.readValue("[22]", Byte.class); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| try { |
| mapper.readValue("[22]", Byte.TYPE); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| |
| try { |
| mapper.readValue("['d']", Character.class); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| try { |
| mapper.readValue("['d']", Character.TYPE); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| |
| try { |
| mapper.readValue("[true]", Boolean.class); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| try { |
| mapper.readValue("[true]", Boolean.TYPE); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| } |
| |
| public void testMultiValueArrayException() throws IOException { |
| final ObjectMapper mapper = new ObjectMapper(); |
| mapper.enable(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS); |
| |
| try { |
| mapper.readValue("[42,42]", Integer.class); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| try { |
| mapper.readValue("[42,42]", Integer.TYPE); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| |
| try { |
| mapper.readValue("[42.273,42.273]", Double.class); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| try { |
| mapper.readValue("[42.2723,42.273]", Double.TYPE); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| |
| try { |
| mapper.readValue("[42342342342342,42342342342342]", Long.class); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| try { |
| mapper.readValue("[42342342342342342,42342342342342]", Long.TYPE); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| |
| try { |
| mapper.readValue("[42,42]", Short.class); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| try { |
| mapper.readValue("[42,42]", Short.TYPE); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| |
| try { |
| mapper.readValue("[327.2323,327.2323]", Float.class); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| try { |
| mapper.readValue("[82.81902,327.2323]", Float.TYPE); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| |
| try { |
| mapper.readValue("[22,23]", Byte.class); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| try { |
| mapper.readValue("[22,23]", Byte.TYPE); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| |
| try { |
| mapper.readValue(asArray(quote("c") + "," + quote("d")), Character.class); |
| |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| try { |
| mapper.readValue(asArray(quote("c") + "," + quote("d")), Character.TYPE); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| |
| try { |
| mapper.readValue("[true,false]", Boolean.class); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| try { |
| mapper.readValue("[true,false]", Boolean.TYPE); |
| fail("Single value array didn't throw an exception when DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS is disabled"); |
| } catch (JsonMappingException exp) { |
| //Exception was thrown correctly |
| } |
| } |
| } |