juplo.de Git - maven-thymeleaf-skin/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   @Test
 284   public void testConvertEmptyObjectToArraySpliterator() throws Exception
 285   {
 286     try
 287     {
 288       SimpleMapper.getArraySpliterator(get("/object/empty/1.json"));
 289       fail("it must not be possible, to get an array-spliterator for an object");
 290     }
 291     catch(IllegalArgumentException e)
 292     {
 293       LOG.info(e.getMessage());
 294     }
 295
 296     try
 297     {
 298       SimpleMapper.getArraySpliterator(get("/object/empty/2.json"));
 299       fail("it must not be possible, to get an array-spliterator for an object");
 300     }
 301     catch(IllegalArgumentException e)
 302     {
 303       LOG.info(e.getMessage());
 304     }
 305
 306     try
 307     {
 308       SimpleMapper.getArraySpliterator(get("/object/empty/3.json"));
 309       fail("it must not be possible, to get an array-spliterator for an object");
 310     }
 311     catch(IllegalArgumentException e)
 312     {
 313       LOG.info(e.getMessage());
 314     }
 315
 316     try
 317     {
 318       SimpleMapper.getArraySpliterator(get("/object/empty/4.json"));
 319       fail("it must not be possible, to get an array-spliterator for an object");
 320     }
 321     catch(IllegalArgumentException e)
 322     {
 323       LOG.info(e.getMessage());
 324     }
 325   }
 326
 327   @Test
 328   public void testConvertEmptyObjectToList() throws Exception
 329   {
 330     try
 331     {
 332       SimpleMapper.convertArray(get("/object/empty/1.json"));
 333       fail("it must not be possible, to get a list for an array");
 334     }
 335     catch(IllegalArgumentException e)
 336     {
 337       LOG.info(e.getMessage());
 338     }
 339
 340     try
 341     {
 342       SimpleMapper.convertArray(get("/object/empty/2.json"));
 343       fail("it must not be possible, to get a list for an array");
 344     }
 345     catch(IllegalArgumentException e)
 346     {
 347       LOG.info(e.getMessage());
 348     }
 349
 350     try
 351     {
 352       SimpleMapper.convertArray(get("/object/empty/3.json"));
 353       fail("it must not be possible, to get a list for an array");
 354     }
 355     catch(IllegalArgumentException e)
 356     {
 357       LOG.info(e.getMessage());
 358     }
 359
 360     try
 361     {
 362       SimpleMapper.convertArray(get("/object/empty/4.json"));
 363       fail("it must not be possible, to get a list for an array");
 364     }
 365     catch(IllegalArgumentException e)
 366     {
 367       LOG.info(e.getMessage());
 368     }
 369   }
 370
 371   @Test
 372   public void testConvertEmptyObjectToObjectSpliterator() throws Exception
 373   {
 374     Spliterator<Entry<String, Object>> spliterator;
 375
 376     spliterator = SimpleMapper.getObjectSpliterator(get("/object/empty/1.json"));
 377     assertFalse(
 378         "The created splitter should have no entries",
 379         spliterator.tryAdvance((Entry<String, Object> e) ->
 380         {
 381           fail("The consumer should never be called!");
 382         }));
 383     spliterator = SimpleMapper.getObjectSpliterator(get("/object/empty/2.json"));
 384     assertFalse(
 385         "The created splitter should have no entries",
 386         spliterator.tryAdvance((Entry<String, Object> e) ->
 387         {
 388           fail("The consumer should never be called!");
 389         }));
 390     spliterator = SimpleMapper.getObjectSpliterator(get("/object/empty/3.json"));
 391     assertFalse(
 392         "The created splitter should have no entries",
 393         spliterator.tryAdvance((Entry<String, Object> e) ->
 394         {
 395           fail("The consumer should never be called!");
 396         }));
 397     spliterator = SimpleMapper.getObjectSpliterator(get("/object/empty/4.json"));
 398     assertFalse(
 399         "The created splitter should have no entries",
 400         spliterator.tryAdvance((Entry<String, Object> e) ->
 401         {
 402           fail("The consumer should never be called!");
 403         }));
 404   }
 405
 406   @Test
 407   public void testConvertEmptyObjectToMap() throws Exception
 408   {
 409     Map<String, Object> map;
 410
 411     map = SimpleMapper.convertObject(get("/object/empty/1.json"));
 412     assertEquals(0, map.size());
 413     map = SimpleMapper.convertObject(get("/object/empty/2.json"));
 414     assertEquals(0, map.size());
 415     map = SimpleMapper.convertObject(get("/object/empty/3.json"));
 416     assertEquals(0, map.size());
 417     map = SimpleMapper.convertObject(get("/object/empty/4.json"));
 418     assertEquals(0, map.size());
 419   }
 420
 421   @Test
 422   public void testConvertEmptyObject() throws Exception
 423   {
 424     Object object;
 425
 426     object = SimpleMapper.convert(get("/object/empty/1.json"));
 427     assertNotNull(object);
 428     assertTrue("the returned object should be a list", object instanceof Map);
 429     assertEquals(0, ((Map)object).size());
 430     object = SimpleMapper.convert(get("/object/empty/2.json"));
 431     assertNotNull(object);
 432     assertTrue("the returned object should be a list", object instanceof Map);
 433     assertEquals(0, ((Map)object).size());
 434     object = SimpleMapper.convert(get("/object/empty/3.json"));
 435     assertNotNull(object);
 436     assertTrue("the returned object should be a list", object instanceof Map);
 437     assertEquals(0, ((Map)object).size());
 438     object = SimpleMapper.convert(get("/object/empty/4.json"));
 439     assertNotNull(object);
 440     assertTrue("the returned object should be a list", object instanceof Map);
 441     assertEquals(0, ((Map)object).size());
 442   }
 443
 444
 445   private JsonParser get(String resource) throws IOException
 446   {
 447     InputStream is = SimpleMapperTest.class.getResourceAsStream(resource);
 448     return factory.createParser(is);
 449   }
 450 }