001    package org.apache.turbine.util.parser;
002    
003    
004    /*
005     * Licensed to the Apache Software Foundation (ASF) under one
006     * or more contributor license agreements.  See the NOTICE file
007     * distributed with this work for additional information
008     * regarding copyright ownership.  The ASF licenses this file
009     * to you under the Apache License, Version 2.0 (the
010     * "License"); you may not use this file except in compliance
011     * with the License.  You may obtain a copy of the License at
012     *
013     *   http://www.apache.org/licenses/LICENSE-2.0
014     *
015     * Unless required by applicable law or agreed to in writing,
016     * software distributed under the License is distributed on an
017     * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
018     * KIND, either express or implied.  See the License for the
019     * specific language governing permissions and limitations
020     * under the License.
021     */
022    
023    
024    import java.math.BigDecimal;
025    
026    import org.apache.fulcrum.parser.BaseValueParser;
027    import org.apache.fulcrum.parser.ParserService;
028    import org.apache.turbine.services.TurbineServices;
029    import org.apache.turbine.test.BaseTestCase;
030    import org.apache.turbine.util.TurbineConfig;
031    
032    /**
033     * Testing of the Fulcrum BaseValueParser class
034     *
035     * @author <a href="mailto:quintonm@bellsouth.net">Quinton McCombs</a>
036     * @version $Id: BaseValueParserTest.java 222043 2004-12-06 17:47:33Z painter $
037     */
038    public class BaseValueParserTest extends BaseTestCase
039    {
040        private org.apache.fulcrum.parser.BaseValueParser parser;
041    
042        private ParserService parserService;
043    
044        private static TurbineConfig tc = null;
045    
046        /**
047         * Constructor for test.
048         *
049         * @param testName name of the test being executed
050         */
051        public BaseValueParserTest(String testName)
052                throws Exception
053        {
054            super(testName);
055    
056            // Setup configuration
057            tc =
058                new TurbineConfig(
059                    ".",
060                    "/conf/test/CompleteTurbineResources.properties");
061            tc.initialize();
062        }
063    
064        /**
065         * Performs any initialization that must happen before each test is run.
066         */
067        protected void setUp()
068        {
069            try
070            {
071                parserService = (ParserService)TurbineServices.getInstance().getService(ParserService.ROLE);
072                parser = (BaseValueParser) parserService.getParser(BaseValueParser.class);
073            }
074            catch (InstantiationException e)
075            {
076                fail(e.getMessage());
077            }
078        }
079    
080        /**
081         * Clean up after each test is run.
082         */
083        protected void tearDown()
084        {
085            if (tc != null) 
086            {
087                tc.dispose();
088            }
089            
090            parser = null;
091        }
092    
093        public void testGetByte()
094        {
095            // no param
096            byte result = parser.getByte("invalid");
097            assertEquals(result, 0);
098    
099            // default
100            result = parser.getByte("default", (byte)3);
101            assertEquals(result, 3);
102    
103            // param exists
104            parser.add("exists", "1");
105            result = parser.getByte("exists");
106            assertEquals(result, 1);
107    
108            // unparsable value
109            parser.add("unparsable", "a");
110            result = parser.getByte("unparsable");
111            assertEquals(result, 0);
112        }
113    
114        public void testGetByteObject()
115        {
116            // no param
117            Byte result = parser.getByteObject("invalid");
118            assertNull(result);
119    
120            // default
121            result = parser.getByteObject("default", new Byte((byte)3));
122            assertEquals(result, new Byte((byte)3));
123    
124            // param exists
125            parser.add("exists", "1");
126            result = parser.getByteObject("exists");
127            assertEquals(result, new Byte((byte)1));
128    
129            // unparsable value
130            parser.add("unparsable", "a");
131            result = parser.getByteObject("unparsable");
132            assertNull(result);
133        }
134    
135        public void testGetInt()
136        {
137            // no param
138            int result = parser.getInt("invalid");
139            assertEquals(result, 0);
140    
141            // default
142            result = parser.getInt("default", 3);
143            assertEquals(result, 3);
144    
145            // param exists
146            parser.add("exists", "1");
147            result = parser.getInt("exists");
148            assertEquals(result, 1);
149    
150            // unparsable value
151            parser.add("unparsable", "a");
152            result = parser.getInt("unparsable");
153            assertEquals(result, 0);
154    
155            // array
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            // array w/ unparsable element
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            // no param
183            Integer result = parser.getIntObject("invalid");
184            assertNull(result);
185    
186            // default
187            result = parser.getIntObject("default", new Integer(3));
188            assertEquals(result, new Integer(3));
189    
190            // param exists
191            parser.add("exists", "1");
192            result = parser.getIntObject("exists");
193            assertEquals(result, new Integer(1));
194    
195            // unparsable value
196            parser.add("unparsable", "a");
197            result = parser.getIntObject("unparsable");
198            assertNull(result);
199    
200            // array
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            // array w/ unparsable element
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            // no param
228            float result = parser.getFloat("invalid");
229            assertEquals(result, 0, 0);
230    
231            // default
232            result = parser.getFloat("default", 3);
233            assertEquals(result, 3, 0);
234    
235            // param exists
236            parser.add("exists", "1");
237            result = parser.getFloat("exists");
238            assertEquals(result, 1, 0);
239    
240            // unparsable value
241            parser.add("unparsable", "a");
242            result = parser.getFloat("unparsable");
243            assertEquals(result, 0, 0);
244    
245            // array
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            // array w/ unparsable element
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            // no param
273            Float result = parser.getFloatObject("invalid");
274            assertNull(result);
275    
276            // default
277            result = parser.getFloatObject("default", new Float(3));
278            assertEquals(result, new Float(3));
279    
280            // param exists
281            parser.add("exists", "1");
282            result = parser.getFloatObject("exists");
283            assertEquals(result, new Float(1));
284    
285            // unparsable value
286            parser.add("unparsable", "a");
287            result = parser.getFloatObject("unparsable");
288            assertNull(result);
289    
290            // array
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            // array w/ unparsable element
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            // no param
318            double result = parser.getDouble("invalid");
319            assertEquals(result, 0, 0);
320    
321            // default
322            result = parser.getDouble("default", 3);
323            assertEquals(result, 3, 0);
324    
325            // param exists
326            parser.add("exists", "1");
327            result = parser.getDouble("exists");
328            assertEquals(result, 1, 0);
329    
330            // unparsable value
331            parser.add("unparsable", "a");
332            result = parser.getDouble("unparsable");
333            assertEquals(result, 0, 0);
334    
335            // array
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            // array w/ unparsable element
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            // no param
363            Double result = parser.getDoubleObject("invalid");
364            assertNull(result);
365    
366            // default
367            result = parser.getDoubleObject("default", new Double(3));
368            assertEquals(result, new Double(3));
369    
370            // param exists
371            parser.add("exists", "1");
372            result = parser.getDoubleObject("exists");
373            assertEquals(result, new Double(1));
374    
375            // unparsable value
376            parser.add("unparsable", "a");
377            result = parser.getDoubleObject("unparsable");
378            assertNull(result);
379    
380            // array
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            // array w/ unparsable element
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            // no param
408            long result = parser.getLong("invalid");
409            assertEquals(result, 0);
410    
411            // default
412            result = parser.getLong("default", 3);
413            assertEquals(result, 3);
414    
415            // param exists
416            parser.add("exists", "1");
417            result = parser.getLong("exists");
418            assertEquals(result, 1);
419    
420            // unparsable value
421            parser.add("unparsable", "a");
422            result = parser.getLong("unparsable");
423            assertEquals(result, 0);
424    
425            // array
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            // array w/ unparsable element
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            // no param
453            Long result = parser.getLongObject("invalid");
454            assertNull(result);
455    
456            // default
457            result = parser.getLongObject("default", new Long(3));
458            assertEquals(result, new Long(3));
459    
460            // param exists
461            parser.add("exists", "1");
462            result = parser.getLongObject("exists");
463            assertEquals(result, new Long(1));
464    
465            // unparsable value
466            parser.add("unparsable", "a");
467            result = parser.getLongObject("unparsable");
468            assertNull(result);
469    
470            // array
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            // array w/ unparsable element
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            // no param
498            boolean result = parser.getBoolean("invalid");
499            assertEquals(result, false);
500    
501            // default
502            result = parser.getBoolean("default", true);
503            assertEquals(result, true);
504    
505            // true values - Case is intentional
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            // unparsable value
520            parser.add("unparsable", "a");
521            result = parser.getBoolean("unparsable");
522            assertEquals(result, false);
523    
524        }
525    
526        public void testGetBooleanObject()
527        {
528            // no param
529            Boolean result = parser.getBooleanObject("invalid");
530            assertNull(result);
531    
532            // default
533            result = parser.getBooleanObject("default", Boolean.TRUE);
534            assertEquals(result, Boolean.TRUE);
535    
536            // true values - Case is intentional
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            // false values - Case is intentional
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            // unparsable value
566            parser.add("unparsable", "a");
567            result = parser.getBooleanObject("unparsable");
568            assertNull(result);
569        }
570    
571        /**
572         * There seems to be some sort of Java version issue that causes this to fail
573         * on Java 1.4.2_09 on OSX.
574         *
575         */
576        public void OFFtestGetBigDecimal()
577        {
578            // no param
579            BigDecimal result = parser.getBigDecimal("invalid");
580            assertEquals(new BigDecimal(0), result);
581    
582            // default
583            result = parser.getBigDecimal("default", new BigDecimal(3));
584            assertEquals(result, new BigDecimal(3));
585    
586            // param exists
587            parser.add("exists", "1");
588            result = parser.getBigDecimal("exists");
589            assertEquals(result, new BigDecimal(1));
590    
591            // unparsable value
592            parser.add("unparsable", "a");
593            result = parser.getBigDecimal("unparsable");
594            assertEquals(new BigDecimal(0), result);
595    
596            // array
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            // array w/ unparsable element
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            // no param
626            String result = parser.getString("invalid");
627            assertNull(result);
628    
629            // default
630            result = parser.getString("default", "default");
631            assertEquals(result, "default");
632    
633            // null value
634            parser.add("null", "null");
635            assertNull( parser.getString("null"));
636    
637            // only return the first added
638            parser.add("multiple", "test");
639            parser.add("multiple", "test2");
640            assertEquals("test2", parser.getString("multiple"));
641    
642            // array
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    }