package com.fasterxml.jackson.databind.ser;
import java.io.*;
import java.util.*;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.annotation.*;
import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;
/**
* Unit tests for checking whether JsonSerializerFactory.Feature
* configuration works
*/
public class TestFeatures
extends BaseMapTest
{
/*
/**********************************************************
/* Helper classes
/**********************************************************
*/
/**
* Class with one explicitly defined getter, one name-based
* auto-detectable getter.
*/
static class GetterClass
{
@JsonProperty("x") public int getX() { return -2; }
public int getY() { return 1; }
}
/**
* Another test-class that explicitly disables auto-detection
*/
@JsonAutoDetect(getterVisibility=Visibility.NONE)
static class DisabledGetterClass
{
@JsonProperty("x") public int getX() { return -2; }
public int getY() { return 1; }
}
/**
* Another test-class that explicitly enables auto-detection
*/
@JsonAutoDetect(isGetterVisibility=Visibility.NONE)
static class EnabledGetterClass
{
@JsonProperty("x") public int getX() { return -2; }
public int getY() { return 1; }
// not auto-detected, since "is getter" auto-detect disabled
public boolean isOk() { return true; }
}
/**
* One more: only detect "isXxx", not "getXXX"
*/
@JsonAutoDetect(getterVisibility=Visibility.NONE)
static class EnabledIsGetterClass
{
// Won't be auto-detected any more
public int getY() { return 1; }
// but this will be
public boolean isOk() { return true; }
}
static class CloseableBean implements Closeable
{
public int a = 3;
protected boolean wasClosed = false;
@Override
public void close() throws IOException {
wasClosed = true;
}
}
private static class StringListBean {
@SuppressWarnings("unused")
public Collection<String> values;
public StringListBean(Collection<String> v) { values = v; }
}
/*
/**********************************************************
/* Test methods
/**********************************************************
*/
public void testGlobalAutoDetection() throws IOException
{
// First: auto-detection enabled (default):
ObjectMapper m = new ObjectMapper();
Map<String,Object> result = writeAndMap(m, new GetterClass());
assertEquals(2, result.size());
assertEquals(Integer.valueOf(-2), result.get("x"));
assertEquals(Integer.valueOf(1), result.get("y"));
// Then auto-detection disabled. But note: we MUST create a new
// mapper, since old version of serializer may be cached by now
m = new ObjectMapper();
m.configure(MapperFeature.AUTO_DETECT_GETTERS, false);
result = writeAndMap(m, new GetterClass());
assertEquals(1, result.size());
assertTrue(result.containsKey("x"));
}
public void testPerClassAutoDetection() throws IOException
{
// First: class-level auto-detection disabling
ObjectMapper m = new ObjectMapper();
Map<String,Object> result = writeAndMap(m, new DisabledGetterClass());
assertEquals(1, result.size());
assertTrue(result.containsKey("x"));
// And then class-level auto-detection enabling, should override defaults
m.configure(MapperFeature.AUTO_DETECT_GETTERS, false);
result = writeAndMap(m, new EnabledGetterClass());
assertEquals(2, result.size());
assertTrue(result.containsKey("x"));
assertTrue(result.containsKey("y"));
}
public void testPerClassAutoDetectionForIsGetter() throws IOException
{
ObjectMapper m = new ObjectMapper();
// class level should override
m.configure(MapperFeature.AUTO_DETECT_GETTERS, true);
m.configure(MapperFeature.AUTO_DETECT_IS_GETTERS, false);
Map<String,Object> result = writeAndMap(m, new EnabledIsGetterClass());
assertEquals(1, result.size());
assertTrue(result.containsKey("ok"));
assertEquals(Boolean.TRUE, result.get("ok"));
}
// Simple test verifying that chainable methods work ok...
public void testConfigChainability()
{
ObjectMapper m = new ObjectMapper();
assertTrue(m.isEnabled(MapperFeature.AUTO_DETECT_SETTERS));
assertTrue(m.isEnabled(MapperFeature.AUTO_DETECT_GETTERS));
m.configure(MapperFeature.AUTO_DETECT_SETTERS, false)
.configure(MapperFeature.AUTO_DETECT_GETTERS, false);
assertFalse(m.isEnabled(MapperFeature.AUTO_DETECT_SETTERS));
assertFalse(m.isEnabled(MapperFeature.AUTO_DETECT_GETTERS));
}
// Test for [JACKSON-282]
@SuppressWarnings("resource")
public void testCloseCloseable() throws IOException
{
ObjectMapper m = new ObjectMapper();
// default should be disabled:
CloseableBean bean = new CloseableBean();
m.writeValueAsString(bean);
assertFalse(bean.wasClosed);
// but can enable it:
m.configure(SerializationFeature.CLOSE_CLOSEABLE, true);
bean = new CloseableBean();
m.writeValueAsString(bean);
assertTrue(bean.wasClosed);
// also: let's ensure that ObjectWriter won't interfere with it
bean = new CloseableBean();
m.writerWithType(CloseableBean.class).writeValueAsString(bean);
assertTrue(bean.wasClosed);
}
// Test for [JACKSON-289]
public void testCharArrays() throws IOException
{
char[] chars = new char[] { 'a','b','c' };
ObjectMapper m = new ObjectMapper();
// default: serialize as Strings
assertEquals(quote("abc"), m.writeValueAsString(chars));
// new feature: serialize as JSON array:
m.configure(SerializationFeature.WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS, true);
assertEquals("[\"a\",\"b\",\"c\"]", m.writeValueAsString(chars));
}
// Test for [JACKSON-401]
public void testFlushingAutomatic() throws IOException
{
ObjectMapper mapper = new ObjectMapper();
assertTrue(mapper.getSerializationConfig().isEnabled(SerializationFeature.FLUSH_AFTER_WRITE_VALUE));
// default is to flush after writeValue()
StringWriter sw = new StringWriter();
JsonGenerator jgen = mapper.getFactory().createGenerator(sw);
mapper.writeValue(jgen, Integer.valueOf(13));
assertEquals("13", sw.toString());
jgen.close();
// ditto with ObjectWriter
sw = new StringWriter();
jgen = mapper.getFactory().createGenerator(sw);
ObjectWriter ow = mapper.writer();
ow.writeValue(jgen, Integer.valueOf(99));
assertEquals("99", sw.toString());
jgen.close();
}
// Test for [JACKSON-401]
public void testFlushingNotAutomatic() throws IOException
{
// but should not occur if configured otherwise
ObjectMapper mapper = new ObjectMapper();
mapper.configure(SerializationFeature.FLUSH_AFTER_WRITE_VALUE, false);
StringWriter sw = new StringWriter();
JsonGenerator jgen = mapper.getFactory().createGenerator(sw);
mapper.writeValue(jgen, Integer.valueOf(13));
// no flushing now:
assertEquals("", sw.toString());
// except when actually flushing
jgen.flush();
assertEquals("13", sw.toString());
jgen.close();
// Also, same should happen with ObjectWriter
sw = new StringWriter();
jgen = mapper.getFactory().createGenerator(sw);
ObjectWriter ow = mapper.writer();
ow.writeValue(jgen, Integer.valueOf(99));
assertEquals("", sw.toString());
// except when actually flushing
jgen.flush();
assertEquals("99", sw.toString());
jgen.close();
}
// Test for [JACKSON-805]
public void testSingleElementCollections() throws IOException
{
final ObjectWriter writer = objectWriter().with(SerializationFeature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED);
// Lists:
ArrayList<String> strs = new ArrayList<String>();
strs.add("xyz");
assertEquals(quote("xyz"), writer.writeValueAsString(strs));
ArrayList<Integer> ints = new ArrayList<Integer>();
ints.add(13);
assertEquals("13", writer.writeValueAsString(ints));
// other Collections, like Sets:
HashSet<Long> longs = new HashSet<Long>();
longs.add(42L);
assertEquals("42", writer.writeValueAsString(longs));
// [Issue#180]
final String EXP_STRINGS = "{\"values\":\"foo\"}";
assertEquals(EXP_STRINGS, writer.writeValueAsString(new StringListBean(Collections.singletonList("foo"))));
final Set<String> SET = new HashSet<String>();
SET.add("foo");
assertEquals(EXP_STRINGS, writer.writeValueAsString(new StringListBean(SET)));
// arrays:
assertEquals("true", writer.writeValueAsString(new boolean[] { true }));
assertEquals("true", writer.writeValueAsString(new Boolean[] { Boolean.TRUE }));
assertEquals("3", writer.writeValueAsString(new int[] { 3 }));
assertEquals(quote("foo"), writer.writeValueAsString(new String[] { "foo" }));
}
}