TestDynaActionForm xref

    1   /*
    2    * $Id: TestDynaActionForm.java 471754 2006-11-06 14:55:09Z husted $
    3    *
    4    * Licensed to the Apache Software Foundation (ASF) under one
    5    * or more contributor license agreements.  See the NOTICE file
    6    * distributed with this work for additional information
    7    * regarding copyright ownership.  The ASF licenses this file
    8    * to you under the Apache License, Version 2.0 (the
    9    * "License"); you may not use this file except in compliance
    10   * with the License.  You may obtain a copy of the License at
    11   *
    12   *  http://www.apache.org/licenses/LICENSE-2.0
    13   *
    14   * Unless required by applicable law or agreed to in writing,
    15   * software distributed under the License is distributed on an
    16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    17   * KIND, either express or implied.  See the License for the
    18   * specific language governing permissions and limitations
    19   * under the License.
    20   */
    21  package org.apache.struts.action;
    22
    23  import junit.framework.Test;
    24  import junit.framework.TestSuite;
    25
    26  import org.apache.commons.beanutils.DynaProperty;
    27  import org.apache.commons.logging.Log;
    28  import org.apache.commons.logging.LogFactory;
    29  import org.apache.struts.config.FormBeanConfig;
    30  import org.apache.struts.config.ModuleConfig;
    31  import org.apache.struts.config.impl.ModuleConfigImpl;
    32  import org.apache.struts.mock.MockHttpServletRequest;
    33
    34  import java.util.ArrayList;
    35  import java.util.HashMap;
    36  import java.util.List;
    37  import java.util.Map;
    38
    39  /**
    40   * Suite of unit tests for the <code>org.apache.struts.action.DynaActionForm</code>
    41   * class.
    42   */
    43  public class TestDynaActionForm extends TestDynaActionFormClass {
    44      /**
    45       * The set of property names we expect to have returned when calling
    46       * <code>getDynaProperties()</code>.  You should update this list when new
    47       * properties are added to TestBean.
    48       */
    49      protected final static String[] properties =
    50          {
    51              "booleanProperty", "booleanSecond", "doubleProperty",
    52              "floatProperty", "intArray", "intIndexed", "intProperty",
    53              "listIndexed", "longProperty", "mappedProperty", "mappedIntProperty",
    54
    55
    56              //        "nullProperty",
    57              "shortProperty", "stringArray", "stringIndexed", "stringProperty",
    58          };
    59
    60      // ----------------------------------------------------- Instance Variables
    61
    62      /**
    63       * Dummy ModuleConfig for calls to reset() and validate().
    64       */
    65      protected ModuleConfig moduleConfig = null;
    66
    67      /**
    68       * The basic <code>DynaActionForm</code> to use for testing.
    69       */
    70      protected DynaActionForm dynaForm = null;
    71
    72      /**
    73       * Dummy ActionMapping for calls to reset() and validate().
    74       */
    75      protected ActionMapping mapping = null;
    76      protected Log log = null;
    77
    78      /**
    79       * Defines the testcase name for JUnit.
    80       *
    81       * @param theName the testcase's name.
    82       */
    83      public TestDynaActionForm(String theName) {
    84          super(theName);
    85      }
    86
    87      /**
    88       * Start the tests.
    89       *
    90       * @param theArgs the arguments. Not used
    91       */
    92      public static void main(String[] theArgs) {
    93          junit.awtui.TestRunner.main(new String[] {
    94                  TestDynaActionForm.class.getName()
    95              });
    96      }
    97
    98      /**
    99       * @return a test suite (<code>TestSuite</code>) that includes all methods
    100      *         starting with "test"
    101      */
    102     public static Test suite() {
    103         // All methods starting with "test" will be executed in the test suite.
    104         return new TestSuite(TestDynaActionForm.class);
    105     }
    106
    107     // ----------------------------------------------------- Setup and Teardown
    108     public void setUp() {
    109         super.setUp();
    110
    111         try {
    112             dynaForm = (DynaActionForm) dynaClass.newInstance();
    113         } catch (IllegalAccessException e) {
    114             throw new RuntimeException(e.getMessage());
    115         } catch (InstantiationException e) {
    116             throw new RuntimeException(e.getMessage());
    117         }
    118
    119         setupComplexProperties();
    120         moduleConfig = new DynaActionFormConfig(beanConfig);
    121         mapping = new DynaActionFormMapping(moduleConfig);
    122         log = LogFactory.getLog(this.getClass().getName() + "."
    123                 + this.getName());
    124     }
    125
    126     public void tearDown() {
    127         super.tearDown();
    128         moduleConfig = null;
    129         dynaForm = null;
    130         mapping = null;
    131     }
    132
    133     // --------------------------------------------- Create New DynaActionForms
    134     // Test basic form bean properties on creation
    135     public void testBeanCreate() {
    136         assertEquals("booleanProperty", Boolean.TRUE,
    137             (Boolean) dynaForm.get("booleanProperty"));
    138         assertEquals("booleanSecond", Boolean.TRUE,
    139             (Boolean) dynaForm.get("booleanSecond"));
    140         assertEquals("doubleProperty", new Double(321.0),
    141             (Double) dynaForm.get("doubleProperty"));
    142         assertEquals("floatProperty", new Float((float) 123.0),
    143             (Float) dynaForm.get("floatProperty"));
    144         assertEquals("intProperty", new Integer(123),
    145             (Integer) dynaForm.get("intProperty"));
    146
    147         // FIXME - listIndexed
    148         assertEquals("longProperty", new Long((long) 321),
    149             (Long) dynaForm.get("longProperty"));
    150
    151         // FIXME - mappedProperty
    152         // FIXME - mappedIntProperty
    153         //        assertEquals("nullProperty", (String) null,
    154         //                     (String) dynaForm.get("nullProperty"));
    155         assertEquals("shortProperty", new Short((short) 987),
    156             (Short) dynaForm.get("shortProperty"));
    157         assertEquals("stringProperty", "This is a string",
    158             (String) dynaForm.get("stringProperty"));
    159     }
    160
    161     // Test initialize() method on indexed values to ensure that the
    162     // result returned by FormPropertyConfig().initial() is never clobbered
    163     public void testIndexedInitialize() {
    164         // Update some values in the indexed properties
    165         dynaForm.set("intArray", 1, new Integer(111));
    166         assertEquals("intArray[1]", new Integer(111),
    167             (Integer) dynaForm.get("intArray", 1));
    168         dynaForm.set("intIndexed", 2, new Integer(222));
    169         assertEquals("intIndexed[2]", new Integer(222),
    170             (Integer) dynaForm.get("intIndexed", 2));
    171         dynaForm.set("stringArray", 3, "New String 3");
    172         assertEquals("stringArray[3]", "New String 3",
    173             (String) dynaForm.get("stringArray", 3));
    174         dynaForm.set("stringIndexed", 4, "New String 4");
    175         assertEquals("stringIndexed[4]", "New String 4",
    176             (String) dynaForm.get("stringIndexed", 4));
    177
    178         // Perform initialize() and revalidate the original values
    179         // while ensuring our initial values did not get corrupted
    180         dynaForm.initialize(mapping);
    181         setupComplexProperties();
    182         testGetIndexedValues();
    183     }
    184
    185     // Test initialize() method going back to initial values
    186     public void testScalarInitialize() {
    187         // Update a bunch of scalar properties to new values
    188         dynaForm.set("booleanProperty", Boolean.FALSE);
    189         assertEquals("booleanProperty", Boolean.FALSE,
    190             (Boolean) dynaForm.get("booleanProperty"));
    191         dynaForm.set("booleanSecond", Boolean.FALSE);
    192         dynaForm.set("doubleProperty", new Double(654.0));
    193         dynaForm.set("floatProperty", new Float((float) 543.0));
    194         dynaForm.set("intProperty", new Integer(555));
    195         dynaForm.set("longProperty", new Long((long) 777));
    196         dynaForm.set("shortProperty", new Short((short) 222));
    197         dynaForm.set("stringProperty", "New String Value");
    198         assertEquals("stringProperty", "New String Value",
    199             (String) dynaForm.get("stringProperty"));
    200
    201         // Perform initialize() and revalidate the original values
    202         dynaForm.initialize(mapping);
    203         setupComplexProperties();
    204         testBeanCreate();
    205     }
    206
    207     // --------------------------------------- Tests from BasicDynaBeanTestCase
    208
    209     /**
    210      * Corner cases on getDynaProperty invalid arguments.
    211      */
    212     public void testGetDescriptorArguments() {
    213         DynaProperty descriptor =
    214             dynaForm.getDynaClass().getDynaProperty("unknown");
    215
    216         assertNull("Unknown property descriptor should be null", descriptor);
    217
    218         try {
    219             dynaForm.getDynaClass().getDynaProperty(null);
    220             fail("Should throw IllegalArgumentException");
    221         } catch (IllegalArgumentException e) {
    222             ; // Expected response
    223         }
    224     }
    225
    226     /**
    227      * Positive getDynaProperty on property <code>booleanProperty</code>.
    228      */
    229     public void testGetDescriptorBoolean() {
    230         testGetDescriptorBase("booleanProperty", Boolean.TYPE);
    231     }
    232
    233     /**
    234      * Positive getDynaProperty on property <code>doubleProperty</code>.
    235      */
    236     public void testGetDescriptorDouble() {
    237         testGetDescriptorBase("doubleProperty", Double.TYPE);
    238     }
    239
    240     /**
    241      * Positive getDynaProperty on property <code>floatProperty</code>.
    242      */
    243     public void testGetDescriptorFloat() {
    244         testGetDescriptorBase("floatProperty", Float.TYPE);
    245     }
    246
    247     /**
    248      * Positive getDynaProperty on property <code>intProperty</code>.
    249      */
    250     public void testGetDescriptorInt() {
    251         testGetDescriptorBase("intProperty", Integer.TYPE);
    252     }
    253
    254     /**
    255      * Positive getDynaProperty on property <code>longProperty</code>.
    256      */
    257     public void testGetDescriptorLong() {
    258         testGetDescriptorBase("longProperty", Long.TYPE);
    259     }
    260
    261     /**
    262      * Positive getDynaProperty on property <code>booleanSecond</code> that
    263      * uses an "is" method as the getter.
    264      */
    265     public void testGetDescriptorSecond() {
    266         testGetDescriptorBase("booleanSecond", Boolean.TYPE);
    267     }
    268
    269     /**
    270      * Positive getDynaProperty on property <code>shortProperty</code>.
    271      */
    272     public void testGetDescriptorShort() {
    273         testGetDescriptorBase("shortProperty", Short.TYPE);
    274     }
    275
    276     /**
    277      * Positive getDynaProperty on property <code>stringProperty</code>.
    278      */
    279     public void testGetDescriptorString() {
    280         testGetDescriptorBase("stringProperty", String.class);
    281     }
    282
    283     /**
    284      * Positive test for getDynaPropertys().  Each property name listed in
    285      * <code>properties</code> should be returned exactly once.
    286      */
    287     public void testGetDescriptors() {
    288         DynaProperty[] pd = dynaForm.getDynaClass().getDynaProperties();
    289
    290         assertNotNull("Got descriptors", pd);
    291
    292         int[] count = new int[properties.length];
    293
    294         for (int i = 0; i < pd.length; i++) {
    295             String name = pd[i].getName();
    296
    297             for (int j = 0; j < properties.length; j++) {
    298                 if (name.equals(properties[j])) {
    299                     count[j]++;
    300                 }
    301             }
    302         }
    303
    304         for (int j = 0; j < properties.length; j++) {
    305             if (count[j] < 0) {
    306                 fail("Missing property " + properties[j]);
    307             } else if (count[j] > 1) {
    308                 fail("Duplicate property " + properties[j]);
    309             }
    310         }
    311     }
    312
    313     /**
    314      * Corner cases on getIndexedProperty invalid arguments.
    315      */
    316     public void testGetIndexedArguments() {
    317         try {
    318             dynaForm.get("intArray", -1);
    319             fail("Should throw IndexOutOfBoundsException");
    320         } catch (IndexOutOfBoundsException e) {
    321             ; // Expected response
    322         }
    323     }
    324
    325     /**
    326      * Positive and negative tests on getIndexedProperty valid arguments.
    327      */
    328     public void testGetIndexedValues() {
    329         Object value = null;
    330
    331         for (int i = 0; i < 5; i++) {
    332             value = dynaForm.get("intArray", i);
    333             assertNotNull("intArray returned value " + i, value);
    334             assertTrue("intArray returned Integer " + i,
    335                 value instanceof Integer);
    336             assertEquals("intArray returned correct " + i, i * 10,
    337                 ((Integer) value).intValue());
    338
    339             value = dynaForm.get("intIndexed", i);
    340             assertNotNull("intIndexed returned value " + i, value);
    341             assertTrue("intIndexed returned Integer " + i,
    342                 value instanceof Integer);
    343             assertEquals("intIndexed returned correct " + i, i * 100,
    344                 ((Integer) value).intValue());
    345
    346             value = dynaForm.get("listIndexed", i);
    347             assertNotNull("listIndexed returned value " + i, value);
    348             assertTrue("list returned String " + i, value instanceof String);
    349             assertEquals("listIndexed returned correct " + i, "String " + i,
    350                 (String) value);
    351
    352             value = dynaForm.get("stringArray", i);
    353             assertNotNull("stringArray returned value " + i, value);
    354             assertTrue("stringArray returned String " + i,
    355                 value instanceof String);
    356             assertEquals("stringArray returned correct " + i, "String " + i,
    357                 (String) value);
    358
    359             value = dynaForm.get("stringIndexed", i);
    360             assertNotNull("stringIndexed returned value " + i, value);
    361             assertTrue("stringIndexed returned String " + i,
    362                 value instanceof String);
    363             assertEquals("stringIndexed returned correct " + i, "String " + i,
    364                 (String) value);
    365         }
    366     }
    367
    368     /**
    369      * Corner cases on getMappedProperty invalid arguments.
    370      */
    371     public void testGetMappedArguments() {
    372         Object value = dynaForm.get("mappedProperty", "unknown");
    373
    374         assertNull("Should not return a value", value);
    375     }
    376
    377     /**
    378      * Positive and negative tests on getMappedProperty valid arguments.
    379      */
    380     public void testGetMappedValues() {
    381         Object value = null;
    382
    383         value = dynaForm.get("mappedProperty", "First Key");
    384         assertEquals("Can find first value", "First Value", value);
    385
    386         value = dynaForm.get("mappedProperty", "Second Key");
    387         assertEquals("Can find second value", "Second Value", value);
    388
    389         value = dynaForm.get("mappedProperty", "Third Key");
    390         assertNull("Can not find third value", value);
    391     }
    392
    393     /**
    394      * Corner cases on getSimpleProperty invalid arguments.
    395      */
    396     public void testGetSimpleArguments() {
    397         try {
    398             dynaForm.get(null);
    399             fail("Should throw IllegalArgumentException");
    400         } catch (IllegalArgumentException e) {
    401             ; // Expected response
    402         }
    403     }
    404
    405     /**
    406      * Test getSimpleProperty on a boolean property.
    407      */
    408     public void testGetSimpleBoolean() {
    409         Object value = dynaForm.get("booleanProperty");
    410
    411         assertNotNull("Got a value", value);
    412         assertTrue("Got correct type", (value instanceof Boolean));
    413         assertTrue("Got correct value", ((Boolean) value).booleanValue() == true);
    414     }
    415
    416     /**
    417      * Test getSimpleProperty on a double property.
    418      */
    419     public void testGetSimpleDouble() {
    420         Object value = dynaForm.get("doubleProperty");
    421
    422         assertNotNull("Got a value", value);
    423         assertTrue("Got correct type", (value instanceof Double));
    424         assertEquals("Got correct value", ((Double) value).doubleValue(),
    425             (double) 321.0, (double) 0.005);
    426     }
    427
    428     /**
    429      * Test getSimpleProperty on a float property.
    430      */
    431     public void testGetSimpleFloat() {
    432         Object value = dynaForm.get("floatProperty");
    433
    434         assertNotNull("Got a value", value);
    435         assertTrue("Got correct type", (value instanceof Float));
    436         assertEquals("Got correct value", ((Float) value).floatValue(),
    437             (float) 123.0, (float) 0.005);
    438     }
    439
    440     /**
    441      * Test getSimpleProperty on a int property.
    442      */
    443     public void testGetSimpleInt() {
    444         Object value = dynaForm.get("intProperty");
    445
    446         assertNotNull("Got a value", value);
    447         assertTrue("Got correct type", (value instanceof Integer));
    448         assertEquals("Got correct value", ((Integer) value).intValue(),
    449             (int) 123);
    450     }
    451
    452     /**
    453      * Test getSimpleProperty on a long property.
    454      */
    455     public void testGetSimpleLong() {
    456         Object value = dynaForm.get("longProperty");
    457
    458         assertNotNull("Got a value", value);
    459         assertTrue("Got correct type", (value instanceof Long));
    460         assertEquals("Got correct value", ((Long) value).longValue(), (long) 321);
    461     }
    462
    463     /**
    464      * Test getSimpleProperty on a short property.
    465      */
    466     public void testGetSimpleShort() {
    467         Object value = dynaForm.get("shortProperty");
    468
    469         assertNotNull("Got a value", value);
    470         assertTrue("Got correct type", (value instanceof Short));
    471         assertEquals("Got correct value", ((Short) value).shortValue(),
    472             (short) 987);
    473     }
    474
    475     /**
    476      * Test getSimpleProperty on a String property.
    477      */
    478     public void testGetSimpleString() {
    479         Object value = dynaForm.get("stringProperty");
    480
    481         assertNotNull("Got a value", value);
    482         assertTrue("Got correct type", (value instanceof String));
    483         assertEquals("Got correct value", (String) value, "This is a string");
    484     }
    485
    486     /**
    487      * Test <code>contains()</code> method for mapped properties.
    488      */
    489     public void testMappedContains() {
    490         assertTrue("Can see first key",
    491             dynaForm.contains("mappedProperty", "First Key"));
    492
    493         assertTrue("Can not see unknown key",
    494             !dynaForm.contains("mappedProperty", "Unknown Key"));
    495     }
    496
    497     /**
    498      * Test <code>remove()</code> method for mapped properties.
    499      */
    500     public void testMappedRemove() {
    501         assertTrue("Can see first key",
    502             dynaForm.contains("mappedProperty", "First Key"));
    503         dynaForm.remove("mappedProperty", "First Key");
    504         assertTrue("Can not see first key",
    505             !dynaForm.contains("mappedProperty", "First Key"));
    506
    507         assertTrue("Can not see unknown key",
    508             !dynaForm.contains("mappedProperty", "Unknown Key"));
    509         dynaForm.remove("mappedProperty", "Unknown Key");
    510         assertTrue("Can not see unknown key",
    511             !dynaForm.contains("mappedProperty", "Unknown Key"));
    512     }
    513
    514     /**
    515      * Test the reset method when the request method is GET.
    516      */
    517     public void testResetGet() {
    518         // set a choice set of props with non-initial values
    519         dynaForm.set("booleanProperty", Boolean.FALSE);
    520         dynaForm.set("booleanSecond", Boolean.FALSE);
    521         dynaForm.set("doubleProperty", new Double(456.0));
    522         dynaForm.set("floatProperty", new Float((float) 456.0));
    523         dynaForm.set("intProperty", new Integer(456));
    524
    525         MockHttpServletRequest request = new MockHttpServletRequest();
    526
    527         request.setMethod("GET");
    528         dynaForm.reset(mapping, request);
    529
    530         assertEquals("booleanProperty should be reset", Boolean.TRUE,
    531             (Boolean) dynaForm.get("booleanProperty"));
    532         assertEquals("booleanSecond should be reset", Boolean.TRUE,
    533             (Boolean) dynaForm.get("booleanSecond"));
    534         assertEquals("doubleProperty should be reset", new Double(321.0),
    535             (Double) dynaForm.get("doubleProperty"));
    536         assertEquals("floatProperty should NOT be reset",
    537             new Float((float) 456.0), (Float) dynaForm.get("floatProperty"));
    538         assertEquals("intProperty should NOT be reset", new Integer(456),
    539             (Integer) dynaForm.get("intProperty"));
    540     }
    541
    542     /**
    543      * Test the reset method when the request method is GET.
    544      */
    545     public void testResetPost() {
    546         // set a choice set of props with non-initial values
    547         dynaForm.set("booleanProperty", Boolean.FALSE);
    548         dynaForm.set("booleanSecond", Boolean.FALSE);
    549         dynaForm.set("doubleProperty", new Double(456.0));
    550         dynaForm.set("floatProperty", new Float((float) 456.0));
    551         dynaForm.set("intProperty", new Integer(456));
    552
    553         MockHttpServletRequest request = new MockHttpServletRequest();
    554
    555         request.setMethod("POST");
    556         dynaForm.reset(mapping, request);
    557
    558         assertEquals("booleanProperty should be reset", Boolean.TRUE,
    559             (Boolean) dynaForm.get("booleanProperty"));
    560         assertEquals("booleanSecond should be reset", Boolean.TRUE,
    561             (Boolean) dynaForm.get("booleanSecond"));
    562         assertEquals("doubleProperty should NOT be reset", new Double(456),
    563             (Double) dynaForm.get("doubleProperty"));
    564         assertEquals("floatProperty should be reset", new Float((float) 123.0),
    565             (Float) dynaForm.get("floatProperty"));
    566         assertEquals("intProperty should NOT be reset", new Integer(456),
    567             (Integer) dynaForm.get("intProperty"));
    568     }
    569
    570     /**
    571      * Corner cases on setIndexedProperty invalid arguments.
    572      */
    573     public void testSetIndexedArguments() {
    574         try {
    575             dynaForm.set("intArray", -1, new Integer(0));
    576             fail("Should throw IndexOutOfBoundsException");
    577         } catch (IndexOutOfBoundsException e) {
    578             ; // Expected response
    579         }
    580     }
    581
    582     /**
    583      * Positive and negative tests on setIndexedProperty valid arguments.
    584      */
    585     public void testSetIndexedValues() {
    586         Object value = null;
    587
    588         dynaForm.set("intArray", 0, new Integer(1));
    589         value = (Integer) dynaForm.get("intArray", 0);
    590         assertNotNull("Returned new value 0", value);
    591         assertTrue("Returned Integer new value 0", value instanceof Integer);
    592         assertEquals("Returned correct new value 0", 1,
    593             ((Integer) value).intValue());
    594
    595         dynaForm.set("intIndexed", 1, new Integer(11));
    596         value = (Integer) dynaForm.get("intIndexed", 1);
    597         assertNotNull("Returned new value 1", value);
    598         assertTrue("Returned Integer new value 1", value instanceof Integer);
    599         assertEquals("Returned correct new value 1", 11,
    600             ((Integer) value).intValue());
    601         dynaForm.set("listIndexed", 2, "New Value 2");
    602         value = (String) dynaForm.get("listIndexed", 2);
    603         assertNotNull("Returned new value 2", value);
    604         assertTrue("Returned String new value 2", value instanceof String);
    605         assertEquals("Returned correct new value 2", "New Value 2",
    606             (String) value);
    607
    608         dynaForm.set("stringArray", 3, "New Value 3");
    609         value = (String) dynaForm.get("stringArray", 3);
    610         assertNotNull("Returned new value 3", value);
    611         assertTrue("Returned String new value 3", value instanceof String);
    612         assertEquals("Returned correct new value 3", "New Value 3",
    613             (String) value);
    614
    615         dynaForm.set("stringIndexed", 4, "New Value 4");
    616         value = (String) dynaForm.get("stringIndexed", 4);
    617         assertNotNull("Returned new value 4", value);
    618         assertTrue("Returned String new value 4", value instanceof String);
    619         assertEquals("Returned correct new value 4", "New Value 4",
    620             (String) value);
    621     }
    622
    623     /**
    624      * Positive and negative tests on setMappedProperty valid arguments.
    625      */
    626     public void testSetMappedValues() {
    627         dynaForm.set("mappedProperty", "First Key", "New First Value");
    628         assertEquals("Can replace old value", "New First Value",
    629             (String) dynaForm.get("mappedProperty", "First Key"));
    630
    631         dynaForm.set("mappedProperty", "Fourth Key", "Fourth Value");
    632         assertEquals("Can set new value", "Fourth Value",
    633             (String) dynaForm.get("mappedProperty", "Fourth Key"));
    634     }
    635
    636     /**
    637      * Test setSimpleProperty on a boolean property.
    638      */
    639     public void testSetSimpleBoolean() {
    640         boolean oldValue =
    641             ((Boolean) dynaForm.get("booleanProperty")).booleanValue();
    642         boolean newValue = !oldValue;
    643
    644         dynaForm.set("booleanProperty", new Boolean(newValue));
    645         assertTrue("Matched new value",
    646             newValue == ((Boolean) dynaForm.get("booleanProperty"))
    647             .booleanValue());
    648     }
    649
    650     /**
    651      * Test setSimpleProperty on a double property.
    652      */
    653     public void testSetSimpleDouble() {
    654         double oldValue =
    655             ((Double) dynaForm.get("doubleProperty")).doubleValue();
    656         double newValue = oldValue + 1.0;
    657
    658         dynaForm.set("doubleProperty", new Double(newValue));
    659         assertEquals("Matched new value", newValue,
    660             ((Double) dynaForm.get("doubleProperty")).doubleValue(),
    661             (double) 0.005);
    662     }
    663
    664     /**
    665      * Test setSimpleProperty on a float property.
    666      */
    667     public void testSetSimpleFloat() {
    668         float oldValue = ((Float) dynaForm.get("floatProperty")).floatValue();
    669         float newValue = oldValue + (float) 1.0;
    670
    671         dynaForm.set("floatProperty", new Float(newValue));
    672         assertEquals("Matched new value", newValue,
    673             ((Float) dynaForm.get("floatProperty")).floatValue(), (float) 0.005);
    674     }
    675
    676     /**
    677      * Test setSimpleProperty on a int property.
    678      */
    679     public void testSetSimpleInt() {
    680         int oldValue = ((Integer) dynaForm.get("intProperty")).intValue();
    681         int newValue = oldValue + 1;
    682
    683         dynaForm.set("intProperty", new Integer(newValue));
    684         assertEquals("Matched new value", newValue,
    685             ((Integer) dynaForm.get("intProperty")).intValue());
    686     }
    687
    688     /**
    689      * Test setSimpleProperty on a long property.
    690      */
    691     public void testSetSimpleLong() {
    692         long oldValue = ((Long) dynaForm.get("longProperty")).longValue();
    693         long newValue = oldValue + 1;
    694
    695         dynaForm.set("longProperty", new Long(newValue));
    696         assertEquals("Matched new value", newValue,
    697             ((Long) dynaForm.get("longProperty")).longValue());
    698     }
    699
    700     /**
    701      * Test setSimpleProperty on a short property.
    702      */
    703     public void testSetSimpleShort() {
    704         short oldValue = ((Short) dynaForm.get("shortProperty")).shortValue();
    705         short newValue = (short) (oldValue + 1);
    706
    707         dynaForm.set("shortProperty", new Short(newValue));
    708         assertEquals("Matched new value", newValue,
    709             ((Short) dynaForm.get("shortProperty")).shortValue());
    710     }
    711
    712     /**
    713      * Test setSimpleProperty on a String property.
    714      */
    715     public void testSetSimpleString() {
    716         String oldValue = (String) dynaForm.get("stringProperty");
    717         String newValue = oldValue + " Extra Value";
    718
    719         dynaForm.set("stringProperty", newValue);
    720         assertEquals("Matched new value", newValue,
    721             (String) dynaForm.get("stringProperty"));
    722     }
    723
    724     // ------------------------------------------------------ Protected Methods
    725
    726     /**
    727      * Set up the complex properties that cannot be configured from the
    728      * initial value expression.
    729      */
    730     protected void setupComplexProperties() {
    731         List listIndexed = new ArrayList();
    732
    733         listIndexed.add("String 0");
    734         listIndexed.add("String 1");
    735         listIndexed.add("String 2");
    736         listIndexed.add("String 3");
    737         listIndexed.add("String 4");
    738         dynaForm.set("listIndexed", listIndexed);
    739
    740         Map mappedProperty = new HashMap();
    741
    742         mappedProperty.put("First Key", "First Value");
    743         mappedProperty.put("Second Key", "Second Value");
    744         dynaForm.set("mappedProperty", mappedProperty);
    745
    746         Map mappedIntProperty = new HashMap();
    747
    748         mappedIntProperty.put("One", new Integer(1));
    749         mappedIntProperty.put("Two", new Integer(2));
    750         dynaForm.set("mappedIntProperty", mappedIntProperty);
    751     }
    752
    753     /**
    754      * Base for testGetDescriptorXxxxx() series of tests.
    755      *
    756      * @param name Name of the property to be retrieved
    757      * @param type Expected class type of this property
    758      */
    759     protected void testGetDescriptorBase(String name, Class type) {
    760         DynaProperty descriptor = dynaForm.getDynaClass().getDynaProperty(name);
    761
    762         assertNotNull("Got descriptor", descriptor);
    763         assertEquals("Got correct type", type, descriptor.getType());
    764     }
    765 }
    766
    767
    768 class DynaActionFormMapping extends ActionMapping {
    769     private ModuleConfig appConfig = null;
    770
    771     public DynaActionFormMapping(ModuleConfig appConfig) {
    772         this.appConfig = appConfig;
    773     }
    774
    775     public ModuleConfig getModuleConfig() {
    776         return (this.appConfig);
    777     }
    778
    779     public String getName() {
    780         return ("dynaForm");
    781     }
    782 }
    783
    784
    785 class DynaActionFormConfig extends ModuleConfigImpl {
    786     private FormBeanConfig beanConfig = null;
    787
    788     public DynaActionFormConfig(FormBeanConfig beanConfig) {
    789         super("");
    790         this.beanConfig = beanConfig;
    791     }
    792
    793     public FormBeanConfig findFormBeanConfig(String name) {
    794         return (this.beanConfig);
    795     }
    796 }