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