/** 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); }