/** Unit test to check for regression of [JACKSON-18]. */
public void testSmallNumbers() throws Exception {
ObjectMapper mapper = new ObjectMapper();
ArrayNode root = mapper.createArrayNode();
for (int i = -20; i <= 20; ++i) {
JsonNode n = root.numberNode(i);
root.add(n);
// Hmmh. Not sure why toString() won't be triggered otherwise...
assertEquals(String.valueOf(i), n.toString());
}
// Loop over 2 different serialization methods
for (int type = 0; type < 2; ++type) {
StringWriter sw = new StringWriter();
if (type == 0) {
JsonGenerator gen = new JsonFactory().createGenerator(sw);
root.serialize(gen, null);
gen.close();
} else {
mapper.writeValue(sw, root);
}
String doc = sw.toString();
JsonParser p = new JsonFactory().createParser(new StringReader(doc));
assertEquals(JsonToken.START_ARRAY, p.nextToken());
for (int i = -20; i <= 20; ++i) {
assertEquals(JsonToken.VALUE_NUMBER_INT, p.nextToken());
assertEquals(i, p.getIntValue());
assertEquals("" + i, p.getText());
}
assertEquals(JsonToken.END_ARRAY, p.nextToken());
p.close();
}
}
public void testFromMap() throws Exception {
ObjectMapper mapper = new ObjectMapper();
ObjectNode root = mapper.createObjectNode();
root.put(FIELD4, TEXT2);
root.put(FIELD3, -1);
root.putArray(FIELD2);
root.put(FIELD1, DOUBLE_VALUE);
/* Let's serialize using one of two alternate methods:
* first preferred (using generator)
* (there are 2 variants here too)
*/
for (int i = 0; i < 2; ++i) {
StringWriter sw = new StringWriter();
if (i == 0) {
JsonGenerator gen = new JsonFactory().createGenerator(sw);
root.serialize(gen, null);
gen.close();
} else {
mapper.writeValue(sw, root);
}
verifyFromMap(sw.toString());
}
// And then convenient but less efficient alternative:
verifyFromMap(root.toString());
}
// [JACKSON-212]
public void testToStringEnumWithEnumMap() throws Exception {
ObjectMapper m = new ObjectMapper();
m.configure(SerializationFeature.WRITE_ENUMS_USING_TO_STRING, true);
EnumMap<LowerCaseEnum, String> enums = new EnumMap<LowerCaseEnum, String>(LowerCaseEnum.class);
enums.put(LowerCaseEnum.C, "value");
assertEquals("{\"c\":\"value\"}", m.writeValueAsString(enums));
}
public void testFromArray() throws Exception {
ObjectMapper mapper = new ObjectMapper();
ArrayNode root = mapper.createArrayNode();
root.add(TEXT1);
root.add(3);
ObjectNode obj = root.addObject();
obj.put(FIELD1, true);
obj.putArray(FIELD2);
root.add(false);
/* Ok, ready... let's serialize using one of two alternate
* methods: first preferred (using generator)
* (there are 2 variants here too)
*/
for (int i = 0; i < 2; ++i) {
StringWriter sw = new StringWriter();
if (i == 0) {
JsonGenerator gen = new JsonFactory().createGenerator(sw);
root.serialize(gen, null);
gen.close();
} else {
mapper.writeValue(sw, root);
}
verifyFromArray(sw.toString());
}
// And then convenient but less efficient alternative:
verifyFromArray(root.toString());
}
protected void initObjectMapper() {
ObjectMapper mapper = new ObjectMapper();
DeserializationConfig config = mapper.copyDeserializationConfig();
config.disable(Feature.FAIL_ON_UNKNOWN_PROPERTIES);
mapper.setDeserializationConfig(config);
context.setMapper(mapper);
}
// [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);
}
// [JACKSON-597]
public void testClass() throws IOException {
ObjectMapper mapper = new ObjectMapper();
assertEquals(quote("java.lang.String"), mapper.writeValueAsString(String.class));
assertEquals(quote("int"), mapper.writeValueAsString(Integer.TYPE));
assertEquals(quote("boolean"), mapper.writeValueAsString(Boolean.TYPE));
assertEquals(quote("void"), mapper.writeValueAsString(Void.TYPE));
}
// [#438]: Support @JsonProperty.index
public void testPropertyIndex() throws Exception {
BeanDescription beanDesc =
mapper.getDeserializationConfig().introspect(mapper.constructType(PropDescBean.class));
_verifyProperty(beanDesc, false, true);
beanDesc = mapper.getSerializationConfig().introspect(mapper.constructType(PropDescBean.class));
_verifyProperty(beanDesc, false, true);
}
public void testJackson744() throws Exception {
BeanDescription beanDesc =
mapper.getDeserializationConfig().introspect(mapper.constructType(Issue744Bean.class));
assertNotNull(beanDesc);
AnnotatedMethod setter = beanDesc.findAnySetter();
assertNotNull(setter);
}
// Update and return given train line with the Jackson parser
// AG
public static <T> TrainLine updateLine(T address, TrainLine line) {
try {
Object trainData = new Object();
if (address instanceof URL) {
// Get train data from web
trainData = mapper.readValue((URL) address, Object.class);
} else if (address instanceof File) {
// Get train data locally
trainData = mapper.readValue((File) address, Object.class);
}
// System.out.println(trainData.toString());
// Go inside the wrapper
Object tripListObj = getFromMap(trainData, TRIP_LIST_KEY);
line = new TrainLine(tripListObj);
} catch (JsonParseException e) {
e.printStackTrace();
} catch (JsonMappingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return line;
}
protected EndpointConfig initWriter(ObjectMapper mapper) {
// first common config
if (_activeView != null) {
_writer = mapper.writerWithView(_activeView);
} else {
_writer = mapper.writer();
}
if (_rootName != null) {
_writer = _writer.withRootName(_rootName);
}
// Then features
if (_serEnable != null) {
_writer = _writer.withFeatures(_serEnable);
}
if (_serDisable != null) {
_writer = _writer.withoutFeatures(_serDisable);
}
// then others
// Finally: couple of features we always set
/* Important: we are NOT to close the underlying stream after
* mapping, so we need to instruct parser:
*/
_writer.getJsonFactory().disable(JsonGenerator.Feature.AUTO_CLOSE_TARGET);
return this;
}
protected EndpointConfig initReader(ObjectMapper mapper) {
// first common config
if (_activeView != null) {
_reader = mapper.readerWithView(_activeView);
} else {
_reader = mapper.reader();
}
if (_rootName != null) {
_reader = _reader.withRootName(_rootName);
}
// Then deser features
if (_deserEnable != null) {
_reader = _reader.withFeatures(_deserEnable);
}
if (_deserDisable != null) {
_reader = _reader.withoutFeatures(_deserDisable);
}
/* Important: we are NOT to close the underlying stream after
* mapping, so we need to instruct parser:
*/
_reader.getJsonFactory().disable(JsonParser.Feature.AUTO_CLOSE_SOURCE);
return this;
}
public void testGlobalVisibilityForGetters() {
ObjectMapper m = new ObjectMapper();
m.configure(MapperFeature.AUTO_DETECT_GETTERS, false);
POJOPropertiesCollector coll = collector(m, SimpleGetterVisibility.class, true);
// should be 1, expect that we disabled getter auto-detection, so
Map<String, POJOPropertyBuilder> props = coll.getPropertyMap();
assertEquals(0, props.size());
}
// [Issue#227]
public void testGenericEnumSerializer() throws Exception {
// By default, serialize using name
ObjectMapper m = new ObjectMapper();
SimpleModule module = new SimpleModule("foobar");
module.addSerializer(Enum.class, new LowerCasingEnumSerializer());
m.registerModule(module);
assertEquals(quote("b"), m.writeValueAsString(TestEnum.B));
}
public void testForJackson288() throws Exception {
final long TIMESTAMP = 12345678L;
ObjectMapper mapper = getJaxbMapper();
Bean288 bean = mapper.readValue("{\"date\":" + TIMESTAMP + "}", Bean288.class);
assertNotNull(bean);
Date d = bean.date;
assertNotNull(d);
assertEquals(TIMESTAMP, d.getTime());
}
// [#269]: Support new @JsonPropertyDescription
public void testPropertyDesc() throws Exception {
// start via deser
BeanDescription beanDesc =
mapper.getDeserializationConfig().introspect(mapper.constructType(PropDescBean.class));
_verifyProperty(beanDesc, true, false);
// and then via ser:
beanDesc = mapper.getSerializationConfig().introspect(mapper.constructType(PropDescBean.class));
_verifyProperty(beanDesc, true, false);
}
// [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 testMapError() throws Exception {
ObjectMapper mapper = new ObjectMapper();
try {
Object result = mapper.readValue("[ 1, 2 ]", new TypeReference<Map<String, String>>() {});
fail("Expected an exception, but got result value: " + result);
} catch (JsonMappingException jex) {
verifyException(jex, "START_ARRAY");
}
}
// Test for [JACKSON-554]
public void testTreeToValue() throws Exception {
String JSON = "{\"leaf\":{\"value\":13}}";
ObjectMapper mapper = new ObjectMapper();
mapper.addMixInAnnotations(Leaf.class, LeafMixIn.class);
JsonNode root = mapper.readTree(JSON);
// Ok, try converting to bean using two mechanisms
Root r1 = mapper.treeToValue(root, Root.class);
assertNotNull(r1);
assertEquals(13, r1.leaf.value);
}
// [JACKSON-684]
public void testAsIndex() throws Exception {
// By default, serialize using name
ObjectMapper m = new ObjectMapper();
assertFalse(m.isEnabled(SerializationFeature.WRITE_ENUMS_USING_INDEX));
assertEquals(quote("B"), m.writeValueAsString(TestEnum.B));
// but we can change (dynamically, too!) it to be number-based
m.enable(SerializationFeature.WRITE_ENUMS_USING_INDEX);
assertEquals("1", m.writeValueAsString(TestEnum.B));
}
// for [JACKSON-701]
public void testInnerClassWithAnnotationsInCreator() throws Exception {
BasicBeanDescription beanDesc;
// first with serialization
beanDesc = mapper.getSerializationConfig().introspect(mapper.constructType(Issue701Bean.class));
assertNotNull(beanDesc);
// then with deserialization
beanDesc =
mapper.getDeserializationConfig().introspect(mapper.constructType(Issue701Bean.class));
assertNotNull(beanDesc);
}
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());
}
// 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());
}
public void testNoCtorMap() throws Exception {
ObjectMapper mapper = new ObjectMapper();
try {
BrokenMap result = mapper.readValue("{ \"a\" : 3 }", BrokenMap.class);
// should never get here; assert added to remove compiler warning
assertNull(result);
} catch (JsonMappingException e) {
// instead, should get this exception:
verifyException(e, "no default constructor found");
}
}
/**
* Initialises the database.
*/
static {
try {
ObjectMapper om = new ObjectMapper();
om.configure( JsonParser.Feature.ALLOW_COMMENTS, true );
String jsonText = Resources.loadResourceAsString( DATABASE_NAME ); // workaround for bug #779, see http://jira.codehaus.org/browse/JACKSON-779
database = om.readTree( jsonText );
} catch ( Exception e ) {
throw new ExceptionInInitializerError( e );
}
}
public void testPolymorphicAtomicRefProperty() throws Exception {
TypeInfoAtomic data = new TypeInfoAtomic();
data.value = new AtomicReference<BaseForAtomic>(new ImplForAtomic(42));
String json = MAPPER.writeValueAsString(data);
TypeInfoAtomic result = MAPPER.readValue(json, TypeInfoAtomic.class);
assertNotNull(result);
BaseForAtomic value = result.value.get();
assertNotNull(value);
assertEquals(ImplForAtomic.class, value.getClass());
assertEquals(42, ((ImplForAtomic) value).x);
}
// [Issue#232]
public void testBigDecimalAsPlainStringTreeConversion() throws Exception {
ObjectMapper mapper = new ObjectMapper();
mapper.enable(SerializationFeature.WRITE_BIGDECIMAL_AS_PLAIN);
Map<String, Object> map = new HashMap<String, Object>();
String PI_STR = "3.00000000";
map.put("pi", new BigDecimal(PI_STR));
JsonNode tree = mapper.valueToTree(map);
assertNotNull(tree);
assertEquals(1, tree.size());
assertTrue(tree.has("pi"));
}
// [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());
}
protected POJOPropertiesCollector collector(
ObjectMapper m0, Class<?> cls, boolean forSerialization) {
BasicClassIntrospector bci = new BasicClassIntrospector();
// no real difference between serialization, deserialization, at least here
if (forSerialization) {
return bci.collectProperties(
m0.getSerializationConfig(), m0.constructType(cls), null, true, "set");
}
return bci.collectProperties(
m0.getDeserializationConfig(), m0.constructType(cls), null, false, "set");
}
// [JACKSON-726]
public void testUUIDKeyMap() throws Exception {
ObjectMapper mapper = new ObjectMapper();
UUID key = UUID.nameUUIDFromBytes("foobar".getBytes("UTF-8"));
String JSON = "{ \"" + key + "\":4}";
Map<UUID, Object> result = mapper.readValue(JSON, new TypeReference<Map<UUID, Object>>() {});
assertNotNull(result);
assertEquals(1, result.size());
Object ob = result.keySet().iterator().next();
assertNotNull(ob);
assertEquals(UUID.class, ob.getClass());
assertEquals(key, ob);
}
