1 package org.apache.fulcrum.parser;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import static org.junit.jupiter.api.Assertions.*;
23
24 import java.math.BigDecimal;
25 import java.util.Calendar;
26 import java.util.Locale;
27
28 import org.apache.avalon.framework.component.ComponentException;
29 import org.apache.fulcrum.testcontainer.BaseUnit5Test;
30 import org.junit.jupiter.api.AfterEach;
31 import org.junit.jupiter.api.BeforeEach;
32 import org.junit.jupiter.api.Test;
33
34
35
36
37
38
39
40
41
42 public class BaseValueParserTest extends BaseUnit5Test
43 {
44
45 private BaseValueParser parser;
46
47 private ParserService parserService;
48
49
50
51
52
53 @BeforeEach
54 public void setUp() throws Exception
55 {
56 try
57 {
58 parserService = (ParserService)this.lookup(ParserService.ROLE);
59 parser = parserService.getParser(BaseValueParser.class);
60 }
61 catch (ComponentException e)
62 {
63 e.printStackTrace();
64 fail(e.getMessage());
65 }
66 }
67
68
69
70
71 @AfterEach
72 public void tearDown()
73 {
74 parserService.putParser(parser);
75 this.release(parserService);
76 }
77
78 @Test
79 public void testDate()
80 {
81 parser.clear();
82 parser.setLocale(Locale.US);
83
84 assertEquals(0, parser.keySet().size(), "Wrong number of keys");
85
86 parser.add("foo", "03/21/2008");
87
88 Calendar cal = Calendar.getInstance(Locale.US);
89 cal.clear();
90 cal.set(2008, 2, 21, 0, 0, 0);
91
92 assertEquals( cal.getTime(), parser.getDate("foo"), "Wrong Date value (US)");
93
94 parser.clear();
95 parser.setLocale(Locale.GERMANY);
96
97 parser.add("foo", "21.03.2008");
98
99 cal = Calendar.getInstance(Locale.GERMANY);
100 cal.clear();
101 cal.set(2008, 2, 21, 0, 0, 0);
102
103 assertEquals( cal.getTime(), parser.getDate("foo"), "Wrong Date value (German)");
104 }
105 @Test
106 public void testGetByte()
107 {
108
109 byte result = parser.getByte("invalid");
110 assertEquals(result, 0);
111
112
113 result = parser.getByte("default", (byte)3);
114 assertEquals(result, 3);
115
116
117 parser.add("exists", "1");
118 result = parser.getByte("exists");
119 assertEquals(result, 1);
120
121
122 parser.add("unparsable", "a");
123 result = parser.getByte("unparsable");
124 assertEquals(result, 0);
125 }
126
127 @Test
128 public void testGetByteObject()
129 {
130
131 Byte result = parser.getByteObject("invalid");
132 assertNull(result);
133
134
135 result = parser.getByteObject("default", new Byte((byte)3));
136 assertEquals(result, new Byte((byte)3));
137
138
139 parser.add("exists", "1");
140 result = parser.getByteObject("exists");
141 assertEquals(result, new Byte((byte)1));
142
143
144 parser.add("unparsable", "a");
145 result = parser.getByteObject("unparsable");
146 assertNull(result);
147 }
148
149 @Test
150 public void testGetInt()
151 {
152
153 int result = parser.getInt("invalid");
154 assertEquals(result, 0);
155
156
157 result = parser.getInt("default", 3);
158 assertEquals(result, 3);
159
160
161 parser.add("exists", "1");
162 result = parser.getInt("exists");
163 assertEquals(result, 1);
164
165
166 parser.add("unparsable", "a");
167 result = parser.getInt("unparsable");
168 assertEquals(result, 0);
169
170
171 parser.add("array", "1");
172 parser.add("array", "2");
173 parser.add("array", "3");
174 int arrayResult[] = parser.getInts("array");
175 int compare[] = {1,2,3};
176 assertEquals(arrayResult.length, compare.length);
177 for( int i=0; i<compare.length; i++)
178 {
179 assertEquals(compare[i], arrayResult[i]);
180 }
181
182
183 parser.add("array2", "1");
184 parser.add("array2", "a");
185 parser.add("array2", "3");
186 int arrayResult2[] = parser.getInts("array2");
187 int compare2[] = {1,0,3};
188 assertEquals(arrayResult2.length, compare2.length);
189 for( int i=0; i<compare2.length; i++)
190 {
191 assertEquals(compare2[i], arrayResult2[i] );
192 }
193 }
194 @Test
195 public void testGetIntObject()
196 {
197
198 Integer result = parser.getIntObject("invalid");
199 assertNull(result);
200
201
202 result = parser.getIntObject("default", new Integer(3));
203 assertEquals(result, new Integer(3));
204
205
206 parser.add("exists", "1");
207 result = parser.getIntObject("exists");
208 assertEquals(result, new Integer(1));
209
210
211 parser.add("unparsable", "a");
212 result = parser.getIntObject("unparsable");
213 assertNull(result);
214
215
216 parser.add("array", "1");
217 parser.add("array", "2");
218 parser.add("array", "3");
219 Integer arrayResult[] = parser.getIntObjects("array");
220 Integer compare[] = {new Integer(1), new Integer(2), new Integer(3)};
221 assertEquals(arrayResult.length, compare.length);
222 for( int i=0; i<compare.length; i++)
223 {
224 assertEquals(compare[i], arrayResult[i]);
225 }
226
227
228 parser.add("array2", "1");
229 parser.add("array2", "a");
230 parser.add("array2", "3");
231 Integer arrayResult2[] = parser.getIntObjects("array2");
232 Integer compare2[] = {new Integer(1), null, new Integer(3)};
233 assertEquals(arrayResult2.length, compare2.length);
234 for( int i=0; i<compare2.length; i++)
235 {
236 assertEquals(compare2[i], arrayResult2[i] );
237 }
238 }
239 @Test
240 public void testGetFloat()
241 {
242
243 float result = parser.getFloat("invalid");
244 assertEquals(0, result);
245
246
247 result = parser.getFloat("default", 3);
248 assertEquals(3, result);
249
250
251 parser.add("exists", "1");
252 result = parser.getFloat("exists");
253 assertEquals(1, result);
254
255
256 parser.add("unparsable", "a");
257 result = parser.getFloat("unparsable");
258 assertEquals(0, result);
259
260
261 parser.add("array", "1");
262 parser.add("array", "2");
263 parser.add("array", "3");
264 float arrayResult[] = parser.getFloats("array");
265 float compare[] = {1,2,3};
266 assertEquals(arrayResult.length, compare.length);
267 for( int i=0; i<compare.length; i++)
268 {
269 assertEquals(compare[i], arrayResult[i]);
270 }
271
272
273 parser.add("array2", "1");
274 parser.add("array2", "a");
275 parser.add("array2", "3");
276 float arrayResult2[] = parser.getFloats("array2");
277 float compare2[] = {1,0,3};
278 assertEquals(compare2.length, arrayResult2.length);
279 for( int i=0; i<compare2.length; i++)
280 {
281 assertEquals(compare2[i], arrayResult2[i]);
282 }
283 }
284 @Test
285 public void testGetFloatObject()
286 {
287
288 Float result = parser.getFloatObject("invalid");
289 assertNull(result);
290
291
292 result = parser.getFloatObject("default", new Float(3));
293 assertEquals(new Float(3), result);
294
295
296 parser.add("exists", "1");
297 result = parser.getFloatObject("exists");
298 assertEquals(new Float(1), result);
299
300
301 parser.add("unparsable", "a");
302 result = parser.getFloatObject("unparsable");
303 assertNull(result);
304
305
306 parser.add("array", "1");
307 parser.add("array", "2");
308 parser.add("array", "3");
309 Float arrayResult[] = parser.getFloatObjects("array");
310 Float compare[] = {new Float(1), new Float(2), new Float(3)};
311 assertEquals(compare.length, arrayResult.length);
312 for( int i=0; i<compare.length; i++)
313 {
314 assertEquals(compare[i], arrayResult[i]);
315 }
316
317
318 parser.add("array2", "1");
319 parser.add("array2", "a");
320 parser.add("array2", "3");
321 Float arrayResult2[] = parser.getFloatObjects("array2");
322 Float compare2[] = {new Float(1), null, new Float(3)};
323 assertEquals(compare2.length, arrayResult2.length);
324 for( int i=0; i<compare2.length; i++)
325 {
326 assertEquals(arrayResult2[i], compare2[i] );
327 }
328 }
329 @Test
330 public void testGetDouble()
331 {
332
333 double result = parser.getDouble("invalid");
334 assertEquals(0, result);
335
336
337 result = parser.getDouble("default", 3);
338 assertEquals(3, result);
339
340
341 parser.add("exists", "1");
342 result = parser.getDouble("exists");
343 assertEquals(1, result);
344
345
346 parser.add("unparsable", "a");
347 result = parser.getDouble("unparsable");
348 assertEquals(0, result);
349
350
351 parser.add("array", "1");
352 parser.add("array", "2");
353 parser.add("array", "3");
354 double arrayResult[] = parser.getDoubles("array");
355 double compare[] = {1,2,3};
356 assertEquals(arrayResult.length, compare.length);
357 for( int i=0; i<compare.length; i++)
358 {
359 assertEquals( arrayResult[i], compare[i]);
360 }
361
362
363 parser.add("array2", "1");
364 parser.add("array2", "a");
365 parser.add("array2", "3");
366 double arrayResult2[] = parser.getDoubles("array2");
367 double compare2[] = {1,0,3};
368 assertEquals(arrayResult2.length, compare2.length);
369 for( int i=0; i<compare2.length; i++)
370 {
371 assertEquals( arrayResult2[i], compare2[i]);
372 }
373 }
374 @Test
375 public void testGetDoubleObject()
376 {
377
378 Double result = parser.getDoubleObject("invalid");
379 assertNull(result);
380
381
382 result = parser.getDoubleObject("default", new Double(3));
383 assertEquals( new Double(3), result);
384
385
386 parser.add("exists", "1");
387 result = parser.getDoubleObject("exists");
388 assertEquals( new Double(1), result);
389
390
391 parser.add("unparsable", "a");
392 result = parser.getDoubleObject("unparsable");
393 assertNull(result);
394
395
396 parser.add("array", "1");
397 parser.add("array", "2");
398 parser.add("array", "3");
399 Double arrayResult[] = parser.getDoubleObjects("array");
400 Double compare[] = {new Double(1), new Double(2), new Double(3)};
401 assertEquals(arrayResult.length, compare.length);
402 for( int i=0; i<compare.length; i++)
403 {
404 assertEquals( arrayResult[i], compare[i]);
405 }
406
407
408 parser.add("array2", "1");
409 parser.add("array2", "a");
410 parser.add("array2", "3");
411 Double arrayResult2[] = parser.getDoubleObjects("array2");
412 Double compare2[] = {new Double(1), null, new Double(3)};
413 assertEquals(arrayResult2.length, compare2.length);
414 for( int i=0; i<compare2.length; i++)
415 {
416 assertEquals( arrayResult2[i], compare2[i] );
417 }
418 }
419 @Test
420 public void testGetLong()
421 {
422
423 long result = parser.getLong("invalid");
424 assertEquals(0, result);
425
426
427 result = parser.getLong("default", 3);
428 assertEquals(3, result);
429
430
431 parser.add("exists", "1");
432 result = parser.getLong("exists");
433 assertEquals(1, result);
434
435
436 parser.add("unparsable", "a");
437 result = parser.getLong("unparsable");
438 assertEquals(0, result);
439
440
441 parser.add("array", "1");
442 parser.add("array", "2");
443 parser.add("array", "3");
444 long arrayResult[] = parser.getLongs("array");
445 long compare[] = {1,2,3};
446 assertEquals(arrayResult.length, compare.length);
447 for( int i=0; i<compare.length; i++)
448 {
449 assertEquals(compare[i], arrayResult[i]);
450 }
451
452
453 parser.add("array2", "1");
454 parser.add("array2", "a");
455 parser.add("array2", "3");
456 long arrayResult2[] = parser.getLongs("array2");
457 long compare2[] = {1,0,3};
458 assertEquals(arrayResult2.length, compare2.length);
459 for( int i=0; i<compare2.length; i++)
460 {
461 assertEquals( arrayResult2[i], compare2[i]);
462 }
463 }
464 @Test
465 public void testGetLongObject()
466 {
467
468 Long result = parser.getLongObject("invalid");
469 assertNull(result);
470
471
472 result = parser.getLongObject("default", new Long(3));
473 assertEquals(result, new Long(3));
474
475
476 parser.add("exists", "1");
477 result = parser.getLongObject("exists");
478 assertEquals(result, new Long(1));
479
480
481 parser.add("unparsable", "a");
482 result = parser.getLongObject("unparsable");
483 assertNull(result);
484
485
486 parser.add("array", "1");
487 parser.add("array", "2");
488 parser.add("array", "3");
489 Long arrayResult[] = parser.getLongObjects("array");
490 Long compare[] = {new Long(1), new Long(2), new Long(3)};
491 assertEquals(arrayResult.length, compare.length);
492 for( int i=0; i<compare.length; i++)
493 {
494 assertEquals(compare[i], arrayResult[i]);
495 }
496
497
498 parser.add("array2", "1");
499 parser.add("array2", "a");
500 parser.add("array2", "3");
501 Long arrayResult2[] = parser.getLongObjects("array2");
502 Long compare2[] = {new Long(1), null, new Long(3)};
503 assertEquals(arrayResult2.length, compare2.length);
504 for( int i=0; i<compare2.length; i++)
505 {
506 assertEquals(compare2[i], arrayResult2[i] );
507 }
508 }
509 @Test
510 public void testGetBoolean()
511 {
512
513 boolean result = parser.getBoolean("invalid");
514 assertEquals(result, false);
515
516
517 result = parser.getBoolean("default", true);
518 assertEquals(result, true);
519
520
521 parser.add("true1", "trUe");
522 result = parser.getBoolean("true1");
523 assertEquals(result, true);
524 parser.add("true2", "yEs");
525 result = parser.getBoolean("true2");
526 assertEquals(result, true);
527 parser.add("true3", "1");
528 result = parser.getBoolean("true3");
529 assertEquals(result, true);
530 parser.add("true4", "oN");
531 result = parser.getBoolean("true4");
532 assertEquals(result, true);
533
534
535 parser.add("unparsable", "a");
536 result = parser.getBoolean("unparsable");
537 assertEquals(result, false);
538
539 }
540 @Test
541 public void testGetBooleanObject()
542 {
543
544 Boolean result = parser.getBooleanObject("invalid");
545 assertNull(result);
546
547
548 result = parser.getBooleanObject("default", Boolean.TRUE);
549 assertEquals(result, Boolean.TRUE);
550
551
552 parser.add("true1", "trUe");
553 result = parser.getBooleanObject("true1");
554 assertEquals(result, Boolean.TRUE);
555 parser.add("true2", "yEs");
556 result = parser.getBooleanObject("true2");
557 assertEquals(result, Boolean.TRUE);
558 parser.add("true3", "1");
559 result = parser.getBooleanObject("true3");
560 assertEquals(result, Boolean.TRUE);
561 parser.add("true4", "oN");
562 result = parser.getBooleanObject("true4");
563 assertEquals(result, Boolean.TRUE);
564
565
566 parser.add("false1", "falSe");
567 result = parser.getBooleanObject("false1");
568 assertEquals(result, Boolean.FALSE);
569 parser.add("false2", "nO");
570 result = parser.getBooleanObject("false2");
571 assertEquals(result, Boolean.FALSE);
572 parser.add("false3", "0");
573 result = parser.getBooleanObject("false3");
574 assertEquals(result, Boolean.FALSE);
575 parser.add("false4", "oFf");
576 result = parser.getBooleanObject("false4");
577 assertEquals(result, Boolean.FALSE);
578
579
580
581 parser.add("unparsable", "a");
582 result = parser.getBooleanObject("unparsable");
583 assertNull(result);
584 }
585 @Test
586 public void testGetBigDecimal()
587 {
588
589 BigDecimal result = parser.getBigDecimal("invalid");
590 assertNull(result);
591
592
593 result = parser.getBigDecimal("default", new BigDecimal(3));
594 assertEquals(result, new BigDecimal(3));
595
596
597 parser.add("exists", "1");
598 result = parser.getBigDecimal("exists");
599 assertEquals(result, new BigDecimal(1));
600
601
602 parser.add("unparsable", "a");
603 result = parser.getBigDecimal("unparsable");
604 assertNull(result);
605
606
607 parser.add("array", "1");
608 parser.add("array", "2");
609 parser.add("array", "3");
610 BigDecimal arrayResult[] = parser.getBigDecimals("array");
611 BigDecimal compare[] = {new BigDecimal(1), new BigDecimal(2),
612 new BigDecimal(3)};
613 assertEquals(arrayResult.length, compare.length);
614 for( int i=0; i<compare.length; i++)
615 {
616 assertEquals(compare[i], arrayResult[i]);
617 }
618
619
620 parser.add("array2", "1");
621 parser.add("array2", "a");
622 parser.add("array2", "3");
623 BigDecimal arrayResult2[] = parser.getBigDecimals("array2");
624 BigDecimal compare2[] = {new BigDecimal(1), null, new BigDecimal(3)};
625 assertEquals(arrayResult2.length, compare2.length);
626 for( int i=0; i<compare2.length; i++)
627 {
628 assertEquals(compare2[i], arrayResult2[i] );
629 }
630 }
631
632 @Test
633 public void testGetString()
634 {
635
636 String result = parser.getString("invalid");
637 assertNull(result);
638
639
640 result = parser.getString("default", "default");
641 assertEquals(result, "default");
642
643
644 parser.add("null", (String) null);
645 assertNull( parser.getString("null"));
646
647
648 parser.add("multiple", "test");
649 parser.add("multiple", "test2");
650 assertEquals("test", parser.getString("multiple"));
651
652
653 parser.add("array", "line1");
654 parser.add("array", "line2");
655 parser.add("array", "line3");
656 String arrayResult[] = parser.getStrings("array");
657 String compare[] = {"line1","line2","line3"};
658 assertEquals(arrayResult.length, compare.length);
659 for( int i=0; i<compare.length; i++)
660 {
661 assertEquals(compare[i], arrayResult[i]);
662 }
663
664 }
665 @Test
666 public void testRecycling() throws Exception {
667 parser.setCharacterEncoding("fake");
668 parser.recycle();
669 assertEquals("US-ASCII",parser.getCharacterEncoding());
670 }
671
672 @Test
673 public void testSetup()
674 {
675 try
676 {
677 BaseValueParser vp = parserService.getParser(BaseValueParser.class);
678 assertFalse(vp.isDisposed());
679 parserService.putParser(vp);
680 }
681 catch (InstantiationException e)
682 {
683 assertTrue(false, "Could not instantiate ValueParser object");
684 }
685
686
687
688
689 }
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706 @Test
707 public void testClear()
708 {
709 parser.clear();
710
711 assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
712
713 parser.add("foo", "bar");
714
715 assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
716
717 parser.clear();
718
719 assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
720 }
721
722 @Test
723 public void testDispose()
724 {
725 parser.clear();
726
727 assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
728
729 parser.add("foo", "bar");
730
731 assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
732
733 parser.dispose();
734
735 assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
736
737 assertTrue(parser.isDisposed());
738 }
739 @Test
740 public void testKeyArray()
741 {
742 parser.clear();
743
744 assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
745
746 parser.add("bar", "foo");
747
748 assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
749
750 parser.add("bar", "baz");
751
752 assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
753 }
754
755 public void testDoubleAdd()
756 {
757 parser.clear();
758 parser.setLocale(Locale.US);
759
760 assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
761
762 double testValue = 2.2;
763
764 parser.add("foo", testValue);
765
766 assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
767
768 assertEquals( "2.2", parser.getString("foo"), "Wrong string value");
769 assertEquals( testValue, parser.getDouble("foo"), 0.001, "Wrong double value");
770 assertEquals( testValue, parser.getDoubleObject("foo").doubleValue(), 0.001, "Wrong Double value");
771
772 double [] doubles = parser.getDoubles("foo");
773 assertEquals( 1, doubles.length,"Wrong Array Size");
774
775 assertEquals( testValue, doubles[0], 0.001,"Wrong double array value");
776
777 Double [] doubleObjs = parser.getDoubleObjects("foo");
778 assertEquals( 1, doubleObjs.length,"Wrong Array Size");
779
780 assertEquals( testValue, doubleObjs[0].doubleValue(), 0.001,"Wrong Double array value");
781
782 parser.clear();
783 parser.setLocale(Locale.GERMANY);
784
785 String testDouble = "2,3";
786 parser.add("foo", testDouble);
787 assertEquals( 2.3, parser.getDouble("foo"), 0.001,"Wrong double value");
788
789 parser.add("unparsable2", "1a");
790 Double result = parser.getDoubleObject("unparsable2");
791 assertNull(result, "Double object should be null");
792 }
793 @Test
794 public void testIntAdd()
795 {
796 parser.clear();
797
798 assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
799
800 int testValue = 123;
801
802 parser.add("foo", testValue);
803
804 assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
805
806 assertEquals( "123", parser.getString("foo"),"Wrong string value");
807 assertEquals( testValue, parser.getInt("foo"),"Wrong int value");
808 assertEquals( testValue, parser.getIntObject("foo").intValue(),"Wrong Int value");
809
810 int [] ints = parser.getInts("foo");
811 assertEquals( 1, ints.length,"Wrong Array Size");
812
813 assertEquals( testValue, ints[0],"Wrong int array value");
814
815 Integer [] intObjs = parser.getIntObjects("foo");
816 assertEquals( 1, intObjs.length,"Wrong Array Size");
817
818 assertEquals( testValue, intObjs[0].intValue(),"Wrong Int array value");
819 }
820 @Test
821 public void testIntegerAdd()
822 {
823 parser.clear();
824
825 assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
826
827 Integer testValue = new Integer(123);
828
829 parser.add("foo", testValue);
830
831 assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
832
833 assertEquals( "123", parser.getString("foo"),"Wrong string value");
834 assertEquals( testValue.intValue(), parser.getInt("foo"),"Wrong int value");
835 assertEquals( testValue.intValue(), parser.getIntObject("foo").intValue(),"Wrong Int value");
836
837 int [] ints = parser.getInts("foo");
838 assertEquals( 1, ints.length,"Wrong Array Size");
839
840 assertEquals( testValue.intValue(), ints[0],"Wrong int array value");
841
842 Integer [] intObjs = parser.getIntObjects("foo");
843 assertEquals( 1, intObjs.length,"Wrong Array Size");
844
845 assertEquals( testValue.intValue(), intObjs[0].intValue(),"Wrong Int array value");
846 }
847 @Test
848 public void testLongAdd()
849 {
850 parser.clear();
851
852 assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
853
854 long testValue = 9223372036854775807l;
855
856 parser.add("foo", testValue);
857
858 assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
859
860 assertEquals( "9223372036854775807", parser.getString("foo"),"Wrong string value");
861 assertEquals( testValue, parser.getLong("foo"),"Wrong long value");
862 assertEquals( testValue, parser.getLongObject("foo").longValue(),"Wrong Long value");
863
864 long [] longs = parser.getLongs("foo");
865 assertEquals( 1, longs.length,"Wrong Array Size");
866
867 assertEquals( testValue, longs[0],"Wrong long array value");
868
869 Long [] longObjs = parser.getLongObjects("foo");
870 assertEquals( 1, longObjs.length,"Wrong Array Size");
871
872 assertEquals( testValue, longObjs[0].longValue(),"Wrong Long array value");
873 }
874 @Test
875 public void testLongToInt()
876 {
877 parser.clear();
878
879 assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
880
881 long testValue = 1234l;
882
883 parser.add("foo", testValue);
884
885 assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
886
887 assertEquals( "1234", parser.getString("foo"),"Wrong string value");
888 assertEquals( (int) testValue, parser.getInt("foo"),"Wrong int value");
889 assertEquals( (int) testValue, parser.getIntObject("foo").intValue(),"Wrong Int value");
890
891 int [] ints = parser.getInts("foo");
892 assertEquals( 1, ints.length,"Wrong Array Size");
893
894 assertEquals( testValue, ints[0],"Wrong int array value");
895
896 Integer [] intObjs = parser.getIntObjects("foo");
897 assertEquals( 1, intObjs.length,"Wrong Array Size");
898
899 assertEquals( testValue, intObjs[0].intValue(),"Wrong Int array value");
900 }
901
902 public void testIntToLong()
903 {
904 parser.clear();
905
906 assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
907
908 int testValue = 123;
909
910 parser.add("foo", testValue);
911
912 assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
913
914 assertEquals( "123", parser.getString("foo"),"Wrong string value");
915 assertEquals( testValue, parser.getLong("foo"),"Wrong long value");
916 assertEquals( testValue, parser.getLongObject("foo").longValue(),"Wrong Long value");
917
918 long [] longs = parser.getLongs("foo");
919 assertEquals( 1, longs.length,"Wrong Array Size");
920
921 assertEquals( testValue, longs[0],"Wrong long array value");
922
923 Long [] longObjs = parser.getLongObjects("foo");
924 assertEquals( 1, longObjs.length,"Wrong Array Size");
925
926 assertEquals( testValue, longObjs[0].longValue(),"Wrong Long array value");
927 }
928 @Test
929 public void testIntToDouble()
930 {
931 parser.clear();
932
933 assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
934
935 int testValue = 123;
936
937 parser.add("foo", testValue);
938
939 assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
940
941 assertEquals( "123", parser.getString("foo"),"Wrong string value");
942 assertEquals( testValue, parser.getDouble("foo"), 0.001,"Wrong double value");
943 assertEquals( testValue, parser.getDoubleObject("foo").doubleValue(), 0.001,"Wrong Double value");
944
945 double [] doubles = parser.getDoubles("foo");
946 assertEquals( 1, doubles.length,"Wrong Array Size");
947
948 assertEquals( testValue, doubles[0], 0.001,"Wrong double array value");
949
950 Double [] doubleObjs = parser.getDoubleObjects("foo");
951 assertEquals( 1, doubleObjs.length,"Wrong Array Size");
952
953 assertEquals( testValue, doubleObjs[0].doubleValue(), 0.001,"Wrong Double array value");
954 }
955 @Test
956 public void testLongToDouble()
957 {
958 parser.clear();
959
960 assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
961
962 long testValue = 9223372036854775807l;
963
964 parser.add("foo", testValue);
965
966 assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
967
968 assertEquals( "9223372036854775807", parser.getString("foo"),"Wrong string value");
969 assertEquals( testValue, parser.getDouble("foo"), 0.001,"Wrong double value");
970 assertEquals( testValue, parser.getDoubleObject("foo").doubleValue(), 0.001,"Wrong Double value");
971
972 double [] doubles = parser.getDoubles("foo");
973 assertEquals( 1, doubles.length,"Wrong Array Size");
974
975 assertEquals( testValue, doubles[0], 0.001,"Wrong double array value");
976
977 Double [] doubleObjs = parser.getDoubleObjects("foo");
978 assertEquals( 1, doubleObjs.length,"Wrong Array Size");
979
980 assertEquals( testValue, doubleObjs[0].doubleValue(), 0.001,"Wrong Double array value");
981 }
982
983 public void testStringAdd()
984 {
985 parser.clear();
986
987 assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
988
989 String testValue = "the quick brown fox";
990
991 parser.add("foo", testValue);
992
993 assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
994
995 assertEquals( testValue, parser.getString("foo"),"Wrong string value");
996
997 String [] Strings = parser.getStrings("foo");
998 assertEquals( 1, Strings.length,"Wrong Array Size");
999
1000 assertEquals( testValue, Strings[0],"Wrong String array value");
1001 }
1002
1003 public void testStringToInt()
1004 {
1005 parser.clear();
1006
1007 assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
1008
1009 String testValue = "123456";
1010
1011 parser.add("foo", testValue);
1012
1013 assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
1014
1015 assertEquals( testValue, parser.getString("foo"),"Wrong string value");
1016
1017 assertEquals( Integer.parseInt(testValue), parser.getInt("foo"),"Wrong int value");
1018 assertEquals( Integer.valueOf(testValue).intValue(), parser.getIntObject("foo").intValue(),"Wrong Int value");
1019
1020 int [] ints = parser.getInts("foo");
1021 assertEquals( 1, ints.length,"Wrong Array Size");
1022
1023 assertEquals( Integer.parseInt(testValue), ints[0],"Wrong int array value");
1024
1025 Integer [] intObjs = parser.getIntObjects("foo");
1026 assertEquals( 1, intObjs.length,"Wrong Array Size");
1027
1028 assertEquals( Integer.valueOf(testValue).intValue(), intObjs[0].intValue(),"Wrong Int array value");
1029 }
1030
1031 public void testStringToLong()
1032 {
1033 parser.clear();
1034
1035 assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
1036
1037 String testValue = "123456";
1038
1039 parser.add("foo", testValue);
1040
1041 assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
1042
1043 assertEquals( testValue, parser.getString("foo"),"Wrong string value");
1044
1045 assertEquals( Long.parseLong(testValue), parser.getLong("foo"),"Wrong long value");
1046 assertEquals( Long.valueOf(testValue).longValue(), parser.getLongObject("foo").longValue(),"Wrong Long value");
1047
1048 long [] longs = parser.getLongs("foo");
1049 assertEquals( 1, longs.length,"Wrong Array Size");
1050
1051 assertEquals( Long.parseLong(testValue), longs[0],"Wrong long array value");
1052
1053 Long [] longObjs = parser.getLongObjects("foo");
1054 assertEquals( 1, longObjs.length,"Wrong Array Size");
1055
1056 assertEquals( Long.valueOf(testValue).longValue(), longObjs[0].longValue(),"Wrong Long array value");
1057 }
1058 @Test
1059 public void testStringArray()
1060 {
1061 parser.clear();
1062
1063 assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
1064
1065 String [] testValue = new String [] {
1066 "foo", "bar", "baz"
1067 };
1068
1069 parser.add("foo", testValue);
1070
1071 assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
1072
1073 String [] res = parser.getStrings("foo");
1074
1075 assertEquals( 3, res.length,"Wrong number of elements");
1076
1077 for (int i = 0; i < res.length; i++)
1078 {
1079 assertEquals( res[i], testValue[i],"Wrong value");
1080 }
1081
1082 assertEquals( testValue[0], parser.getString("foo"),"Wrong element returned");
1083
1084 parser.add("foo", "xxx");
1085
1086 res = parser.getStrings("foo");
1087
1088 assertEquals( 4, res.length,"Wrong number of elements");
1089
1090 for (int i = 0; i < 3; i++)
1091 {
1092 assertEquals( res[i], testValue[i],"Wrong value");
1093 }
1094
1095 assertEquals(res[3], "xxx");
1096
1097
1098 assertEquals( testValue[0], parser.getString("foo"),"Wrong element returned");
1099 }
1100 @Test
1101 public void testRemove()
1102 {
1103 parser.clear();
1104
1105 assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
1106
1107 String testValue = "the quick brown fox";
1108
1109 parser.add("foo", testValue);
1110
1111 assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
1112
1113 assertEquals( testValue, parser.getString("foo"),"Wrong string value");
1114
1115 assertNotNull(parser.remove("foo"));
1116
1117 assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
1118
1119 assertNull(parser.getString("foo"));
1120
1121
1122 assertNull(parser.remove("baz"));
1123
1124
1125 assertNull(parser.remove(null));
1126 }
1127 @Test
1128 public void testRemoveArray()
1129 {
1130 parser.clear();
1131
1132 assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
1133
1134 String testValue = "the quick brown fox";
1135
1136 parser.add("foo", testValue);
1137
1138 assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
1139
1140 parser.add("foo", testValue);
1141
1142 assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
1143
1144 assertEquals( testValue, parser.getString("foo"),"Wrong string value");
1145
1146 String [] res = parser.getStrings("foo");
1147
1148 assertEquals( 2, res.length,"Wrong number of elements");
1149
1150 for (int i = 0; i < res.length; i++)
1151 {
1152 assertEquals( res[i], testValue,"Wrong value");
1153 }
1154
1155 parser.remove("foo");
1156
1157 assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
1158
1159 assertNull(parser.getString("foo"));
1160 }
1161 @Test
1162 public void testContainsKey()
1163 {
1164 parser.clear();
1165
1166 parser.add("foo", "bar");
1167 parser.add("bar", new String [] { "foo", "bar" });
1168
1169 assertTrue(parser.containsKey("foo"));
1170 assertTrue(parser.containsKey("bar"));
1171 assertFalse(parser.containsKey("baz"));
1172 }
1173 @Test
1174 public void testBooleanObject()
1175 {
1176 parser.clear();
1177
1178 parser.add("t1", "true");
1179 parser.add("t2", "yes");
1180 parser.add("t3", "on");
1181 parser.add("t4", "1");
1182 parser.add("t5", 1);
1183
1184 parser.add("f1", "false");
1185 parser.add("f2", "no");
1186 parser.add("f3", "off");
1187 parser.add("f4", "0");
1188 parser.add("f5", 0);
1189
1190 parser.add("e1", "nix");
1191 parser.add("e2", "weg");
1192 parser.add("e3", 200);
1193 parser.add("e4", -2.5);
1194
1195 assertEquals( Boolean.TRUE, parser.getBooleanObject("t1"),"Value is not true");
1196 assertEquals( Boolean.TRUE, parser.getBooleanObject("t2"),"Value is not true");
1197 assertEquals( Boolean.TRUE, parser.getBooleanObject("t3"),"Value is not true");
1198 assertEquals( Boolean.TRUE, parser.getBooleanObject("t4"),"Value is not true");
1199 assertEquals( Boolean.TRUE, parser.getBooleanObject("t5"),"Value is not true");
1200
1201 assertEquals( Boolean.FALSE, parser.getBooleanObject("f1"),"Value is not false");
1202 assertEquals( Boolean.FALSE, parser.getBooleanObject("f2"),"Value is not false");
1203 assertEquals( Boolean.FALSE, parser.getBooleanObject("f3"),"Value is not false");
1204 assertEquals( Boolean.FALSE, parser.getBooleanObject("f4"),"Value is not false");
1205 assertEquals( Boolean.FALSE, parser.getBooleanObject("f5"),"Value is not false");
1206
1207 assertNull(parser.getBooleanObject("e1"));
1208 assertNull(parser.getBooleanObject("e2"));
1209 assertNull(parser.getBooleanObject("e3"));
1210 assertNull(parser.getBooleanObject("e4"));
1211
1212 assertNull(parser.getBooleanObject("does-not-exist"));
1213 }
1214 @Test
1215 public void testBoolDefault()
1216 {
1217 parser.clear();
1218
1219 parser.add("t1", "true");
1220 parser.add("f1", "false");
1221
1222 assertTrue(parser.getBoolean("t1"));
1223 assertFalse(parser.getBoolean("f1"));
1224
1225 assertFalse(parser.getBoolean("does not exist"));
1226
1227 assertTrue(parser.getBoolean("t1", false));
1228 assertFalse(parser.getBoolean("f1", true));
1229
1230 assertFalse(parser.getBoolean("does not exist", false));
1231 assertTrue(parser.getBoolean("does not exist", true));
1232 }
1233 @Test
1234 public void testBooleanDefault()
1235 {
1236 parser.clear();
1237
1238 parser.add("t1", "true");
1239 parser.add("f1", "false");
1240
1241 assertEquals( Boolean.TRUE, parser.getBooleanObject("t1"),"Value is not true");
1242 assertEquals( Boolean.FALSE, parser.getBooleanObject("f1"),"Value is not false");
1243
1244 assertNull(parser.getBooleanObject("does not exist"));
1245
1246 assertEquals( Boolean.TRUE, parser.getBooleanObject("t1", Boolean.FALSE),"Value is not true");
1247 assertEquals( Boolean.TRUE, parser.getBooleanObject("t1", null),"Value is not true");
1248 assertEquals( Boolean.FALSE, parser.getBooleanObject("f1", Boolean.TRUE),"Value is not false");
1249 assertEquals( Boolean.FALSE, parser.getBooleanObject("f1", null),"Value is not false");
1250
1251 assertNull(parser.getBooleanObject("does not exist", null));
1252 }
1253 @Test
1254 public void testDoubleArray()
1255 {
1256 parser.clear();
1257
1258 assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
1259
1260 double [] testValue = {
1261 1.0, 2.0, 3.0
1262 };
1263
1264 for (int i = 0; i < testValue.length; i++)
1265 {
1266 parser.add("foo", testValue[i]);
1267
1268 String [] res = parser.getStrings("foo");
1269 assertEquals( res.length, i + 1,"Wrong number of elements");
1270 }
1271
1272 assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
1273
1274 double [] res = parser.getDoubles("foo");
1275
1276 assertEquals( 3, res.length,"Wrong number of elements");
1277
1278 for (int i = 0; i < res.length; i++)
1279 {
1280 assertEquals( res[i], testValue[i], 0.001,"Wrong value");
1281 }
1282
1283 Double [] resObj = parser.getDoubleObjects("foo");
1284
1285 assertEquals( 3, resObj.length,"Wrong number of elements");
1286
1287 for (int i = 0; i < resObj.length; i++)
1288 {
1289 assertEquals( resObj[i].doubleValue(), testValue[i], 0.001,"Wrong value");
1290 }
1291
1292 assertEquals( testValue[0], parser.getDoubleObject("foo").doubleValue(), 0.001,"Wrong element returned");
1293
1294 parser.add("foo", 4.0);
1295
1296 res = parser.getDoubles("foo");
1297
1298 assertEquals( 4, res.length,"Wrong number of elements");
1299
1300 for (int i = 0; i < 3; i++)
1301 {
1302 assertEquals( res[i], testValue[i], 0.001,"Wrong value");
1303 }
1304
1305 assertEquals(res[3], 4.0, 0.001);
1306
1307 resObj = parser.getDoubleObjects("foo");
1308
1309 assertEquals( 4, resObj.length,"Wrong number of elements");
1310
1311 for (int i = 0; i < 3; i++)
1312 {
1313 assertEquals( resObj[i].doubleValue(), testValue[i], 0.001,"Wrong value");
1314 }
1315
1316 assertEquals(resObj[3].doubleValue(), 4.0, 0.001);
1317
1318
1319 assertEquals( testValue[0], parser.getDouble("foo"), 0.001,"Wrong element returned");
1320 }
1321 @Test
1322 public void testFloatArray()
1323 {
1324 parser.clear();
1325
1326 assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
1327
1328 float [] testValue = {
1329 1.0f, 2.0f, 3.0f
1330 };
1331
1332 for (int i = 0; i < testValue.length; i++)
1333 {
1334 parser.add("foo", testValue[i]);
1335
1336 String [] res = parser.getStrings("foo");
1337 assertEquals( res.length, i + 1,"Wrong number of elements");
1338 }
1339
1340 assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
1341
1342 float [] res = parser.getFloats("foo");
1343
1344 assertEquals( 3, res.length,"Wrong number of elements");
1345
1346 for (int i = 0; i < res.length; i++)
1347 {
1348 assertEquals( res[i], testValue[i], 0.001f,"Wrong value");
1349 }
1350
1351 Float [] resObj = parser.getFloatObjects("foo");
1352
1353 assertEquals( 3, resObj.length,"Wrong number of elements");
1354
1355 for (int i = 0; i < resObj.length; i++)
1356 {
1357 assertEquals( resObj[i].floatValue(), testValue[i], 0.001f,"Wrong value");
1358 }
1359
1360 assertEquals( testValue[0], parser.getFloatObject("foo").floatValue(), 0.001f,"Wrong element returned");
1361
1362 parser.add("foo", 4.0f);
1363
1364 res = parser.getFloats("foo");
1365
1366 assertEquals( 4, res.length,"Wrong number of elements");
1367
1368 for (int i = 0; i < 3; i++)
1369 {
1370 assertEquals( res[i], testValue[i], 0.001f,"Wrong value");
1371 }
1372
1373 assertEquals(res[3], 4.0f, 0.001f);
1374
1375 resObj = parser.getFloatObjects("foo");
1376
1377 assertEquals( 4, resObj.length,"Wrong number of elements");
1378
1379 for (int i = 0; i < 3; i++)
1380 {
1381 assertEquals( resObj[i].floatValue(), testValue[i], 0.001f,"Wrong value");
1382 }
1383
1384 assertEquals(resObj[3].floatValue(), 4.0f, 0.001f);
1385
1386
1387 assertEquals( testValue[0], parser.getFloat("foo"), 0.001f,"Wrong element returned");
1388 }
1389 @Test
1390 public void testBigDecimalArray()
1391 {
1392 parser.clear();
1393
1394 assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
1395
1396 long [] testValue = {
1397 12345678,87654321,1092837465,
1398 };
1399
1400 for (int i = 0; i < testValue.length; i++)
1401 {
1402 parser.add("foo", testValue[i]);
1403
1404 String [] res = parser.getStrings("foo");
1405 assertEquals( res.length, i + 1,"Wrong number of elements");
1406 }
1407
1408 assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
1409
1410 BigDecimal [] res = parser.getBigDecimals("foo");
1411
1412 assertEquals( 3, res.length,"Wrong number of elements");
1413
1414 for (int i = 0; i < res.length; i++)
1415 {
1416 assertEquals( res[i].longValue(), testValue[i],"Wrong value");
1417 }
1418
1419 assertEquals( testValue[0], parser.getBigDecimal("foo").longValue(),"Wrong element returned");
1420
1421 parser.add("foo", 77777777);
1422
1423 res = parser.getBigDecimals("foo");
1424
1425 assertEquals( 4, res.length,"Wrong number of elements");
1426
1427 for (int i = 0; i < 3; i++)
1428 {
1429 assertEquals( res[i].longValue(), testValue[i], 0.001,"Wrong value");
1430 }
1431
1432 assertEquals(res[3].longValue(), 77777777);
1433
1434
1435 assertEquals( testValue[0], parser.getBigDecimal("foo").longValue(),"Wrong element returned");
1436 }
1437 @Test
1438 public void testIntegerArray()
1439 {
1440 parser.clear();
1441
1442 assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
1443
1444 int [] testValue = {
1445 1, 2, 3
1446 };
1447
1448 for (int i = 0; i < testValue.length; i++)
1449 {
1450 parser.add("foo", testValue[i]);
1451
1452 String [] res = parser.getStrings("foo");
1453 assertEquals( res.length, i + 1,"Wrong number of elements");
1454 }
1455
1456 assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
1457
1458 int [] res = parser.getInts("foo");
1459
1460 assertEquals( 3, res.length,"Wrong number of elements");
1461
1462 for (int i = 0; i < res.length; i++)
1463 {
1464 assertEquals( res[i], testValue[i],"Wrong value");
1465 }
1466
1467 Integer [] resObj = parser.getIntObjects("foo");
1468
1469 assertEquals( 3, resObj.length,"Wrong number of elements");
1470
1471 for (int i = 0; i < resObj.length; i++)
1472 {
1473 assertEquals( resObj[i].intValue(), testValue[i],"Wrong value");
1474 }
1475
1476 assertEquals( testValue[0], parser.getIntObject("foo").intValue(),"Wrong element returned");
1477
1478 parser.add("foo", 4);
1479
1480 res = parser.getInts("foo");
1481
1482 assertEquals( 4, res.length,"Wrong number of elements");
1483
1484 for (int i = 0; i < 3; i++)
1485 {
1486 assertEquals( res[i], testValue[i],"Wrong value");
1487 }
1488
1489 assertEquals(res[3], 4);
1490
1491 resObj = parser.getIntObjects("foo");
1492
1493 assertEquals( 4, resObj.length,"Wrong number of elements");
1494
1495 for (int i = 0; i < 3; i++)
1496 {
1497 assertEquals( resObj[i].intValue(), testValue[i],"Wrong value");
1498 }
1499
1500 assertEquals(resObj[3].intValue(), 4);
1501
1502
1503 assertEquals( testValue[0], parser.getInt("foo"),"Wrong element returned");
1504 }
1505 @Test
1506 public void testLongArray()
1507 {
1508 parser.clear();
1509
1510 assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
1511
1512 long [] testValue = {
1513 1l, 2l, 3l
1514 };
1515
1516 for (int i = 0; i < testValue.length; i++)
1517 {
1518 parser.add("foo", testValue[i]);
1519
1520 String [] res = parser.getStrings("foo");
1521 assertEquals( res.length, i + 1,"Wrong number of elements");
1522 }
1523
1524 assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
1525
1526 long [] res = parser.getLongs("foo");
1527
1528 assertEquals( 3, res.length,"Wrong number of elements");
1529
1530 for (int i = 0; i < res.length; i++)
1531 {
1532 assertEquals( res[i], testValue[i],"Wrong value");
1533 }
1534
1535 Long [] resObj = parser.getLongObjects("foo");
1536
1537 assertEquals( 3, resObj.length,"Wrong number of elements");
1538
1539 for (int i = 0; i < resObj.length; i++)
1540 {
1541 assertEquals( resObj[i].longValue(), testValue[i],"Wrong value");
1542 }
1543
1544 assertEquals( testValue[0], parser.getLongObject("foo").longValue(),"Wrong element returned");
1545
1546 parser.add("foo", 4);
1547
1548 res = parser.getLongs("foo");
1549
1550 assertEquals( 4, res.length,"Wrong number of elements");
1551
1552 for (int i = 0; i < 3; i++)
1553 {
1554 assertEquals( res[i], testValue[i],"Wrong value");
1555 }
1556
1557 assertEquals(res[3], 4);
1558
1559 resObj = parser.getLongObjects("foo");
1560
1561 assertEquals( 4, resObj.length,"Wrong number of elements");
1562
1563 for (int i = 0; i < 3; i++)
1564 {
1565 assertEquals( resObj[i].longValue(), testValue[i],"Wrong value");
1566 }
1567
1568 assertEquals(resObj[3].longValue(), 4);
1569
1570
1571 assertEquals( testValue[0], parser.getLong("foo"),"Wrong element returned");
1572 }
1573 @Test
1574 public void testByteArray()
1575 throws Exception
1576 {
1577 parser.clear();
1578
1579 assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
1580
1581 String testValue = "abcdefg";
1582
1583 parser.add("foo", testValue);
1584
1585 assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
1586
1587 byte [] res = parser.getBytes("foo");
1588
1589 assertEquals( 7, res.length,"Wrong number of elements");
1590
1591 for (int i = 0; i < res.length; i++)
1592 {
1593 byte [] testByte = testValue.substring(i, i + 1).getBytes(parser.getCharacterEncoding());
1594 assertEquals( 1, testByte.length,"More than one byte for a char!");
1595 assertEquals( res[i], testByte[0],"Wrong value");
1596 }
1597 }
1598 @Test
1599 public void testByte()
1600 {
1601 parser.clear();
1602
1603 assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
1604
1605 String [] testValue = {
1606 "0", "127", "-1",
1607 "0", "-127", "100"
1608 };
1609
1610
1611 for (int i = 0; i < testValue.length; i++)
1612 {
1613 parser.add("foo" + i, testValue[i]);
1614 }
1615
1616 assertEquals( 6, parser.keySet().size(),"Wrong number of keys");
1617
1618 assertEquals( (byte) 0, parser.getByte("foo0"),"Wrong value");
1619 assertEquals( (byte) 127, parser.getByte("foo1"),"Wrong value");
1620 assertEquals( (byte) -1, parser.getByte("foo2"),"Wrong value");
1621 assertEquals( (byte) 0, parser.getByte("foo3"),"Wrong value");
1622 assertEquals( (byte) -127, parser.getByte("foo4"),"Wrong value");
1623 assertEquals( (byte) 100, parser.getByte("foo5"),"Wrong value");
1624
1625 assertEquals( new Byte((byte) 0), parser.getByteObject("foo0"),"Wrong value");
1626 assertEquals( new Byte((byte) 127), parser.getByteObject("foo1"),"Wrong value");
1627 assertEquals( new Byte((byte) -1), parser.getByteObject("foo2"),"Wrong value");
1628 assertEquals( new Byte((byte) 0), parser.getByteObject("foo3"),"Wrong value");
1629 assertEquals( new Byte((byte) -127), parser.getByteObject("foo4"),"Wrong value");
1630 assertEquals( new Byte((byte) 100), parser.getByteObject("foo5"),"Wrong value");
1631
1632 }
1633 @Test
1634 public void testStringDefault()
1635 {
1636 parser.clear();
1637
1638 assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
1639
1640 parser.add("foo", "bar");
1641
1642 assertEquals( "bar", parser.getString("foo", "xxx"),"Wrong value found");
1643 assertEquals( "bar", parser.getString("foo", null),"Wrong value found");
1644
1645 assertEquals( "baz", parser.getString("does-not-exist", "baz"),"Wrong value found");
1646 assertNull(parser.getString("does-not-exist", null));
1647 }
1648 @Test
1649 public void testSetString()
1650 {
1651 parser.clear();
1652
1653 assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
1654
1655 parser.add("foo", "bar");
1656
1657 assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
1658
1659 parser.add("bar", "foo");
1660
1661 assertEquals( 2, parser.keySet().size(), "Wrong number of keys");
1662
1663 parser.add("bar", "baz");
1664
1665 assertEquals( 2, parser.keySet().size(), "Wrong number of keys");
1666
1667 String [] res = parser.getStrings("bar");
1668 assertEquals( 2, res.length, "Wrong number of values");
1669 assertEquals( "foo", res[0], "Wrong value found");
1670 assertEquals( "baz", res[1], "Wrong value found");
1671
1672 parser.setString("bar", "xxx");
1673
1674 assertEquals( 2, parser.keySet().size(), "Wrong number of keys");
1675
1676 res = parser.getStrings("bar");
1677 assertEquals( 1, res.length, "Wrong number of values");
1678 assertEquals( "xxx", res[0], "Wrong value found");
1679 }
1680 @Test
1681 public void testSetStrings()
1682 {
1683 parser.clear();
1684
1685 assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
1686
1687 parser.add("foo", "bar");
1688
1689 assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
1690
1691 parser.add("bar", "foo");
1692
1693 assertEquals( 2, parser.keySet().size(), "Wrong number of keys");
1694
1695 parser.add("bar", "baz");
1696
1697 assertEquals( 2, parser.keySet().size(), "Wrong number of keys");
1698
1699 String [] res = parser.getStrings("bar");
1700 assertEquals( 2, res.length, "Wrong number of values");
1701 assertEquals( "foo", res[0], "Wrong value found");
1702 assertEquals( "baz", res[1], "Wrong value found");
1703
1704 String [] newValues = new String [] { "aaa", "bbb", "ccc", "ddd" };
1705
1706 parser.setStrings("bar", newValues);
1707
1708 assertEquals( 2, parser.keySet().size(),"Wrong number of keys");
1709
1710 res = parser.getStrings("bar");
1711 assertEquals( newValues.length, res.length,"Wrong number of values");
1712
1713 for (int i = 0 ; i < newValues.length; i++)
1714 {
1715 assertEquals( newValues[i], res[i],"Wrong value found");
1716 }
1717 }
1718 @Test
1719 public void testSetProperties()
1720 throws Exception
1721 {
1722 parser.clear();
1723
1724 parser.add("longValue", 12345l);
1725 parser.add("doubleValue", 2.0);
1726 parser.add("intValue", 200);
1727 parser.add("stringValue", "foobar");
1728 parser.add("booleanValue", "true");
1729
1730 PropertyBeanertyBean.html#PropertyBean">PropertyBean bp = new PropertyBean();
1731 bp.setDoNotTouchValue("abcdef");
1732
1733 parser.setProperties(bp);
1734
1735 assertEquals( "abcdef", bp.getDoNotTouchValue(), "Wrong value in bean");
1736 assertEquals( "foobar", bp.getStringValue(), "Wrong value in bean");
1737 assertEquals( 200, bp.getIntValue(), "Wrong value in bean");
1738 assertEquals( 2.0, bp.getDoubleValue(), 0.001, "Wrong value in bean");
1739 assertEquals( 12345l, bp.getLongValue(), "Wrong value in bean");
1740 assertEquals( Boolean.TRUE, bp.getBooleanValue(), "Wrong value in bean");
1741 }
1742
1743 public void testAddNulls()
1744 {
1745 parser.clear();
1746
1747 assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
1748
1749 parser.add("foo", (Integer) null);
1750
1751 assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
1752
1753 parser.add("foo", (String) null);
1754
1755 assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
1756
1757 parser.add("bar", "null");
1758
1759 assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
1760
1761 }
1762 @Test
1763 public void testAddNullArrays()
1764 {
1765 String [] res = null;
1766
1767 parser.clear();
1768
1769 assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
1770
1771 parser.add("foo", new String [] { "foo", "bar" });
1772 res = parser.getStrings("foo");
1773 assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
1774 assertEquals( 2, res.length,"Wrong number of values");
1775
1776
1777 parser.add("foo", (String) null);
1778 res = parser.getStrings("foo");
1779 assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
1780 assertEquals( 2, res.length,"Wrong number of values");
1781
1782
1783 parser.add("foo", (String []) null);
1784 res = parser.getStrings("foo");
1785 assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
1786 assertEquals( 2, res.length,"Wrong number of values");
1787
1788
1789 parser.add("foo", new String [0]);
1790 res = parser.getStrings("foo");
1791 assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
1792 assertEquals( 2, res.length, "Wrong number of values");
1793
1794
1795 parser.add("foo", new String [] { null });
1796 res = parser.getStrings("foo");
1797 assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
1798 assertEquals( 2, res.length, "Wrong number of values");
1799
1800
1801 parser.add("foo", new String [] { "bla", null, "foo" });
1802 res = parser.getStrings("foo");
1803 assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
1804 assertEquals( 4, res.length, "Wrong number of values");
1805 }
1806 @Test
1807 public void testNonExistingResults()
1808 {
1809 parser.clear();
1810
1811 assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
1812
1813 assertEquals( 0.0, parser.getDouble("foo"), 0.001, "Wrong value for non existing key");
1814 assertNull(parser.getDoubles("foo"));
1815 assertNull(parser.getDoubleObject("foo"));
1816 assertNull(parser.getDoubleObjects("foo"));
1817
1818 assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
1819
1820 assertNull(parser.getString("foo"));
1821 assertNull(parser.getStrings("foo"));
1822
1823 assertEquals( 0.0f, parser.getFloat("foo"), 0.001, "Wrong value for non existing key");
1824 assertNull(parser.getFloats("foo"));
1825 assertNull(parser.getFloatObject("foo"));
1826 assertNull(parser.getFloatObjects("foo"));
1827
1828 assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
1829
1830 assertNull(parser.getBigDecimal("foo"));
1831 assertNull(parser.getBigDecimals("foo"));
1832
1833 assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
1834
1835 assertEquals( 0, parser.getInt("foo"), "Wrong value for non existing key");
1836 assertNull(parser.getInts("foo"));
1837 assertNull(parser.getIntObject("foo"));
1838 assertNull(parser.getIntObjects("foo"));
1839
1840 assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
1841
1842 assertEquals( 0, parser.getLong("foo"), "Wrong value for non existing key");
1843 assertNull(parser.getLongs("foo"));
1844 assertNull(parser.getLongObject("foo"));
1845 assertNull(parser.getLongObjects("foo"));
1846
1847 assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
1848
1849 assertEquals( 0, parser.getByte("foo"), "Wrong value for non existing key");
1850 assertNull(parser.getByteObject("foo"));
1851
1852 assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
1853 }
1854
1855 @Test
1856 public void testBooleanArray() {
1857 String[] booleanString = {"on", "off", "false", "true", " ", "justaword"};
1858 parser.add("foo", booleanString);
1859 boolean[] theArray = parser.getBooleans("foo");
1860
1861 assertEquals(6, theArray.length);
1862 assertTrue(theArray[0]);
1863 assertFalse(theArray[1]);
1864 assertFalse(theArray[2]);
1865 assertTrue(theArray[3]);
1866 assertFalse(theArray[4]);
1867 assertFalse(theArray[5]);
1868
1869 assertNull(parser.getBooleans("keydontexist"));
1870 }
1871 @Test
1872 public void testBooleanObjectArray() {
1873 String[] booleanString = {"on", "off", "false", "true", " ", "justaword"};
1874 parser.add("foo", booleanString);
1875 Boolean[] theArray = parser.getBooleanObjects("foo");
1876
1877 assertEquals(6, theArray.length);
1878 assertEquals(Boolean.TRUE, theArray[0]);
1879 assertEquals(Boolean.FALSE, theArray[1]);
1880 assertEquals(Boolean.FALSE, theArray[2]);
1881 assertEquals(Boolean.TRUE, theArray[3]);
1882 assertEquals(null, theArray[4]);
1883 assertEquals(null, theArray[5]);
1884
1885 assertNull(parser.getBooleanObjects("keydontexist"));
1886 }
1887 @Test
1888 public void testGet() {
1889
1890
1891 String result = parser.get("invalid");
1892 assertNull(result);
1893
1894
1895 parser.add("valid", "value");
1896 assertEquals("value", parser.get("valid"));
1897
1898
1899 parser.add("multiple", "test");
1900 parser.add("multiple", "test2");
1901 assertEquals("test", parser.get("multiple"));
1902
1903
1904 }
1905
1906 }