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