| 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.exc.InvalidFormatException; |
| 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.readerFor(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 testUUIDInvalid() throws Exception |
| { |
| // and finally, exception handling too [databind#1000], for invalid cases |
| try { |
| MAPPER.readValue(quote("abcde"), UUID.class); |
| fail("Should fail on invalid UUID string"); |
| } catch (InvalidFormatException e) { |
| verifyException(e, "UUID has to be represented by standard"); |
| } |
| try { |
| MAPPER.readValue(quote("76e6d183-5f68-4afa-b94a-922c1fdb83fx"), UUID.class); |
| fail("Should fail on invalid UUID string"); |
| } catch (InvalidFormatException e) { |
| verifyException(e, "non-hex character 'x'"); |
| } |
| // should also test from-bytes version, but that's trickier... leave for now. |
| } |
| |
| 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(); |
| } |
| } |
| |