package org.apache.commons.beanutils2;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   */
  
  import static org.junit.Assert.assertEquals;
  import static org.junit.Assert.assertNotNull;
  import static org.junit.Assert.assertNull;
  import static org.junit.Assert.fail;
  
  import java.beans.IntrospectionException;
  
  import org.apache.commons.beanutils2.testbeans.MappedPropertyChildBean;
  import org.apache.commons.beanutils2.testbeans.MappedPropertyChildInterface;
  import org.apache.commons.beanutils2.testbeans.MappedPropertyTestBean;
  import org.apache.commons.beanutils2.testbeans.MappedPropertyTestInterface;
  import org.junit.Ignore;
  import org.junit.Test;
  
  /**
   * <p>
   * Test Case for the <code>MappedPropertyDescriptor</code>.
   * </p>
   * Extracted from BeanUtils1
   */
  public class MappedPropertyTestCase
  {
  
      @Test( expected = IntrospectionException.class )
      public void testConstructorNullClass()
          throws Exception
      {
          new MappedPropertyDescriptor( null, MappedPropertyTestBean.class );
      }
  
      @Test( expected = IntrospectionException.class )
      public void testConstructorEmptyStringClass()
          throws Exception
      {
          new MappedPropertyDescriptor( "", MappedPropertyTestBean.class );
      }
  
      @Test( expected = IntrospectionException.class )
      public void testConstructorNullNullNull()
          throws Exception
      {
          new MappedPropertyDescriptor( null, null, null );
      }
  
      @Test( expected = IntrospectionException.class )
      public void testConstructorEmptyStringNullNull()
          throws Exception
      {
          new MappedPropertyDescriptor( "", null, null );
      }
  
      /**
       * Test valid method name
       */
      @Test
      public void testFound()
      {
          String property = "mapproperty";
          Class<MappedPropertyTestBean> clazz = MappedPropertyTestBean.class;
          try
          {
              MappedPropertyDescriptor desc = new MappedPropertyDescriptor( property, clazz );
              assertNotNull( "Getter is missing", desc.getMappedReadMethod() );
              assertNotNull( "Setter is missing", desc.getMappedWriteMethod() );
          }
          catch ( Exception ex )
          {
              fail( "Property '" + property + "' Not Found in " + clazz.getName() + ": " + ex );
          }
      }
  
      /**
       * Test boolean "is" method name
       */
      @Test
      public void testBooleanMapped()
      {
          String property = "mappedBoolean";
         Class<MappedPropertyTestBean> clazz = MappedPropertyTestBean.class;
         try
         {
             MappedPropertyDescriptor desc = new MappedPropertyDescriptor( property, clazz );
             assertNotNull( "Getter is missing", desc.getMappedReadMethod() );
             assertNotNull( "Setter is missing", desc.getMappedWriteMethod() );
         }
         catch ( Exception ex )
         {
             fail( "Property '" + property + "' Not Found in " + clazz.getName() + ": " + ex );
         }
     }
 
     /**
      * Test invalid method name
      */
     @Test
     public void testNotFound()
     {
         String property = "xxxxxxx";
         Class<MappedPropertyTestBean> clazz = MappedPropertyTestBean.class;
         try
         {
             new MappedPropertyDescriptor( property, clazz );
             fail( "Property '" + property + "' found in " + clazz.getName() );
         }
         catch ( Exception ex )
         {
             // expected result
         }
     }
 
     /**
      * Test Mapped Property - Getter only
      */
     @Test
     public void testMappedGetterOnly()
     {
         String property = "mappedGetterOnly";
         Class<MappedPropertyTestBean> clazz = MappedPropertyTestBean.class;
         try
         {
             MappedPropertyDescriptor desc = new MappedPropertyDescriptor( property, clazz );
             assertNotNull( "Getter is missing", desc.getMappedReadMethod() );
             assertNull( "Setter is found", desc.getMappedWriteMethod() );
         }
         catch ( Exception ex )
         {
             fail( "Property '" + property + "' Not Found in " + clazz.getName() + ": " + ex );
         }
     }
 
     /**
      * Test Mapped Property - Setter Only
      */
     @Test
     public void testMappedSetterOnly()
     {
         String property = "mappedSetterOnly";
         Class<MappedPropertyTestBean> clazz = MappedPropertyTestBean.class;
         try
         {
             MappedPropertyDescriptor desc = new MappedPropertyDescriptor( property, clazz );
             assertNull( "Getter is found", desc.getMappedReadMethod() );
             assertNotNull( "Setter is missing", desc.getMappedWriteMethod() );
         }
         catch ( Exception ex )
         {
             fail( "Property '" + property + "' Not Found in " + clazz.getName() + ": " + ex );
         }
     }
 
     /**
      * Test Mapped Property - Invalid Setter
      */
     @Test
     public void testInvalidSetter()
     {
         String property = "invalidSetter";
         Class<MappedPropertyTestBean> clazz = MappedPropertyTestBean.class;
         try
         {
             MappedPropertyDescriptor desc = new MappedPropertyDescriptor( property, clazz );
             assertNotNull( "Getter is missing", desc.getMappedReadMethod() );
             assertNull( "Setter is found", desc.getMappedWriteMethod() );
         }
         catch ( Exception ex )
         {
             fail( "Property '" + property + "' Not Found in " + clazz.getName() + ": " + ex );
         }
     }
 
     /**
      * Test Mapped Property - Invalid Getter
      */
     @Test
     public void testInvalidGetter()
     {
         String property = "invalidGetter";
         Class<MappedPropertyTestBean> clazz = MappedPropertyTestBean.class;
         try
         {
             MappedPropertyDescriptor desc = new MappedPropertyDescriptor( property, clazz );
             assertNull( "Getter is found", desc.getMappedReadMethod() );
             assertNotNull( "Setter is missing", desc.getMappedWriteMethod() );
         }
         catch ( Exception ex )
         {
             fail( "Property '" + property + "' Not Found in " + clazz.getName() + ": " + ex );
         }
     }
 
     /**
      * Test Mapped Property - Different Types Expect to find the getDifferentTypes() method, but not the
      * setDifferentTypes() method because setDifferentTypes() sets and Integer, while getDifferentTypes() returns a
      * Long.
      */
     @Test
     public void testDifferentTypes()
     {
         String property = "differentTypes";
         Class<MappedPropertyTestBean> clazz = MappedPropertyTestBean.class;
         try
         {
             MappedPropertyDescriptor desc = new MappedPropertyDescriptor( property, clazz );
             assertNotNull( "Getter is missing", desc.getMappedReadMethod() );
             assertNull( "Setter is found", desc.getMappedWriteMethod() );
         }
         catch ( Exception ex )
         {
             fail( "Property '" + property + "' Not Found in " + clazz.getName() + ": " + ex );
         }
     }
 
     /**
      * Test Mpa getter
      */
     @Test
     @Ignore // TODO review this test
     public void testMapGetter()
     {
         MappedPropertyTestBean bean = new MappedPropertyTestBean();
         Class<MappedPropertyTestBean> clazz = MappedPropertyTestBean.class;
         String property = "myMap";
         try
         {
             String testValue = "test value";
             String testKey = "testKey";
             // BeanUtils.setProperty( bean, "myMap(" + testKey + ")", "test value" );
             assertEquals( "Map getter", testValue, bean.getMyMap().get( testKey ) );
         }
         catch ( Exception ex )
         {
             fail( "Test set mapped property failed: " + ex );
         }
     }
 
     /**
      * Test property with any two args
      */
     @Test
     public void testAnyArgsProperty()
     {
         String property = "anyMapped";
         Class<MappedPropertyTestBean> clazz = MappedPropertyTestBean.class;
         try
         {
             MappedPropertyDescriptor desc = new MappedPropertyDescriptor( property, clazz );
             assertNull( "Getter is found", desc.getMappedReadMethod() );
             assertNotNull( "Setter is missing", desc.getMappedWriteMethod() );
         }
         catch ( Exception ex )
         {
             fail( "Property '" + property + "' Not Found in " + clazz.getName() + ": " + ex );
         }
     }
 
     /**
      * Test property with two primitve args
      */
     @Test
     public void testPrimitiveArgsProperty()
     {
         String property = "mappedPrimitive";
         Class<MappedPropertyTestBean> clazz = MappedPropertyTestBean.class;
         try
         {
             MappedPropertyDescriptor desc = new MappedPropertyDescriptor( property, clazz );
             assertNull( "Getter is found", desc.getMappedReadMethod() );
             assertNotNull( "Setter is missing", desc.getMappedWriteMethod() );
         }
         catch ( Exception ex )
         {
             fail( "Property '" + property + "' Not Found in " + clazz.getName() + ": " + ex );
         }
     }
 
     /**
      * Test 'protected' mapped property
      */
     @Test( expected = IntrospectionException.class )
     public void testProtected()
         throws IntrospectionException
     {
         String property = "protectedProperty";
         Class<MappedPropertyTestBean> clazz = MappedPropertyTestBean.class;
         new MappedPropertyDescriptor( property, clazz );
     }
 
     /**
      * Test 'public' method in parent
      */
     @Test
     public void testPublicParentMethod()
     {
         String property = "mapproperty";
         Class<MappedPropertyChildBean> clazz = MappedPropertyChildBean.class;
         try
         {
             MappedPropertyDescriptor desc = new MappedPropertyDescriptor( property, clazz );
             assertNotNull( "Getter is missing", desc.getMappedReadMethod() );
             assertNotNull( "Setter is missing", desc.getMappedWriteMethod() );
         }
         catch ( Exception ex )
         {
             fail( "Property '" + property + "' Not Found in " + clazz.getName() + ": " + ex );
         }
     }
 
     /**
      * Test 'protected' method in parent
      */
     @Test( expected = IntrospectionException.class )
     public void testProtectedParentMethod()
         throws IntrospectionException
     {
         String property = "protectedMapped";
         Class<MappedPropertyChildBean> clazz = MappedPropertyChildBean.class;
         new MappedPropertyDescriptor( property, clazz );
     }
 
     /**
      * Test Interface with mapped property
      */
     @Test
     public void testInterfaceMapped()
     {
         String property = "mapproperty";
         Class<MappedPropertyTestInterface> clazz = MappedPropertyTestInterface.class;
         try
         {
             MappedPropertyDescriptor desc = new MappedPropertyDescriptor( property, clazz );
             assertNotNull( "Getter is missing", desc.getMappedReadMethod() );
             assertNotNull( "Setter is missing", desc.getMappedWriteMethod() );
         }
         catch ( Exception ex )
         {
             fail( "Property '" + property + "' Not Found in " + clazz.getName() + ": " + ex );
         }
     }
 
     /**
      * Test property not found in interface
      */
     @Test( expected = IntrospectionException.class )
     public void testInterfaceNotFound()
         throws IntrospectionException
     {
         String property = "XXXXXX";
         Class<MappedPropertyTestInterface> clazz = MappedPropertyTestInterface.class;
         new MappedPropertyDescriptor( property, clazz );
     }
 
     /**
      * Test Interface Inherited mapped property
      */
     @Test
     public void testChildInterfaceMapped()
     {
         String property = "mapproperty";
         Class<MappedPropertyChildInterface> clazz = MappedPropertyChildInterface.class;
         try
         {
             MappedPropertyDescriptor desc = new MappedPropertyDescriptor( property, clazz );
             assertNotNull( "Getter is missing", desc.getMappedReadMethod() );
             assertNotNull( "Setter is missing", desc.getMappedWriteMethod() );
         }
         catch ( Exception ex )
         {
             fail( "Property '" + property + "' Not Found in " + clazz.getName() + ": " + ex );
         }
     }
 }