1 package org.apache.turbine.util.parser;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 import java.math.BigDecimal;
20
21 import junit.framework.TestSuite;
22
23 import org.apache.turbine.TurbineConstants;
24 import org.apache.turbine.test.BaseTurbineTest;
25 import org.apache.turbine.util.DateSelector;
26 import org.apache.turbine.util.TimeSelector;
27
28 /***
29 * test whether the Default parameter parser returns its uploaded file items
30 * in the keySet().
31 *
32 * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
33 * @version $Id: BaseValueParserTest.java 293298 2005-10-03 10:50:07Z henning $
34 */
35
36 public class BaseValueParserTest
37 extends BaseTurbineTest
38 {
39 public BaseValueParserTest(String name)
40 throws Exception
41 {
42 super(name, "conf/test/TurbineResources.properties");
43 }
44
45 public static TestSuite suite()
46 {
47 return new TestSuite(BaseValueParserTest.class);
48 }
49
50 public void testSetup()
51 {
52 BaseValueParser vp = new BaseValueParser();
53 assertFalse(vp.isDisposed());
54
55 assertEquals("Wrong Character Encoding", TurbineConstants.PARAMETER_ENCODING_DEFAULT, vp.getCharacterEncoding());
56 }
57
58 public void testSetupWithEncoding()
59 {
60 String encoding = "ISO-8859-2";
61
62 BaseValueParser vp = new BaseValueParser(encoding);
63 assertFalse(vp.isDisposed());
64
65 assertEquals("Wrong Character Encoding", encoding, vp.getCharacterEncoding());
66 }
67
68 public void testChangeEncoding()
69 {
70 ValueParser vp = new BaseValueParser();
71
72 assertEquals("Wrong Character Encoding", TurbineConstants.PARAMETER_ENCODING_DEFAULT, vp.getCharacterEncoding());
73
74 String encoding = "ISO-8859-2";
75 vp.setCharacterEncoding(encoding);
76
77 assertEquals("Wrong Character Encoding", encoding, vp.getCharacterEncoding());
78 }
79
80 public void testClear()
81 {
82 ValueParser vp = new BaseValueParser();
83
84 assertEquals("Wrong number of keys", 0, vp.keySet().size());
85
86 vp.add("foo", "bar");
87
88 assertEquals("Wrong number of keys", 1, vp.keySet().size());
89
90 vp.clear();
91
92 assertEquals("Wrong number of keys", 0, vp.keySet().size());
93 }
94
95 public void testDispose()
96 {
97 BaseValueParser vp = new BaseValueParser();
98
99 assertEquals("Wrong number of keys", 0, vp.keySet().size());
100
101 vp.add("foo", "bar");
102
103 assertEquals("Wrong number of keys", 1, vp.keySet().size());
104
105 vp.dispose();
106
107 assertEquals("Wrong number of keys", 0, vp.keySet().size());
108 assertTrue(vp.isDisposed());
109 }
110
111 public void testKeyArray()
112 {
113 ValueParser vp = new BaseValueParser();
114
115 assertEquals("Wrong number of keys", 0, vp.keySet().size());
116
117 vp.add("foo", "bar");
118
119 assertEquals("Wrong number of keys", 1, vp.keySet().size());
120
121 vp.add("bar", "foo");
122
123 assertEquals("Wrong number of keys", 2, vp.keySet().size());
124
125 vp.add("bar", "baz");
126
127 assertEquals("Wrong number of keys", 2, vp.keySet().size());
128 }
129
130 public void testDoubleAdd()
131 {
132 ValueParser vp = new BaseValueParser();
133
134 assertEquals("Wrong number of keys", 0, vp.keySet().size());
135
136 double testValue = 2.0;
137
138 vp.add("foo", testValue);
139
140 assertEquals("Wrong number of keys", 1, vp.keySet().size());
141
142 assertEquals("Wrong string value", "2.0", vp.getString("foo"));
143 assertEquals("Wrong double value", (double) testValue, vp.getDouble("foo"), 0.001);
144 assertEquals("Wrong Double value", (double) testValue, vp.getDoubleObject("foo").doubleValue(), 0.001);
145
146 double [] doubles = vp.getDoubles("foo");
147 assertEquals("Wrong Array Size", 1, doubles.length);
148
149 assertEquals("Wrong double array value", testValue, doubles[0], 0.001);
150
151 Double [] doubleObjs = vp.getDoubleObjects("foo");
152 assertEquals("Wrong Array Size", 1, doubleObjs.length);
153
154 assertEquals("Wrong Double array value", testValue, doubleObjs[0].doubleValue(), 0.001);
155 }
156
157 public void testIntAdd()
158 {
159 ValueParser vp = new BaseValueParser();
160
161 assertEquals("Wrong number of keys", 0, vp.keySet().size());
162
163 int testValue = 123;
164
165 vp.add("foo", testValue);
166
167 assertEquals("Wrong number of keys", 1, vp.keySet().size());
168
169 assertEquals("Wrong string value", "123", vp.getString("foo"));
170 assertEquals("Wrong int value", (int) testValue, vp.getInt("foo"));
171 assertEquals("Wrong Int value", (int) testValue, vp.getIntObject("foo").intValue());
172
173 int [] ints = vp.getInts("foo");
174 assertEquals("Wrong Array Size", 1, ints.length);
175
176 assertEquals("Wrong int array value", testValue, ints[0]);
177
178 Integer [] intObjs = vp.getIntObjects("foo");
179 assertEquals("Wrong Array Size", 1, intObjs.length);
180
181 assertEquals("Wrong Int array value", testValue, intObjs[0].intValue());
182 }
183
184 public void testIntegerAdd()
185 {
186 ValueParser vp = new BaseValueParser();
187
188 assertEquals("Wrong number of keys", 0, vp.keySet().size());
189
190 Integer testValue = new Integer(123);
191
192 vp.add("foo", testValue);
193
194 assertEquals("Wrong number of keys", 1, vp.keySet().size());
195
196 assertEquals("Wrong string value", "123", vp.getString("foo"));
197 assertEquals("Wrong int value", (int) testValue.intValue(), vp.getInt("foo"));
198 assertEquals("Wrong Int value", (int) testValue.intValue(), vp.getIntObject("foo").intValue());
199
200 int [] ints = vp.getInts("foo");
201 assertEquals("Wrong Array Size", 1, ints.length);
202
203 assertEquals("Wrong int array value", testValue.intValue(), ints[0]);
204
205 Integer [] intObjs = vp.getIntObjects("foo");
206 assertEquals("Wrong Array Size", 1, intObjs.length);
207
208 assertEquals("Wrong Int array value", testValue.intValue(), intObjs[0].intValue());
209 }
210
211 public void testLongAdd()
212 {
213 ValueParser vp = new BaseValueParser();
214
215 assertEquals("Wrong number of keys", 0, vp.keySet().size());
216
217 long testValue = 9223372036854775807l;
218
219 vp.add("foo", testValue);
220
221 assertEquals("Wrong number of keys", 1, vp.keySet().size());
222
223 assertEquals("Wrong string value", "9223372036854775807", vp.getString("foo"));
224 assertEquals("Wrong long value", (long) testValue, vp.getLong("foo"));
225 assertEquals("Wrong Long value", (long) testValue, vp.getLongObject("foo").longValue());
226
227 long [] longs = vp.getLongs("foo");
228 assertEquals("Wrong Array Size", 1, longs.length);
229
230 assertEquals("Wrong long array value", testValue, longs[0]);
231
232 Long [] longObjs = vp.getLongObjects("foo");
233 assertEquals("Wrong Array Size", 1, longObjs.length);
234
235 assertEquals("Wrong Long array value", testValue, longObjs[0].longValue());
236 }
237
238 public void testLongToInt()
239 {
240 ValueParser vp = new BaseValueParser();
241
242 assertEquals("Wrong number of keys", 0, vp.keySet().size());
243
244 long testValue = 1234l;
245
246 vp.add("foo", testValue);
247
248 assertEquals("Wrong number of keys", 1, vp.keySet().size());
249
250 assertEquals("Wrong string value", "1234", vp.getString("foo"));
251 assertEquals("Wrong int value", (int) testValue, vp.getInt("foo"));
252 assertEquals("Wrong Int value", (int) testValue, vp.getIntObject("foo").intValue());
253
254 int [] ints = vp.getInts("foo");
255 assertEquals("Wrong Array Size", 1, ints.length);
256
257 assertEquals("Wrong int array value", testValue, ints[0]);
258
259 Integer [] intObjs = vp.getIntObjects("foo");
260 assertEquals("Wrong Array Size", 1, intObjs.length);
261
262 assertEquals("Wrong Int array value", testValue, intObjs[0].intValue());
263 }
264
265 public void testIntToLong()
266 {
267 ValueParser vp = new BaseValueParser();
268
269 assertEquals("Wrong number of keys", 0, vp.keySet().size());
270
271 int testValue = 123;
272
273 vp.add("foo", testValue);
274
275 assertEquals("Wrong number of keys", 1, vp.keySet().size());
276
277 assertEquals("Wrong string value", "123", vp.getString("foo"));
278 assertEquals("Wrong long value", (long) testValue, vp.getLong("foo"));
279 assertEquals("Wrong Long value", (long) testValue, vp.getLongObject("foo").longValue());
280
281 long [] longs = vp.getLongs("foo");
282 assertEquals("Wrong Array Size", 1, longs.length);
283
284 assertEquals("Wrong long array value", testValue, longs[0]);
285
286 Long [] longObjs = vp.getLongObjects("foo");
287 assertEquals("Wrong Array Size", 1, longObjs.length);
288
289 assertEquals("Wrong Long array value", testValue, longObjs[0].longValue());
290 }
291
292 public void testIntToDouble()
293 {
294 ValueParser vp = new BaseValueParser();
295
296 assertEquals("Wrong number of keys", 0, vp.keySet().size());
297
298 int testValue = 123;
299
300 vp.add("foo", testValue);
301
302 assertEquals("Wrong number of keys", 1, vp.keySet().size());
303
304 assertEquals("Wrong string value", "123", vp.getString("foo"));
305 assertEquals("Wrong double value", (double) testValue, vp.getDouble("foo"), 0.001);
306 assertEquals("Wrong Double value", (double) testValue, vp.getDoubleObject("foo").doubleValue(), 0.001);
307
308 double [] doubles = vp.getDoubles("foo");
309 assertEquals("Wrong Array Size", 1, doubles.length);
310
311 assertEquals("Wrong double array value", testValue, doubles[0], 0.001);
312
313 Double [] doubleObjs = vp.getDoubleObjects("foo");
314 assertEquals("Wrong Array Size", 1, doubleObjs.length);
315
316 assertEquals("Wrong Double array value", testValue, doubleObjs[0].doubleValue(), 0.001);
317 }
318
319 public void testLongToDouble()
320 {
321 ValueParser vp = new BaseValueParser();
322
323 assertEquals("Wrong number of keys", 0, vp.keySet().size());
324
325 long testValue = 9223372036854775807l;
326
327 vp.add("foo", testValue);
328
329 assertEquals("Wrong number of keys", 1, vp.keySet().size());
330
331 assertEquals("Wrong string value", "9223372036854775807", vp.getString("foo"));
332 assertEquals("Wrong double value", (double) testValue, vp.getDouble("foo"), 0.001);
333 assertEquals("Wrong Double value", (double) testValue, vp.getDoubleObject("foo").doubleValue(), 0.001);
334
335 double [] doubles = vp.getDoubles("foo");
336 assertEquals("Wrong Array Size", 1, doubles.length);
337
338 assertEquals("Wrong double array value", testValue, doubles[0], 0.001);
339
340 Double [] doubleObjs = vp.getDoubleObjects("foo");
341 assertEquals("Wrong Array Size", 1, doubleObjs.length);
342
343 assertEquals("Wrong Double array value", testValue, doubleObjs[0].doubleValue(), 0.001);
344 }
345
346 public void testStringAdd()
347 {
348 ValueParser vp = new BaseValueParser();
349
350 assertEquals("Wrong number of keys", 0, vp.keySet().size());
351
352 String testValue = "the quick brown fox";
353
354 vp.add("foo", testValue);
355
356 assertEquals("Wrong number of keys", 1, vp.keySet().size());
357
358 assertEquals("Wrong string value", testValue, vp.getString("foo"));
359
360 String [] Strings = vp.getStrings("foo");
361 assertEquals("Wrong Array Size", 1, Strings.length);
362
363 assertEquals("Wrong String array value", testValue, Strings[0]);
364 }
365
366 public void testStringToInt()
367 {
368 ValueParser vp = new BaseValueParser();
369
370 assertEquals("Wrong number of keys", 0, vp.keySet().size());
371
372 String testValue = "123456";
373
374 vp.add("foo", testValue);
375
376 assertEquals("Wrong number of keys", 1, vp.keySet().size());
377
378 assertEquals("Wrong string value", testValue, vp.getString("foo"));
379
380 assertEquals("Wrong int value", Integer.parseInt(testValue), vp.getInt("foo"));
381 assertEquals("Wrong Int value", Integer.valueOf(testValue).intValue(), vp.getIntObject("foo").intValue());
382
383 int [] ints = vp.getInts("foo");
384 assertEquals("Wrong Array Size", 1, ints.length);
385
386 assertEquals("Wrong int array value", Integer.parseInt(testValue), ints[0]);
387
388 Integer [] intObjs = vp.getIntObjects("foo");
389 assertEquals("Wrong Array Size", 1, intObjs.length);
390
391 assertEquals("Wrong Int array value", Integer.valueOf(testValue).intValue(), intObjs[0].intValue());
392 }
393
394 public void testStringToLong()
395 {
396 ValueParser vp = new BaseValueParser();
397
398 assertEquals("Wrong number of keys", 0, vp.keySet().size());
399
400 String testValue = "123456";
401
402 vp.add("foo", testValue);
403
404 assertEquals("Wrong number of keys", 1, vp.keySet().size());
405
406 assertEquals("Wrong string value", testValue, vp.getString("foo"));
407
408 assertEquals("Wrong long value", Long.parseLong(testValue), vp.getLong("foo"));
409 assertEquals("Wrong Long value", Long.valueOf(testValue).longValue(), vp.getLongObject("foo").longValue());
410
411 long [] longs = vp.getLongs("foo");
412 assertEquals("Wrong Array Size", 1, longs.length);
413
414 assertEquals("Wrong long array value", Long.parseLong(testValue), longs[0]);
415
416 Long [] longObjs = vp.getLongObjects("foo");
417 assertEquals("Wrong Array Size", 1, longObjs.length);
418
419 assertEquals("Wrong Long array value", Long.valueOf(testValue).longValue(), longObjs[0].longValue());
420 }
421
422 public void testStringArray()
423 {
424 ValueParser vp = new BaseValueParser();
425
426 assertEquals("Wrong number of keys", 0, vp.keySet().size());
427
428 String [] testValue = new String [] {
429 "foo", "bar", "baz"
430 };
431
432 vp.add("foo", testValue);
433
434 assertEquals("Wrong number of keys", 1, vp.keySet().size());
435
436 String [] res = vp.getStrings("foo");
437
438 assertEquals("Wrong number of elements", 3, res.length);
439
440 for (int i = 0; i < res.length; i++)
441 {
442 assertEquals("Wrong value", res[i], testValue[i]);
443 }
444
445 assertEquals("Wrong element returned", testValue[0], vp.getString("foo"));
446
447 vp.add("foo", "xxx");
448
449 res = vp.getStrings("foo");
450
451 assertEquals("Wrong number of elements", 4, res.length);
452
453 for (int i = 0; i < 3; i++)
454 {
455 assertEquals("Wrong value", res[i], testValue[i]);
456 }
457
458 assertEquals(res[3], "xxx");
459
460
461 assertEquals("Wrong element returned", testValue[0], vp.getString("foo"));
462 }
463
464 public void testRemove()
465 {
466 ValueParser vp = new BaseValueParser();
467
468 assertEquals("Wrong number of keys", 0, vp.keySet().size());
469
470 String testValue = "the quick brown fox";
471
472 vp.add("foo", testValue);
473
474 assertEquals("Wrong number of keys", 1, vp.keySet().size());
475
476 assertEquals("Wrong string value", testValue, vp.getString("foo"));
477
478 assertNotNull(vp.remove("foo"));
479
480 assertEquals("Wrong number of keys", 0, vp.keySet().size());
481
482 assertNull(vp.getString("foo"));
483
484
485 assertNull(vp.remove("baz"));
486
487
488 assertNull(vp.remove(null));
489 }
490
491 public void testRemoveArray()
492 {
493 ValueParser vp = new BaseValueParser();
494
495 assertEquals("Wrong number of keys", 0, vp.keySet().size());
496
497 String testValue = "the quick brown fox";
498
499 vp.add("foo", testValue);
500
501 assertEquals("Wrong number of keys", 1, vp.keySet().size());
502
503 vp.add("foo", testValue);
504
505 assertEquals("Wrong number of keys", 1, vp.keySet().size());
506
507 assertEquals("Wrong string value", testValue, vp.getString("foo"));
508
509 String [] res = vp.getStrings("foo");
510
511 assertEquals("Wrong number of elements", 2, res.length);
512
513 for (int i = 0; i < res.length; i++)
514 {
515 assertEquals("Wrong value", res[i], testValue);
516 }
517
518 vp.remove("foo");
519
520 assertEquals("Wrong number of keys", 0, vp.keySet().size());
521
522 assertNull(vp.getString("foo"));
523 }
524
525 public void testContainsKey()
526 {
527 ValueParser vp = new BaseValueParser();
528
529 vp.add("foo", "bar");
530 vp.add("bar", new String [] { "foo", "bar" });
531
532 assertTrue(vp.containsKey("foo"));
533 assertTrue(vp.containsKey("bar"));
534 assertFalse(vp.containsKey("baz"));
535 }
536
537 public void testDateSelector()
538 {
539 BaseValueParser vp = new BaseValueParser();
540
541 assertEquals("Wrong number of keys", 0, vp.keySet().size());
542 assertFalse(vp.containsDateSelectorKeys("foo"));
543
544 vp.add("foo" + DateSelector.DAY_SUFFIX, "1");
545
546 assertEquals("Wrong number of keys", 1, vp.keySet().size());
547 assertFalse(vp.containsDateSelectorKeys("foo"));
548
549 vp.add("foo" + DateSelector.MONTH_SUFFIX, "1");
550
551 assertEquals("Wrong number of keys", 2, vp.keySet().size());
552 assertFalse(vp.containsDateSelectorKeys("foo"));
553
554 vp.add("foo" + DateSelector.YEAR_SUFFIX, "2005");
555
556 assertEquals("Wrong number of keys", 3, vp.keySet().size());
557 assertTrue(vp.containsDateSelectorKeys("foo"));
558 }
559
560 public void testTimeSelector()
561 {
562 BaseValueParser vp = new BaseValueParser();
563
564 assertEquals("Wrong number of keys", 0, vp.keySet().size());
565 assertFalse(vp.containsTimeSelectorKeys("foo"));
566
567 vp.add("foo" + TimeSelector.HOUR_SUFFIX, "22");
568
569 assertEquals("Wrong number of keys", 1, vp.keySet().size());
570 assertFalse(vp.containsTimeSelectorKeys("foo"));
571
572 vp.add("foo" + TimeSelector.MINUTE_SUFFIX, "58");
573
574 assertEquals("Wrong number of keys", 2, vp.keySet().size());
575 assertFalse(vp.containsTimeSelectorKeys("foo"));
576
577 vp.add("foo" + TimeSelector.SECOND_SUFFIX, "0");
578
579 assertEquals("Wrong number of keys", 3, vp.keySet().size());
580 assertTrue(vp.containsTimeSelectorKeys("foo"));
581 }
582
583 public void testBooleanObject()
584 {
585 ValueParser vp = new BaseValueParser();
586
587 vp.add("t1", "true");
588 vp.add("t2", "yes");
589 vp.add("t3", "on");
590 vp.add("t4", "1");
591 vp.add("t5", 1);
592
593 vp.add("f1", "false");
594 vp.add("f2", "no");
595 vp.add("f3", "off");
596 vp.add("f4", "0");
597 vp.add("f5", 0);
598
599 vp.add("e1", "nix");
600 vp.add("e2", "weg");
601 vp.add("e3", 200);
602 vp.add("e4", -2.5);
603
604 assertEquals("Value is not true", Boolean.TRUE, vp.getBooleanObject("t1"));
605 assertEquals("Value is not true", Boolean.TRUE, vp.getBooleanObject("t2"));
606 assertEquals("Value is not true", Boolean.TRUE, vp.getBooleanObject("t3"));
607 assertEquals("Value is not true", Boolean.TRUE, vp.getBooleanObject("t4"));
608 assertEquals("Value is not true", Boolean.TRUE, vp.getBooleanObject("t5"));
609
610 assertEquals("Value is not false", Boolean.FALSE, vp.getBooleanObject("f1"));
611 assertEquals("Value is not false", Boolean.FALSE, vp.getBooleanObject("f2"));
612 assertEquals("Value is not false", Boolean.FALSE, vp.getBooleanObject("f3"));
613 assertEquals("Value is not false", Boolean.FALSE, vp.getBooleanObject("f4"));
614 assertEquals("Value is not false", Boolean.FALSE, vp.getBooleanObject("f5"));
615
616 assertNull(vp.getBooleanObject("e1"));
617 assertNull(vp.getBooleanObject("e2"));
618 assertNull(vp.getBooleanObject("e3"));
619 assertNull(vp.getBooleanObject("e4"));
620
621 assertNull(vp.getBooleanObject("does-not-exist"));
622 }
623
624 public void testBoolDefault()
625 {
626 ValueParser vp = new BaseValueParser();
627
628 vp.add("t1", "true");
629 vp.add("f1", "false");
630
631 assertTrue(vp.getBoolean("t1"));
632 assertFalse(vp.getBoolean("f1"));
633
634 assertFalse(vp.getBoolean("does not exist"));
635
636 assertTrue(vp.getBoolean("t1", false));
637 assertFalse(vp.getBoolean("f1", true));
638
639 assertFalse(vp.getBoolean("does not exist", false));
640 assertTrue(vp.getBoolean("does not exist", true));
641 }
642
643 public void testBooleanDefault()
644 {
645 ValueParser vp = new BaseValueParser();
646
647 vp.add("t1", "true");
648 vp.add("f1", "false");
649
650 assertEquals("Value is not true", Boolean.TRUE, vp.getBooleanObject("t1"));
651 assertEquals("Value is not false", Boolean.FALSE, vp.getBooleanObject("f1"));
652
653 assertNull(vp.getBooleanObject("does not exist"));
654
655 assertEquals("Value is not true", Boolean.TRUE, vp.getBooleanObject("t1", Boolean.FALSE));
656 assertEquals("Value is not true", Boolean.TRUE, vp.getBooleanObject("t1", null));
657 assertEquals("Value is not false", Boolean.FALSE, vp.getBooleanObject("f1", Boolean.TRUE));
658 assertEquals("Value is not false", Boolean.FALSE, vp.getBooleanObject("f1", null));
659
660 assertNull(vp.getBooleanObject("does not exist", null));
661 }
662
663 public void testDoubleArray()
664 {
665 ValueParser vp = new BaseValueParser();
666
667 assertEquals("Wrong number of keys", 0, vp.keySet().size());
668
669 double [] testValue = {
670 1.0, 2.0, 3.0
671 };
672
673 for (int i = 0; i < testValue.length; i++)
674 {
675 vp.add("foo", testValue[i]);
676
677 String [] res = vp.getStrings("foo");
678 assertEquals("Wrong number of elements", res.length, i + 1);
679 }
680
681 assertEquals("Wrong number of keys", 1, vp.keySet().size());
682
683 double [] res = vp.getDoubles("foo");
684
685 assertEquals("Wrong number of elements", 3, res.length);
686
687 for (int i = 0; i < res.length; i++)
688 {
689 assertEquals("Wrong value", res[i], testValue[i], 0.001);
690 }
691
692 Double [] resObj = vp.getDoubleObjects("foo");
693
694 assertEquals("Wrong number of elements", 3, resObj.length);
695
696 for (int i = 0; i < resObj.length; i++)
697 {
698 assertEquals("Wrong value", resObj[i].doubleValue(), testValue[i], 0.001);
699 }
700
701 assertEquals("Wrong element returned", testValue[0], vp.getDoubleObject("foo").doubleValue(), 0.001);
702
703 vp.add("foo", 4.0);
704
705 res = vp.getDoubles("foo");
706
707 assertEquals("Wrong number of elements", 4, res.length);
708
709 for (int i = 0; i < 3; i++)
710 {
711 assertEquals("Wrong value", res[i], testValue[i], 0.001);
712 }
713
714 assertEquals(res[3], 4.0, 0.001);
715
716 resObj = vp.getDoubleObjects("foo");
717
718 assertEquals("Wrong number of elements", 4, resObj.length);
719
720 for (int i = 0; i < 3; i++)
721 {
722 assertEquals("Wrong value", resObj[i].doubleValue(), testValue[i], 0.001);
723 }
724
725 assertEquals(resObj[3].doubleValue(), 4.0, 0.001);
726
727
728 assertEquals("Wrong element returned", testValue[0], vp.getDouble("foo"), 0.001);
729 }
730
731 public void testFloatArray()
732 {
733 ValueParser vp = new BaseValueParser();
734
735 assertEquals("Wrong number of keys", 0, vp.keySet().size());
736
737 float [] testValue = {
738 1.0f, 2.0f, 3.0f
739 };
740
741 for (int i = 0; i < testValue.length; i++)
742 {
743 vp.add("foo", testValue[i]);
744
745 String [] res = vp.getStrings("foo");
746 assertEquals("Wrong number of elements", res.length, i + 1);
747 }
748
749 assertEquals("Wrong number of keys", 1, vp.keySet().size());
750
751 float [] res = vp.getFloats("foo");
752
753 assertEquals("Wrong number of elements", 3, res.length);
754
755 for (int i = 0; i < res.length; i++)
756 {
757 assertEquals("Wrong value", res[i], testValue[i], 0.001f);
758 }
759
760 Float [] resObj = vp.getFloatObjects("foo");
761
762 assertEquals("Wrong number of elements", 3, resObj.length);
763
764 for (int i = 0; i < resObj.length; i++)
765 {
766 assertEquals("Wrong value", resObj[i].floatValue(), testValue[i], 0.001f);
767 }
768
769 assertEquals("Wrong element returned", testValue[0], vp.getFloatObject("foo").floatValue(), 0.001f);
770
771 vp.add("foo", 4.0f);
772
773 res = vp.getFloats("foo");
774
775 assertEquals("Wrong number of elements", 4, res.length);
776
777 for (int i = 0; i < 3; i++)
778 {
779 assertEquals("Wrong value", res[i], testValue[i], 0.001f);
780 }
781
782 assertEquals(res[3], 4.0f, 0.001f);
783
784 resObj = vp.getFloatObjects("foo");
785
786 assertEquals("Wrong number of elements", 4, resObj.length);
787
788 for (int i = 0; i < 3; i++)
789 {
790 assertEquals("Wrong value", resObj[i].floatValue(), testValue[i], 0.001f);
791 }
792
793 assertEquals(resObj[3].floatValue(), 4.0f, 0.001f);
794
795
796 assertEquals("Wrong element returned", testValue[0], vp.getFloat("foo"), 0.001f);
797 }
798
799 public void testBigDecimalArray()
800 {
801 ValueParser vp = new BaseValueParser();
802
803 assertEquals("Wrong number of keys", 0, vp.keySet().size());
804
805 long [] testValue = {
806 12345678,87654321,1092837465,
807 };
808
809 for (int i = 0; i < testValue.length; i++)
810 {
811 vp.add("foo", testValue[i]);
812
813 String [] res = vp.getStrings("foo");
814 assertEquals("Wrong number of elements", res.length, i + 1);
815 }
816
817 assertEquals("Wrong number of keys", 1, vp.keySet().size());
818
819 BigDecimal [] res = vp.getBigDecimals("foo");
820
821 assertEquals("Wrong number of elements", 3, res.length);
822
823 for (int i = 0; i < res.length; i++)
824 {
825 assertEquals("Wrong value", res[i].longValue(), testValue[i]);
826 }
827
828 assertEquals("Wrong element returned", testValue[0], vp.getBigDecimal("foo").longValue());
829
830 vp.add("foo", 77777777);
831
832 res = vp.getBigDecimals("foo");
833
834 assertEquals("Wrong number of elements", 4, res.length);
835
836 for (int i = 0; i < 3; i++)
837 {
838 assertEquals("Wrong value", res[i].longValue(), testValue[i], 0.001);
839 }
840
841 assertEquals(res[3].longValue(), 77777777);
842
843
844 assertEquals("Wrong element returned", testValue[0], vp.getBigDecimal("foo").longValue());
845 }
846
847 public void testIntegerArray()
848 {
849 ValueParser vp = new BaseValueParser();
850
851 assertEquals("Wrong number of keys", 0, vp.keySet().size());
852
853 int [] testValue = {
854 1, 2, 3
855 };
856
857 for (int i = 0; i < testValue.length; i++)
858 {
859 vp.add("foo", testValue[i]);
860
861 String [] res = vp.getStrings("foo");
862 assertEquals("Wrong number of elements", res.length, i + 1);
863 }
864
865 assertEquals("Wrong number of keys", 1, vp.keySet().size());
866
867 int [] res = vp.getInts("foo");
868
869 assertEquals("Wrong number of elements", 3, res.length);
870
871 for (int i = 0; i < res.length; i++)
872 {
873 assertEquals("Wrong value", res[i], testValue[i]);
874 }
875
876 Integer [] resObj = vp.getIntObjects("foo");
877
878 assertEquals("Wrong number of elements", 3, resObj.length);
879
880 for (int i = 0; i < resObj.length; i++)
881 {
882 assertEquals("Wrong value", resObj[i].intValue(), testValue[i]);
883 }
884
885 assertEquals("Wrong element returned", testValue[0], vp.getIntObject("foo").intValue());
886
887 vp.add("foo", 4);
888
889 res = vp.getInts("foo");
890
891 assertEquals("Wrong number of elements", 4, res.length);
892
893 for (int i = 0; i < 3; i++)
894 {
895 assertEquals("Wrong value", res[i], testValue[i]);
896 }
897
898 assertEquals(res[3], 4);
899
900 resObj = vp.getIntObjects("foo");
901
902 assertEquals("Wrong number of elements", 4, resObj.length);
903
904 for (int i = 0; i < 3; i++)
905 {
906 assertEquals("Wrong value", resObj[i].intValue(), testValue[i]);
907 }
908
909 assertEquals(resObj[3].intValue(), 4);
910
911
912 assertEquals("Wrong element returned", testValue[0], vp.getInt("foo"));
913 }
914
915 public void testLongArray()
916 {
917 ValueParser vp = new BaseValueParser();
918
919 assertEquals("Wrong number of keys", 0, vp.keySet().size());
920
921 long [] testValue = {
922 1l, 2l, 3l
923 };
924
925 for (int i = 0; i < testValue.length; i++)
926 {
927 vp.add("foo", testValue[i]);
928
929 String [] res = vp.getStrings("foo");
930 assertEquals("Wrong number of elements", res.length, i + 1);
931 }
932
933 assertEquals("Wrong number of keys", 1, vp.keySet().size());
934
935 long [] res = vp.getLongs("foo");
936
937 assertEquals("Wrong number of elements", 3, res.length);
938
939 for (int i = 0; i < res.length; i++)
940 {
941 assertEquals("Wrong value", res[i], testValue[i]);
942 }
943
944 Long [] resObj = vp.getLongObjects("foo");
945
946 assertEquals("Wrong number of elements", 3, resObj.length);
947
948 for (int i = 0; i < resObj.length; i++)
949 {
950 assertEquals("Wrong value", resObj[i].longValue(), testValue[i]);
951 }
952
953 assertEquals("Wrong element returned", testValue[0], vp.getLongObject("foo").longValue());
954
955 vp.add("foo", 4);
956
957 res = vp.getLongs("foo");
958
959 assertEquals("Wrong number of elements", 4, res.length);
960
961 for (int i = 0; i < 3; i++)
962 {
963 assertEquals("Wrong value", res[i], testValue[i]);
964 }
965
966 assertEquals(res[3], 4);
967
968 resObj = vp.getLongObjects("foo");
969
970 assertEquals("Wrong number of elements", 4, resObj.length);
971
972 for (int i = 0; i < 3; i++)
973 {
974 assertEquals("Wrong value", resObj[i].longValue(), testValue[i]);
975 }
976
977 assertEquals(resObj[3].longValue(), 4);
978
979
980 assertEquals("Wrong element returned", testValue[0], vp.getLong("foo"));
981 }
982
983 public void testByteArray()
984 throws Exception
985 {
986 ValueParser vp = new BaseValueParser();
987
988 assertEquals("Wrong number of keys", 0, vp.keySet().size());
989
990 String testValue = "abcdefg";
991
992 vp.add("foo", testValue);
993
994 assertEquals("Wrong number of keys", 1, vp.keySet().size());
995
996 byte [] res = vp.getBytes("foo");
997
998 assertEquals("Wrong number of elements", 7, res.length);
999
1000 for (int i = 0; i < res.length; i++)
1001 {
1002 byte [] testByte = testValue.substring(i, i + 1).getBytes(vp.getCharacterEncoding());
1003 assertEquals("More than one byte for a char!", 1, testByte.length);
1004 assertEquals("Wrong value", res[i], testByte[0]);
1005 }
1006 }
1007
1008 public void testByte()
1009 {
1010 ValueParser vp = new BaseValueParser();
1011
1012 assertEquals("Wrong number of keys", 0, vp.keySet().size());
1013
1014 String [] testValue = {
1015 "0", "127", "-1",
1016 "0", "-127", "100"
1017 };
1018
1019
1020 for (int i = 0; i < testValue.length; i++)
1021 {
1022 vp.add("foo" + i, testValue[i]);
1023 }
1024
1025 assertEquals("Wrong number of keys", 6, vp.keySet().size());
1026
1027 assertEquals("Wrong value", (byte) 0, vp.getByte("foo0"));
1028 assertEquals("Wrong value", (byte) 127, vp.getByte("foo1"));
1029 assertEquals("Wrong value", (byte) -1, vp.getByte("foo2"));
1030 assertEquals("Wrong value", (byte) 0, vp.getByte("foo3"));
1031 assertEquals("Wrong value", (byte) -127, vp.getByte("foo4"));
1032 assertEquals("Wrong value", (byte) 100, vp.getByte("foo5"));
1033
1034 assertEquals("Wrong value", new Byte((byte) 0), vp.getByteObject("foo0"));
1035 assertEquals("Wrong value", new Byte((byte) 127), vp.getByteObject("foo1"));
1036 assertEquals("Wrong value", new Byte((byte) -1), vp.getByteObject("foo2"));
1037 assertEquals("Wrong value", new Byte((byte) 0), vp.getByteObject("foo3"));
1038 assertEquals("Wrong value", new Byte((byte) -127), vp.getByteObject("foo4"));
1039 assertEquals("Wrong value", new Byte((byte) 100), vp.getByteObject("foo5"));
1040
1041 }
1042
1043 public void testStringDefault()
1044 {
1045 ValueParser vp = new BaseValueParser();
1046
1047 assertEquals("Wrong number of keys", 0, vp.keySet().size());
1048
1049 vp.add("foo", "bar");
1050
1051 assertEquals("Wrong value found", "bar", vp.getString("foo", "xxx"));
1052 assertEquals("Wrong value found", "bar", vp.getString("foo", null));
1053
1054 assertEquals("Wrong value found", "baz", vp.getString("does-not-exist", "baz"));
1055 assertNull(vp.getString("does-not-exist", null));
1056 }
1057
1058 public void testSetString()
1059 {
1060 ValueParser vp = new BaseValueParser();
1061
1062 assertEquals("Wrong number of keys", 0, vp.keySet().size());
1063
1064 vp.add("foo", "bar");
1065
1066 assertEquals("Wrong number of keys", 1, vp.keySet().size());
1067
1068 vp.add("bar", "foo");
1069
1070 assertEquals("Wrong number of keys", 2, vp.keySet().size());
1071
1072 vp.add("bar", "baz");
1073
1074 assertEquals("Wrong number of keys", 2, vp.keySet().size());
1075
1076 String [] res = vp.getStrings("bar");
1077 assertEquals("Wrong number of values", 2, res.length);
1078 assertEquals("Wrong value found", "foo", res[0]);
1079 assertEquals("Wrong value found", "baz", res[1]);
1080
1081 vp.setString("bar", "xxx");
1082
1083 assertEquals("Wrong number of keys", 2, vp.keySet().size());
1084
1085 res = vp.getStrings("bar");
1086 assertEquals("Wrong number of values", 1, res.length);
1087 assertEquals("Wrong value found", "xxx", res[0]);
1088 }
1089
1090 public void testSetStrings()
1091 {
1092 ValueParser vp = new BaseValueParser();
1093
1094 assertEquals("Wrong number of keys", 0, vp.keySet().size());
1095
1096 vp.add("foo", "bar");
1097
1098 assertEquals("Wrong number of keys", 1, vp.keySet().size());
1099
1100 vp.add("bar", "foo");
1101
1102 assertEquals("Wrong number of keys", 2, vp.keySet().size());
1103
1104 vp.add("bar", "baz");
1105
1106 assertEquals("Wrong number of keys", 2, vp.keySet().size());
1107
1108 String [] res = vp.getStrings("bar");
1109 assertEquals("Wrong number of values", 2, res.length);
1110 assertEquals("Wrong value found", "foo", res[0]);
1111 assertEquals("Wrong value found", "baz", res[1]);
1112
1113 String [] newValues = new String [] { "aaa", "bbb", "ccc", "ddd" };
1114
1115 vp.setStrings("bar", newValues);
1116
1117 assertEquals("Wrong number of keys", 2, vp.keySet().size());
1118
1119 res = vp.getStrings("bar");
1120 assertEquals("Wrong number of values", newValues.length, res.length);
1121
1122 for (int i = 0 ; i < newValues.length; i++)
1123 {
1124 assertEquals("Wrong value found", newValues[i], res[i]);
1125 }
1126 }
1127
1128 public void testSetProperties()
1129 throws Exception
1130 {
1131 ValueParser vp = new BaseValueParser();
1132
1133 vp.add("longvalue", 12345l);
1134 vp.add("doublevalue", 2.0);
1135 vp.add("intValue", 200);
1136 vp.add("stringvalue", "foobar");
1137 vp.add("booleanvalue", "true");
1138
1139 PropertyBean bp = new PropertyBean();
1140 bp.setDoNotTouchValue("abcdef");
1141
1142 vp.setProperties(bp);
1143
1144 assertEquals("Wrong value in bean", "abcdef", bp.getDoNotTouchValue());
1145 assertEquals("Wrong value in bean", "foobar", bp.getStringValue());
1146 assertEquals("Wrong value in bean", 200, bp.getIntValue());
1147 assertEquals("Wrong value in bean", 2.0, bp.getDoubleValue(), 0.001);
1148 assertEquals("Wrong value in bean", 12345l, bp.getLongValue());
1149 assertEquals("Wrong value in bean", Boolean.TRUE, bp.getBooleanValue());
1150 }
1151
1152 public void testAddNulls()
1153 {
1154 ValueParser vp = new BaseValueParser();
1155
1156 assertEquals("Wrong number of keys", 0, vp.keySet().size());
1157
1158 vp.add("foo", (Integer) null);
1159
1160 assertEquals("Wrong number of keys", 0, vp.keySet().size());
1161
1162 vp.add("foo", (String) null);
1163
1164 assertEquals("Wrong number of keys", 0, vp.keySet().size());
1165
1166 vp.add("bar", "null");
1167
1168 assertEquals("Wrong number of keys", 1, vp.keySet().size());
1169
1170 }
1171
1172 public void testAddNullArrays()
1173 {
1174 String [] res = null;
1175
1176 ValueParser vp = new BaseValueParser();
1177 assertEquals("Wrong number of keys", 0, vp.keySet().size());
1178
1179 vp.add("foo", new String [] { "foo", "bar" });
1180 res = vp.getStrings("foo");
1181 assertEquals("Wrong number of keys", 1, vp.keySet().size());
1182 assertEquals("Wrong number of values", 2, res.length);
1183
1184
1185 vp.add("foo", (String) null);
1186 res = vp.getStrings("foo");
1187 assertEquals("Wrong number of keys", 1, vp.keySet().size());
1188 assertEquals("Wrong number of values", 2, res.length);
1189
1190
1191 vp.add("foo", (String []) null);
1192 res = vp.getStrings("foo");
1193 assertEquals("Wrong number of keys", 1, vp.keySet().size());
1194 assertEquals("Wrong number of values", 2, res.length);
1195
1196
1197 vp.add("foo", new String [0]);
1198 res = vp.getStrings("foo");
1199 assertEquals("Wrong number of keys", 1, vp.keySet().size());
1200 assertEquals("Wrong number of values", 2, res.length);
1201
1202
1203 vp.add("foo", new String [] { null });
1204 res = vp.getStrings("foo");
1205 assertEquals("Wrong number of keys", 1, vp.keySet().size());
1206 assertEquals("Wrong number of values", 2, res.length);
1207
1208
1209 vp.add("foo", new String [] { "bla", null, "foo" });
1210 res = vp.getStrings("foo");
1211 assertEquals("Wrong number of keys", 1, vp.keySet().size());
1212 assertEquals("Wrong number of values", 4, res.length);
1213 }
1214
1215 public void testNonExistingResults()
1216 {
1217 ValueParser vp = new BaseValueParser();
1218 assertEquals("Wrong number of keys", 0, vp.keySet().size());
1219
1220 assertEquals("Wrong value for non existing key", 0.0, vp.getDouble("foo"), 0.001);
1221 assertNull(vp.getDoubles("foo"));
1222 assertNull(vp.getDoubleObject("foo"));
1223 assertNull(vp.getDoubleObjects("foo"));
1224
1225 assertEquals("Wrong number of keys", 0, vp.keySet().size());
1226
1227 assertNull(vp.getString("foo"));
1228 assertNull(vp.getStrings("foo"));
1229
1230 assertEquals("Wrong value for non existing key", 0.0f, vp.getFloat("foo"), 0.001);
1231 assertNull(vp.getFloats("foo"));
1232 assertNull(vp.getFloatObject("foo"));
1233 assertNull(vp.getFloatObjects("foo"));
1234
1235 assertEquals("Wrong number of keys", 0, vp.keySet().size());
1236
1237 assertEquals("Wrong value for non existing key", 0.0, vp.getBigDecimal("foo").doubleValue(), 0.001);
1238 assertNull(vp.getBigDecimals("foo"));
1239
1240 assertEquals("Wrong number of keys", 0, vp.keySet().size());
1241
1242 assertEquals("Wrong value for non existing key", 0, vp.getInt("foo"));
1243 assertNull(vp.getInts("foo"));
1244 assertNull(vp.getIntObject("foo"));
1245 assertNull(vp.getIntObjects("foo"));
1246
1247 assertEquals("Wrong number of keys", 0, vp.keySet().size());
1248
1249 assertEquals("Wrong value for non existing key", 0, vp.getLong("foo"));
1250 assertNull(vp.getLongs("foo"));
1251 assertNull(vp.getLongObject("foo"));
1252 assertNull(vp.getLongObjects("foo"));
1253
1254 assertEquals("Wrong number of keys", 0, vp.keySet().size());
1255
1256 assertEquals("Wrong value for non existing key", 0, vp.getByte("foo"));
1257 assertNull(vp.getByteObject("foo"));
1258
1259 assertEquals("Wrong number of keys", 0, vp.keySet().size());
1260 }
1261 }
1262