import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Spliterator;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Test
public void testConvertEmptyInputToArraySpliterator() throws Exception
{
+ LOG.info("<-- Start Of New Test-Case!");
+
Spliterator<Object> spliterator;
spliterator = SimpleMapper.getArraySpliterator(get("/empty/1.json"));
@Test
public void testConvertEmptyInputToList() throws Exception
{
+ LOG.info("<-- Start Of New Test-Case!");
+
List<Object> list;
list = SimpleMapper.convertArray(get("/empty/1.json"));
@Test
public void testConvertEmptyInputToObjectSpliterator() throws Exception
{
+ LOG.info("<-- Start Of New Test-Case!");
+
Spliterator<Entry<String, Object>> spliterator;
spliterator = SimpleMapper.getObjectSpliterator(get("/empty/1.json"));
@Test
public void testConvertEmptyInputToMap() throws Exception
{
+ LOG.info("<-- Start Of New Test-Case!");
+
Map<String, Object> map;
map = SimpleMapper.convertObject(get("/empty/1.json"));
@Test
public void testConvertEmptyInput() throws Exception
{
+ LOG.info("<-- Start Of New Test-Case!");
+
Object object;
object = SimpleMapper.convert(get("/empty/1.json"));
@Test
public void testConvertEmptyArrayToArraySpliterator() throws Exception
{
+ LOG.info("<-- Start Of New Test-Case!");
+
Spliterator<Object> spliterator;
spliterator = SimpleMapper.getArraySpliterator(get("/array/empty/1.json"));
@Test
public void testConvertEmptyArrayToList() throws Exception
{
+ LOG.info("<-- Start Of New Test-Case!");
+
List<Object> list;
list = SimpleMapper.convertArray(get("/array/empty/1.json"));
@Test
public void testConvertEmptyArrayToObjectSpliterator() throws Exception
{
+ LOG.info("<-- Start Of New Test-Case!");
+
try
{
SimpleMapper.getObjectSpliterator(get("/array/empty/1.json"));
}
catch(IllegalArgumentException e)
{
- LOG.info(e.getMessage());
+ LOG.trace("expected exception", e);
}
try
}
catch(IllegalArgumentException e)
{
- LOG.info(e.getMessage());
+ LOG.trace("expected exception", e);
}
try
}
catch(IllegalArgumentException e)
{
- LOG.info(e.getMessage());
+ LOG.trace("expected exception", e);
}
try
}
catch(IllegalArgumentException e)
{
- LOG.info(e.getMessage());
+ LOG.trace("expected exception", e);
}
}
@Test
public void testConvertEmptyArrayToMap() throws Exception
{
+ LOG.info("<-- Start Of New Test-Case!");
+
try
{
SimpleMapper.convertObject(get("/array/empty/1.json"));
}
catch(IllegalArgumentException e)
{
- LOG.info(e.getMessage());
+ LOG.trace("expected exception", e);
}
try
}
catch(IllegalArgumentException e)
{
- LOG.info(e.getMessage());
+ LOG.trace("expected exception", e);
}
try
}
catch(IllegalArgumentException e)
{
- LOG.info(e.getMessage());
+ LOG.trace("expected exception", e);
}
try
}
catch(IllegalArgumentException e)
{
- LOG.info(e.getMessage());
+ LOG.trace("expected exception", e);
}
}
@Test
public void testConvertEmptyArray() throws Exception
{
+ LOG.info("<-- Start Of New Test-Case!");
+
Object object;
object = SimpleMapper.convert(get("/array/empty/1.json"));
@Test
public void testConvertEmptyObjectToArraySpliterator() throws Exception
{
+ LOG.info("<-- Start Of New Test-Case!");
+
try
{
SimpleMapper.getArraySpliterator(get("/object/empty/1.json"));
}
catch(IllegalArgumentException e)
{
- LOG.info(e.getMessage());
+ LOG.trace("expected exception", e);
}
try
}
catch(IllegalArgumentException e)
{
- LOG.info(e.getMessage());
+ LOG.trace("expected exception", e);
}
try
}
catch(IllegalArgumentException e)
{
- LOG.info(e.getMessage());
+ LOG.trace("expected exception", e);
}
try
}
catch(IllegalArgumentException e)
{
- LOG.info(e.getMessage());
+ LOG.trace("expected exception", e);
}
}
@Test
public void testConvertEmptyObjectToList() throws Exception
{
+ LOG.info("<-- Start Of New Test-Case!");
+
try
{
SimpleMapper.convertArray(get("/object/empty/1.json"));
}
catch(IllegalArgumentException e)
{
- LOG.info(e.getMessage());
+ LOG.trace("expected exception", e);
}
try
}
catch(IllegalArgumentException e)
{
- LOG.info(e.getMessage());
+ LOG.trace("expected exception", e);
}
try
}
catch(IllegalArgumentException e)
{
- LOG.info(e.getMessage());
+ LOG.trace("expected exception", e);
}
try
}
catch(IllegalArgumentException e)
{
- LOG.info(e.getMessage());
+ LOG.trace("expected exception", e);
}
}
@Test
public void testConvertEmptyObjectToObjectSpliterator() throws Exception
{
+ LOG.info("<-- Start Of New Test-Case!");
+
Spliterator<Entry<String, Object>> spliterator;
spliterator = SimpleMapper.getObjectSpliterator(get("/object/empty/1.json"));
@Test
public void testConvertEmptyObjectToMap() throws Exception
{
+ LOG.info("<-- Start Of New Test-Case!");
+
Map<String, Object> map;
map = SimpleMapper.convertObject(get("/object/empty/1.json"));
@Test
public void testConvertEmptyObject() throws Exception
{
+ LOG.info("<-- Start Of New Test-Case!");
+
Object object;
object = SimpleMapper.convert(get("/object/empty/1.json"));
@Test
public void testConvertArrayToArraySpliterator() throws Exception
{
+ LOG.info("<-- Start Of New Test-Case!");
+
Spliterator<Object> spliterator;
spliterator = SimpleMapper.getArraySpliterator(get("/array/1.json"));
@Test
public void testConvertArrayToList() throws Exception
{
+ LOG.info("<-- Start Of New Test-Case!");
+
List<Object> list;
list = SimpleMapper.convertArray(get("/array/1.json"));
@Test
public void testConvertArrayToObjectSpliterator() throws Exception
{
+ LOG.info("<-- Start Of New Test-Case!");
+
try
{
SimpleMapper.getObjectSpliterator(get("/array/1.json"));
}
catch(IllegalArgumentException e)
{
- LOG.info(e.getMessage());
+ LOG.trace("expected exception", e);
}
try
}
catch(IllegalArgumentException e)
{
- LOG.info(e.getMessage());
+ LOG.trace("expected exception", e);
}
}
@Test
public void testConvertArrayToMap() throws Exception
{
+ LOG.info("<-- Start Of New Test-Case!");
+
try
{
SimpleMapper.convertObject(get("/array/1.json"));
}
catch(IllegalArgumentException e)
{
- LOG.info(e.getMessage());
+ LOG.trace("expected exception", e);
}
try
}
catch(IllegalArgumentException e)
{
- LOG.info(e.getMessage());
+ LOG.trace("expected exception", e);
}
}
@Test
public void testConvertArray() throws Exception
{
+ LOG.info("<-- Start Of New Test-Case!");
+
Object object;
List<Object> list;
checkPartnerPageData(list.get(3));
}
+
+ @Test
+ public void testConvertObjectToArraySpliterator() throws Exception
+ {
+ LOG.info("<-- Start Of New Test-Case!");
+
+ try
+ {
+ SimpleMapper.getArraySpliterator(get("/object/1.json"));
+ fail("it must not be possible, to get an array-spliterator for an object");
+ }
+ catch(IllegalArgumentException e)
+ {
+ LOG.trace("expected exception", e);
+ }
+
+ try
+ {
+ SimpleMapper.getArraySpliterator(get("/object/2.json"));
+ fail("it must not be possible, to get an array-spliterator for an object");
+ }
+ catch(IllegalArgumentException e)
+ {
+ LOG.trace("expected exception", e);
+ }
+ }
+
+ @Test
+ public void testConvertObjectToList() throws Exception
+ {
+ LOG.info("<-- Start Of New Test-Case!");
+
+ try
+ {
+ SimpleMapper.convertArray(get("/object/1.json"));
+ fail("it must not be possible, to get a list for an object");
+ }
+ catch(IllegalArgumentException e)
+ {
+ LOG.trace("expected exception", e);
+ }
+
+ try
+ {
+ SimpleMapper.convertArray(get("/object/2.json"));
+ fail("it must not be possible, to get a list for an object");
+ }
+ catch(IllegalArgumentException e)
+ {
+ LOG.trace("expected exception", e);
+ }
+ }
+
+ @Test
+ public void testConvertObjectToObjectSpliterator() throws Exception
+ {
+ LOG.info("<-- Start Of New Test-Case!");
+
+ Spliterator<Entry<String, Object>> spliterator;
+
+ spliterator = SimpleMapper.getObjectSpliterator(get("/object/1.json"));
+ checkObjectSpliterator(spliterator);
+ spliterator = SimpleMapper.getObjectSpliterator(get("/object/2.json"));
+ checkObjectSpliterator(spliterator);
+ }
+
+ void checkObjectSpliterator(Spliterator<Entry<String, Object>> spliterator)
+ throws
+ Exception
+ {
+ assertNotNull(spliterator);
+
+ final LinkedHashMap<String, Object> map = new LinkedHashMap<>();
+ for (int i = 0; i < 4; i++)
+ assertTrue(
+ "The created splitter should have a " + (i+1) + ". entry",
+ spliterator.tryAdvance((Entry<String, Object> e) -> {
+ map.put(e.getKey(), e.getValue());
+ }));
+
+ assertFalse(
+ "The created splitter should have no more entries",
+ spliterator.tryAdvance((Object t) ->
+ {
+ fail("The consumer should not have been called");
+ }));
+
+ checkVariables(map);
+ }
+
+ @Test
+ public void testConvertObjectToMap() throws Exception
+ {
+ LOG.info("<-- Start Of New Test-Case!");
+
+ Map<String, Object> map;
+
+ map = SimpleMapper.convertObject(get("/object/1.json"));
+ assertNotNull(map);
+ assertEquals(4, map.size());
+ checkVariables(map);
+ map = SimpleMapper.convertObject(get("/object/2.json"));
+ assertNotNull(map);
+ assertEquals(4, map.size());
+ checkVariables(map);
+ }
+
+ @Test
+ public void testConvertObject() throws Exception
+ {
+ LOG.info("<-- Start Of New Test-Case!");
+
+ Object object;
+ Map<String, Object> map;
+
+ object = SimpleMapper.convert(get("/object/1.json"));
+ assertNotNull(object);
+ assertTrue("the returned object should be a map", object instanceof Map);
+ map = (Map<String, Object>)object;
+ assertEquals(4, map.size());
+ checkVariables(map);
+ object = SimpleMapper.convert(get("/object/2.json"));
+ assertNotNull(object);
+ assertTrue("the returned object should be a map", object instanceof Map);
+ map = (Map<String, Object>)object;
+ assertEquals(4, map.size());
+ checkVariables(map);
+ }
+
+ void checkVariables(Map<String, Object> map)
+ {
+ Iterator<Entry<String, Object>> iterator = map.entrySet().iterator();
+ Entry<String, Object> entry;
+
+ assertTrue("The map should have a first element", iterator.hasNext());
+ entry = iterator.next();
+ assertEquals("bootstrap", entry.getKey());
+ assertEquals("bootstrap.min.css", entry.getValue());
+
+ assertTrue("The map should have a second element", iterator.hasNext());
+ entry = iterator.next();
+ assertEquals("pages", entry.getKey());
+ assertTrue(
+ "The pages-variable should be of type List",
+ entry.getValue() instanceof List
+ );
+ assertEquals(4, ((List)entry.getValue()).size());
+ checkPartnerPageData(((List)entry.getValue()).get(3));
+
+ assertTrue("The map should have a third element", iterator.hasNext());
+ entry = iterator.next();
+ assertEquals("footer", entry.getKey());
+ assertTrue(
+ "The footer-variable should be of type List",
+ entry.getValue() instanceof List
+ );
+ assertEquals(3, ((List)entry.getValue()).size());
+
+ assertTrue("The map should have a third element", iterator.hasNext());
+ entry = iterator.next();
+ assertEquals("sponsorship", entry.getKey());
+ assertTrue(
+ "The sponsorship-variable should be of type List",
+ entry.getValue() instanceof List
+ );
+ assertEquals(3, ((List)entry.getValue()).size());
+ }
+
+
void checkPartnerPageData(Object page)
{
assertTrue("The page-data should be of type Map", page instanceof Map);
projects / simple-mapper / blobdiff