Merge branch '2.15'

Author: cowtowncoder

src/test/java/tools/jackson/dataformat/xml/lists/StringListRoundtripTest.java

@@ -7,6 +7,7 @@
 import org.junit.Test;
 
 import tools.jackson.core.type.TypeReference;
+import tools.jackson.databind.ObjectMapper;
 import tools.jackson.dataformat.xml.XmlMapper;
 
 import static tools.jackson.dataformat.xml.deser.FromXmlParser.Feature.PROCESS_XSI_NIL;
@@ -18,37 +19,42 @@
 
 // [dataformat-xml#584]
 public class StringListRoundtripTest {
-	private final static XmlMapper MAPPER = new XmlMapper();
+	private final static String[] TEST_DATA = new String[] {"", "test", null, "test2"};
 
-	@Test
+	private final static XmlMapper MAPPER_READ_WRITE_NULLS = XmlMapper.builder()
+             .enable(PROCESS_XSI_NIL)
+             .enable(WRITE_NULLS_AS_XSI_NIL)
+             .build();
+     private final static XmlMapper MAPPER_READ_NULLS = XmlMapper.builder()
+             .enable(PROCESS_XSI_NIL)
+             .disable(WRITE_NULLS_AS_XSI_NIL)
+             .build();
+     private final static XmlMapper MAPPER_WRITE_NULLS = XmlMapper.builder()
+             .disable(PROCESS_XSI_NIL)
+             .enable(WRITE_NULLS_AS_XSI_NIL)
+             .build();
+
+     @Test
 	public void testStringArray() throws Exception
 	{
 		// default mode, should get back empty string
-		MAPPER.disable(WRITE_NULLS_AS_XSI_NIL);
-		MAPPER.enable(PROCESS_XSI_NIL);
-		stringArrayRoundtrip(false);
+		_stringArrayRoundtrip(MAPPER_READ_NULLS, false);
 
 		// xsi null enabled, should get back null
-		MAPPER.enable(WRITE_NULLS_AS_XSI_NIL);
-		MAPPER.enable(PROCESS_XSI_NIL);
-		stringArrayRoundtrip(true);
+		_stringArrayRoundtrip(MAPPER_READ_WRITE_NULLS, true);
 
 		// xsi null write enabled but processing disabled, should get back empty string
-		MAPPER.enable(WRITE_NULLS_AS_XSI_NIL);
-		MAPPER.disable(PROCESS_XSI_NIL);
-		stringArrayRoundtrip(false);
+		_stringArrayRoundtrip(MAPPER_WRITE_NULLS, false);
 	}
 
-	private void stringArrayRoundtrip(boolean shouldBeNull) throws Exception
+	private void _stringArrayRoundtrip(ObjectMapper mapper, boolean shouldBeNull) throws Exception
 	{
-		String[] array = new String[] {"", "test", null, "test2"};
-
 		// serialize to string
-		String xml = MAPPER.writeValueAsString(array);
+		String xml = mapper.writeValueAsString(TEST_DATA);
 		assertNotNull(xml);
 
 		// then bring it back
-		String[] result = MAPPER.readValue(xml, String[].class);
+		String[] result = mapper.readValue(xml, String[].class);
 		assertEquals(4, result.length);
 		assertEquals("", result[0]);
 		assertEquals("test", result[1]);
@@ -62,35 +68,78 @@ private void stringArrayRoundtrip(boolean shouldBeNull) throws Exception
 		assertEquals("test2", result[3]);
 	}
 
+	@Test
+	public void testStringArrayPojo() throws Exception
+	{
+		// default mode, should get back empty string
+		_stringArrayPojoRoundtrip(MAPPER_READ_NULLS, false);
+
+		// xsi null enabled, should get back null
+		_stringArrayPojoRoundtrip(MAPPER_READ_WRITE_NULLS, true);
+
+		// xsi null write enabled but processing disabled, should get back empty string
+		_stringArrayPojoRoundtrip(MAPPER_WRITE_NULLS, false);
+	}
+
+	private void _stringArrayPojoRoundtrip(ObjectMapper mapper, boolean shouldBeNull) throws Exception
+	{
+		ArrayPojo arrayPojo = new ArrayPojo();
+		arrayPojo.setArray(TEST_DATA);
+
+		// serialize to string
+		String xml = mapper.writeValueAsString(arrayPojo);
+		assertNotNull(xml);
+
+		// then bring it back
+		ArrayPojo result = mapper.readValue(xml, ArrayPojo.class);
+		assertEquals(4, result.array.length);
+		assertEquals("", result.array[0]);
+		assertEquals("test", result.array[1]);
+		if (shouldBeNull)
+		{
+			assertNull(result.array[2]);
+		} else
+		{
+			assertEquals("", result.array[2]);
+		}
+		assertEquals("test2", result.array[3]);
+	}
+
+	static class ArrayPojo {
+		String[] array;
+
+		public String[] getArray() {
+			return array;
+		}
+
+		public void setArray(String[] array) {
+			this.array = array;
+		}
+	}
+
 	@Test
 	public void testStringList() throws Exception
 	{
 		// default mode, should get back empty string
-		MAPPER.disable(WRITE_NULLS_AS_XSI_NIL);
-		MAPPER.enable(PROCESS_XSI_NIL);
-		stringListRoundtrip(false);
+		_stringListRoundtrip(MAPPER_READ_NULLS, false);
 
 		// xsi null enabled, should get back null
-		MAPPER.enable(WRITE_NULLS_AS_XSI_NIL);
-		MAPPER.enable(PROCESS_XSI_NIL);
-		stringListRoundtrip(true);
+		_stringListRoundtrip(MAPPER_READ_WRITE_NULLS, true);
 
 		// xsi null write enabled but processing disabled, should get back empty string
-		MAPPER.enable(WRITE_NULLS_AS_XSI_NIL);
-		MAPPER.disable(PROCESS_XSI_NIL);
-		stringListRoundtrip(false);
+		_stringListRoundtrip(MAPPER_WRITE_NULLS, false);
 	}
 
-	private void stringListRoundtrip(boolean shouldBeNull) throws Exception
+	private void _stringListRoundtrip(ObjectMapper mapper, boolean shouldBeNull) throws Exception
 	{
-		List<String> list = asList("", "test", null, "test2");
+		List<String> list = asList(TEST_DATA);
 
 		// serialize to string
-		String xml = MAPPER.writeValueAsString(list);
+		String xml = mapper.writeValueAsString(list);
 		assertNotNull(xml);
 
 		// then bring it back
-		List<String> result = MAPPER.readValue(xml, new TypeReference<List<String>>() {});
+		List<String> result = mapper.readValue(xml, new TypeReference<List<String>>() {});
 		assertEquals(4, result.size());
 		assertEquals("", result.get(0));
 		assertEquals("test", result.get(1));
@@ -105,25 +154,68 @@ private void stringListRoundtrip(boolean shouldBeNull) throws Exception
 	}
 
 	@Test
-	public void testStringMap() throws Exception
+	public void testStringListPojo() throws Exception
 	{
 		// default mode, should get back empty string
-		MAPPER.disable(WRITE_NULLS_AS_XSI_NIL);
-		MAPPER.enable(PROCESS_XSI_NIL);
-		stringMapRoundtrip(false);
+		_stringListPojoRoundtrip(MAPPER_READ_NULLS, false);
 
 		// xsi null enabled, should get back null
-		MAPPER.enable(WRITE_NULLS_AS_XSI_NIL);
-		MAPPER.enable(PROCESS_XSI_NIL);
-		stringMapRoundtrip(true);
+		_stringListPojoRoundtrip(MAPPER_READ_WRITE_NULLS, true);
 
 		// xsi null write enabled but processing disabled, should get back empty string
-		MAPPER.enable(WRITE_NULLS_AS_XSI_NIL);
-		MAPPER.disable(PROCESS_XSI_NIL);
-		stringMapRoundtrip(false);
+		_stringListPojoRoundtrip(MAPPER_WRITE_NULLS, false);
 	}
 
-	private void stringMapRoundtrip(boolean shouldBeNull) throws Exception
+	private void _stringListPojoRoundtrip(ObjectMapper mapper, boolean shouldBeNull) throws Exception
+	{
+		ListPojo listPojo =  new ListPojo();
+		listPojo.setList(asList(TEST_DATA));
+
+		// serialize to string
+		String xml = mapper.writeValueAsString(listPojo);
+		assertNotNull(xml);
+
+		// then bring it back
+		ListPojo result = mapper.readValue(xml, ListPojo.class);
+		assertEquals(4, result.list.size());
+		assertEquals("", result.list.get(0));
+		assertEquals("test", result.list.get(1));
+		if (shouldBeNull)
+		{
+			assertNull(result.list.get(2));
+		} else
+		{
+			assertEquals("", result.list.get(2));
+		}
+		assertEquals("test2", result.list.get(3));
+	}
+
+	static class ListPojo {
+		List<String> list;
+
+		public List<String> getList() {
+			return list;
+		}
+
+		public void setList(List<String> list) {
+			this.list = list;
+		}
+	}
+
+	@Test
+	public void testStringMapPojo() throws Exception
+	{
+		// default mode, should get back empty string
+		_stringMapPojoRoundtrip(MAPPER_READ_NULLS, false);
+
+		// xsi null enabled, should get back null
+		_stringMapPojoRoundtrip(MAPPER_READ_WRITE_NULLS, true);
+
+		// xsi null write enabled but processing disabled, should get back empty string
+		_stringMapPojoRoundtrip(MAPPER_WRITE_NULLS, false);
+	}
+
+	private void _stringMapPojoRoundtrip(ObjectMapper mapper, boolean shouldBeNull) throws Exception
 	{
 		Map<String, String> map = new HashMap<String, String>() {{
 			put("a", "");
@@ -132,14 +224,14 @@ private void stringMapRoundtrip(boolean shouldBeNull) throws Exception
 			put("d", "test2");
 		}};
 		MapPojo mapPojo = new MapPojo();
-		mapPojo.setMap( map );
+		mapPojo.setMap(map);
 
 		// serialize to string
-		String xml = MAPPER.writeValueAsString(mapPojo);
+		String xml = mapper.writeValueAsString(mapPojo);
 		assertNotNull(xml);
 
 		// then bring it back
-		MapPojo result = MAPPER.readValue(xml, MapPojo.class);
+		MapPojo result = mapper.readValue(xml, MapPojo.class);
 		assertEquals(4, result.map.size());
 		assertEquals("", result.map.get("a"));
 		assertEquals("test", result.map.get("b"));
@@ -153,11 +245,8 @@ private void stringMapRoundtrip(boolean shouldBeNull) throws Exception
 		assertEquals("test2", result.map.get("d"));
 	}
 
-	private static class MapPojo {
-		private Map<String, String> map;
-
-		public MapPojo() {
-		}
+	static class MapPojo {
+		Map<String, String> map;
 
 		public Map<String, String> getMap() {
 			return map;
@@ -167,4 +256,75 @@ public void setMap(Map<String, String> map) {
 			this.map = map;
 		}
 	}
+
+	@Test
+	public void testStringPojo() throws Exception
+	{
+		// default mode, should get back empty string
+		_stringPojoRoundtrip(MAPPER_READ_NULLS, false);
+
+		// xsi null enabled, should get back null
+
+		// 19-Mar-2023, tatu: I think this fails due to [dataformat-xml#359]:
+		//   need to comment out for now
+
+//		_stringPojoRoundtrip(MAPPER_READ_WRITE_NULLS, true);
+
+		// xsi null write enabled but processing disabled, should get back empty string
+		_stringPojoRoundtrip(MAPPER_WRITE_NULLS, false);
+	}
+
+	private void _stringPojoRoundtrip(ObjectMapper mapper, boolean shouldBeNull) throws Exception
+	{
+		StringPojo stringPojo = new StringPojo();
+		stringPojo.setNormalString("test");
+		stringPojo.setEmptyString("");
+		stringPojo.setNullString(null);
+
+		// serialize to string
+		String xml = mapper.writeValueAsString(stringPojo);
+		assertNotNull(xml);
+
+		// then bring it back
+		StringPojo result = mapper.readValue(xml, StringPojo.class);
+		assertEquals("test", result.normalString);
+		assertEquals("", result.emptyString);
+		if (shouldBeNull)
+		{
+			assertNull(result.nullString);
+		} else
+		{
+			assertEquals("", result.nullString);
+		}
+	}
+
+	static class StringPojo {
+		String normalString;
+		String emptyString;
+		String nullString;
+
+		public String getNormalString() {
+			return normalString;
+		}
+
+		public void setNormalString(String normalString) {
+			this.normalString = normalString;
+		}
+
+		public String getEmptyString() {
+			return emptyString;
+		}
+
+		public void setEmptyString(String emptyString) {
+			this.emptyString = emptyString;
+		}
+
+		public String getNullString() {
+			return nullString;
+		}
+
+		public void setNullString(String nullString) {
+			this.nullString = nullString;
+		}
+	}
 }