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 }