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.ArrayList;
   8 import java.util.Iterator;
   9 import java.util.LinkedHashMap;
  10 import java.util.List;
  11 import java.util.Map;
  12 import java.util.Map.Entry;
  13 import java.util.Spliterator;
  14 import org.junit.Test;
  15 import org.slf4j.Logger;
  16 import org.slf4j.LoggerFactory;
  17 import static org.junit.Assert.assertEquals;
  18 import static org.junit.Assert.assertFalse;
  19 import static org.junit.Assert.assertNotNull;
  20 import static org.junit.Assert.assertNull;
  21 import static org.junit.Assert.assertTrue;
  22 import static org.junit.Assert.fail;
  23
  24
  25 /**
  26  *
  27  * @author Kai Moritz
  28  */
  29 public class SimpleMapperTest
  30 {
  31   private static final Logger LOG =
  32       LoggerFactory.getLogger(SimpleMapperTest.class);
  33
  34
  35   private final JsonFactory factory = new JsonFactory();
  36
  37
  38   @Test
  39   public void testConvertEmptyInputToArraySpliterator() throws Exception
  40   {
  41     LOG.info("<-- Start Of New Test-Case!");
  42
  43     Spliterator<Object> spliterator;
  44
  45     spliterator = SimpleMapper.getArraySpliterator(get("/empty/1.json"));
  46     assertNull(spliterator);
  47     spliterator = SimpleMapper.getArraySpliterator(get("/empty/2.json"));
  48     assertNull(spliterator);
  49     spliterator = SimpleMapper.getArraySpliterator(get("/empty/3.json"));
  50     assertNull(spliterator);
  51     spliterator = SimpleMapper.getArraySpliterator(get("/empty/4.json"));
  52     assertNull(spliterator);
  53     spliterator = SimpleMapper.getArraySpliterator(get("/empty/5.json"));
  54     assertNull(spliterator);
  55   }
  56
  57   @Test
  58   public void testConvertEmptyInputToList() throws Exception
  59   {
  60     LOG.info("<-- Start Of New Test-Case!");
  61
  62     List<Object> list;
  63
  64     list = SimpleMapper.convertArray(get("/empty/1.json"));
  65     assertNull(list);
  66     list = SimpleMapper.convertArray(get("/empty/2.json"));
  67     assertNull(list);
  68     list = SimpleMapper.convertArray(get("/empty/3.json"));
  69     assertNull(list);
  70     list = SimpleMapper.convertArray(get("/empty/4.json"));
  71     assertNull(list);
  72     list = SimpleMapper.convertArray(get("/empty/5.json"));
  73     assertNull(list);
  74   }
  75
  76   @Test
  77   public void testConvertEmptyInputToObjectSpliterator() throws Exception
  78   {
  79     LOG.info("<-- Start Of New Test-Case!");
  80
  81     Spliterator<Entry<String, Object>> spliterator;
  82
  83     spliterator = SimpleMapper.getObjectSpliterator(get("/empty/1.json"));
  84     assertNull(spliterator);
  85     spliterator = SimpleMapper.getObjectSpliterator(get("/empty/2.json"));
  86     assertNull(spliterator);
  87     spliterator = SimpleMapper.getObjectSpliterator(get("/empty/3.json"));
  88     assertNull(spliterator);
  89     spliterator = SimpleMapper.getObjectSpliterator(get("/empty/4.json"));
  90     assertNull(spliterator);
  91     spliterator = SimpleMapper.getObjectSpliterator(get("/empty/5.json"));
  92     assertNull(spliterator);
  93   }
  94
  95   @Test
  96   public void testConvertEmptyInputToMap() throws Exception
  97   {
  98     LOG.info("<-- Start Of New Test-Case!");
  99
 100     Map<String, Object> map;
 101
 102     map = SimpleMapper.convertObject(get("/empty/1.json"));
 103     assertNull(map);
 104     map = SimpleMapper.convertObject(get("/empty/2.json"));
 105     assertNull(map);
 106     map = SimpleMapper.convertObject(get("/empty/3.json"));
 107     assertNull(map);
 108     map = SimpleMapper.convertObject(get("/empty/4.json"));
 109     assertNull(map);
 110     map = SimpleMapper.convertObject(get("/empty/5.json"));
 111     assertNull(map);
 112   }
 113
 114   @Test
 115   public void testConvertEmptyInput() throws Exception
 116   {
 117     LOG.info("<-- Start Of New Test-Case!");
 118
 119     Object object;
 120
 121     object = SimpleMapper.convert(get("/empty/1.json"));
 122     assertNull(object);
 123     object = SimpleMapper.convert(get("/empty/2.json"));
 124     assertNull(object);
 125     object = SimpleMapper.convert(get("/empty/3.json"));
 126     assertNull(object);
 127     object = SimpleMapper.convert(get("/empty/4.json"));
 128     assertNull(object);
 129     object = SimpleMapper.convert(get("/empty/5.json"));
 130     assertNull(object);
 131   }
 132
 133
 134   @Test
 135   public void testConvertEmptyArrayToArraySpliterator() throws Exception
 136   {
 137     LOG.info("<-- Start Of New Test-Case!");
 138
 139     Spliterator<Object> spliterator;
 140
 141     spliterator = SimpleMapper.getArraySpliterator(get("/array/empty/1.json"));
 142     assertFalse(
 143         "The created splitter should have no entries",
 144         spliterator.tryAdvance((Object t) ->
 145         {
 146           fail("The consumer should never be called!");
 147         }));
 148     spliterator = SimpleMapper.getArraySpliterator(get("/array/empty/2.json"));
 149     assertFalse(
 150         "The created splitter should have no entries",
 151         spliterator.tryAdvance((Object t) ->
 152         {
 153           fail("The consumer should never be called!");
 154         }));
 155     spliterator = SimpleMapper.getArraySpliterator(get("/array/empty/3.json"));
 156     assertFalse(
 157         "The created splitter should have no entries",
 158         spliterator.tryAdvance((Object t) ->
 159         {
 160           fail("The consumer should never be called!");
 161         }));
 162     spliterator = SimpleMapper.getArraySpliterator(get("/array/empty/4.json"));
 163     assertFalse(
 164         "The created splitter should have no entries",
 165         spliterator.tryAdvance((Object t) ->
 166         {
 167           fail("The consumer should never be called!");
 168         }));
 169   }
 170
 171   @Test
 172   public void testConvertEmptyArrayToList() throws Exception
 173   {
 174     LOG.info("<-- Start Of New Test-Case!");
 175
 176     List<Object> list;
 177
 178     list = SimpleMapper.convertArray(get("/array/empty/1.json"));
 179     assertEquals(0, list.size());
 180     list = SimpleMapper.convertArray(get("/array/empty/2.json"));
 181     assertEquals(0, list.size());
 182     list = SimpleMapper.convertArray(get("/array/empty/3.json"));
 183     assertEquals(0, list.size());
 184     list = SimpleMapper.convertArray(get("/array/empty/4.json"));
 185     assertEquals(0, list.size());
 186   }
 187
 188   @Test
 189   public void testConvertEmptyArrayToObjectSpliterator() throws Exception
 190   {
 191     LOG.info("<-- Start Of New Test-Case!");
 192
 193     try
 194     {
 195       SimpleMapper.getObjectSpliterator(get("/array/empty/1.json"));
 196       fail("it must not be possible, to get an object-spliterator for an array");
 197     }
 198     catch(IllegalArgumentException e)
 199     {
 200       LOG.trace("expected exception", e);
 201     }
 202
 203     try
 204     {
 205       SimpleMapper.getObjectSpliterator(get("/array/empty/2.json"));
 206       fail("it must not be possible, to get an object-spliterator for an array");
 207     }
 208     catch(IllegalArgumentException e)
 209     {
 210       LOG.trace("expected exception", e);
 211     }
 212
 213     try
 214     {
 215       SimpleMapper.getObjectSpliterator(get("/array/empty/3.json"));
 216       fail("it must not be possible, to get an object-spliterator for an array");
 217     }
 218     catch(IllegalArgumentException e)
 219     {
 220       LOG.trace("expected exception", e);
 221     }
 222
 223     try
 224     {
 225       SimpleMapper.getObjectSpliterator(get("/array/empty/4.json"));
 226       fail("it must not be possible, to get an object-spliterator for an array");
 227     }
 228     catch(IllegalArgumentException e)
 229     {
 230       LOG.trace("expected exception", e);
 231     }
 232   }
 233
 234   @Test
 235   public void testConvertEmptyArrayToMap() throws Exception
 236   {
 237     LOG.info("<-- Start Of New Test-Case!");
 238
 239     try
 240     {
 241       SimpleMapper.convertObject(get("/array/empty/1.json"));
 242       fail("it must not be possible, to get a map for an array");
 243     }
 244     catch(IllegalArgumentException e)
 245     {
 246       LOG.trace("expected exception", e);
 247     }
 248
 249     try
 250     {
 251       SimpleMapper.convertObject(get("/array/empty/2.json"));
 252       fail("it must not be possible, to get a map for an array");
 253     }
 254     catch(IllegalArgumentException e)
 255     {
 256       LOG.trace("expected exception", e);
 257     }
 258
 259     try
 260     {
 261       SimpleMapper.convertObject(get("/array/empty/3.json"));
 262       fail("it must not be possible, to get a map for an array");
 263     }
 264     catch(IllegalArgumentException e)
 265     {
 266       LOG.trace("expected exception", e);
 267     }
 268
 269     try
 270     {
 271       SimpleMapper.convertObject(get("/array/empty/4.json"));
 272       fail("it must not be possible, to get a map for an array");
 273     }
 274     catch(IllegalArgumentException e)
 275     {
 276       LOG.trace("expected exception", e);
 277     }
 278   }
 279
 280   @Test
 281   public void testConvertEmptyArray() throws Exception
 282   {
 283     LOG.info("<-- Start Of New Test-Case!");
 284
 285     Object object;
 286
 287     object = SimpleMapper.convert(get("/array/empty/1.json"));
 288     assertNotNull(object);
 289     assertTrue("the returned object should be a list", object instanceof List);
 290     assertEquals(0, ((List)object).size());
 291     object = SimpleMapper.convert(get("/array/empty/2.json"));
 292     assertNotNull(object);
 293     assertTrue("the returned object should be a list", object instanceof List);
 294     assertEquals(0, ((List)object).size());
 295     object = SimpleMapper.convert(get("/array/empty/3.json"));
 296     assertNotNull(object);
 297     assertTrue("the returned object should be a list", object instanceof List);
 298     assertEquals(0, ((List)object).size());
 299     object = SimpleMapper.convert(get("/array/empty/4.json"));
 300     assertNotNull(object);
 301     assertTrue("the returned object should be a list", object instanceof List);
 302     assertEquals(0, ((List)object).size());
 303   }
 304
 305
 306   @Test
 307   public void testConvertEmptyObjectToArraySpliterator() throws Exception
 308   {
 309     LOG.info("<-- Start Of New Test-Case!");
 310
 311     try
 312     {
 313       SimpleMapper.getArraySpliterator(get("/object/empty/1.json"));
 314       fail("it must not be possible, to get an array-spliterator for an object");
 315     }
 316     catch(IllegalArgumentException e)
 317     {
 318       LOG.trace("expected exception", e);
 319     }
 320
 321     try
 322     {
 323       SimpleMapper.getArraySpliterator(get("/object/empty/2.json"));
 324       fail("it must not be possible, to get an array-spliterator for an object");
 325     }
 326     catch(IllegalArgumentException e)
 327     {
 328       LOG.trace("expected exception", e);
 329     }
 330
 331     try
 332     {
 333       SimpleMapper.getArraySpliterator(get("/object/empty/3.json"));
 334       fail("it must not be possible, to get an array-spliterator for an object");
 335     }
 336     catch(IllegalArgumentException e)
 337     {
 338       LOG.trace("expected exception", e);
 339     }
 340
 341     try
 342     {
 343       SimpleMapper.getArraySpliterator(get("/object/empty/4.json"));
 344       fail("it must not be possible, to get an array-spliterator for an object");
 345     }
 346     catch(IllegalArgumentException e)
 347     {
 348       LOG.trace("expected exception", e);
 349     }
 350   }
 351
 352   @Test
 353   public void testConvertEmptyObjectToList() throws Exception
 354   {
 355     LOG.info("<-- Start Of New Test-Case!");
 356
 357     try
 358     {
 359       SimpleMapper.convertArray(get("/object/empty/1.json"));
 360       fail("it must not be possible, to get a list for an array");
 361     }
 362     catch(IllegalArgumentException e)
 363     {
 364       LOG.trace("expected exception", e);
 365     }
 366
 367     try
 368     {
 369       SimpleMapper.convertArray(get("/object/empty/2.json"));
 370       fail("it must not be possible, to get a list for an array");
 371     }
 372     catch(IllegalArgumentException e)
 373     {
 374       LOG.trace("expected exception", e);
 375     }
 376
 377     try
 378     {
 379       SimpleMapper.convertArray(get("/object/empty/3.json"));
 380       fail("it must not be possible, to get a list for an array");
 381     }
 382     catch(IllegalArgumentException e)
 383     {
 384       LOG.trace("expected exception", e);
 385     }
 386
 387     try
 388     {
 389       SimpleMapper.convertArray(get("/object/empty/4.json"));
 390       fail("it must not be possible, to get a list for an array");
 391     }
 392     catch(IllegalArgumentException e)
 393     {
 394       LOG.trace("expected exception", e);
 395     }
 396   }
 397
 398   @Test
 399   public void testConvertEmptyObjectToObjectSpliterator() throws Exception
 400   {
 401     LOG.info("<-- Start Of New Test-Case!");
 402
 403     Spliterator<Entry<String, Object>> spliterator;
 404
 405     spliterator = SimpleMapper.getObjectSpliterator(get("/object/empty/1.json"));
 406     assertFalse(
 407         "The created splitter should have no entries",
 408         spliterator.tryAdvance((Entry<String, Object> e) ->
 409         {
 410           fail("The consumer should never be called!");
 411         }));
 412     spliterator = SimpleMapper.getObjectSpliterator(get("/object/empty/2.json"));
 413     assertFalse(
 414         "The created splitter should have no entries",
 415         spliterator.tryAdvance((Entry<String, Object> e) ->
 416         {
 417           fail("The consumer should never be called!");
 418         }));
 419     spliterator = SimpleMapper.getObjectSpliterator(get("/object/empty/3.json"));
 420     assertFalse(
 421         "The created splitter should have no entries",
 422         spliterator.tryAdvance((Entry<String, Object> e) ->
 423         {
 424           fail("The consumer should never be called!");
 425         }));
 426     spliterator = SimpleMapper.getObjectSpliterator(get("/object/empty/4.json"));
 427     assertFalse(
 428         "The created splitter should have no entries",
 429         spliterator.tryAdvance((Entry<String, Object> e) ->
 430         {
 431           fail("The consumer should never be called!");
 432         }));
 433   }
 434
 435   @Test
 436   public void testConvertEmptyObjectToMap() throws Exception
 437   {
 438     LOG.info("<-- Start Of New Test-Case!");
 439
 440     Map<String, Object> map;
 441
 442     map = SimpleMapper.convertObject(get("/object/empty/1.json"));
 443     assertEquals(0, map.size());
 444     map = SimpleMapper.convertObject(get("/object/empty/2.json"));
 445     assertEquals(0, map.size());
 446     map = SimpleMapper.convertObject(get("/object/empty/3.json"));
 447     assertEquals(0, map.size());
 448     map = SimpleMapper.convertObject(get("/object/empty/4.json"));
 449     assertEquals(0, map.size());
 450   }
 451
 452   @Test
 453   public void testConvertEmptyObject() throws Exception
 454   {
 455     LOG.info("<-- Start Of New Test-Case!");
 456
 457     Object object;
 458
 459     object = SimpleMapper.convert(get("/object/empty/1.json"));
 460     assertNotNull(object);
 461     assertTrue("the returned object should be a list", object instanceof Map);
 462     assertEquals(0, ((Map)object).size());
 463     object = SimpleMapper.convert(get("/object/empty/2.json"));
 464     assertNotNull(object);
 465     assertTrue("the returned object should be a list", object instanceof Map);
 466     assertEquals(0, ((Map)object).size());
 467     object = SimpleMapper.convert(get("/object/empty/3.json"));
 468     assertNotNull(object);
 469     assertTrue("the returned object should be a list", object instanceof Map);
 470     assertEquals(0, ((Map)object).size());
 471     object = SimpleMapper.convert(get("/object/empty/4.json"));
 472     assertNotNull(object);
 473     assertTrue("the returned object should be a list", object instanceof Map);
 474     assertEquals(0, ((Map)object).size());
 475   }
 476
 477
 478   @Test
 479   public void testConvertArrayToArraySpliterator() throws Exception
 480   {
 481     LOG.info("<-- Start Of New Test-Case!");
 482
 483     Spliterator<Object> spliterator;
 484
 485     spliterator = SimpleMapper.getArraySpliterator(get("/array/1.json"));
 486     checkArraySpliterator(spliterator);
 487     spliterator = SimpleMapper.getArraySpliterator(get("/array/2.json"));
 488     checkArraySpliterator(spliterator);
 489   }
 490
 491   void checkArraySpliterator(Spliterator<Object> spliterator) throws Exception
 492   {
 493     assertNotNull(spliterator);
 494
 495     final ArrayList<Object> entries = new ArrayList<>(4);
 496     for (int i = 0; i < 4; i++)
 497       assertTrue(
 498           "The created splitter should have a " + (i+1) + ". entry",
 499           spliterator.tryAdvance((Object t) -> { entries.add(t); })
 500           );
 501
 502     assertFalse(
 503         "The created splitter should have no more entries",
 504         spliterator.tryAdvance((Object t) ->
 505         {
 506           fail("The consumer should not have been called");
 507         }));
 508
 509     checkPartnerPageData(entries.get(3));
 510   }
 511
 512   @Test
 513   public void testConvertArrayToList() throws Exception
 514   {
 515     LOG.info("<-- Start Of New Test-Case!");
 516
 517     List<Object> list;
 518
 519     list = SimpleMapper.convertArray(get("/array/1.json"));
 520     assertNotNull(list);
 521     assertEquals(4, list.size());
 522     checkPartnerPageData(list.get(3));
 523     list = SimpleMapper.convertArray(get("/array/2.json"));
 524     assertNotNull(list);
 525     assertEquals(4, list.size());
 526     checkPartnerPageData(list.get(3));
 527   }
 528
 529   @Test
 530   public void testConvertArrayToObjectSpliterator() throws Exception
 531   {
 532     LOG.info("<-- Start Of New Test-Case!");
 533
 534     try
 535     {
 536       SimpleMapper.getObjectSpliterator(get("/array/1.json"));
 537       fail("it must not be possible, to get an object-spliterator for an array");
 538     }
 539     catch(IllegalArgumentException e)
 540     {
 541       LOG.trace("expected exception", e);
 542     }
 543
 544     try
 545     {
 546       SimpleMapper.getObjectSpliterator(get("/array/2.json"));
 547       fail("it must not be possible, to get an object-spliterator for an array");
 548     }
 549     catch(IllegalArgumentException e)
 550     {
 551       LOG.trace("expected exception", e);
 552     }
 553   }
 554
 555   @Test
 556   public void testConvertArrayToMap() throws Exception
 557   {
 558     LOG.info("<-- Start Of New Test-Case!");
 559
 560     try
 561     {
 562       SimpleMapper.convertObject(get("/array/1.json"));
 563       fail("it must not be possible, to get a map for an array");
 564     }
 565     catch(IllegalArgumentException e)
 566     {
 567       LOG.trace("expected exception", e);
 568     }
 569
 570     try
 571     {
 572       SimpleMapper.convertObject(get("/array/2.json"));
 573       fail("it must not be possible, to get a map for an array");
 574     }
 575     catch(IllegalArgumentException e)
 576     {
 577       LOG.trace("expected exception", e);
 578     }
 579   }
 580
 581   @Test
 582   public void testConvertArray() throws Exception
 583   {
 584     LOG.info("<-- Start Of New Test-Case!");
 585
 586     Object object;
 587     List<Object> list;
 588
 589     object = SimpleMapper.convert(get("/array/1.json"));
 590     assertNotNull(object);
 591     assertTrue("the returned object should be a list", object instanceof List);
 592     list = (List<Object>)object;
 593     assertEquals(4, list.size());
 594     checkPartnerPageData(list.get(3));
 595     object = SimpleMapper.convert(get("/array/2.json"));
 596     assertNotNull(object);
 597     assertTrue("the returned object should be a list", object instanceof List);
 598     list = (List<Object>)object;
 599     assertEquals(4, list.size());
 600     checkPartnerPageData(list.get(3));
 601   }
 602
 603
 604   @Test
 605   public void testConvertObjectToArraySpliterator() throws Exception
 606   {
 607     LOG.info("<-- Start Of New Test-Case!");
 608
 609     try
 610     {
 611       SimpleMapper.getArraySpliterator(get("/object/1.json"));
 612       fail("it must not be possible, to get an array-spliterator for an object");
 613     }
 614     catch(IllegalArgumentException e)
 615     {
 616       LOG.trace("expected exception", e);
 617     }
 618
 619     try
 620     {
 621       SimpleMapper.getArraySpliterator(get("/object/2.json"));
 622       fail("it must not be possible, to get an array-spliterator for an object");
 623     }
 624     catch(IllegalArgumentException e)
 625     {
 626       LOG.trace("expected exception", e);
 627     }
 628   }
 629
 630   @Test
 631   public void testConvertObjectToList() throws Exception
 632   {
 633     LOG.info("<-- Start Of New Test-Case!");
 634
 635     try
 636     {
 637       SimpleMapper.convertArray(get("/object/1.json"));
 638       fail("it must not be possible, to get a list for an object");
 639     }
 640     catch(IllegalArgumentException e)
 641     {
 642       LOG.trace("expected exception", e);
 643     }
 644
 645     try
 646     {
 647       SimpleMapper.convertArray(get("/object/2.json"));
 648       fail("it must not be possible, to get a list for an object");
 649     }
 650     catch(IllegalArgumentException e)
 651     {
 652       LOG.trace("expected exception", e);
 653     }
 654   }
 655
 656   @Test
 657   public void testConvertObjectToObjectSpliterator() throws Exception
 658   {
 659     LOG.info("<-- Start Of New Test-Case!");
 660
 661     Spliterator<Entry<String, Object>> spliterator;
 662
 663     spliterator = SimpleMapper.getObjectSpliterator(get("/object/1.json"));
 664     checkObjectSpliterator(spliterator);
 665     spliterator = SimpleMapper.getObjectSpliterator(get("/object/2.json"));
 666     checkObjectSpliterator(spliterator);
 667   }
 668
 669   void checkObjectSpliterator(Spliterator<Entry<String, Object>> spliterator)
 670       throws
 671         Exception
 672   {
 673     assertNotNull(spliterator);
 674
 675     final LinkedHashMap<String, Object> map = new LinkedHashMap<>();
 676     for (int i = 0; i < 4; i++)
 677       assertTrue(
 678           "The created splitter should have a " + (i+1) + ". entry",
 679           spliterator.tryAdvance((Entry<String, Object> e) -> {
 680             map.put(e.getKey(), e.getValue());
 681           }));
 682
 683     assertFalse(
 684         "The created splitter should have no more entries",
 685         spliterator.tryAdvance((Object t) ->
 686         {
 687           fail("The consumer should not have been called");
 688         }));
 689
 690     checkVariables(map);
 691   }
 692
 693   @Test
 694   public void testConvertObjectToMap() throws Exception
 695   {
 696     LOG.info("<-- Start Of New Test-Case!");
 697
 698     Map<String, Object> map;
 699
 700     map = SimpleMapper.convertObject(get("/object/1.json"));
 701     assertNotNull(map);
 702     assertEquals(4, map.size());
 703     checkVariables(map);
 704     map = SimpleMapper.convertObject(get("/object/2.json"));
 705     assertNotNull(map);
 706     assertEquals(4, map.size());
 707     checkVariables(map);
 708   }
 709
 710   @Test
 711   public void testConvertObject() throws Exception
 712   {
 713     LOG.info("<-- Start Of New Test-Case!");
 714
 715     Object object;
 716     Map<String, Object> map;
 717
 718     object = SimpleMapper.convert(get("/object/1.json"));
 719     assertNotNull(object);
 720     assertTrue("the returned object should be a map", object instanceof Map);
 721     map = (Map<String, Object>)object;
 722     assertEquals(4, map.size());
 723     checkVariables(map);
 724     object = SimpleMapper.convert(get("/object/2.json"));
 725     assertNotNull(object);
 726     assertTrue("the returned object should be a map", object instanceof Map);
 727     map = (Map<String, Object>)object;
 728     assertEquals(4, map.size());
 729     checkVariables(map);
 730   }
 731
 732   void checkVariables(Map<String, Object> map)
 733   {
 734     Iterator<Entry<String, Object>> iterator = map.entrySet().iterator();
 735     Entry<String, Object> entry;
 736
 737     assertTrue("The map should have a first element", iterator.hasNext());
 738     entry = iterator.next();
 739     assertEquals("bootstrap", entry.getKey());
 740     assertEquals("bootstrap.min.css", entry.getValue());
 741
 742     assertTrue("The map should have a second element", iterator.hasNext());
 743     entry = iterator.next();
 744     assertEquals("pages", entry.getKey());
 745     assertTrue(
 746         "The pages-variable should be of type List",
 747         entry.getValue() instanceof List
 748         );
 749     assertEquals(4, ((List)entry.getValue()).size());
 750     checkPartnerPageData(((List)entry.getValue()).get(3));
 751
 752     assertTrue("The map should have a third element", iterator.hasNext());
 753     entry = iterator.next();
 754     assertEquals("footer", entry.getKey());
 755     assertTrue(
 756         "The footer-variable should be of type List",
 757         entry.getValue() instanceof List
 758         );
 759     assertEquals(3, ((List)entry.getValue()).size());
 760
 761     assertTrue("The map should have a third element", iterator.hasNext());
 762     entry = iterator.next();
 763     assertEquals("sponsorship", entry.getKey());
 764     assertTrue(
 765         "The sponsorship-variable should be of type List",
 766         entry.getValue() instanceof List
 767         );
 768     assertEquals(3, ((List)entry.getValue()).size());
 769   }
 770
 771
 772   void checkPartnerPageData(Object page)
 773   {
 774     assertTrue("The page-data should be of type Map", page instanceof Map);
 775     Map<String, Object> map = (Map<String, Object>)page;
 776     assertEquals(4, map.size());
 777     assertEquals("/partner.html", map.get("uri"));
 778     assertTrue(
 779         "The page-data should have an entry \"children\" of type Map",
 780         map.get("children") instanceof Map
 781         );
 782     map = (Map<String, Object>)map.get("children");
 783     assertEquals(6, map.size());
 784     assertTrue(
 785         "The children-map should haven an entry \"/partner/juplo.html\" of type Map",
 786         map.get("/partner/juplo.html") instanceof Map
 787         );
 788     map = (Map<String, Object>)map.get("/partner/juplo.html");
 789     assertEquals(2, map.size());
 790     assertEquals(
 791         "Wir sind Unterstützer der Nerd-Plattform juplo.de",
 792         map.get("title")
 793         );
 794   }
 795
 796
 797   private JsonParser get(String resource) throws IOException
 798   {
 799     InputStream is = SimpleMapperTest.class.getResourceAsStream(resource);
 800     return factory.createParser(is);
 801   }
 802 }