1 package org.apache.turbine.util;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import java.math.BigDecimal;
23
24 import junit.framework.TestSuite;
25
26 import org.apache.commons.configuration.BaseConfiguration;
27 import org.apache.commons.configuration.Configuration;
28
29 import org.apache.turbine.services.ServiceManager;
30 import org.apache.turbine.services.TurbineServices;
31 import org.apache.turbine.test.BaseTestCase;
32 import org.apache.turbine.util.parser.BaseValueParser;
33 import org.apache.turbine.util.parser.ParserUtils;
34
35 /***
36 * Testing of the BaseValueParser class
37 *
38 * @author <a href="mailto:quintonm@bellsouth.net">Quinton McCombs</a>
39 * @version $Id: BaseValueParserTest.java 645801 2008-04-08 09:08:05Z tv $
40 */
41 public class BaseValueParserTest extends BaseTestCase
42 {
43 private BaseValueParser parser;
44
45 /***
46 * Constructor for test.
47 *
48 * @param testName name of the test being executed
49 */
50 public BaseValueParserTest(String testName)
51 throws Exception
52 {
53 super(testName);
54
55
56 ServiceManager serviceManager = TurbineServices.getInstance();
57 serviceManager.setApplicationRoot(".");
58 Configuration cfg = new BaseConfiguration();
59 cfg.setProperty(ParserUtils.URL_CASE_FOLDING_KEY,
60 ParserUtils.URL_CASE_FOLDING_LOWER_VALUE );
61 serviceManager.setConfiguration(cfg);
62
63 }
64
65 /***
66 * Performs any initialization that must happen before each test is run.
67 */
68 protected void setUp()
69 {
70 parser = new BaseValueParser();
71 }
72
73 /***
74 * Clean up after each test is run.
75 */
76 protected void tearDown()
77 {
78 parser = null;
79 }
80
81 /***
82 * Factory method for creating a TestSuite for this class.
83 *
84 * @return the test suite
85 */
86 public static TestSuite suite()
87 {
88 TestSuite suite = new TestSuite(BaseValueParserTest.class);
89 return suite;
90 }
91
92 public void testGetByte()
93 {
94
95 byte result = parser.getByte("invalid");
96 assertEquals(result, 0);
97
98
99 result = parser.getByte("default", (byte)3);
100 assertEquals(result, 3);
101
102
103 parser.add("exists", "1");
104 result = parser.getByte("exists");
105 assertEquals(result, 1);
106
107
108 parser.add("unparsable", "a");
109 result = parser.getByte("unparsable");
110 assertEquals(result, 0);
111 }
112
113 public void testGetByteObject()
114 {
115
116 Byte result = parser.getByteObject("invalid");
117 assertNull(result);
118
119
120 result = parser.getByteObject("default", new Byte((byte)3));
121 assertEquals(result, new Byte((byte)3));
122
123
124 parser.add("exists", "1");
125 result = parser.getByteObject("exists");
126 assertEquals(result, new Byte((byte)1));
127
128
129 parser.add("unparsable", "a");
130 result = parser.getByteObject("unparsable");
131 assertNull(result);
132 }
133
134 public void testGetInt()
135 {
136
137 int result = parser.getInt("invalid");
138 assertEquals(result, 0);
139
140
141 result = parser.getInt("default", 3);
142 assertEquals(result, 3);
143
144
145 parser.add("exists", "1");
146 result = parser.getInt("exists");
147 assertEquals(result, 1);
148
149
150 parser.add("unparsable", "a");
151 result = parser.getInt("unparsable");
152 assertEquals(result, 0);
153
154
155 parser.add("array", "1");
156 parser.add("array", "2");
157 parser.add("array", "3");
158 int arrayResult[] = parser.getInts("array");
159 int compare[] = {1,2,3};
160 assertEquals(arrayResult.length, compare.length);
161 for( int i=0; i<compare.length; i++)
162 {
163 assertEquals(compare[i], arrayResult[i]);
164 }
165
166
167 parser.add("array2", "1");
168 parser.add("array2", "a");
169 parser.add("array2", "3");
170 int arrayResult2[] = parser.getInts("array2");
171 int compare2[] = {1,0,3};
172 assertEquals(arrayResult2.length, compare2.length);
173 for( int i=0; i<compare2.length; i++)
174 {
175 assertEquals(compare2[i], arrayResult2[i] );
176 }
177 }
178
179 public void testGetIntObject()
180 {
181
182 Integer result = parser.getIntObject("invalid");
183 assertNull(result);
184
185
186 result = parser.getIntObject("default", new Integer(3));
187 assertEquals(result, new Integer(3));
188
189
190 parser.add("exists", "1");
191 result = parser.getIntObject("exists");
192 assertEquals(result, new Integer(1));
193
194
195 parser.add("unparsable", "a");
196 result = parser.getIntObject("unparsable");
197 assertNull(result);
198
199
200 parser.add("array", "1");
201 parser.add("array", "2");
202 parser.add("array", "3");
203 Integer arrayResult[] = parser.getIntObjects("array");
204 Integer compare[] = {new Integer(1), new Integer(2), new Integer(3)};
205 assertEquals(arrayResult.length, compare.length);
206 for( int i=0; i<compare.length; i++)
207 {
208 assertEquals(compare[i], arrayResult[i]);
209 }
210
211
212 parser.add("array2", "1");
213 parser.add("array2", "a");
214 parser.add("array2", "3");
215 Integer arrayResult2[] = parser.getIntObjects("array2");
216 Integer compare2[] = {new Integer(1), null, new Integer(3)};
217 assertEquals(arrayResult2.length, compare2.length);
218 for( int i=0; i<compare2.length; i++)
219 {
220 assertEquals(compare2[i], arrayResult2[i] );
221 }
222 }
223
224 public void testGetFloat()
225 {
226
227 float result = parser.getFloat("invalid");
228 assertEquals(result, 0, 0);
229
230
231 result = parser.getFloat("default", 3);
232 assertEquals(result, 3, 0);
233
234
235 parser.add("exists", "1");
236 result = parser.getFloat("exists");
237 assertEquals(result, 1, 0);
238
239
240 parser.add("unparsable", "a");
241 result = parser.getFloat("unparsable");
242 assertEquals(result, 0, 0);
243
244
245 parser.add("array", "1");
246 parser.add("array", "2");
247 parser.add("array", "3");
248 float arrayResult[] = parser.getFloats("array");
249 float compare[] = {1,2,3};
250 assertEquals(arrayResult.length, compare.length);
251 for( int i=0; i<compare.length; i++)
252 {
253 assertEquals(compare[i], arrayResult[i], 0);
254 }
255
256
257 parser.add("array2", "1");
258 parser.add("array2", "a");
259 parser.add("array2", "3");
260 float arrayResult2[] = parser.getFloats("array2");
261 float compare2[] = {1,0,3};
262 assertEquals(arrayResult2.length, compare2.length);
263 for( int i=0; i<compare2.length; i++)
264 {
265 assertEquals(compare2[i], arrayResult2[i], 0);
266 }
267 }
268
269 public void testGetFloatObject()
270 {
271
272 Float result = parser.getFloatObject("invalid");
273 assertNull(result);
274
275
276 result = parser.getFloatObject("default", new Float(3));
277 assertEquals(result, new Float(3));
278
279
280 parser.add("exists", "1");
281 result = parser.getFloatObject("exists");
282 assertEquals(result, new Float(1));
283
284
285 parser.add("unparsable", "a");
286 result = parser.getFloatObject("unparsable");
287 assertNull(result);
288
289
290 parser.add("array", "1");
291 parser.add("array", "2");
292 parser.add("array", "3");
293 Float arrayResult[] = parser.getFloatObjects("array");
294 Float compare[] = {new Float(1), new Float(2), new Float(3)};
295 assertEquals(arrayResult.length, compare.length);
296 for( int i=0; i<compare.length; i++)
297 {
298 assertEquals(compare[i], arrayResult[i]);
299 }
300
301
302 parser.add("array2", "1");
303 parser.add("array2", "a");
304 parser.add("array2", "3");
305 Float arrayResult2[] = parser.getFloatObjects("array2");
306 Float compare2[] = {new Float(1), null, new Float(3)};
307 assertEquals(arrayResult2.length, compare2.length);
308 for( int i=0; i<compare2.length; i++)
309 {
310 assertEquals(compare2[i], arrayResult2[i] );
311 }
312 }
313
314 public void testGetDouble()
315 {
316
317 double result = parser.getDouble("invalid");
318 assertEquals(result, 0, 0);
319
320
321 result = parser.getDouble("default", 3);
322 assertEquals(result, 3, 0);
323
324
325 parser.add("exists", "1");
326 result = parser.getDouble("exists");
327 assertEquals(result, 1, 0);
328
329
330 parser.add("unparsable", "a");
331 result = parser.getDouble("unparsable");
332 assertEquals(result, 0, 0);
333
334
335 parser.add("array", "1");
336 parser.add("array", "2");
337 parser.add("array", "3");
338 double arrayResult[] = parser.getDoubles("array");
339 double compare[] = {1,2,3};
340 assertEquals(arrayResult.length, compare.length);
341 for( int i=0; i<compare.length; i++)
342 {
343 assertEquals(compare[i], arrayResult[i], 0);
344 }
345
346
347 parser.add("array2", "1");
348 parser.add("array2", "a");
349 parser.add("array2", "3");
350 double arrayResult2[] = parser.getDoubles("array2");
351 double compare2[] = {1,0,3};
352 assertEquals(arrayResult2.length, compare2.length);
353 for( int i=0; i<compare2.length; i++)
354 {
355 assertEquals(compare2[i], arrayResult2[i], 0);
356 }
357 }
358
359 public void testGetDoubleObject()
360 {
361
362 Double result = parser.getDoubleObject("invalid");
363 assertNull(result);
364
365
366 result = parser.getDoubleObject("default", new Double(3));
367 assertEquals(result, new Double(3));
368
369
370 parser.add("exists", "1");
371 result = parser.getDoubleObject("exists");
372 assertEquals(result, new Double(1));
373
374
375 parser.add("unparsable", "a");
376 result = parser.getDoubleObject("unparsable");
377 assertNull(result);
378
379
380 parser.add("array", "1");
381 parser.add("array", "2");
382 parser.add("array", "3");
383 Double arrayResult[] = parser.getDoubleObjects("array");
384 Double compare[] = {new Double(1), new Double(2), new Double(3)};
385 assertEquals(arrayResult.length, compare.length);
386 for( int i=0; i<compare.length; i++)
387 {
388 assertEquals(compare[i], arrayResult[i]);
389 }
390
391
392 parser.add("array2", "1");
393 parser.add("array2", "a");
394 parser.add("array2", "3");
395 Double arrayResult2[] = parser.getDoubleObjects("array2");
396 Double compare2[] = {new Double(1), null, new Double(3)};
397 assertEquals(arrayResult2.length, compare2.length);
398 for( int i=0; i<compare2.length; i++)
399 {
400 assertEquals(compare2[i], arrayResult2[i] );
401 }
402 }
403
404 public void testGetLong()
405 {
406
407 long result = parser.getLong("invalid");
408 assertEquals(result, 0);
409
410
411 result = parser.getLong("default", 3);
412 assertEquals(result, 3);
413
414
415 parser.add("exists", "1");
416 result = parser.getLong("exists");
417 assertEquals(result, 1);
418
419
420 parser.add("unparsable", "a");
421 result = parser.getLong("unparsable");
422 assertEquals(result, 0);
423
424
425 parser.add("array", "1");
426 parser.add("array", "2");
427 parser.add("array", "3");
428 long arrayResult[] = parser.getLongs("array");
429 long compare[] = {1,2,3};
430 assertEquals(arrayResult.length, compare.length);
431 for( int i=0; i<compare.length; i++)
432 {
433 assertEquals(compare[i], arrayResult[i]);
434 }
435
436
437 parser.add("array2", "1");
438 parser.add("array2", "a");
439 parser.add("array2", "3");
440 long arrayResult2[] = parser.getLongs("array2");
441 long compare2[] = {1,0,3};
442 assertEquals(arrayResult2.length, compare2.length);
443 for( int i=0; i<compare2.length; i++)
444 {
445 assertEquals(compare2[i], arrayResult2[i]);
446 }
447 }
448
449 public void testGetLongObject()
450 {
451
452 Long result = parser.getLongObject("invalid");
453 assertNull(result);
454
455
456 result = parser.getLongObject("default", new Long(3));
457 assertEquals(result, new Long(3));
458
459
460 parser.add("exists", "1");
461 result = parser.getLongObject("exists");
462 assertEquals(result, new Long(1));
463
464
465 parser.add("unparsable", "a");
466 result = parser.getLongObject("unparsable");
467 assertNull(result);
468
469
470 parser.add("array", "1");
471 parser.add("array", "2");
472 parser.add("array", "3");
473 Long arrayResult[] = parser.getLongObjects("array");
474 Long compare[] = {new Long(1), new Long(2), new Long(3)};
475 assertEquals(arrayResult.length, compare.length);
476 for( int i=0; i<compare.length; i++)
477 {
478 assertEquals(compare[i], arrayResult[i]);
479 }
480
481
482 parser.add("array2", "1");
483 parser.add("array2", "a");
484 parser.add("array2", "3");
485 Long arrayResult2[] = parser.getLongObjects("array2");
486 Long compare2[] = {new Long(1), null, new Long(3)};
487 assertEquals(arrayResult2.length, compare2.length);
488 for( int i=0; i<compare2.length; i++)
489 {
490 assertEquals(compare2[i], arrayResult2[i] );
491 }
492 }
493
494 public void testGetBoolean()
495 {
496
497 boolean result = parser.getBoolean("invalid");
498 assertEquals(result, false);
499
500
501 result = parser.getBoolean("default", true);
502 assertEquals(result, true);
503
504
505 parser.add("true1", "trUe");
506 result = parser.getBoolean("true1");
507 assertEquals(result, true);
508 parser.add("true2", "yEs");
509 result = parser.getBoolean("true2");
510 assertEquals(result, true);
511 parser.add("true3", "1");
512 result = parser.getBoolean("true3");
513 assertEquals(result, true);
514 parser.add("true4", "oN");
515 result = parser.getBoolean("true4");
516 assertEquals(result, true);
517
518
519 parser.add("unparsable", "a");
520 result = parser.getBoolean("unparsable");
521 assertEquals(result, false);
522
523 }
524
525 public void testGetBooleanObject()
526 {
527
528 Boolean result = parser.getBooleanObject("invalid");
529 assertNull(result);
530
531
532 result = parser.getBooleanObject("default", Boolean.TRUE);
533 assertEquals(result, Boolean.TRUE);
534
535
536 parser.add("true1", "trUe");
537 result = parser.getBooleanObject("true1");
538 assertEquals(result, Boolean.TRUE);
539 parser.add("true2", "yEs");
540 result = parser.getBooleanObject("true2");
541 assertEquals(result, Boolean.TRUE);
542 parser.add("true3", "1");
543 result = parser.getBooleanObject("true3");
544 assertEquals(result, Boolean.TRUE);
545 parser.add("true4", "oN");
546 result = parser.getBooleanObject("true4");
547 assertEquals(result, Boolean.TRUE);
548
549
550 parser.add("false1", "falSe");
551 result = parser.getBooleanObject("false1");
552 assertEquals(result, Boolean.FALSE);
553 parser.add("false2", "nO");
554 result = parser.getBooleanObject("false2");
555 assertEquals(result, Boolean.FALSE);
556 parser.add("false3", "0");
557 result = parser.getBooleanObject("false3");
558 assertEquals(result, Boolean.FALSE);
559 parser.add("false4", "oFf");
560 result = parser.getBooleanObject("false4");
561 assertEquals(result, Boolean.FALSE);
562
563
564
565 parser.add("unparsable", "a");
566 result = parser.getBooleanObject("unparsable");
567 assertNull(result);
568 }
569
570 public void testGetBigDecimal()
571 {
572
573 BigDecimal result = parser.getBigDecimal("invalid");
574 assertNull(result);
575
576
577 result = parser.getBigDecimal("default", new BigDecimal(3));
578 assertEquals(result, new BigDecimal(3));
579
580
581 parser.add("exists", "1");
582 result = parser.getBigDecimal("exists");
583 assertEquals(result, new BigDecimal(1));
584
585
586 parser.add("unparsable", "a");
587 result = parser.getBigDecimal("unparsable");
588 assertNull(result);
589
590
591 parser.add("array", "1");
592 parser.add("array", "2");
593 parser.add("array", "3");
594 BigDecimal arrayResult[] = parser.getBigDecimals("array");
595 BigDecimal compare[] = {new BigDecimal(1), new BigDecimal(2),
596 new BigDecimal(3)};
597 assertEquals(arrayResult.length, compare.length);
598 for( int i=0; i<compare.length; i++)
599 {
600 assertEquals(compare[i], arrayResult[i]);
601 }
602
603
604 parser.add("array2", "1");
605 parser.add("array2", "a");
606 parser.add("array2", "3");
607 BigDecimal arrayResult2[] = parser.getBigDecimals("array2");
608 BigDecimal compare2[] = {new BigDecimal(1), null, new BigDecimal(3)};
609 assertEquals(arrayResult2.length, compare2.length);
610 for( int i=0; i<compare2.length; i++)
611 {
612 assertEquals(compare2[i], arrayResult2[i] );
613 }
614 }
615
616
617 public void getString()
618 {
619
620 String result = parser.getString("invalid");
621 assertNull(result);
622
623
624 result = parser.getString("default", "default");
625 assertEquals(result, "default");
626
627
628 parser.add("null", "null");
629 assertNull( parser.getString("null"));
630
631
632 parser.add("multiple", "test");
633 parser.add("multiple", "test2");
634 assertEquals("test2", parser.getString("multiple"));
635
636
637 parser.add("array", "line1");
638 parser.add("array", "line2");
639 parser.add("array", "line3");
640 String arrayResult[] = parser.getStrings("array");
641 String compare[] = {"line1","line2","line3"};
642 assertEquals(arrayResult.length, compare.length);
643 for( int i=0; i<compare.length; i++)
644 {
645 assertEquals(compare[i], arrayResult[i]);
646 }
647
648 }
649
650 }