public void testAnnotationIntrospectorCopyin() {
ObjectMapper m = new ObjectMapper();
m.setAnnotationIntrospector(new MyAnnotationIntrospector());
assertEquals(
MyAnnotationIntrospector.class,
m.getDeserializationConfig().getAnnotationIntrospector().getClass());
ObjectMapper m2 = m.copy();
assertEquals(
MyAnnotationIntrospector.class,
m2.getDeserializationConfig().getAnnotationIntrospector().getClass());
assertEquals(
MyAnnotationIntrospector.class,
m2.getSerializationConfig().getAnnotationIntrospector().getClass());
}
// [Issue#28]: ObjectMapper.copy()
public void testCopy() throws Exception {
ObjectMapper m = new ObjectMapper();
assertTrue(m.isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES));
m.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
assertFalse(m.isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES));
InjectableValues inj = new InjectableValues.Std();
m.setInjectableValues(inj);
assertFalse(m.isEnabled(JsonParser.Feature.ALLOW_COMMENTS));
m.enable(JsonParser.Feature.ALLOW_COMMENTS);
assertTrue(m.isEnabled(JsonParser.Feature.ALLOW_COMMENTS));
// // First: verify that handling of features is decoupled:
ObjectMapper m2 = m.copy();
assertFalse(m2.isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES));
m2.enable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
assertTrue(m2.isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES));
assertSame(inj, m2.getInjectableValues());
// but should NOT change the original
assertFalse(m.isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES));
// nor vice versa:
assertFalse(m.isEnabled(DeserializationFeature.UNWRAP_ROOT_VALUE));
assertFalse(m2.isEnabled(DeserializationFeature.UNWRAP_ROOT_VALUE));
m.enable(DeserializationFeature.UNWRAP_ROOT_VALUE);
assertTrue(m.isEnabled(DeserializationFeature.UNWRAP_ROOT_VALUE));
assertFalse(m2.isEnabled(DeserializationFeature.UNWRAP_ROOT_VALUE));
// // Also, underlying JsonFactory instances should be distinct
assertNotSame(m.getFactory(), m2.getFactory());
// [Issue#122]: Need to ensure mix-ins are not shared
assertEquals(0, m.getSerializationConfig().mixInCount());
assertEquals(0, m2.getSerializationConfig().mixInCount());
assertEquals(0, m.getDeserializationConfig().mixInCount());
assertEquals(0, m2.getDeserializationConfig().mixInCount());
m.addMixIn(String.class, Integer.class);
assertEquals(1, m.getSerializationConfig().mixInCount());
assertEquals(0, m2.getSerializationConfig().mixInCount());
assertEquals(1, m.getDeserializationConfig().mixInCount());
assertEquals(0, m2.getDeserializationConfig().mixInCount());
// [Issue#913]: Ensure JsonFactory Features copied
assertTrue(m2.isEnabled(JsonParser.Feature.ALLOW_COMMENTS));
}
// [#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);
}
// [#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);
}
// 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);
}
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");
}
// Test to ensure that we can check property ordering defaults...
public void testConfigForPropertySorting() throws Exception {
ObjectMapper m = new ObjectMapper();
// sort-alphabetically is disabled by default:
assertFalse(m.isEnabled(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY));
SerializationConfig sc = m.getSerializationConfig();
assertFalse(sc.isEnabled(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY));
assertFalse(sc.shouldSortPropertiesAlphabetically());
DeserializationConfig dc = m.getDeserializationConfig();
assertFalse(dc.shouldSortPropertiesAlphabetically());
// but when enabled, should be visible:
m.enable(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY);
sc = m.getSerializationConfig();
assertTrue(sc.isEnabled(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY));
assertTrue(sc.shouldSortPropertiesAlphabetically());
dc = m.getDeserializationConfig();
// and not just via SerializationConfig, but also via DeserializationConfig
assertTrue(dc.isEnabled(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY));
assertTrue(dc.shouldSortPropertiesAlphabetically());
}
@Test
public void testBooleanSetters() {
this.factory.setAutoDetectFields(false);
this.factory.setAutoDetectGettersSetters(false);
this.factory.setFailOnEmptyBeans(false);
this.factory.setIndentOutput(true);
this.factory.afterPropertiesSet();
ObjectMapper objectMapper = this.factory.getObject();
assertFalse(objectMapper.getSerializationConfig().isEnabled(MapperFeature.AUTO_DETECT_FIELDS));
assertFalse(
objectMapper.getDeserializationConfig().isEnabled(MapperFeature.AUTO_DETECT_FIELDS));
assertFalse(objectMapper.getSerializationConfig().isEnabled(MapperFeature.AUTO_DETECT_GETTERS));
assertFalse(
objectMapper.getDeserializationConfig().isEnabled(MapperFeature.AUTO_DETECT_SETTERS));
assertFalse(
objectMapper.getSerializationConfig().isEnabled(SerializationFeature.FAIL_ON_EMPTY_BEANS));
assertTrue(objectMapper.getSerializationConfig().isEnabled(SerializationFeature.INDENT_OUTPUT));
assertTrue(
objectMapper.getSerializationConfig().getSerializationInclusion()
== JsonInclude.Include.ALWAYS);
}
public JacksonJaxbJsonProvider buildJacksonJaxbJsonProvider() {
ObjectMapper mapper = new ObjectMapper();
// mapper.enable(SerializationFeature.INDENT_OUTPUT);
AnnotationIntrospector pair =
AnnotationIntrospector.pair(
new PrioritizeJSONPropertyJaxbAnnotationIntrospector(),
new JacksonAnnotationIntrospector());
mapper.getDeserializationConfig().with(pair);
mapper.getSerializationConfig().with(pair);
mapper.setAnnotationIntrospectors(pair, pair);
// create JsonProvider to provide custom ObjectMapper
ResteasyJackson2Provider provider = new ResteasyJackson2Provider();
provider.setMapper(mapper);
return provider;
}
@Override
public String nameForDeserialization(final BeanPropertyDefinition beanProperty) {
DeserializationConfig deserializationConfig = objectMapper.getDeserializationConfig();
Optional<PropertyNamingStrategy> namingStrategy =
Optional.fromNullable(deserializationConfig.getPropertyNamingStrategy());
String newName =
namingStrategy
.transform(overTheWireName(beanProperty, deserializationConfig))
.or(beanProperty.getName());
LOG.debug("Name '{}' renamed to '{}'", beanProperty.getName(), newName);
return newName;
}
public void testCustomPoolResolver() throws Exception {
Map<Object, WithCustomResolution> pool = new HashMap<Object, WithCustomResolution>();
pool.put(1, new WithCustomResolution(1, 1));
pool.put(2, new WithCustomResolution(2, 2));
pool.put(3, new WithCustomResolution(3, 3));
pool.put(4, new WithCustomResolution(4, 4));
pool.put(5, new WithCustomResolution(5, 5));
ContextAttributes attrs =
mapper.getDeserializationConfig().getAttributes().withSharedAttribute(POOL_KEY, pool);
String content = "{\"data\":[1,2,3,4,5]}";
CustomResolutionWrapper wrapper =
mapper.reader(CustomResolutionWrapper.class).with(attrs).readValue(content);
assertFalse(wrapper.data.isEmpty());
for (WithCustomResolution ob : wrapper.data) {
assertSame(pool.get(ob.id), ob);
}
}
@Test
public void testBasicParse() throws IOException {
ObjectMapper mapper = new XmlMapper();
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
AnnotationIntrospector introspector = new JacksonXmlAnnotationIntrospector();
mapper.getDeserializationConfig().withAppendedAnnotationIntrospector(introspector);
CheckstyleWarning expected =
expectedWarning(EXPECTED_PATH, 27, "First sentence should end with a period.", "warning");
try (InputStreamReader inputStreamReader =
new InputStreamReader(
CheckstyleWarningGeneratorTest.class.getResourceAsStream("/checkstyle-result.xml"))) {
CheckStyleReport report = mapper.readValue(inputStreamReader, CheckStyleReport.class);
Set<CheckstyleWarning> warnings = checkstyleWarningGenerator.generateWarnings(commit, report);
assertThat(warnings, contains(expected));
}
}
public static ObjectMapper setupInjectablesInObjectMapper(ObjectMapper objectMapper) {
objectMapper.registerModule(
new SimpleModule("testModule").registerSubtypes(LocalLoadSpec.class));
final GuiceAnnotationIntrospector guiceIntrospector = new GuiceAnnotationIntrospector();
objectMapper.setAnnotationIntrospectors(
new AnnotationIntrospectorPair(
guiceIntrospector, objectMapper.getSerializationConfig().getAnnotationIntrospector()),
new AnnotationIntrospectorPair(
guiceIntrospector,
objectMapper.getDeserializationConfig().getAnnotationIntrospector()));
objectMapper.setInjectableValues(
new GuiceInjectableValues(
GuiceInjectors.makeStartupInjectorWithModules(
ImmutableList.of(
new Module() {
@Override
public void configure(Binder binder) {
binder.bind(LocalDataSegmentPuller.class);
}
}))));
return objectMapper;
}
@Test
public void testCompleteSetup() {
NopAnnotationIntrospector annotationIntrospector = NopAnnotationIntrospector.instance;
ObjectMapper objectMapper = new ObjectMapper();
assertTrue(this.factory.isSingleton());
assertEquals(ObjectMapper.class, this.factory.getObjectType());
Map<Class<?>, JsonDeserializer<?>> deserializers = new HashMap<Class<?>, JsonDeserializer<?>>();
deserializers.put(Date.class, new DateDeserializer());
factory.setObjectMapper(objectMapper);
JsonSerializer serializer1 = new ClassSerializer();
JsonSerializer serializer2 = new NumberSerializer();
factory.setSerializers(serializer1);
factory.setSerializersByType(
Collections.<Class<?>, JsonSerializer<?>>singletonMap(Boolean.class, serializer2));
factory.setDeserializersByType(deserializers);
factory.setAnnotationIntrospector(annotationIntrospector);
this.factory.setFeaturesToEnable(
SerializationFeature.FAIL_ON_EMPTY_BEANS,
DeserializationFeature.UNWRAP_ROOT_VALUE,
JsonParser.Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER,
JsonGenerator.Feature.WRITE_NUMBERS_AS_STRINGS);
this.factory.setFeaturesToDisable(
MapperFeature.AUTO_DETECT_GETTERS,
MapperFeature.AUTO_DETECT_FIELDS,
JsonParser.Feature.AUTO_CLOSE_SOURCE,
JsonGenerator.Feature.QUOTE_FIELD_NAMES);
assertFalse(getSerializerFactoryConfig(objectMapper).hasSerializers());
assertFalse(getDeserializerFactoryConfig(objectMapper).hasDeserializers());
this.factory.setSerializationInclusion(JsonInclude.Include.NON_NULL);
this.factory.afterPropertiesSet();
assertTrue(objectMapper == this.factory.getObject());
assertTrue(getSerializerFactoryConfig(objectMapper).hasSerializers());
assertTrue(getDeserializerFactoryConfig(objectMapper).hasDeserializers());
Serializers serializers =
getSerializerFactoryConfig(objectMapper).serializers().iterator().next();
assertTrue(
serializers.findSerializer(null, SimpleType.construct(Class.class), null) == serializer1);
assertTrue(
serializers.findSerializer(null, SimpleType.construct(Boolean.class), null) == serializer2);
assertNull(serializers.findSerializer(null, SimpleType.construct(Number.class), null));
assertTrue(
annotationIntrospector
== objectMapper.getSerializationConfig().getAnnotationIntrospector());
assertTrue(
annotationIntrospector
== objectMapper.getDeserializationConfig().getAnnotationIntrospector());
assertTrue(
objectMapper.getSerializationConfig().isEnabled(SerializationFeature.FAIL_ON_EMPTY_BEANS));
assertTrue(
objectMapper
.getDeserializationConfig()
.isEnabled(DeserializationFeature.UNWRAP_ROOT_VALUE));
assertTrue(
objectMapper
.getFactory()
.isEnabled(JsonParser.Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER));
assertTrue(objectMapper.getFactory().isEnabled(JsonGenerator.Feature.WRITE_NUMBERS_AS_STRINGS));
assertFalse(objectMapper.getSerializationConfig().isEnabled(MapperFeature.AUTO_DETECT_GETTERS));
assertFalse(
objectMapper.getDeserializationConfig().isEnabled(MapperFeature.AUTO_DETECT_FIELDS));
assertFalse(objectMapper.getFactory().isEnabled(JsonParser.Feature.AUTO_CLOSE_SOURCE));
assertFalse(objectMapper.getFactory().isEnabled(JsonGenerator.Feature.QUOTE_FIELD_NAMES));
assertTrue(
objectMapper.getSerializationConfig().getSerializationInclusion()
== JsonInclude.Include.NON_NULL);
}
