Projekt-Seite erstellt: Velocity-Template - ...
[simple-mapper] / 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 }