    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  package org.apache.commons.beanutils;
    18
    19  import junit.framework.TestCase;
    20  import junit.framework.Test;
    21  import junit.framework.TestSuite;
    22  import java.lang.reflect.Method;
    23  import org.apache.commons.logging.Log;
    24  import org.apache.commons.logging.LogFactory;
    25
    26  /***
    27   * <p>Test Case for the <code>MappedPropertyDescriptor</code>.</p>
    28   *
    29   * @author Niall Pemberton
    30   */
    31  public class MappedPropertyTestCase extends TestCase {
    32
    33      private static final Log log = LogFactory.getLog(MappedPropertyTestCase.class);
    34
    35
    36      // ---------------------------------------------------------- Constructors
    37
    38      /***
    39       * Construct a new instance of this test case.
    40       *
    41       * @param name Name of the test case
    42       */
    43      public MappedPropertyTestCase(String name) {
    44          super(name);
    45      }
    46
    47      // -------------------------------------------------- Overall Test Methods
    48
    49      /***
    50       * Run this Test
    51       */
    52      public static void main(String[] args) {
    53        junit.textui.TestRunner.run(suite());
    54      }
    55
    56      /***
    57       * Set up instance variables required by this test case.
    58       */
    59      public void setUp() throws Exception {
    60      }
    61
    62      /***
    63       * Return the tests included in this test suite.
    64       */
    65      public static Test suite() {
    66          return (new TestSuite(MappedPropertyTestCase.class));
    67      }
    68
    69      /***
    70       * Tear down instance variables required by this test case.
    71       */
    72      public void tearDown() {
    73      }
    74
    75      // ------------------------------------------------ Individual Test Methods
    76
    77      /***
    78       * Test valid method name
    79       */
    80      public void testFound() {
    81          String property = "mapproperty";
    82          Class clazz = MappedPropertyTestBean.class;
    83          try {
    84              MappedPropertyDescriptor desc
    85                  = new MappedPropertyDescriptor(property, clazz);
    86              assertNotNull("Getter is missing", desc.getMappedReadMethod());
    87              assertNotNull("Setter is missing", desc.getMappedWriteMethod());
    88          } catch (Exception ex) {
    89              fail("Property '" + property + "' Not Found in " + clazz.getName() + ": " + ex);
    90          }
    91      }
    92
    93      /***
    94       * Test boolean "is" method name
    95       */
    96      public void testBooleanMapped() {
    97          String property = "mappedBoolean";
    98          Class clazz = MappedPropertyTestBean.class;
    99          try {
    100             MappedPropertyDescriptor desc
    101                 = new MappedPropertyDescriptor(property, clazz);
    102             assertNotNull("Getter is missing", desc.getMappedReadMethod());
    103             assertNotNull("Setter is missing", desc.getMappedWriteMethod());
    104         } catch (Exception ex) {
    105             fail("Property '" + property + "' Not Found in " + clazz.getName() + ": " + ex);
    106         }
    107     }
    108
    109     /***
    110      * Test invalid method name
    111      */
    112     public void testNotFound() {
    113         String property = "xxxxxxx";
    114         Class clazz = MappedPropertyTestBean.class;
    115         try {
    116             MappedPropertyDescriptor desc
    117                 = new MappedPropertyDescriptor(property, clazz);
    118             fail("Property '" + property + "' found in " + clazz.getName());
    119         } catch (Exception ex) {
    120             // expected result
    121         }
    122     }
    123
    124     /***
    125      * Test Mapped Property - Getter only
    126      */
    127     public void testMappedGetterOnly() {
    128         String property = "mappedGetterOnly";
    129         Class clazz = MappedPropertyTestBean.class;
    130         try {
    131             MappedPropertyDescriptor desc
    132                 = new MappedPropertyDescriptor(property, clazz);
    133             assertNotNull("Getter is missing", desc.getMappedReadMethod());
    134             assertNull("Setter is found", desc.getMappedWriteMethod());
    135         } catch (Exception ex) {
    136             fail("Property '" + property + "' Not Found in " + clazz.getName() + ": " + ex);
    137         }
    138     }
    139
    140     /***
    141      * Test Mapped Property - Setter Only
    142      */
    143     public void testMappedSetterOnly() {
    144         String property = "mappedSetterOnly";
    145         Class clazz = MappedPropertyTestBean.class;
    146         try {
    147             MappedPropertyDescriptor desc
    148                 = new MappedPropertyDescriptor(property, clazz);
    149             assertNull("Getter is found", desc.getMappedReadMethod());
    150             assertNotNull("Setter is missing", desc.getMappedWriteMethod());
    151         } catch (Exception ex) {
    152             fail("Property '" + property + "' Not Found in " + clazz.getName() + ": " + ex);
    153         }
    154     }
    155
    156     /***
    157      * Test Mapped Property - Invalid Setter
    158      */
    159     public void testInvalidSetter() {
    160         String property = "invalidSetter";
    161         Class clazz = MappedPropertyTestBean.class;
    162         try {
    163             MappedPropertyDescriptor desc
    164                 = new MappedPropertyDescriptor(property, clazz);
    165             assertNotNull("Getter is missing", desc.getMappedReadMethod());
    166             assertNull("Setter is found", desc.getMappedWriteMethod());
    167         } catch (Exception ex) {
    168             fail("Property '" + property + "' Not Found in " + clazz.getName() + ": " + ex);
    169         }
    170     }
    171
    172     /***
    173      * Test Mapped Property - Invalid Getter
    174      */
    175     public void testInvalidGetter() {
    176         String property = "invalidGetter";
    177         Class clazz = MappedPropertyTestBean.class;
    178         try {
    179             MappedPropertyDescriptor desc
    180                 = new MappedPropertyDescriptor(property, clazz);
    181             assertNull("Getter is found", desc.getMappedReadMethod());
    182             assertNotNull("Setter is missing", desc.getMappedWriteMethod());
    183         } catch (Exception ex) {
    184             fail("Property '" + property + "' Not Found in " + clazz.getName() + ": " + ex);
    185         }
    186     }
    187
    188     /***
    189      * Test Mapped Property - Different Types
    190      *
    191      * Expect to find the getDifferentTypes() method, but not
    192      * the setDifferentTypes() method because setDifferentTypes()
    193      * sets and Integer, while getDifferentTypes() returns a Long.
    194      */
    195     public void testDifferentTypes() {
    196         String property = "differentTypes";
    197         Class clazz = MappedPropertyTestBean.class;
    198         try {
    199             MappedPropertyDescriptor desc
    200                 = new MappedPropertyDescriptor(property, clazz);
    201             assertNotNull("Getter is missing", desc.getMappedReadMethod());
    202             assertNull("Setter is found", desc.getMappedWriteMethod());
    203         } catch (Exception ex) {
    204             fail("Property '" + property + "' Not Found in " + clazz.getName() + ": " + ex);
    205         }
    206     }
    207
    208     /***
    209      * Test Mpa getter
    210      */
    211     public void testMapGetter() {
    212         MappedPropertyTestBean bean = new MappedPropertyTestBean();
    213         Class clazz = MappedPropertyTestBean.class;
    214         String property = "myMap";
    215         try {
    216             String testValue = "test value";
    217             String testKey   = "testKey";
    218             BeanUtils.setProperty(bean, "myMap("+testKey+")", "test value");
    219             assertEquals("Map getter", testValue, bean.getMyMap().get(testKey));
    220         } catch (Exception ex) {
    221             fail("Test set mapped property failed: " + ex);
    222         }
    223     }
    224
    225
    226     /***
    227      * Test property with any two args
    228      */
    229     public void testAnyArgsProperty() {
    230         String property = "anyMapped";
    231         Class clazz = MappedPropertyTestBean.class;
    232         try {
    233             MappedPropertyDescriptor desc
    234                 = new MappedPropertyDescriptor(property, clazz);
    235             assertNull("Getter is found", desc.getMappedReadMethod());
    236             assertNotNull("Setter is missing", desc.getMappedWriteMethod());
    237         } catch (Exception ex) {
    238             fail("Property '" + property + "' Not Found in " + clazz.getName() + ": " + ex);
    239         }
    240     }
    241
    242     /***
    243      * Test property with two primitve args
    244      */
    245     public void testPrimitiveArgsProperty() {
    246         String property = "mappedPrimitive";
    247         Class clazz = MappedPropertyTestBean.class;
    248         try {
    249             MappedPropertyDescriptor desc
    250                 = new MappedPropertyDescriptor(property, clazz);
    251             assertNull("Getter is found", desc.getMappedReadMethod());
    252             assertNotNull("Setter is missing", desc.getMappedWriteMethod());
    253         } catch (Exception ex) {
    254             fail("Property '" + property + "' Not Found in " + clazz.getName() + ": " + ex);
    255         }
    256     }
    257
    258     /***
    259      * Test 'protected' mapped property
    260      */
    261     public void testProtected() {
    262         String property = "protectedProperty";
    263         Class clazz = MappedPropertyTestBean.class;
    264         try {
    265             MappedPropertyDescriptor desc
    266                 = new MappedPropertyDescriptor(property, clazz);
    267             fail("Property '" + property + "' found in " + clazz.getName());
    268         } catch (Exception ex) {
    269             // expected result
    270         }
    271     }
    272
    273
    274     /***
    275      * Test 'public' method in parent
    276      */
    277     public void testPublicParentMethod() {
    278         String property = "mapproperty";
    279         Class clazz = MappedPropertyChildBean.class;
    280         try {
    281             MappedPropertyDescriptor desc
    282                 = new MappedPropertyDescriptor(property, clazz);
    283             assertNotNull("Getter is missing", desc.getMappedReadMethod());
    284             assertNotNull("Setter is missing", desc.getMappedWriteMethod());
    285         } catch (Exception ex) {
    286             fail("Property '" + property + "' Not Found in " + clazz.getName() + ": " + ex);
    287         }
    288     }
    289
    290     /***
    291      * Test 'protected' method in parent
    292      */
    293     public void testProtectedParentMethod() {
    294         String property = "protectedMapped";
    295         Class clazz = MappedPropertyChildBean.class;
    296         try {
    297             MappedPropertyDescriptor desc
    298                 = new MappedPropertyDescriptor(property, clazz);
    299             fail("Property '" + property + "' found in " + clazz.getName());
    300         } catch (Exception ex) {
    301         }
    302     }
    303
    304
    305     /***
    306      * Test Interface with mapped property
    307      */
    308     public void testInterfaceMapped() {
    309         String property = "mapproperty";
    310         Class clazz = MappedPropertyTestInterface.class;
    311         try {
    312             MappedPropertyDescriptor desc
    313                 = new MappedPropertyDescriptor(property, clazz);
    314             assertNotNull("Getter is missing", desc.getMappedReadMethod());
    315             assertNotNull("Setter is missing", desc.getMappedWriteMethod());
    316         } catch (Exception ex) {
    317             fail("Property '" + property + "' Not Found in " + clazz.getName() + ": " + ex);
    318         }
    319     }
    320
    321     /***
    322      * Test property not found in interface
    323      */
    324     public void testInterfaceNotFound() {
    325         String property = "XXXXXX";
    326         Class clazz = MappedPropertyTestInterface.class;
    327         try {
    328             MappedPropertyDescriptor desc
    329                 = new MappedPropertyDescriptor(property, clazz);
    330             fail("Property '" + property + "' found in " + clazz.getName());
    331         } catch (Exception ex) {
    332         }
    333     }
    334
    335     /***
    336      * Test Interface Inherited mapped property
    337      */
    338     public void testChildInterfaceMapped() {
    339         String property = "mapproperty";
    340         Class clazz = MappedPropertyChildInterface.class;
    341         try {
    342             MappedPropertyDescriptor desc
    343                 = new MappedPropertyDescriptor(property, clazz);
    344             assertNotNull("Getter is missing", desc.getMappedReadMethod());
    345             assertNotNull("Setter is missing", desc.getMappedWriteMethod());
    346         } catch (Exception ex) {
    347             fail("Property '" + property + "' Not Found in " + clazz.getName() + ": " + ex);
    348         }
    349     }
    350 }