Java API By Example, From Geeks To Geeks.

1 /* 2  * Copyright 2001-2004 The Apache Software Foundation. 3  * 4  * Licensed under the Apache License, Version 2.0 (the "License"); 5  * you may not use this file except in compliance with the License. 6  * You may obtain a copy of the License at 7  * 8  * http://www.apache.org/licenses/LICENSE-2.0 9  * 10  * Unless required by applicable law or agreed to in writing, software 11  * distributed under the License is distributed on an "AS IS" BASIS, 12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13  * See the License for the specific language governing permissions and 14  * limitations under the License. 15  */ 16 17 18 package org.apache.commons.beanutils; 19 20 21 import java.lang.reflect.InvocationTargetException ; 22 import java.util.ArrayList ; 23 import java.util.HashMap ; 24 import java.util.List ; 25 import java.util.Map ; 26 27 import junit.framework.TestCase; 28 import junit.framework.Test; 29 import junit.framework.TestSuite; 30 31 32 /** 33  * Test accessing DynaBeans transparently via PropertyUtils. 34  * 35  * @author Craig R. McClanahan 36  * @version $Revision: 1.12 $ $Date: 2004/02/28 13:18:36 $ 37  */ 38 39 public class DynaPropertyUtilsTestCase extends TestCase { 40 41 42     // ----------------------------------------------------- Instance Variables 43 44 45     /** 46      * The basic test bean for each test. 47      */ 48     protected DynaBean bean = null; 49 50 51     /** 52      * The set of properties that should be described. 53      */ 54     protected String describes[] = 55     { "booleanProperty", 56       "booleanSecond", 57       "doubleProperty", 58       "floatProperty", 59       "intArray", 60       "intIndexed", 61       "intProperty", 62       "listIndexed", 63       "longProperty", 64       "mappedObjects", 65       "mappedProperty", 66       "mappedIntProperty", 67       "nested", 68       "nullProperty", 69       // "readOnlyProperty", 70 "shortProperty", 71       "stringArray", 72       "stringIndexed", 73       "stringProperty" 74     }; 75 76 77     /** 78      * The nested bean pointed at by the "nested" property. 79      */ 80     protected TestBean nested = null; 81 82 83     // ----------------------------------------------------------- Constructors 84 85 86     /** 87      * Construct a new instance of this test case. 88      * 89      * @param name Name of the test case 90      */ 91     public DynaPropertyUtilsTestCase(String name) { 92 93         super(name); 94 95     } 96 97 98     // --------------------------------------------------- Overall Test Methods 99 100 101     /** 102      * Set up instance variables required by this test case. 103      */ 104     public void setUp() throws Exception { 105 106         // Instantiate a new DynaBean instance 107 DynaClass dynaClass = createDynaClass(); 108         bean = dynaClass.newInstance(); 109 110         // Initialize the DynaBean's property values (like TestBean) 111 bean.set("booleanProperty", new Boolean (true)); 112         bean.set("booleanSecond", new Boolean (true)); 113         bean.set("doubleProperty", new Double (321.0)); 114         bean.set("floatProperty", new Float ((float) 123.0)); 115         int intArray[] = { 0, 10, 20, 30, 40 }; 116         bean.set("intArray", intArray); 117         int intIndexed[] = { 0, 10, 20, 30, 40 }; 118         bean.set("intIndexed", intIndexed); 119         bean.set("intProperty", new Integer (123)); 120         List listIndexed = new ArrayList (); 121         listIndexed.add("String 0"); 122         listIndexed.add("String 1"); 123         listIndexed.add("String 2"); 124         listIndexed.add("String 3"); 125         listIndexed.add("String 4"); 126         bean.set("listIndexed", listIndexed); 127         bean.set("longProperty", new Long ((long) 321)); 128         HashMap mapProperty = new HashMap (); 129         mapProperty.put("First Key", "First Value"); 130         mapProperty.put("Second Key", "Second Value"); 131         bean.set("mapProperty", mapProperty); 132         HashMap mappedObjects = new HashMap (); 133         mappedObjects.put("First Key", "First Value"); 134         mappedObjects.put("Second Key", "Second Value"); 135         bean.set("mappedObjects", mappedObjects); 136         HashMap mappedProperty = new HashMap (); 137         mappedProperty.put("First Key", "First Value"); 138         mappedProperty.put("Second Key", "Second Value"); 139         bean.set("mappedProperty", mappedProperty); 140         HashMap mappedIntProperty = new HashMap (); 141         mappedIntProperty.put("One", new Integer (1)); 142         mappedIntProperty.put("Two", new Integer (2)); 143         bean.set("mappedIntProperty", mappedIntProperty); 144         nested = new TestBean(); 145         bean.set("nested", nested); 146         // Property "nullProperty" is not initialized, so it should return null 147 bean.set("shortProperty", new Short ((short) 987)); 148         String stringArray[] = 149                 { "String 0", "String 1", "String 2", "String 3", "String 4" }; 150         bean.set("stringArray", stringArray); 151         String stringIndexed[] = 152                 { "String 0", "String 1", "String 2", "String 3", "String 4" }; 153         bean.set("stringIndexed", stringIndexed); 154         bean.set("stringProperty", "This is a string"); 155 156     } 157 158 159     /** 160      * Return the tests included in this test suite. 161      */ 162     public static Test suite() { 163 164         return (new TestSuite(DynaPropertyUtilsTestCase.class)); 165 166     } 167 168 169     /** 170      * Tear down instance variables required by this test case. 171      */ 172     public void tearDown() { 173 174         bean = null; 175         nested = null; 176 177     } 178 179 180 181     // ------------------------------------------------ Individual Test Methods 182 183 184     /** 185      * Test copyProperties() when the origin is a a <code>Map</code>. 186      */ 187     public void testCopyPropertiesMap() { 188 189         Map map = new HashMap (); 190         map.put("booleanProperty", Boolean.FALSE); 191         map.put("doubleProperty", new Double (333.0)); 192         map.put("dupProperty", new String [] { "New 0", "New 1", "New 2" }); 193         map.put("floatProperty", new Float ((float) 222.0)); 194         map.put("intArray", new int[] { 0, 100, 200 }); 195         map.put("intProperty", new Integer (111)); 196         map.put("longProperty", new Long (444)); 197         map.put("shortProperty", new Short ((short) 555)); 198         map.put("stringProperty", "New String Property"); 199 200         try { 201             PropertyUtils.copyProperties(bean, map); 202         } catch (Throwable t) { 203             fail("Threw " + t.toString()); 204         } 205 206         // Scalar properties 207 assertEquals("booleanProperty", false, 208                      ((Boolean ) bean.get("booleanProperty")).booleanValue()); 209         assertEquals("doubleProperty", 333.0, 210                      ((Double ) bean.get("doubleProperty")).doubleValue(), 211                      0.005); 212         assertEquals("floatProperty", (float) 222.0, 213                      ((Float ) bean.get("floatProperty")).floatValue(), 214                      (float) 0.005); 215         assertEquals("intProperty", 111, 216                      ((Integer ) bean.get("intProperty")).intValue()); 217         assertEquals("longProperty", (long) 444, 218                      ((Long ) bean.get("longProperty")).longValue()); 219         assertEquals("shortProperty", (short) 555, 220                      ((Short ) bean.get("shortProperty")).shortValue()); 221         assertEquals("stringProperty", "New String Property", 222                      (String ) bean.get("stringProperty")); 223                       224         // Indexed Properties 225 String dupProperty[] = (String []) bean.get("dupProperty"); 226         assertNotNull("dupProperty present", dupProperty); 227         assertEquals("dupProperty length", 3, dupProperty.length); 228         assertEquals("dupProperty[0]", "New 0", dupProperty[0]); 229         assertEquals("dupProperty[1]", "New 1", dupProperty[1]); 230         assertEquals("dupProperty[2]", "New 2", dupProperty[2]); 231         int intArray[] = (int[]) bean.get("intArray"); 232         assertNotNull("intArray present", intArray); 233         assertEquals("intArray length", 3, intArray.length); 234         assertEquals("intArray[0]", 0, intArray[0]); 235         assertEquals("intArray[1]", 100, intArray[1]); 236         assertEquals("intArray[2]", 200, intArray[2]); 237 238     } 239 240 241     /** 242      * Test the describe() method. 243      */ 244     public void testDescribe() { 245 246         Map map = null; 247         try { 248             map = PropertyUtils.describe(bean); 249         } catch (Exception e) { 250             fail("Threw exception " + e); 251         } 252 253         // Verify existence of all the properties that should be present 254 for (int i = 0; i < describes.length; i++) { 255             assertTrue("Property '" + describes[i] + "' is present", 256                        map.containsKey(describes[i])); 257         } 258         assertTrue("Property 'writeOnlyProperty' is not present", 259                    !map.containsKey("writeOnlyProperty")); 260 261         // Verify the values of scalar properties 262 assertEquals("Value of 'booleanProperty'", 263                      Boolean.TRUE, 264                      (Boolean ) map.get("booleanProperty")); 265         assertEquals("Value of 'doubleProperty'", 266                      new Double (321.0), 267                      (Double ) map.get("doubleProperty")); 268         assertEquals("Value of 'floatProperty'", 269                      new Float ((float) 123.0), 270                      (Float ) map.get("floatProperty")); 271         assertEquals("Value of 'intProperty'", 272                      new Integer (123), 273                      (Integer ) map.get("intProperty")); 274         assertEquals("Value of 'longProperty'", 275                      new Long (321), 276                      (Long ) map.get("longProperty")); 277         assertEquals("Value of 'shortProperty'", 278                      new Short ((short) 987), 279                      (Short ) map.get("shortProperty")); 280         assertEquals("Value of 'stringProperty'", 281                      "This is a string", 282                      (String ) map.get("stringProperty")); 283 284     } 285 286 287     /** 288      * Corner cases on getIndexedProperty invalid arguments. 289      */ 290     public void testGetIndexedArguments() { 291 292         // Use explicit index argument 293 294         try { 295             PropertyUtils.getIndexedProperty(null, "intArray", 0); 296             fail("Should throw IllegalArgumentException 1"); 297         } catch (IllegalArgumentException e) { 298             ; // Expected response 299 } catch (Throwable t) { 300             fail("Threw " + t + " instead of IllegalArgumentException 1"); 301         } 302 303         try { 304             PropertyUtils.getIndexedProperty(bean, null, 0); 305             fail("Should throw IllegalArgumentException 2"); 306         } catch (IllegalArgumentException e) { 307             ; // Expected response 308 } catch (Throwable t) { 309             fail("Threw " + t + " instead of IllegalArgumentException 2"); 310         } 311 312         // Use index expression 313 314         try { 315             PropertyUtils.getIndexedProperty(null, 316                     "intArray[0]"); 317             fail("Should throw IllegalArgumentException 3"); 318         } catch (IllegalArgumentException e) { 319             ; // Expected response 320 } catch (Throwable t) { 321             fail("Threw " + t + " instead of IllegalArgumentException 3"); 322         } 323 324         try { 325             PropertyUtils.getIndexedProperty(bean, "[0]"); 326             fail("Should throw NoSuchMethodException 4"); 327         } catch (NoSuchMethodException e) { 328             ; // Expected response 329 } catch (Throwable t) { 330             fail("Threw " + t + " instead of NoSuchMethodException 4"); 331         } 332 333         try { 334             PropertyUtils.getIndexedProperty(bean, "intArray"); 335             fail("Should throw IllegalArgumentException 5"); 336         } catch (IllegalArgumentException e) { 337             ; // Expected response 338 } catch (Throwable t) { 339             fail("Threw " + t + " instead of IllegalArgumentException 5"); 340         } 341 342         // Use explicit index argument 343 344         try { 345             PropertyUtils.getIndexedProperty(null, "intIndexed", 0); 346             fail("Should throw IllegalArgumentException 1"); 347         } catch (IllegalArgumentException e) { 348             ; // Expected response 349 } catch (Throwable t) { 350             fail("Threw " + t + " instead of IllegalArgumentException 1"); 351         } 352 353         try { 354             PropertyUtils.getIndexedProperty(bean, null, 0); 355             fail("Should throw IllegalArgumentException 2"); 356         } catch (IllegalArgumentException e) { 357             ; // Expected response 358 } catch (Throwable t) { 359             fail("Threw " + t + " instead of IllegalArgumentException 2"); 360         } 361 362         // Use index expression 363 364         try { 365             PropertyUtils.getIndexedProperty(null, 366                     "intIndexed[0]"); 367             fail("Should throw IllegalArgumentException 3"); 368         } catch (IllegalArgumentException e) { 369             ; // Expected response 370 } catch (Throwable t) { 371             fail("Threw " + t + " instead of IllegalArgumentException 3"); 372         } 373 374         try { 375             PropertyUtils.getIndexedProperty(bean, "[0]"); 376             fail("Should throw NoSuchMethodException 4"); 377         } catch (NoSuchMethodException e) { 378             ; // Expected response 379 } catch (Throwable t) { 380             fail("Threw " + t + " instead of NoSuchMethodException 4"); 381         } 382 383         try { 384             PropertyUtils.getIndexedProperty(bean, "intIndexed"); 385             fail("Should throw IllegalArgumentException 5"); 386         } catch (IllegalArgumentException e) { 387             ; // Expected response 388 } catch (Throwable t) { 389             fail("Threw " + t + " instead of IllegalArgumentException 5"); 390         } 391 392     } 393 394 395     /** 396      * Positive and negative tests on getIndexedProperty valid arguments. 397      */ 398     public void testGetIndexedValues() { 399 400         Object value = null; 401 402         // Use explicit key argument 403 404         for (int i = 0; i < 5; i++) { 405 406             try { 407                 value = 408                         PropertyUtils.getIndexedProperty(bean, "intArray", i); 409                 assertNotNull("intArray returned value " + i, value); 410                 assertTrue("intArray returned Integer " + i, 411                         value instanceof Integer ); 412                 assertEquals("intArray returned correct " + i, i * 10, 413                         ((Integer ) value).intValue()); 414             } catch (Throwable t) { 415                 fail("intArray " + i + " threw " + t); 416             } 417 418             try { 419                 value = 420                         PropertyUtils.getIndexedProperty(bean, "intIndexed", i); 421                 assertNotNull("intIndexed returned value " + i, value); 422                 assertTrue("intIndexed returned Integer " + i, 423                         value instanceof Integer ); 424                 assertEquals("intIndexed returned correct " + i, i * 10, 425                         ((Integer ) value).intValue()); 426             } catch (Throwable t) { 427                 fail("intIndexed " + i + " threw " + t); 428             } 429 430             try { 431                 value = 432                         PropertyUtils.getIndexedProperty(bean, "listIndexed", i); 433                 assertNotNull("listIndexed returned value " + i, value); 434                 assertTrue("list returned String " + i, 435                         value instanceof String ); 436                 assertEquals("listIndexed returned correct " + i, 437                         "String " + i, (String ) value); 438             } catch (Throwable t) { 439                 fail("listIndexed " + i + " threw " + t); 440             } 441 442             try { 443                 value = 444                         PropertyUtils.getIndexedProperty(bean, "stringArray", i); 445                 assertNotNull("stringArray returned value " + i, value); 446                 assertTrue("stringArray returned String " + i, 447                         value instanceof String ); 448                 assertEquals("stringArray returned correct " + i, 449                         "String " + i, (String ) value); 450             } catch (Throwable t) { 451                 fail("stringArray " + i + " threw " + t); 452             } 453 454             try { 455                 value = 456                         PropertyUtils.getIndexedProperty(bean, "stringIndexed", i); 457                 assertNotNull("stringIndexed returned value " + i, value); 458                 assertTrue("stringIndexed returned String " + i, 459                         value instanceof String ); 460                 assertEquals("stringIndexed returned correct " + i, 461                         "String " + i, (String ) value); 462             } catch (Throwable t) { 463                 fail("stringIndexed " + i + " threw " + t); 464             } 465 466         } 467 468         // Use key expression 469 470         for (int i = 0; i < 5; i++) { 471 472             try { 473                 value = 474                         PropertyUtils.getIndexedProperty(bean, 475                                 "intArray[" + i + "]"); 476                 assertNotNull("intArray returned value " + i, value); 477                 assertTrue("intArray returned Integer " + i, 478                         value instanceof Integer ); 479                 assertEquals("intArray returned correct " + i, i * 10, 480                         ((Integer ) value).intValue()); 481             } catch (Throwable t) { 482                 fail("intArray " + i + " threw " + t); 483             } 484 485             try { 486                 value = 487                         PropertyUtils.getIndexedProperty(bean, 488                                 "intIndexed[" + i + "]"); 489                 assertNotNull("intIndexed returned value " + i, value); 490                 assertTrue("intIndexed returned Integer " + i, 491                         value instanceof Integer ); 492                 assertEquals("intIndexed returned correct " + i, i * 10, 493                         ((Integer ) value).intValue()); 494             } catch (Throwable t) { 495                 fail("intIndexed " + i + " threw " + t); 496             } 497 498             try { 499                 value = 500                         PropertyUtils.getIndexedProperty(bean, 501                                 "listIndexed[" + i + "]"); 502                 assertNotNull("listIndexed returned value " + i, value); 503                 assertTrue("listIndexed returned String " + i, 504                         value instanceof String ); 505                 assertEquals("listIndexed returned correct " + i, 506                         "String " + i, (String ) value); 507             } catch (Throwable t) { 508                 fail("listIndexed " + i + " threw " + t); 509             } 510 511             try { 512                 value = 513                         PropertyUtils.getIndexedProperty(bean, 514                                 "stringArray[" + i + "]"); 515                 assertNotNull("stringArray returned value " + i, value); 516                 assertTrue("stringArray returned String " + i, 517                         value instanceof String ); 518                 assertEquals("stringArray returned correct " + i, 519                         "String " + i, (String ) value); 520             } catch (Throwable t) { 521                 fail("stringArray " + i + " threw " + t); 522             } 523 524             try { 525                 value = 526                         PropertyUtils.getIndexedProperty(bean, 527                                 "stringIndexed[" + i + "]"); 528                 assertNotNull("stringIndexed returned value " + i, value); 529                 assertTrue("stringIndexed returned String " + i, 530                         value instanceof String ); 531                 assertEquals("stringIndexed returned correct " + i, 532                         "String " + i, (String ) value); 533             } catch (Throwable t) { 534                 fail("stringIndexed " + i + " threw " + t); 535             } 536 537         } 538 539         // Index out of bounds tests 540 541         try { 542             value = 543                     PropertyUtils.getIndexedProperty(bean, 544                             "intArray", -1); 545             fail("Should have thrown ArrayIndexOutOfBoundsException"); 546         } catch (ArrayIndexOutOfBoundsException t) { 547             ; // Expected results 548 } catch (Throwable t) { 549             fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); 550         } 551 552         try { 553             value = 554                     PropertyUtils.getIndexedProperty(bean, 555                             "intArray", 5); 556             fail("Should have thrown ArrayIndexOutOfBoundsException"); 557         } catch (ArrayIndexOutOfBoundsException t) { 558             ; // Expected results 559 } catch (Throwable t) { 560             fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); 561         } 562 563         try { 564             value = 565                     PropertyUtils.getIndexedProperty(bean, 566                             "intIndexed", -1); 567             fail("Should have thrown ArrayIndexOutOfBoundsException"); 568         } catch (ArrayIndexOutOfBoundsException t) { 569             ; // Expected results 570 } catch (Throwable t) { 571             fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); 572         } 573 574         try { 575             value = 576                     PropertyUtils.getIndexedProperty(bean, 577                             "intIndexed", 5); 578             fail("Should have thrown ArrayIndexOutOfBoundsException"); 579         } catch (ArrayIndexOutOfBoundsException t) { 580             ; // Expected results 581 } catch (Throwable t) { 582             fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); 583         } 584 585         try { 586             value = 587                     PropertyUtils.getIndexedProperty(bean, 588                             "listIndexed", -1); 589             fail("Should have thrown IndexOutOfBoundsException"); 590         } catch (IndexOutOfBoundsException t) { 591             ; // Expected results 592 } catch (Throwable t) { 593             fail("Threw " + t + " instead of IndexOutOfBoundsException"); 594         } 595 596         try { 597             value = 598                     PropertyUtils.getIndexedProperty(bean, 599                             "listIndexed", 5); 600             fail("Should have thrown IndexOutOfBoundsException"); 601         } catch (IndexOutOfBoundsException t) { 602             ; // Expected results 603 } catch (Throwable t) { 604             fail("Threw " + t + " instead of IndexOutOfBoundsException"); 605         } 606 607         try { 608             value = 609                     PropertyUtils.getIndexedProperty(bean, 610                             "stringArray", -1); 611             fail("Should have thrown ArrayIndexOutOfBoundsException"); 612         } catch (ArrayIndexOutOfBoundsException t) { 613             ; // Expected results 614 } catch (Throwable t) { 615             fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); 616         } 617 618         try { 619             value = 620                     PropertyUtils.getIndexedProperty(bean, 621                             "stringArray", 5); 622             fail("Should have thrown ArrayIndexOutOfBoundsException"); 623         } catch (ArrayIndexOutOfBoundsException t) { 624             ; // Expected results 625 } catch (Throwable t) { 626             fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); 627         } 628 629         try { 630             value = 631                     PropertyUtils.getIndexedProperty(bean, 632                             "stringIndexed", -1); 633             fail("Should have thrown ArrayIndexOutOfBoundsException"); 634         } catch (ArrayIndexOutOfBoundsException t) { 635             ; // Expected results 636 } catch (Throwable t) { 637             fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); 638         } 639 640         try { 641             value = 642                     PropertyUtils.getIndexedProperty(bean, 643                             "stringIndexed", 5); 644             fail("Should have thrown ArrayIndexOutOfBoundsException"); 645         } catch (ArrayIndexOutOfBoundsException t) { 646             ; // Expected results 647 } catch (Throwable t) { 648             fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); 649         } 650 651     } 652 653 654     /** 655      * Corner cases on getMappedProperty invalid arguments. 656      */ 657     public void testGetMappedArguments() { 658 659         // Use explicit key argument 660 661         try { 662             PropertyUtils.getMappedProperty(null, "mappedProperty", 663                     "First Key"); 664             fail("Should throw IllegalArgumentException 1"); 665         } catch (IllegalArgumentException e) { 666             ; // Expected response 667 } catch (Throwable t) { 668             fail("Threw " + t + " instead of IllegalArgumentException 1"); 669         } 670 671         try { 672             PropertyUtils.getMappedProperty(bean, null, "First Key"); 673             fail("Should throw IllegalArgumentException 2"); 674         } catch (IllegalArgumentException e) { 675             ; // Expected response 676 } catch (Throwable t) { 677             fail("Threw " + t + " instead of IllegalArgumentException 2"); 678         } 679 680         try { 681             PropertyUtils.getMappedProperty(bean, "mappedProperty", null); 682             fail("Should throw IllegalArgumentException 3"); 683         } catch (IllegalArgumentException e) { 684             ; // Expected response 685 } catch (Throwable t) { 686             fail("Threw " + t + " instead of IllegalArgumentException 3"); 687         } 688 689         // Use key expression 690 691         try { 692             PropertyUtils.getMappedProperty(null, 693                     "mappedProperty(First Key)"); 694             fail("Should throw IllegalArgumentException 4"); 695         } catch (IllegalArgumentException e) { 696             ; // Expected response 697 } catch (Throwable t) { 698             fail("Threw " + t + " instead of IllegalArgumentException 4"); 699         } 700 701         try { 702             PropertyUtils.getMappedProperty(bean, "(Second Key)"); 703             fail("Should throw IllegalArgumentException 5"); 704         } catch (NoSuchMethodException e) { 705             ; // Expected response 706 } catch (Throwable t) { 707             fail("Threw " + t + " instead of NoSuchMethodException 5"); 708         } 709 710         try { 711             PropertyUtils.getMappedProperty(bean, "mappedProperty"); 712             fail("Should throw IllegalArgumentException 6"); 713         } catch (IllegalArgumentException e) { 714             ; // Expected response 715 } catch (Throwable t) { 716             fail("Threw " + t + " instead of IllegalArgumentException 6"); 717         } 718 719     } 720 721 722     /** 723      * Test getting mapped values with periods in the key. 724      */ 725     public void testGetMappedPeriods() { 726 727         bean.set("mappedProperty", "key.with.a.dot", "Special Value"); 728         assertEquals("Can retrieve directly", 729                      "Special Value", 730                      (String ) bean.get("mappedProperty", "key.with.a.dot")); 731         try { 732             assertEquals("Can retrieve via getMappedProperty", 733                          "Special Value", 734                          PropertyUtils.getMappedProperty 735                          (bean, "mappedProperty", "key.with.a.dot")); 736         } catch (Exception e) { 737             fail("Thew exception: " + e); 738         } 739         try { 740             assertEquals("Can retrieve via getNestedProperty", 741                          "Special Value", 742                          PropertyUtils.getNestedProperty 743                          (bean, "mappedProperty(key.with.a.dot)")); 744         } catch (Exception e) { 745             fail("Thew exception: " + e); 746         } 747 748         bean.set("mappedObjects", "nested.property", new TestBean()); 749         assertNotNull("Can retrieve directly", 750                       bean.get("mappedObjects", "nested.property")); 751         try { 752             assertEquals("Can retrieve nested", 753                          "This is a string", 754                          PropertyUtils.getNestedProperty 755                          (bean, 756                           "mappedObjects(nested.property).stringProperty")); 757         } catch (Exception e) { 758             fail("Thew exception: " + e); 759         } 760 761     } 762 763 764     /** 765      * Test getting mapped values with slashes in the key. This is different 766      * from periods because slashes are not syntactically significant. 767      */ 768     public void testGetMappedSlashes() { 769 770         bean.set("mappedProperty", "key/with/a/slash", "Special Value"); 771         assertEquals("Can retrieve directly", 772                      "Special Value", 773                      bean.get("mappedProperty", "key/with/a/slash")); 774         try { 775             assertEquals("Can retrieve via getMappedProperty", 776                          "Special Value", 777                          PropertyUtils.getMappedProperty 778                          (bean, "mappedProperty", "key/with/a/slash")); 779         } catch (Exception e) { 780             fail("Thew exception: " + e); 781         } 782         try { 783             assertEquals("Can retrieve via getNestedProperty", 784                          "Special Value", 785                          PropertyUtils.getNestedProperty 786                          (bean, "mappedProperty(key/with/a/slash)")); 787         } catch (Exception e) { 788             fail("Thew exception: " + e); 789         } 790 791         bean.set("mappedObjects", "nested/property", new TestBean()); 792         assertNotNull("Can retrieve directly", 793                       bean.get("mappedObjects", "nested/property")); 794         try { 795             assertEquals("Can retrieve nested", 796                          "This is a string", 797                          PropertyUtils.getNestedProperty 798                          (bean, 799                           "mappedObjects(nested/property).stringProperty")); 800         } catch (Exception e) { 801             fail("Thew exception: " + e); 802         } 803 804     } 805 806 807     /** 808      * Positive and negative tests on getMappedProperty valid arguments. 809      */ 810     public void testGetMappedValues() { 811 812         Object value = null; 813 814         // Use explicit key argument 815 816         try { 817             value = PropertyUtils.getMappedProperty(bean, "mappedProperty", 818                     "First Key"); 819             assertEquals("Can find first value", "First Value", value); 820         } catch (Throwable t) { 821             fail("Finding first value threw " + t); 822         } 823 824         try { 825             value = PropertyUtils.getMappedProperty(bean, "mappedProperty", 826                     "Second Key"); 827             assertEquals("Can find second value", "Second Value", value); 828         } catch (Throwable t) { 829             fail("Finding second value threw " + t); 830         } 831 832         try { 833             value = PropertyUtils.getMappedProperty(bean, "mappedProperty", 834                     "Third Key"); 835             assertNull("Can not find third value", value); 836         } catch (Throwable t) { 837             fail("Finding third value threw " + t); 838         } 839 840         // Use key expression with parentheses 841 842         try { 843             value = 844                     PropertyUtils.getMappedProperty(bean, 845                             "mappedProperty(First Key)"); 846             assertEquals("Can find first value", "First Value", value); 847         } catch (Throwable t) { 848             fail("Finding first value threw " + t); 849         } 850 851         try { 852             value = 853                     PropertyUtils.getMappedProperty(bean, 854                             "mappedProperty(Second Key)"); 855             assertEquals("Can find second value", "Second Value", value); 856         } catch (Throwable t) { 857             fail("Finding second value threw " + t); 858         } 859 860         try { 861             value = 862                     PropertyUtils.getMappedProperty(bean, 863                             "mappedProperty(Third Key)"); 864             assertNull("Can not find third value", value); 865         } catch (Throwable t) { 866             fail("Finding third value threw " + t); 867         } 868 869         // Use key expression with dotted syntax 870 871         try { 872             value = 873                     PropertyUtils.getNestedProperty(bean, 874                             "mapProperty.First Key"); 875             assertEquals("Can find first value", "First Value", value); 876         } catch (Throwable t) { 877             fail("Finding first value threw " + t); 878         } 879 880         try { 881             value = 882                     PropertyUtils.getNestedProperty(bean, 883                             "mapProperty.Second Key"); 884             assertEquals("Can find second value", "Second Value", value); 885         } catch (Throwable t) { 886             fail("Finding second value threw " + t); 887         } 888 889         try { 890             value = 891                     PropertyUtils.getNestedProperty(bean, 892                             "mapProperty.Third Key"); 893             assertNull("Can not find third value", value); 894         } catch (Throwable t) { 895             fail("Finding third value threw " + t); 896         } 897 898     } 899 900 901     /** 902      * Corner cases on getNestedProperty invalid arguments. 903      */ 904     public void testGetNestedArguments() { 905 906         try { 907             PropertyUtils.getNestedProperty(null, "stringProperty"); 908             fail("Should throw IllegalArgumentException 1"); 909         } catch (IllegalArgumentException e) { 910             ; // Expected response 911 } catch (Throwable t) { 912             fail("Threw " + t + " instead of IllegalArgumentException 1"); 913         } 914 915         try { 916             PropertyUtils.getNestedProperty(bean, null); 917             fail("Should throw IllegalArgumentException 2"); 918         } catch (IllegalArgumentException e) { 919             ; // Expected response 920 } catch (Throwable t) { 921             fail("Threw " + t + " instead of IllegalArgumentException 2"); 922         } 923 924     } 925 926 927     /** 928      * Test getNestedProperty on a boolean property. 929      */ 930     public void testGetNestedBoolean() { 931 932         try { 933             Object value = 934                     PropertyUtils.getNestedProperty 935                     (bean, "nested.booleanProperty"); 936             assertNotNull("Got a value", value); 937             assertTrue("Got correct type", (value instanceof Boolean )); 938             TestBean nested = (TestBean) bean.get("nested"); 939             assertTrue("Got correct value", 940                     ((Boolean ) value).booleanValue() == 941                     nested.getBooleanProperty()); 942         } catch (IllegalAccessException e) { 943             fail("IllegalAccessException"); 944         } catch (IllegalArgumentException e) { 945             fail("IllegalArgumentException"); 946         } catch (InvocationTargetException e) { 947             fail("InvocationTargetException"); 948         } catch (NoSuchMethodException e) { 949             fail("NoSuchMethodException"); 950         } 951 952     } 953 954 955     /** 956      * Test getNestedProperty on a double property. 957      */ 958     public void testGetNestedDouble() { 959 960         try { 961             Object value = 962                     PropertyUtils.getNestedProperty 963                     (bean, "nested.doubleProperty"); 964             assertNotNull("Got a value", value); 965             assertTrue("Got correct type", (value instanceof Double )); 966             TestBean nested = (TestBean) bean.get("nested"); 967             assertEquals("Got correct value", 968                     ((Double ) value).doubleValue(), 969                     nested.getDoubleProperty(), 970                     0.005); 971         } catch (IllegalAccessException e) { 972             fail("IllegalAccessException"); 973         } catch (IllegalArgumentException e) { 974             fail("IllegalArgumentException"); 975         } catch (InvocationTargetException e) { 976             fail("InvocationTargetException"); 977         } catch (NoSuchMethodException e) { 978             fail("NoSuchMethodException"); 979         } 980 981     } 982 983 984     /** 985      * Test getNestedProperty on a float property. 986      */ 987     public void testGetNestedFloat() { 988 989         try { 990             Object value = 991                     PropertyUtils.getNestedProperty 992                     (bean, "nested.floatProperty"); 993             assertNotNull("Got a value", value); 994             assertTrue("Got correct type", (value instanceof Float )); 995             TestBean nested = (TestBean) bean.get("nested"); 996             assertEquals("Got correct value", 997                     ((Float ) value).floatValue(), 998                     nested.getFloatProperty(), 999                     (float) 0.005); 1000        } catch (IllegalAccessException e) { 1001            fail("IllegalAccessException"); 1002        } catch (IllegalArgumentException e) { 1003            fail("IllegalArgumentException"); 1004        } catch (InvocationTargetException e) { 1005            fail("InvocationTargetException"); 1006        } catch (NoSuchMethodException e) { 1007            fail("NoSuchMethodException"); 1008        } 1009 1010    } 1011 1012 1013    /** 1014     * Test getNestedProperty on an int property. 1015     */ 1016    public void testGetNestedInt() { 1017 1018        try { 1019            Object value = 1020                    PropertyUtils.getNestedProperty 1021                    (bean, "nested.intProperty"); 1022            assertNotNull("Got a value", value); 1023            assertTrue("Got correct type", (value instanceof Integer )); 1024            TestBean nested = (TestBean) bean.get("nested"); 1025            assertEquals("Got correct value", 1026                    ((Integer ) value).intValue(), 1027                    nested.getIntProperty()); 1028        } catch (IllegalAccessException e) { 1029            fail("IllegalAccessException"); 1030        } catch (IllegalArgumentException e) { 1031            fail("IllegalArgumentException"); 1032        } catch (InvocationTargetException e) { 1033            fail("InvocationTargetException"); 1034        } catch (NoSuchMethodException e) { 1035            fail("NoSuchMethodException"); 1036        } 1037 1038    } 1039 1040 1041    /** 1042     * Test getNestedProperty on a long property. 1043     */ 1044    public void testGetNestedLong() { 1045 1046        try { 1047            Object value = 1048                    PropertyUtils.getNestedProperty 1049                    (bean, "nested.longProperty"); 1050            assertNotNull("Got a value", value); 1051            assertTrue("Got correct type", (value instanceof Long )); 1052            TestBean nested = (TestBean) bean.get("nested"); 1053            assertEquals("Got correct value", 1054                    ((Long ) value).longValue(), 1055                    nested.getLongProperty()); 1056        } catch (IllegalAccessException e) { 1057            fail("IllegalAccessException"); 1058        } catch (IllegalArgumentException e) { 1059            fail("IllegalArgumentException"); 1060        } catch (InvocationTargetException e) { 1061            fail("InvocationTargetException"); 1062        } catch (NoSuchMethodException e) { 1063            fail("NoSuchMethodException"); 1064        } 1065 1066    } 1067 1068 1069    /** 1070     * Test getNestedProperty on a read-only String property. 1071     */ 1072    public void testGetNestedReadOnly() { 1073 1074        try { 1075            Object value = 1076                    PropertyUtils.getNestedProperty 1077                    (bean, "nested.readOnlyProperty"); 1078            assertNotNull("Got a value", value); 1079            assertTrue("Got correct type", (value instanceof String )); 1080            TestBean nested = (TestBean) bean.get("nested"); 1081            assertEquals("Got correct value", 1082                    (String ) value, 1083                    nested.getReadOnlyProperty()); 1084        } catch (IllegalAccessException e) { 1085            fail("IllegalAccessException"); 1086        } catch (IllegalArgumentException e) { 1087            fail("IllegalArgumentException"); 1088        } catch (InvocationTargetException e) { 1089            fail("InvocationTargetException"); 1090        } catch (NoSuchMethodException e) { 1091            fail("NoSuchMethodException"); 1092        } 1093 1094    } 1095 1096 1097    /** 1098     * Test getNestedProperty on a short property. 1099     */ 1100    public void testGetNestedShort() { 1101 1102        try { 1103            Object value = 1104                    PropertyUtils.getNestedProperty 1105                    (bean, "nested.shortProperty"); 1106            assertNotNull("Got a value", value); 1107            assertTrue("Got correct type", (value instanceof Short )); 1108            TestBean nested = (TestBean) bean.get("nested"); 1109            assertEquals("Got correct value", 1110                    ((Short ) value).shortValue(), 1111                    nested.getShortProperty()); 1112        } catch (IllegalAccessException e) { 1113            fail("IllegalAccessException"); 1114        } catch (IllegalArgumentException e) { 1115            fail("IllegalArgumentException"); 1116        } catch (InvocationTargetException e) { 1117            fail("InvocationTargetException"); 1118        } catch (NoSuchMethodException e) { 1119            fail("NoSuchMethodException"); 1120        } 1121 1122    } 1123 1124 1125    /** 1126     * Test getNestedProperty on a String property. 1127     */ 1128    public void testGetNestedString() { 1129 1130        try { 1131            Object value = 1132                    PropertyUtils.getNestedProperty 1133                    (bean, "nested.stringProperty"); 1134            assertNotNull("Got a value", value); 1135            assertTrue("Got correct type", (value instanceof String )); 1136            TestBean nested = (TestBean) bean.get("nested"); 1137            assertEquals("Got correct value", 1138                    ((String ) value), 1139                    nested.getStringProperty()); 1140        } catch (IllegalAccessException e) { 1141            fail("IllegalAccessException"); 1142        } catch (IllegalArgumentException e) { 1143            fail("IllegalArgumentException"); 1144        } catch (InvocationTargetException e) { 1145            fail("InvocationTargetException"); 1146        } catch (NoSuchMethodException e) { 1147            fail("NoSuchMethodException"); 1148        } 1149 1150    } 1151 1152 1153    /** 1154     * Negative test getNestedProperty on an unknown property. 1155     */ 1156    public void testGetNestedUnknown() { 1157 1158        try { 1159            PropertyUtils.getNestedProperty(bean, "nested.unknown"); 1160            fail("Should have thrown NoSuchMethodException"); 1161        } catch (IllegalAccessException e) { 1162            fail("IllegalAccessException"); 1163        } catch (IllegalArgumentException e) { 1164            fail("IllegalArgumentException"); 1165        } catch (InvocationTargetException e) { 1166            fail("InvocationTargetException"); 1167        } catch (NoSuchMethodException e) { 1168            ; // Correct result for this test 1169 } 1170 1171    } 1172 1173 1174    /** 1175     * Corner cases on getSimpleProperty invalid arguments. 1176     */ 1177    public void testGetSimpleArguments() { 1178 1179        try { 1180            PropertyUtils.getSimpleProperty(null, "stringProperty"); 1181            fail("Should throw IllegalArgumentException 1"); 1182        } catch (IllegalArgumentException e) { 1183            ; // Expected response 1184 } catch (Throwable t) { 1185            fail("Threw " + t + " instead of IllegalArgumentException 1"); 1186        } 1187 1188        try { 1189            PropertyUtils.getSimpleProperty(bean, null); 1190            fail("Should throw IllegalArgumentException 2"); 1191        } catch (IllegalArgumentException e) { 1192            ; // Expected response 1193 } catch (Throwable t) { 1194            fail("Threw " + t + " instead of IllegalArgumentException 2"); 1195        } 1196 1197    } 1198 1199 1200    /** 1201     * Test getSimpleProperty on a boolean property. 1202     */ 1203    public void testGetSimpleBoolean() { 1204 1205        try { 1206            Object value = 1207                    PropertyUtils.getSimpleProperty(bean, 1208                            "booleanProperty"); 1209            assertNotNull("Got a value", value); 1210            assertTrue("Got correct type", (value instanceof Boolean )); 1211            assertTrue("Got correct value", 1212                    ((Boolean ) value).booleanValue() == true); 1213        } catch (IllegalAccessException e) { 1214            fail("IllegalAccessException"); 1215        } catch (IllegalArgumentException e) { 1216            fail("IllegalArgumentException"); 1217        } catch (InvocationTargetException e) { 1218            fail("InvocationTargetException"); 1219        } catch (NoSuchMethodException e) { 1220            fail("NoSuchMethodException"); 1221        } 1222 1223    } 1224 1225 1226    /** 1227     * Test getSimpleProperty on a double property. 1228     */ 1229    public void testGetSimpleDouble() { 1230 1231        try { 1232            Object value = 1233                    PropertyUtils.getSimpleProperty(bean, 1234                            "doubleProperty"); 1235            assertNotNull("Got a value", value); 1236            assertTrue("Got correct type", (value instanceof Double )); 1237            assertEquals("Got correct value", 1238                    ((Double ) value).doubleValue(), 1239                    (double) 321.0, 1240                    (double) 0.005); 1241        } catch (IllegalAccessException e) { 1242            fail("IllegalAccessException"); 1243        } catch (IllegalArgumentException e) { 1244            fail("IllegalArgumentException"); 1245        } catch (InvocationTargetException e) { 1246            fail("InvocationTargetException"); 1247        } catch (NoSuchMethodException e) { 1248            fail("NoSuchMethodException"); 1249        } 1250 1251    } 1252 1253 1254    /** 1255     * Test getSimpleProperty on a float property. 1256     */ 1257    public void testGetSimpleFloat() { 1258 1259        try { 1260            Object value = 1261                    PropertyUtils.getSimpleProperty(bean, 1262                            "floatProperty"); 1263            assertNotNull("Got a value", value); 1264            assertTrue("Got correct type", (value instanceof Float )); 1265            assertEquals("Got correct value", 1266                    ((Float ) value).floatValue(), 1267                    (float) 123.0, 1268                    (float) 0.005); 1269        } catch (IllegalAccessException e) { 1270            fail("IllegalAccessException"); 1271        } catch (IllegalArgumentException e) { 1272            fail("IllegalArgumentException"); 1273        } catch (InvocationTargetException e) { 1274            fail("InvocationTargetException"); 1275        } catch (NoSuchMethodException e) { 1276            fail("NoSuchMethodException"); 1277        } 1278 1279    } 1280 1281 1282    /** 1283     * Negative test getSimpleProperty on an indexed property. 1284     */ 1285    public void testGetSimpleIndexed() { 1286 1287        Object value = null; 1288        try { 1289            value = PropertyUtils.getSimpleProperty(bean, 1290                    "intIndexed[0]"); 1291            fail("Should have thrown IllegalArgumentException"); 1292        } catch (IllegalAccessException e) { 1293            fail("IllegalAccessException"); 1294        } catch (IllegalArgumentException e) { 1295            ; // Correct result for this test 1296 } catch (InvocationTargetException e) { 1297            fail("InvocationTargetException"); 1298        } catch (NoSuchMethodException e) { 1299            fail("NoSuchMethodException"); 1300        } 1301 1302    } 1303 1304 1305    /** 1306     * Test getSimpleProperty on an int property. 1307     */ 1308    public void testGetSimpleInt() { 1309 1310        try { 1311            Object value = 1312                    PropertyUtils.getSimpleProperty(bean, 1313                            "intProperty"); 1314            assertNotNull("Got a value", value); 1315            assertTrue("Got correct type", (value instanceof Integer )); 1316            assertEquals("Got correct value", 1317                    ((Integer ) value).intValue(), 1318                    123); 1319        } catch (IllegalAccessException e) { 1320            fail("IllegalAccessException"); 1321        } catch (IllegalArgumentException e) { 1322            fail("IllegalArgumentException"); 1323        } catch (InvocationTargetException e) { 1324            fail("InvocationTargetException"); 1325        } catch (NoSuchMethodException e) { 1326            fail("NoSuchMethodException"); 1327        } 1328 1329    } 1330 1331 1332    /** 1333     * Test getSimpleProperty on a long property. 1334     */ 1335    public void testGetSimpleLong() { 1336 1337        try { 1338            Object value = 1339                    PropertyUtils.getSimpleProperty(bean, 1340                            "longProperty"); 1341            assertNotNull("Got a value", value); 1342            assertTrue("Got correct type", (value instanceof Long )); 1343            assertEquals("Got correct value", 1344                    ((Long ) value).longValue(), 1345                    (long) 321); 1346        } catch (IllegalAccessException e) { 1347            fail("IllegalAccessException"); 1348        } catch (IllegalArgumentException e) { 1349            fail("IllegalArgumentException"); 1350        } catch (InvocationTargetException e) { 1351            fail("InvocationTargetException"); 1352        } catch (NoSuchMethodException e) { 1353            fail("NoSuchMethodException"); 1354        } 1355 1356    } 1357 1358 1359    /** 1360     * Negative test getSimpleProperty on a nested property. 1361     */ 1362    public void testGetSimpleNested() { 1363 1364        Object value = null; 1365        try { 1366            value = PropertyUtils.getSimpleProperty(bean, 1367                    "nested.stringProperty"); 1368            fail("Should have thrown IllegaArgumentException"); 1369        } catch (IllegalAccessException e) { 1370            fail("IllegalAccessException"); 1371        } catch (IllegalArgumentException e) { 1372            ; // Correct result for this test 1373 } catch (InvocationTargetException e) { 1374            fail("InvocationTargetException"); 1375        } catch (NoSuchMethodException e) { 1376            fail("NoSuchMethodException"); 1377        } 1378 1379    } 1380 1381 1382    /** 1383     * Test getSimpleProperty on a short property. 1384     */ 1385    public void testGetSimpleShort() { 1386 1387        try { 1388            Object value = 1389                    PropertyUtils.getSimpleProperty(bean, 1390                            "shortProperty"); 1391            assertNotNull("Got a value", value); 1392            assertTrue("Got correct type", (value instanceof Short )); 1393            assertEquals("Got correct value", 1394                    ((Short ) value).shortValue(), 1395                    (short) 987); 1396        } catch (IllegalAccessException e) { 1397            fail("IllegalAccessException"); 1398        } catch (IllegalArgumentException e) { 1399            fail("IllegalArgumentException"); 1400        } catch (InvocationTargetException e) { 1401            fail("InvocationTargetException"); 1402        } catch (NoSuchMethodException e) { 1403            fail("NoSuchMethodException"); 1404        } 1405 1406    } 1407 1408 1409    /** 1410     * Test getSimpleProperty on a String property. 1411     */ 1412    public void testGetSimpleString() { 1413 1414        try { 1415            Object value = 1416                    PropertyUtils.getSimpleProperty(bean, 1417                            "stringProperty"); 1418            assertNotNull("Got a value", value); 1419            assertTrue("Got correct type", (value instanceof String )); 1420            assertEquals("Got correct value", 1421                    (String ) value, 1422                    "This is a string"); 1423        } catch (IllegalAccessException e) { 1424            fail("IllegalAccessException"); 1425        } catch (IllegalArgumentException e) { 1426            fail("IllegalArgumentException"); 1427        } catch (InvocationTargetException e) { 1428            fail("InvocationTargetException"); 1429        } catch (NoSuchMethodException e) { 1430            fail("NoSuchMethodException"); 1431        } 1432 1433    } 1434 1435 1436    /** 1437     * Negative test getSimpleProperty on an unknown property. 1438     */ 1439    public void testGetSimpleUnknown() { 1440 1441        try { 1442            PropertyUtils.getSimpleProperty(bean, "unknown"); 1443            fail("Should have thrown NoSuchMethodException"); 1444        } catch (IllegalAccessException e) { 1445            fail("IllegalAccessException"); 1446        } catch (IllegalArgumentException e) { 1447            fail("IllegalArgumentException"); 1448        } catch (InvocationTargetException e) { 1449            fail("InvocationTargetException"); 1450        } catch (NoSuchMethodException e) { 1451            ; // Correct result for this test 1452 } 1453 1454    } 1455 1456 1457    /** 1458     * Corner cases on setIndexedProperty invalid arguments. 1459     */ 1460    public void testSetIndexedArguments() { 1461 1462        // Use explicit index argument 1463 1464        try { 1465            PropertyUtils.setIndexedProperty(null, "intArray", 0, 1466                    new Integer (1)); 1467            fail("Should throw IllegalArgumentException 1"); 1468        } catch (IllegalArgumentException e) { 1469            ; // Expected response 1470 } catch (Throwable t) { 1471            fail("Threw " + t + " instead of IllegalArgumentException 1"); 1472        } 1473 1474        try { 1475            PropertyUtils.setIndexedProperty(bean, null, 0, 1476                    new Integer (1)); 1477            fail("Should throw IllegalArgumentException 2"); 1478        } catch (IllegalArgumentException e) { 1479            ; // Expected response 1480 } catch (Throwable t) { 1481            fail("Threw " + t + " instead of IllegalArgumentException 2"); 1482        } 1483 1484        // Use index expression 1485 1486        try { 1487            PropertyUtils.setIndexedProperty(null, 1488                    "intArray[0]", 1489                    new Integer (1)); 1490            fail("Should throw IllegalArgumentException 3"); 1491        } catch (IllegalArgumentException e) { 1492            ; // Expected response 1493 } catch (Throwable t) { 1494            fail("Threw " + t + " instead of IllegalArgumentException 3"); 1495        } 1496 1497        try { 1498            PropertyUtils.setIndexedProperty(bean, "[0]", 1499                    new Integer (1)); 1500            fail("Should throw NoSuchMethodException 4"); 1501        } catch (NoSuchMethodException e) { 1502            ; // Expected response 1503 } catch (Throwable t) { 1504            fail("Threw " + t + " instead of NoSuchMethodException 4"); 1505        } 1506 1507        try { 1508            PropertyUtils.setIndexedProperty(bean, "intArray", 1509                    new Integer (1)); 1510            fail("Should throw IllegalArgumentException 5"); 1511        } catch (IllegalArgumentException e) { 1512            ; // Expected response 1513 } catch (Throwable t) { 1514            fail("Threw " + t + " instead of IllegalArgumentException 5"); 1515        } 1516 1517        // Use explicit index argument 1518 1519        try { 1520            PropertyUtils.setIndexedProperty(null, "intIndexed", 0, 1521                    new Integer (1)); 1522            fail("Should throw IllegalArgumentException 1"); 1523        } catch (IllegalArgumentException e) { 1524            ; // Expected response 1525 } catch (Throwable t) { 1526            fail("Threw " + t + " instead of IllegalArgumentException 1"); 1527        } 1528 1529        try { 1530            PropertyUtils.setIndexedProperty(bean, null, 0, 1531                    new Integer (1)); 1532            fail("Should throw IllegalArgumentException 2"); 1533        } catch (IllegalArgumentException e) { 1534            ; // Expected response 1535 } catch (Throwable t) { 1536            fail("Threw " + t + " instead of IllegalArgumentException 2"); 1537        } 1538 1539        // Use index expression 1540 1541        try { 1542            PropertyUtils.setIndexedProperty(null, 1543                    "intIndexed[0]", 1544                    new Integer (1)); 1545            fail("Should throw IllegalArgumentException 3"); 1546        } catch (IllegalArgumentException e) { 1547            ; // Expected response 1548 } catch (Throwable t) { 1549            fail("Threw " + t + " instead of IllegalArgumentException 3"); 1550        } 1551 1552        try { 1553            PropertyUtils.setIndexedProperty(bean, "[0]", 1554                    new Integer (1)); 1555            fail("Should throw NoSuchMethodException 4"); 1556        } catch (NoSuchMethodException e) { 1557            ; // Expected response 1558 } catch (Throwable t) { 1559            fail("Threw " + t + " instead of NoSuchMethodException 4"); 1560        } 1561 1562        try { 1563            PropertyUtils.setIndexedProperty(bean, "intIndexed", 1564                    new Integer (1)); 1565            fail("Should throw IllegalArgumentException 5"); 1566        } catch (IllegalArgumentException e) { 1567            ; // Expected response 1568 } catch (Throwable t) { 1569            fail("Threw " + t + " instead of IllegalArgumentException 5"); 1570        } 1571 1572    } 1573 1574 1575    /** 1576     * Positive and negative tests on setIndexedProperty valid arguments. 1577     */ 1578    public void testSetIndexedValues() { 1579 1580        Object value = null; 1581 1582        // Use explicit index argument 1583 1584        try { 1585            PropertyUtils.setIndexedProperty(bean, 1586                    "intArray", 0, 1587                    new Integer (1)); 1588            value = 1589                    PropertyUtils.getIndexedProperty(bean, 1590                            "intArray", 0); 1591            assertNotNull("Returned new value 0", value); 1592            assertTrue("Returned Integer new value 0", 1593                    value instanceof Integer ); 1594            assertEquals("Returned correct new value 0", 1, 1595                    ((Integer ) value).intValue()); 1596        } catch (Throwable t) { 1597            fail("Threw " + t); 1598        } 1599 1600        try { 1601            PropertyUtils.setIndexedProperty(bean, 1602                    "intIndexed", 1, 1603                    new Integer (11)); 1604            value = 1605                    PropertyUtils.getIndexedProperty(bean, 1606                            "intIndexed", 1); 1607            assertNotNull("Returned new value 1", value); 1608            assertTrue("Returned Integer new value 1", 1609                    value instanceof Integer ); 1610            assertEquals("Returned correct new value 1", 11, 1611                    ((Integer ) value).intValue()); 1612        } catch (Throwable t) { 1613            fail("Threw " + t); 1614        } 1615 1616        try { 1617            PropertyUtils.setIndexedProperty(bean, 1618                    "listIndexed", 2, 1619                    "New Value 2"); 1620            value = 1621                    PropertyUtils.getIndexedProperty(bean, 1622                            "listIndexed", 2); 1623            assertNotNull("Returned new value 2", value); 1624            assertTrue("Returned String new value 2", 1625                    value instanceof String ); 1626            assertEquals("Returned correct new value 2", "New Value 2", 1627                    (String ) value); 1628        } catch (Throwable t) { 1629            fail("Threw " + t); 1630        } 1631 1632        try { 1633            PropertyUtils.setIndexedProperty(bean, 1634                    "stringArray", 2, 1635                    "New Value 2"); 1636            value = 1637                    PropertyUtils.getIndexedProperty(bean, 1638                            "stringArray", 2); 1639            assertNotNull("Returned new value 2", value); 1640            assertTrue("Returned String new value 2", 1641                    value instanceof String ); 1642            assertEquals("Returned correct new value 2", "New Value 2", 1643                    (String ) value); 1644        } catch (Throwable t) { 1645            fail("Threw " + t); 1646        } 1647 1648        try { 1649            PropertyUtils.setIndexedProperty(bean, 1650                    "stringArray", 3, 1651                    "New Value 3"); 1652            value = 1653                    PropertyUtils.getIndexedProperty(bean, 1654                            "stringArray", 3); 1655            assertNotNull("Returned new value 3", value); 1656            assertTrue("Returned String new value 3", 1657                    value instanceof String ); 1658            assertEquals("Returned correct new value 3", "New Value 3", 1659                    (String ) value); 1660        } catch (Throwable t) { 1661            fail("Threw " + t); 1662        } 1663 1664        // Use index expression 1665 1666        try { 1667            PropertyUtils.setIndexedProperty(bean, 1668                    "intArray[4]", 1669                    new Integer (1)); 1670            value = 1671                    PropertyUtils.getIndexedProperty(bean, 1672                            "intArray[4]"); 1673            assertNotNull("Returned new value 4", value); 1674            assertTrue("Returned Integer new value 4", 1675                    value instanceof Integer ); 1676            assertEquals("Returned correct new value 4", 1, 1677                    ((Integer ) value).intValue()); 1678        } catch (Throwable t) { 1679            fail("Threw " + t); 1680        } 1681 1682        try { 1683            PropertyUtils.setIndexedProperty(bean, 1684                    "intIndexed[3]", 1685                    new Integer (11)); 1686            value = 1687                    PropertyUtils.getIndexedProperty(bean, 1688                            "intIndexed[3]"); 1689            assertNotNull("Returned new value 5", value); 1690            assertTrue("Returned Integer new value 5", 1691                    value instanceof Integer ); 1692            assertEquals("Returned correct new value 5", 11, 1693                    ((Integer ) value).intValue()); 1694        } catch (Throwable t) { 1695            fail("Threw " + t); 1696        } 1697 1698        try { 1699            PropertyUtils.setIndexedProperty(bean, 1700                    "listIndexed[1]", 1701                    "New Value 2"); 1702            value = 1703                    PropertyUtils.getIndexedProperty(bean, 1704                            "listIndexed[1]"); 1705            assertNotNull("Returned new value 6", value); 1706            assertTrue("Returned String new value 6", 1707                    value instanceof String ); 1708            assertEquals("Returned correct new value 6", "New Value 2", 1709                    (String ) value); 1710        } catch (Throwable t) { 1711            fail("Threw " + t); 1712        } 1713 1714        try { 1715            PropertyUtils.setIndexedProperty(bean, 1716                    "stringArray[1]", 1717                    "New Value 2"); 1718            value = 1719                    PropertyUtils.getIndexedProperty(bean, 1720                            "stringArray[2]"); 1721            assertNotNull("Returned new value 6", value); 1722            assertTrue("Returned String new value 6", 1723                    value instanceof String ); 1724            assertEquals("Returned correct new value 6", "New Value 2", 1725                    (String ) value); 1726        } catch (Throwable t) { 1727            fail("Threw " + t); 1728        } 1729 1730        try { 1731            PropertyUtils.setIndexedProperty(bean, 1732                    "stringArray[0]", 1733                    "New Value 3"); 1734            value = 1735                    PropertyUtils.getIndexedProperty(bean, 1736                            "stringArray[0]"); 1737            assertNotNull("Returned new value 7", value); 1738            assertTrue("Returned String new value 7", 1739                    value instanceof String ); 1740            assertEquals("Returned correct new value 7", "New Value 3", 1741                    (String ) value); 1742        } catch (Throwable t) { 1743            fail("Threw " + t); 1744        } 1745 1746        // Index out of bounds tests 1747 1748        try { 1749            PropertyUtils.setIndexedProperty(bean, 1750                    "intArray", -1, 1751                    new Integer (0)); 1752            fail("Should have thrown ArrayIndexOutOfBoundsException"); 1753        } catch (ArrayIndexOutOfBoundsException t) { 1754            ; // Expected results 1755 } catch (Throwable t) { 1756            fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); 1757        } 1758 1759        try { 1760            PropertyUtils.setIndexedProperty(bean, 1761                    "intArray", 5, 1762                    new Integer (0)); 1763            fail("Should have thrown ArrayIndexOutOfBoundsException"); 1764        } catch (ArrayIndexOutOfBoundsException t) { 1765            ; // Expected results 1766 } catch (Throwable t) { 1767            fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); 1768        } 1769 1770        try { 1771            PropertyUtils.setIndexedProperty(bean, 1772                    "intIndexed", -1, 1773                    new Integer (0)); 1774            fail("Should have thrown ArrayIndexOutOfBoundsException"); 1775        } catch (ArrayIndexOutOfBoundsException t) { 1776            ; // Expected results 1777 } catch (Throwable t) { 1778            fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); 1779        } 1780 1781        try { 1782            PropertyUtils.setIndexedProperty(bean, 1783                    "intIndexed", 5, 1784                    new Integer (0)); 1785            fail("Should have thrown ArrayIndexOutOfBoundsException"); 1786        } catch (ArrayIndexOutOfBoundsException t) { 1787            ; // Expected results 1788 } catch (Throwable t) { 1789            fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); 1790        } 1791 1792        try { 1793            PropertyUtils.setIndexedProperty(bean, 1794                    "listIndexed", 5, 1795                    "New String"); 1796            fail("Should have thrown IndexOutOfBoundsException"); 1797        } catch (IndexOutOfBoundsException t) { 1798            ; // Expected results 1799 } catch (Throwable t) { 1800            fail("Threw " + t + " instead of IndexOutOfBoundsException"); 1801        } 1802 1803        try { 1804            PropertyUtils.setIndexedProperty(bean, 1805                    "listIndexed", -1, 1806                    "New String"); 1807            fail("Should have thrown IndexOutOfBoundsException"); 1808        } catch (IndexOutOfBoundsException t) { 1809            ; // Expected results 1810 } catch (Throwable t) { 1811            fail("Threw " + t + " instead of IndexOutOfBoundsException"); 1812        } 1813 1814        try { 1815            PropertyUtils.setIndexedProperty(bean, 1816                    "stringArray", -1, 1817                    "New String"); 1818            fail("Should have thrown ArrayIndexOutOfBoundsException"); 1819        } catch (ArrayIndexOutOfBoundsException t) { 1820            ; // Expected results 1821 } catch (Throwable t) { 1822            fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); 1823        } 1824 1825        try { 1826            PropertyUtils.setIndexedProperty(bean, 1827                    "stringArray", 5, 1828                    "New String"); 1829            fail("Should have thrown ArrayIndexOutOfBoundsException"); 1830        } catch (ArrayIndexOutOfBoundsException t) { 1831            ; // Expected results 1832 } catch (Throwable t) { 1833            fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); 1834        } 1835 1836        try { 1837            PropertyUtils.setIndexedProperty(bean, 1838                    "stringIndexed", -1, 1839                    "New String"); 1840            fail("Should have thrown ArrayIndexOutOfBoundsException"); 1841        } catch (ArrayIndexOutOfBoundsException t) { 1842            ; // Expected results 1843 } catch (Throwable t) { 1844            fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); 1845        } 1846 1847        try { 1848            PropertyUtils.setIndexedProperty(bean, 1849                    "stringIndexed", 5, 1850                    "New String"); 1851            fail("Should have thrown ArrayIndexOutOfBoundsException"); 1852        } catch (ArrayIndexOutOfBoundsException t) { 1853            ; // Expected results 1854 } catch (Throwable t) { 1855            fail("Threw " + t + " instead of ArrayIndexOutOfBoundsException"); 1856        } 1857 1858    } 1859 1860 1861    /** 1862     * Corner cases on getMappedProperty invalid arguments. 1863     */ 1864    public void testSetMappedArguments() { 1865 1866        // Use explicit key argument 1867 1868        try { 1869            PropertyUtils.setMappedProperty(null, "mappedProperty", 1870                    "First Key", "First Value"); 1871            fail("Should throw IllegalArgumentException 1"); 1872        } catch (IllegalArgumentException e) { 1873            ; // Expected response 1874 } catch (Throwable t) { 1875            fail("Threw " + t + " instead of IllegalArgumentException 1"); 1876        } 1877 1878        try { 1879            PropertyUtils.setMappedProperty(bean, null, "First Key", 1880                    "First Value"); 1881            fail("Should throw IllegalArgumentException 2"); 1882        } catch (IllegalArgumentException e) { 1883            ; // Expected response 1884 } catch (Throwable t) { 1885            fail("Threw " + t + " instead of IllegalArgumentException 2"); 1886        } 1887 1888        try { 1889            PropertyUtils.setMappedProperty(bean, "mappedProperty", null, 1890                    "First Value"); 1891            fail("Should throw IllegalArgumentException 3"); 1892        } catch (IllegalArgumentException e) { 1893            ; // Expected response 1894 } catch (Throwable t) { 1895            fail("Threw " + t + " instead of IllegalArgumentException 3"); 1896        } 1897 1898        // Use key expression 1899 1900        try { 1901            PropertyUtils.setMappedProperty(null, 1902                    "mappedProperty(First Key)", 1903                    "First Value"); 1904            fail("Should throw IllegalArgumentException 4"); 1905        } catch (IllegalArgumentException e) { 1906            ; // Expected response 1907 } catch (Throwable t) { 1908            fail("Threw " + t + " instead of IllegalArgumentException 4"); 1909        } 1910 1911        try { 1912            PropertyUtils.setMappedProperty(bean, "(Second Key)", 1913                    "Second Value"); 1914            fail("Should throw IllegalArgumentException 5"); 1915        } catch (NoSuchMethodException e) { 1916            ; // Expected response 1917 } catch (Throwable t) { 1918            fail("Threw " + t + " instead of NoSuchMethodException 5"); 1919        } 1920 1921        try { 1922            PropertyUtils.setMappedProperty(bean, "mappedProperty", 1923                    "Third Value"); 1924            fail("Should throw IllegalArgumentException 6"); 1925        } catch (IllegalArgumentException e) { 1926            ; // Expected response 1927 } catch (Throwable t) { 1928            fail("Threw " + t + " instead of IllegalArgumentException 6"); 1929        } 1930 1931    } 1932 1933 1934    /** 1935     * Positive and negative tests on setMappedProperty valid arguments. 1936     */ 1937    public void testSetMappedValues() { 1938 1939        Object value = null; 1940 1941        // Use explicit key argument 1942 1943        try { 1944            value = PropertyUtils.getMappedProperty(bean, "mappedProperty", 1945                    "Fourth Key"); 1946            assertNull("Can not find fourth value", value); 1947        } catch (Throwable t) { 1948            fail("Finding fourth value threw " + t); 1949        } 1950 1951        try { 1952            PropertyUtils.setMappedProperty(bean, "mappedProperty", 1953                    "Fourth Key", "Fourth Value"); 1954        } catch (Throwable t) { 1955            fail("Setting fourth value threw " + t); 1956        } 1957 1958        try { 1959            value = PropertyUtils.getMappedProperty(bean, "mappedProperty", 1960                    "Fourth Key"); 1961            assertEquals("Can find fourth value", "Fourth Value", value); 1962        } catch (Throwable t) { 1963            fail("Finding fourth value threw " + t); 1964        } 1965 1966        // Use key expression with parentheses 1967 1968        try { 1969            value = 1970                    PropertyUtils.getMappedProperty(bean, 1971                            "mappedProperty(Fifth Key)"); 1972            assertNull("Can not find fifth value", value); 1973        } catch (Throwable t) { 1974            fail("Finding fifth value threw " + t); 1975        } 1976 1977        try { 1978            PropertyUtils.setMappedProperty(bean, 1979                    "mappedProperty(Fifth Key)", 1980                    "Fifth Value"); 1981        } catch (Throwable t) { 1982            fail("Setting fifth value threw " + t); 1983        } 1984 1985        try { 1986            value = 1987                    PropertyUtils.getMappedProperty(bean, 1988                            "mappedProperty(Fifth Key)"); 1989            assertEquals("Can find fifth value", "Fifth Value", value); 1990        } catch (Throwable t) { 1991            fail("Finding fifth value threw " + t); 1992        } 1993 1994        // Use key expression with dotted expression 1995 1996        try { 1997            value = 1998                    PropertyUtils.getNestedProperty(bean, 1999                            "mapProperty.Sixth Key"); 2000            assertNull("Can not find sixth value", value); 2001        } catch (Throwable t) { 2002            fail("Finding fifth value threw " + t); 2003        } 2004 2005        try { 2006            PropertyUtils.setNestedProperty(bean, 2007                    "mapProperty.Sixth Key", 2008                    "Sixth Value"); 2009        } catch (Throwable t) { 2010            fail("Setting sixth value threw " + t); 2011        } 2012 2013        try { 2014            value = 2015                    PropertyUtils.getNestedProperty(bean, 2016                            "mapProperty.Sixth Key"); 2017            assertEquals("Can find sixth value", "Sixth Value", value); 2018        } catch (Throwable t) { 2019            fail("Finding sixth value threw " + t); 2020        } 2021 2022    } 2023 2024 2025    /** 2026     * Corner cases on setNestedProperty invalid arguments. 2027     */ 2028    public void testSetNestedArguments() { 2029 2030        try { 2031            PropertyUtils.setNestedProperty(null, "stringProperty", ""); 2032            fail("Should throw IllegalArgumentException 1"); 2033        } catch (IllegalArgumentException e) { 2034            ; // Expected response 2035 } catch (Throwable t) { 2036            fail("Threw " + t + " instead of IllegalArgumentException 1"); 2037        } 2038 2039        try { 2040            PropertyUtils.setNestedProperty(bean, null, ""); 2041            fail("Should throw IllegalArgumentException 2"); 2042        } catch (IllegalArgumentException e) { 2043            ; // Expected response 2044 } catch (Throwable t) { 2045            fail("Threw " + t + " instead of IllegalArgumentException 2"); 2046        } 2047 2048    } 2049 2050 2051    /** 2052     * Test setNextedProperty on a boolean property. 2053     */ 2054    public void testSetNestedBoolean() { 2055 2056        try { 2057            boolean oldValue = nested.getBooleanProperty(); 2058            boolean newValue = !oldValue; 2059            PropertyUtils.setNestedProperty(bean, 2060                    "nested.booleanProperty", 2061                    new Boolean (newValue)); 2062            assertTrue("Matched new value", 2063                    newValue == 2064                    nested.getBooleanProperty()); 2065        } catch (IllegalAccessException e) { 2066            fail("IllegalAccessException"); 2067        } catch (IllegalArgumentException e) { 2068            fail("IllegalArgumentException"); 2069        } catch (InvocationTargetException e) { 2070            fail("InvocationTargetException"); 2071        } catch (NoSuchMethodException e) { 2072            fail("NoSuchMethodException"); 2073        } 2074 2075    } 2076 2077 2078    /** 2079     * Test setNestedProperty on a double property. 2080     */ 2081    public void testSetNestedDouble() { 2082 2083        try { 2084            double oldValue = nested.getDoubleProperty(); 2085            double newValue = oldValue + 1.0; 2086            PropertyUtils.setNestedProperty(bean, 2087                    "nested.doubleProperty", 2088                    new Double (newValue)); 2089            assertEquals("Matched new value", 2090                    newValue, 2091                    nested.getDoubleProperty(), 2092                    0.005); 2093        } catch (IllegalAccessException e) { 2094            fail("IllegalAccessException"); 2095        } catch (IllegalArgumentException e) { 2096            fail("IllegalArgumentException"); 2097        } catch (InvocationTargetException e) { 2098            fail("InvocationTargetException"); 2099        } catch (NoSuchMethodException e) { 2100            fail("NoSuchMethodException"); 2101        } 2102 2103    } 2104 2105 2106    /** 2107     * Test setNestedProperty on a float property. 2108     */ 2109    public void testSetNestedFloat() { 2110 2111        try { 2112            float oldValue = nested.getFloatProperty(); 2113            float newValue = oldValue + (float) 1.0; 2114            PropertyUtils.setNestedProperty(bean, 2115                    "nested.floatProperty", 2116                    new Float (newValue)); 2117            assertEquals("Matched new value", 2118                    newValue, 2119                    nested.getFloatProperty(), 2120                    (float) 0.005); 2121        } catch (IllegalAccessException e) { 2122            fail("IllegalAccessException"); 2123        } catch (IllegalArgumentException e) { 2124            fail("IllegalArgumentException"); 2125        } catch (InvocationTargetException e) { 2126            fail("InvocationTargetException"); 2127        } catch (NoSuchMethodException e) { 2128            fail("NoSuchMethodException"); 2129        } 2130 2131    } 2132 2133 2134    /** 2135     * Test setNestedProperty on a int property. 2136     */ 2137    public void testSetNestedInt() { 2138 2139        try { 2140            int oldValue = nested.getIntProperty(); 2141            int newValue = oldValue + 1; 2142            PropertyUtils.setNestedProperty(bean, 2143                    "nested.intProperty", 2144                    new Integer (newValue)); 2145            assertEquals("Matched new value", 2146                    newValue, 2147                    nested.getIntProperty()); 2148        } catch (IllegalAccessException e) { 2149            fail("IllegalAccessException"); 2150        } catch (IllegalArgumentException e) { 2151            fail("IllegalArgumentException"); 2152        } catch (InvocationTargetException e) { 2153            fail("InvocationTargetException"); 2154        } catch (NoSuchMethodException e) { 2155            fail("NoSuchMethodException"); 2156        } 2157 2158    } 2159 2160 2161    /** 2162     * Test setNestedProperty on a long property. 2163     */ 2164    public void testSetNestedLong() { 2165 2166        try { 2167            long oldValue = nested.getLongProperty(); 2168            long newValue = oldValue + 1; 2169            PropertyUtils.setNestedProperty(bean, 2170                    "nested.longProperty", 2171                    new Long (newValue)); 2172            assertEquals("Matched new value", 2173                    newValue, 2174                    nested.getLongProperty()); 2175        } catch (IllegalAccessException e) { 2176            fail("IllegalAccessException"); 2177        } catch (IllegalArgumentException e) { 2178            fail("IllegalArgumentException"); 2179        } catch (InvocationTargetException e) { 2180            fail("InvocationTargetException"); 2181        } catch (NoSuchMethodException e) { 2182            fail("NoSuchMethodException"); 2183        } 2184 2185    } 2186 2187 2188    /** 2189     * Test setNestedProperty on a read-only String property. 2190     */ 2191    public void testSetNestedReadOnly() { 2192 2193        try { 2194            String oldValue = nested.getWriteOnlyPropertyValue(); 2195            String newValue = oldValue + " Extra Value"; 2196            PropertyUtils.setNestedProperty(bean, 2197                    "nested.readOnlyProperty", 2198                    newValue); 2199            fail("Should have thrown NoSuchMethodException"); 2200        } catch (IllegalAccessException e) { 2201            fail("IllegalAccessException"); 2202        } catch (IllegalArgumentException e) { 2203            fail("IllegalArgumentException"); 2204        } catch (InvocationTargetException e) { 2205            fail("InvocationTargetException"); 2206        } catch (NoSuchMethodException e) { 2207            ; // Correct result for this test 2208 } 2209 2210    } 2211 2212 2213    /** 2214     * Test setNestedProperty on a short property. 2215     */ 2216    public void testSetNestedShort() { 2217 2218        try { 2219            short oldValue = nested.getShortProperty(); 2220            short newValue = oldValue; 2221            newValue++; 2222            PropertyUtils.setNestedProperty(bean, 2223                    "nested.shortProperty", 2224                    new Short (newValue)); 2225            assertEquals("Matched new value", 2226                    newValue, 2227                    nested.getShortProperty()); 2228        } catch (IllegalAccessException e) { 2229            fail("IllegalAccessException"); 2230        } catch (IllegalArgumentException e) { 2231            fail("IllegalArgumentException"); 2232        } catch (InvocationTargetException e) { 2233            fail("InvocationTargetException"); 2234        } catch (NoSuchMethodException e) { 2235            fail("NoSuchMethodException"); 2236        } 2237 2238    } 2239 2240 2241    /** 2242     * Test setNestedProperty on a String property. 2243     */ 2244    public void testSetNestedString() { 2245 2246        try { 2247            String oldValue = nested.getStringProperty(); 2248            String newValue = oldValue + " Extra Value"; 2249            PropertyUtils.setNestedProperty(bean, 2250                    "nested.stringProperty", 2251                    newValue); 2252            assertEquals("Matched new value", 2253                    newValue, 2254                    nested.getStringProperty()); 2255        } catch (IllegalAccessException e) { 2256            fail("IllegalAccessException"); 2257        } catch (IllegalArgumentException e) { 2258            fail("IllegalArgumentException"); 2259        } catch (InvocationTargetException e) { 2260            fail("InvocationTargetException"); 2261        } catch (NoSuchMethodException e) { 2262            fail("NoSuchMethodException"); 2263        } 2264 2265    } 2266 2267 2268    /** 2269     * Test setNestedProperty on an unknown property name. 2270     */ 2271    public void testSetNestedUnknown() { 2272 2273        try { 2274            String newValue = "New String Value"; 2275            PropertyUtils.setNestedProperty(bean, 2276                    "nested.unknown", 2277                    newValue); 2278            fail("Should have thrown NoSuchMethodException"); 2279        } catch (IllegalAccessException e) { 2280            fail("IllegalAccessException"); 2281        } catch (IllegalArgumentException e) { 2282            fail("IllegalArgumentException"); 2283        } catch (InvocationTargetException e) { 2284            fail("InvocationTargetException"); 2285        } catch (NoSuchMethodException e) { 2286            ; // Correct result for this test 2287 } 2288 2289    } 2290 2291 2292    /** 2293     * Test setNestedProperty on a write-only String property. 2294     */ 2295    public void testSetNestedWriteOnly() { 2296 2297        try { 2298            String oldValue = nested.getWriteOnlyPropertyValue(); 2299            String newValue = oldValue + " Extra Value"; 2300            PropertyUtils.setNestedProperty(bean, 2301                    "nested.writeOnlyProperty", 2302                    newValue); 2303            assertEquals("Matched new value", 2304                    newValue, 2305                    nested.getWriteOnlyPropertyValue()); 2306        } catch (IllegalAccessException e) { 2307            fail("IllegalAccessException"); 2308        } catch (IllegalArgumentException e) { 2309            fail("IllegalArgumentException"); 2310        } catch (InvocationTargetException e) { 2311            fail("InvocationTargetException"); 2312        } catch (NoSuchMethodException e) { 2313            fail("NoSuchMethodException"); 2314        } 2315 2316    } 2317 2318 2319    /** 2320     * Corner cases on setSimpleProperty invalid arguments. 2321     */ 2322    public void testSetSimpleArguments() { 2323 2324        try { 2325            PropertyUtils.setSimpleProperty(null, "stringProperty", ""); 2326            fail("Should throw IllegalArgumentException 1"); 2327        } catch (IllegalArgumentException e) { 2328            ; // Expected response 2329 } catch (Throwable t) { 2330            fail("Threw " + t + " instead of IllegalArgumentException 1"); 2331        } 2332 2333        try { 2334            PropertyUtils.setSimpleProperty(bean, null, ""); 2335            fail("Should throw IllegalArgumentException 2"); 2336        } catch (IllegalArgumentException e) { 2337            ; // Expected response 2338 } catch (Throwable t) { 2339            fail("Threw " + t + " instead of IllegalArgumentException 2"); 2340        } 2341 2342    } 2343 2344 2345    /** 2346     * Test setSimpleProperty on a boolean property. 2347     */ 2348    public void testSetSimpleBoolean() { 2349 2350        try { 2351            boolean oldValue = ((Boolean ) bean.get("booleanProperty")).booleanValue(); 2352            boolean newValue = !oldValue; 2353            PropertyUtils.setSimpleProperty(bean, 2354                    "booleanProperty", 2355                    new Boolean (newValue)); 2356            assertTrue("Matched new value", 2357                    newValue == 2358                    ((Boolean ) bean.get("booleanProperty")).booleanValue()); 2359        } catch (IllegalAccessException e) { 2360            fail("IllegalAccessException"); 2361        } catch (IllegalArgumentException e) { 2362            fail("IllegalArgumentException"); 2363        } catch (InvocationTargetException e) { 2364            fail("InvocationTargetException"); 2365        } catch (NoSuchMethodException e) { 2366            fail("NoSuchMethodException"); 2367        } 2368 2369    } 2370 2371 2372    /** 2373     * Test setSimpleProperty on a double property. 2374     */ 2375    public void testSetSimpleDouble() { 2376 2377        try { 2378            double oldValue = ((Double ) bean.get("doubleProperty")).doubleValue(); 2379            double newValue = oldValue + 1.0; 2380            PropertyUtils.setSimpleProperty(bean, 2381                    "doubleProperty", 2382                    new Double (newValue)); 2383            assertEquals("Matched new value", 2384                    newValue, 2385                    ((Double ) bean.get("doubleProperty")).doubleValue(), 2386                    0.005); 2387        } catch (IllegalAccessException e) { 2388            fail("IllegalAccessException"); 2389        } catch (IllegalArgumentException e) { 2390            fail("IllegalArgumentException"); 2391        } catch (InvocationTargetException e) { 2392            fail("InvocationTargetException"); 2393        } catch (NoSuchMethodException e) { 2394            fail("NoSuchMethodException"); 2395        } 2396 2397    } 2398 2399 2400    /** 2401     * Test setSimpleProperty on a float property. 2402     */ 2403    public void testSetSimpleFloat() { 2404 2405        try { 2406            float oldValue = ((Float ) bean.get("floatProperty")).floatValue(); 2407            float newValue = oldValue + (float) 1.0; 2408            PropertyUtils.setSimpleProperty(bean, 2409                    "floatProperty", 2410                    new Float (newValue)); 2411            assertEquals("Matched new value", 2412                    newValue, 2413                    ((Float ) bean.get("floatProperty")).floatValue(), 2414                    (float) 0.005); 2415        } catch (IllegalAccessException e) { 2416            fail("IllegalAccessException"); 2417        } catch (IllegalArgumentException e) { 2418            fail("IllegalArgumentException"); 2419        } catch (InvocationTargetException e) { 2420            fail("InvocationTargetException"); 2421        } catch (NoSuchMethodException e) { 2422            fail("NoSuchMethodException"); 2423        } 2424 2425    } 2426 2427 2428    /** 2429     * Negative test setSimpleProperty on an indexed property. 2430     */ 2431    public void testSetSimpleIndexed() { 2432 2433        try { 2434            PropertyUtils.setSimpleProperty(bean, 2435                    "stringIndexed[0]", 2436                    "New String Value"); 2437            fail("Should have thrown IllegalArgumentException"); 2438        } catch (IllegalAccessException e) { 2439            fail("IllegalAccessException"); 2440        } catch (IllegalArgumentException e) { 2441            ; // Correct result for this test 2442 } catch (InvocationTargetException e) { 2443            fail("InvocationTargetException"); 2444        } catch (NoSuchMethodException e) { 2445            fail("NoSuchMethodException"); 2446        } 2447 2448    } 2449 2450 2451    /** 2452     * Test setSimpleProperty on a int property. 2453     */ 2454    public void testSetSimpleInt() { 2455 2456        try { 2457            int oldValue = ((Integer ) bean.get("intProperty")).intValue(); 2458            int newValue = oldValue + 1; 2459            PropertyUtils.setSimpleProperty(bean, 2460                    "intProperty", 2461                    new Integer (newValue)); 2462            assertEquals("Matched new value", 2463                    newValue, 2464                    ((Integer ) bean.get("intProperty")).intValue()); 2465        } catch (IllegalAccessException e) { 2466            fail("IllegalAccessException"); 2467        } catch (IllegalArgumentException e) { 2468            fail("IllegalArgumentException"); 2469        } catch (InvocationTargetException e) { 2470            fail("InvocationTargetException"); 2471        } catch (NoSuchMethodException e) { 2472            fail("NoSuchMethodException"); 2473        } 2474 2475    } 2476 2477 2478    /** 2479     * Test setSimpleProperty on a long property. 2480     */ 2481    public void testSetSimpleLong() { 2482 2483        try { 2484            long oldValue = ((Long ) bean.get("longProperty")).longValue(); 2485            long newValue = oldValue + 1; 2486            PropertyUtils.setSimpleProperty(bean, 2487                    "longProperty", 2488                    new Long (newValue)); 2489            assertEquals("Matched new value", 2490                    newValue, 2491                    ((Long ) bean.get("longProperty")).longValue()); 2492        } catch (IllegalAccessException e) { 2493            fail("IllegalAccessException"); 2494        } catch (IllegalArgumentException e) { 2495            fail("IllegalArgumentException"); 2496        } catch (InvocationTargetException e) { 2497            fail("InvocationTargetException"); 2498        } catch (NoSuchMethodException e) { 2499            fail("NoSuchMethodException"); 2500        } 2501 2502    } 2503 2504 2505    /** 2506     * Negative test setSimpleProperty on a nested property. 2507     */ 2508    public void testSetSimpleNested() { 2509 2510        try { 2511            PropertyUtils.setSimpleProperty(bean, 2512                    "nested.stringProperty", 2513                    "New String Value"); 2514            fail("Should have thrown IllegalArgumentException"); 2515        } catch (IllegalAccessException e) { 2516            fail("IllegalAccessException"); 2517        } catch (IllegalArgumentException e) { 2518            ; // Correct result for this test 2519 } catch (InvocationTargetException e) { 2520            fail("InvocationTargetException"); 2521        } catch (NoSuchMethodException e) { 2522            fail("NoSuchMethodException"); 2523        } 2524 2525    } 2526 2527 2528    /** 2529     * Test setSimpleProperty on a short property. 2530     */ 2531    public void testSetSimpleShort() { 2532 2533        try { 2534            short oldValue = ((Short ) bean.get("shortProperty")).shortValue(); 2535            short newValue = oldValue; 2536            newValue++; 2537            PropertyUtils.setSimpleProperty(bean, 2538                    "shortProperty", 2539                    new Short (newValue)); 2540            assertEquals("Matched new value", 2541                    newValue, 2542                    ((Short ) bean.get("shortProperty")).shortValue()); 2543        } catch (IllegalAccessException e) { 2544            fail("IllegalAccessException"); 2545        } catch (IllegalArgumentException e) { 2546            fail("IllegalArgumentException"); 2547        } catch (InvocationTargetException e) { 2548            fail("InvocationTargetException"); 2549        } catch (NoSuchMethodException e) { 2550            fail("NoSuchMethodException"); 2551        } 2552 2553    } 2554 2555 2556    /** 2557     * Test setSimpleProperty on a String property. 2558     */ 2559    public void testSetSimpleString() { 2560 2561        try { 2562            String oldValue = (String ) bean.get("stringProperty"); 2563            String newValue = oldValue + " Extra Value"; 2564            PropertyUtils.setSimpleProperty(bean, 2565                    "stringProperty", 2566                    newValue); 2567            assertEquals("Matched new value", 2568                    newValue, 2569                    (String ) bean.get("stringProperty")); 2570        } catch (IllegalAccessException e) { 2571            fail("IllegalAccessException"); 2572        } catch (IllegalArgumentException e) { 2573            fail("IllegalArgumentException"); 2574        } catch (InvocationTargetException e) { 2575            fail("InvocationTargetException"); 2576        } catch (NoSuchMethodException e) { 2577            fail("NoSuchMethodException"); 2578        } 2579 2580    } 2581 2582 2583    /** 2584     * Test setSimpleProperty on an unknown property name. 2585     */ 2586    public void testSetSimpleUnknown() { 2587 2588        try { 2589            String newValue = "New String Value"; 2590            PropertyUtils.setSimpleProperty(bean, 2591                    "unknown", 2592                    newValue); 2593            fail("Should have thrown NoSuchMethodException"); 2594        } catch (IllegalAccessException e) { 2595            fail("IllegalAccessException"); 2596        } catch (IllegalArgumentException e) { 2597            fail("IllegalArgumentException"); 2598        } catch (InvocationTargetException e) { 2599            fail("InvocationTargetException"); 2600        } catch (NoSuchMethodException e) { 2601            ; // Correct result for this test 2602 } 2603 2604    } 2605 2606 2607    // ------------------------------------------------------ Protected Methods 2608 2609 2610    /** 2611     * Create and return a <code>DynaClass</code> instance for our test 2612     * <code>DynaBean</code>. 2613     */ 2614    protected DynaClass createDynaClass() { 2615 2616        int intArray[] = new int[0]; 2617        String stringArray[] = new String [0]; 2618 2619        DynaClass dynaClass = new BasicDynaClass 2620                ("TestDynaClass", null, 2621                        new DynaProperty[]{ 2622                            new DynaProperty("booleanProperty", Boolean.TYPE), 2623                            new DynaProperty("booleanSecond", Boolean.TYPE), 2624                            new DynaProperty("doubleProperty", Double.TYPE), 2625                            new DynaProperty("dupProperty", stringArray.getClass()), 2626                            new DynaProperty("floatProperty", Float.TYPE), 2627                            new DynaProperty("intArray", intArray.getClass()), 2628                            new DynaProperty("intIndexed", intArray.getClass()), 2629                            new DynaProperty("intProperty", Integer.TYPE), 2630                            new DynaProperty("listIndexed", List .class), 2631                            new DynaProperty("longProperty", Long.TYPE), 2632                            new DynaProperty("mapProperty", Map .class), 2633                            new DynaProperty("mappedObjects", Map .class), 2634                            new DynaProperty("mappedProperty", Map .class), 2635                            new DynaProperty("mappedIntProperty", Map .class), 2636                            new DynaProperty("nested", TestBean.class), 2637                            new DynaProperty("nullProperty", String .class), 2638                            new DynaProperty("shortProperty", Short.TYPE), 2639                            new DynaProperty("stringArray", stringArray.getClass()), 2640                            new DynaProperty("stringIndexed", stringArray.getClass()), 2641                            new DynaProperty("stringProperty", String .class), 2642                        }); 2643        return (dynaClass); 2644 2645    } 2646 2647 2648} 2649

A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame Popular Tags