juplo.de Git - simple-mapper/blob - src/test/java/de/juplo/jackson/SimpleMapperTest.java

   1 package de.juplo.jackson;
   2
   3 import com.fasterxml.jackson.core.JsonFactory;
   4 import com.fasterxml.jackson.core.JsonParser;
   5 import java.io.IOException;
   6 import java.io.InputStream;
   7 import java.util.List;
   8 import java.util.Map;
   9 import java.util.Map.Entry;
  10 import java.util.Spliterator;
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertFalse;
  13 import static org.junit.Assert.assertNotNull;
  14 import static org.junit.Assert.assertNull;
  15 import static org.junit.Assert.assertTrue;
  16 import static org.junit.Assert.fail;
  17 import org.junit.Test;
  18 import org.slf4j.Logger;
  19 import org.slf4j.LoggerFactory;
  20
  21
  22 /**
  23  *
  24  * @author Kai Moritz
  25  */
  26 public class SimpleMapperTest
  27 {
  28   private static final Logger LOG =
  29       LoggerFactory.getLogger(SimpleMapperTest.class);
  30
  31
  32   private final JsonFactory factory = new JsonFactory();
  33
  34
  35   @Test
  36   public void testConvertEmptyInputToArraySpliterator() throws Exception
  37   {
  38     Spliterator<Object> spliterator;
  39
  40     spliterator = SimpleMapper.getArraySpliterator(get("/empty/1.json"));
  41     assertNull(spliterator);
  42     spliterator = SimpleMapper.getArraySpliterator(get("/empty/2.json"));
  43     assertNull(spliterator);
  44     spliterator = SimpleMapper.getArraySpliterator(get("/empty/3.json"));
  45     assertNull(spliterator);
  46     spliterator = SimpleMapper.getArraySpliterator(get("/empty/4.json"));
  47     assertNull(spliterator);
  48     spliterator = SimpleMapper.getArraySpliterator(get("/empty/5.json"));
  49     assertNull(spliterator);
  50   }
  51
  52   @Test
  53   public void testConvertEmptyInputToList() throws Exception
  54   {
  55     List<Object> list;
  56
  57     list = SimpleMapper.convertArray(get("/empty/1.json"));
  58     assertNull(list);
  59     list = SimpleMapper.convertArray(get("/empty/2.json"));
  60     assertNull(list);
  61     list = SimpleMapper.convertArray(get("/empty/3.json"));
  62     assertNull(list);
  63     list = SimpleMapper.convertArray(get("/empty/4.json"));
  64     assertNull(list);
  65     list = SimpleMapper.convertArray(get("/empty/5.json"));
  66     assertNull(list);
  67   }
  68
  69   @Test
  70   public void testConvertEmptyInputToObjectSpliterator() throws Exception
  71   {
  72     Spliterator<Entry<String, Object>> spliterator;
  73
  74     spliterator = SimpleMapper.getObjectSpliterator(get("/empty/1.json"));
  75     assertNull(spliterator);
  76     spliterator = SimpleMapper.getObjectSpliterator(get("/empty/2.json"));
  77     assertNull(spliterator);
  78     spliterator = SimpleMapper.getObjectSpliterator(get("/empty/3.json"));
  79     assertNull(spliterator);
  80     spliterator = SimpleMapper.getObjectSpliterator(get("/empty/4.json"));
  81     assertNull(spliterator);
  82     spliterator = SimpleMapper.getObjectSpliterator(get("/empty/5.json"));
  83     assertNull(spliterator);
  84   }
  85
  86   @Test
  87   public void testConvertEmptyInputToMap() throws Exception
  88   {
  89     Map<String, Object> map;
  90
  91     map = SimpleMapper.convertObject(get("/empty/1.json"));
  92     assertNull(map);
  93     map = SimpleMapper.convertObject(get("/empty/2.json"));
  94     assertNull(map);
  95     map = SimpleMapper.convertObject(get("/empty/3.json"));
  96     assertNull(map);
  97     map = SimpleMapper.convertObject(get("/empty/4.json"));
  98     assertNull(map);
  99     map = SimpleMapper.convertObject(get("/empty/5.json"));
 100     assertNull(map);
 101   }
 102
 103   @Test
 104   public void testConvertEmptyInput() throws Exception
 105   {
 106     Object object;
 107
 108     object = SimpleMapper.convert(get("/empty/1.json"));
 109     assertNull(object);
 110     object = SimpleMapper.convert(get("/empty/2.json"));
 111     assertNull(object);
 112     object = SimpleMapper.convert(get("/empty/3.json"));
 113     assertNull(object);
 114     object = SimpleMapper.convert(get("/empty/4.json"));
 115     assertNull(object);
 116     object = SimpleMapper.convert(get("/empty/5.json"));
 117     assertNull(object);
 118   }
 119
 120
 121   @Test
 122   public void testConvertEmptyArrayToArraySpliterator() throws Exception
 123   {
 124     Spliterator<Object> spliterator;
 125
 126     spliterator = SimpleMapper.getArraySpliterator(get("/array/empty/1.json"));
 127     assertFalse(
 128         "The created splitter should have no entries",
 129         spliterator.tryAdvance((Object t) ->
 130         {
 131           fail("The consumer should never be called!");
 132         }));
 133     spliterator = SimpleMapper.getArraySpliterator(get("/array/empty/2.json"));
 134     assertFalse(
 135         "The created splitter should have no entries",
 136         spliterator.tryAdvance((Object t) ->
 137         {
 138           fail("The consumer should never be called!");
 139         }));
 140     spliterator = SimpleMapper.getArraySpliterator(get("/array/empty/3.json"));
 141     assertFalse(
 142         "The created splitter should have no entries",
 143         spliterator.tryAdvance((Object t) ->
 144         {
 145           fail("The consumer should never be called!");
 146         }));
 147     spliterator = SimpleMapper.getArraySpliterator(get("/array/empty/4.json"));
 148     assertFalse(
 149         "The created splitter should have no entries",
 150         spliterator.tryAdvance((Object t) ->
 151         {
 152           fail("The consumer should never be called!");
 153         }));
 154   }
 155
 156   @Test
 157   public void testConvertEmptyArrayToList() throws Exception
 158   {
 159     List<Object> list;
 160
 161     list = SimpleMapper.convertArray(get("/array/empty/1.json"));
 162     assertEquals(0, list.size());
 163     list = SimpleMapper.convertArray(get("/array/empty/2.json"));
 164     assertEquals(0, list.size());
 165     list = SimpleMapper.convertArray(get("/array/empty/3.json"));
 166     assertEquals(0, list.size());
 167     list = SimpleMapper.convertArray(get("/array/empty/4.json"));
 168     assertEquals(0, list.size());
 169   }
 170
 171   @Test
 172   public void testConvertEmptyArrayToObjectSpliterator() throws Exception
 173   {
 174     try
 175     {
 176       SimpleMapper.getObjectSpliterator(get("/array/empty/1.json"));
 177       fail("it must not be possible, to get an object-spliterator for an array");
 178     }
 179     catch(IllegalArgumentException e)
 180     {
 181       LOG.info(e.getMessage());
 182     }
 183
 184     try
 185     {
 186       SimpleMapper.getObjectSpliterator(get("/array/empty/2.json"));
 187       fail("it must not be possible, to get an object-spliterator for an array");
 188     }
 189     catch(IllegalArgumentException e)
 190     {
 191       LOG.info(e.getMessage());
 192     }
 193
 194     try
 195     {
 196       SimpleMapper.getObjectSpliterator(get("/array/empty/3.json"));
 197       fail("it must not be possible, to get an object-spliterator for an array");
 198     }
 199     catch(IllegalArgumentException e)
 200     {
 201       LOG.info(e.getMessage());
 202     }
 203
 204     try
 205     {
 206       SimpleMapper.getObjectSpliterator(get("/array/empty/4.json"));
 207       fail("it must not be possible, to get an object-spliterator for an array");
 208     }
 209     catch(IllegalArgumentException e)
 210     {
 211       LOG.info(e.getMessage());
 212     }
 213   }
 214
 215   @Test
 216   public void testConvertEmptyArrayToMap() throws Exception
 217   {
 218     try
 219     {
 220       SimpleMapper.convertObject(get("/array/empty/1.json"));
 221       fail("it must not be possible, to get a map for an array");
 222     }
 223     catch(IllegalArgumentException e)
 224     {
 225       LOG.info(e.getMessage());
 226     }
 227
 228     try
 229     {
 230       SimpleMapper.convertObject(get("/array/empty/2.json"));
 231       fail("it must not be possible, to get a map for an array");
 232     }
 233     catch(IllegalArgumentException e)
 234     {
 235       LOG.info(e.getMessage());
 236     }
 237
 238     try
 239     {
 240       SimpleMapper.convertObject(get("/array/empty/3.json"));
 241       fail("it must not be possible, to get a map for an array");
 242     }
 243     catch(IllegalArgumentException e)
 244     {
 245       LOG.info(e.getMessage());
 246     }
 247
 248     try
 249     {
 250       SimpleMapper.convertObject(get("/array/empty/4.json"));
 251       fail("it must not be possible, to get a map for an array");
 252     }
 253     catch(IllegalArgumentException e)
 254     {
 255       LOG.info(e.getMessage());
 256     }
 257   }
 258
 259   @Test
 260   public void testConvertEmptyArray() throws Exception
 261   {
 262     Object object;
 263
 264     object = SimpleMapper.convert(get("/array/empty/1.json"));
 265     assertNotNull(object);
 266     assertTrue("the returned object should be a list", object instanceof List);
 267     assertEquals(0, ((List)object).size());
 268     object = SimpleMapper.convert(get("/array/empty/2.json"));
 269     assertNotNull(object);
 270     assertTrue("the returned object should be a list", object instanceof List);
 271     assertEquals(0, ((List)object).size());
 272     object = SimpleMapper.convert(get("/array/empty/3.json"));
 273     assertNotNull(object);
 274     assertTrue("the returned object should be a list", object instanceof List);
 275     assertEquals(0, ((List)object).size());
 276     object = SimpleMapper.convert(get("/array/empty/4.json"));
 277     assertNotNull(object);
 278     assertTrue("the returned object should be a list", object instanceof List);
 279     assertEquals(0, ((List)object).size());
 280   }
 281
 282
 283   private JsonParser get(String resource) throws IOException
 284   {
 285     InputStream is = SimpleMapperTest.class.getResourceAsStream(resource);
 286     return factory.createParser(is);
 287   }
 288 }