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