1   package org.apache.turbine.util.parser;
2   
3   /*
4    * Copyright 2001-2005 The Apache Software Foundation.
5    *
6    * Licensed under the Apache License, Version 2.0 (the "License")
7    * you may not use this file except in compliance with the License.
8    * You may obtain a copy of the License at
9    *
10   *     http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing, software
13   * distributed under the License is distributed on an "AS IS" BASIS,
14   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15   * See the License for the specific language governing permissions and
16   * limitations under the License.
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         // should append at the end.
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         // Test non-existing key
485         assertNull(vp.remove("baz"));
486 
487         // Test removing null value
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         // should append at the end.
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         // should append at the end.
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         // should append at the end.
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         // should append at the end.
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         // should append at the end.
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         // null value should not change contents
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         // null value should not change contents
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         // empty String array should not change contents
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         // String array with null value should not change contents
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         // String array with null value should only add non-null values
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