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