package org.apache.commons.beanutils2.testbeans;
   
   /*
    * 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 java.io.Serializable;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.commons.lang3.builder.EqualsBuilder;
  
  /**
   * General purpose test bean for JUnit tests for the "beanutils" component.
   *
   * @author Craig R. McClanahan
   * @author Rodney Waldhoff
   * @version $Revision: 1441782 $ $Date: 2013-02-02 19:10:33 +0100 (Sa, 02 Feb 2013) $
   */
  public class TestBean
      implements Serializable
  {
  
      /**
       *
       */
      private static final long serialVersionUID = 1L;
  
      // ----------------------------------------------------------- Constructors
  
      public TestBean()
      {
          listIndexed.add( "String 0" );
          listIndexed.add( "String 1" );
          listIndexed.add( "String 2" );
          listIndexed.add( "String 3" );
          listIndexed.add( "String 4" );
      }
  
      public TestBean( String stringProperty )
      {
          setStringProperty( stringProperty );
      }
  
      public TestBean( float floatProperty )
      {
          setFloatProperty( floatProperty );
      }
  
      public TestBean( boolean booleanProperty )
      {
          setBooleanProperty( booleanProperty );
      }
  
      public TestBean( Boolean booleanSecond )
      {
          setBooleanSecond( booleanSecond.booleanValue() );
      }
  
      public TestBean( float floatProperty, String stringProperty )
      {
          setFloatProperty( floatProperty );
          setStringProperty( stringProperty );
      }
  
      public TestBean( boolean booleanProperty, String stringProperty )
      {
          setBooleanProperty( booleanProperty );
          setStringProperty( stringProperty );
      }
  
      public TestBean( Boolean booleanSecond, String stringProperty )
      {
          setBooleanSecond( booleanSecond.booleanValue() );
          setStringProperty( stringProperty );
      }
  
      public TestBean( Integer intProperty )
      {
          setIntProperty( intProperty.intValue() );
      }
  
     public TestBean( double doubleProperty )
     {
         setDoubleProperty( doubleProperty );
     }
 
     TestBean( int intProperty )
     {
         setIntProperty( intProperty );
     }
 
     protected TestBean( boolean booleanProperty, boolean booleanSecond, String stringProperty )
     {
         setBooleanProperty( booleanProperty );
         setBooleanSecond( booleanSecond );
         setStringProperty( stringProperty );
     }
 
     public TestBean( List<String> listIndexed )
     {
         this.listIndexed = listIndexed;
     }
 
     public TestBean( String[][] string2dArray )
     {
         this.string2dArray = string2dArray;
     }
 
     // ------------------------------------------------------------- Properties
 
     /**
      * A boolean property.
      */
     private boolean booleanProperty = true;
 
     public boolean getBooleanProperty()
     {
         return ( booleanProperty );
     }
 
     public void setBooleanProperty( boolean booleanProperty )
     {
         this.booleanProperty = booleanProperty;
     }
 
     /**
      * A boolean property that uses an "is" method for the getter.
      */
     private boolean booleanSecond = true;
 
     public boolean isBooleanSecond()
     {
         return ( booleanSecond );
     }
 
     public void setBooleanSecond( boolean booleanSecond )
     {
         this.booleanSecond = booleanSecond;
     }
 
     /**
      * A byte property.
      */
     private byte byteProperty = (byte) 121;
 
     public byte getByteProperty()
     {
         return ( this.byteProperty );
     }
 
     public void setByteProperty( byte byteProperty )
     {
         this.byteProperty = byteProperty;
     }
 
     /**
      * A java.util.Date property.
      */
     private java.util.Date dateProperty;
 
     public java.util.Date getDateProperty()
     {
         return dateProperty;
     }
 
     public void setDateProperty( java.util.Date dateProperty )
     {
         this.dateProperty = dateProperty;
     }
 
     /**
      * A java.util.Date property.
      */
     private java.util.Date[] dateArrayProperty;
 
     public java.util.Date[] getDateArrayProperty()
     {
         return dateArrayProperty;
     }
 
     public void setDateArrayProperty( java.util.Date[] dateArrayProperty )
     {
         this.dateArrayProperty = dateArrayProperty;
     }
 
     /**
      * A double property.
      */
     private double doubleProperty = 321.0;
 
     public double getDoubleProperty()
     {
         return ( this.doubleProperty );
     }
 
     public void setDoubleProperty( double doubleProperty )
     {
         this.doubleProperty = doubleProperty;
     }
 
     /**
      * An "indexed property" accessible via both array and subscript based getters and setters.
      */
     private String[] dupProperty = { "Dup 0", "Dup 1", "Dup 2", "Dup 3", "Dup 4" };
 
     public String[] getDupProperty()
     {
         return ( this.dupProperty );
     }
 
     public String getDupProperty( int index )
     {
         return ( this.dupProperty[index] );
     }
 
     public void setDupProperty( int index, String value )
     {
         this.dupProperty[index] = value;
     }
 
     public void setDupProperty( String[] dupProperty )
     {
         this.dupProperty = dupProperty;
     }
 
     /**
      * A float property.
      */
     private float floatProperty = (float) 123.0;
 
     public float getFloatProperty()
     {
         return ( this.floatProperty );
     }
 
     public void setFloatProperty( float floatProperty )
     {
         this.floatProperty = floatProperty;
     }
 
     /**
      * An integer array property accessed as an array.
      */
     private int intArray[] = { 0, 10, 20, 30, 40 };
 
     public int[] getIntArray()
     {
         return ( this.intArray );
     }
 
     public void setIntArray( int[] intArray )
     {
         this.intArray = intArray;
     }
 
     /**
      * An integer array property accessed as an indexed property.
      */
     private final int intIndexed[] = { 0, 10, 20, 30, 40 };
 
     public int getIntIndexed( int index )
     {
         return ( intIndexed[index] );
     }
 
     public void setIntIndexed( int index, int value )
     {
         intIndexed[index] = value;
     }
 
     /**
      * An integer property.
      */
     private int intProperty = 123;
 
     public int getIntProperty()
     {
         return ( this.intProperty );
     }
 
     public void setIntProperty( int intProperty )
     {
         this.intProperty = intProperty;
     }
 
     /**
      * A List property accessed as an indexed property.
      */
     private List<String> listIndexed = new ArrayList<String>();
 
     public List<String> getListIndexed()
     {
         return ( listIndexed );
     }
 
     /**
      * A long property.
      */
     private long longProperty = 321;
 
     public long getLongProperty()
     {
         return ( this.longProperty );
     }
 
     public void setLongProperty( long longProperty )
     {
         this.longProperty = longProperty;
     }
 
     /**
      * A mapped property with only a getter and setter for a Map.
      */
     private Map<String, Object> mapProperty = null;
 
     public Map<String, Object> getMapProperty()
     {
         // Create the map the very first time
         if ( mapProperty == null )
         {
             mapProperty = new HashMap<String, Object>();
             mapProperty.put( "First Key", "First Value" );
             mapProperty.put( "Second Key", "Second Value" );
         }
         return ( mapProperty );
     }
 
     public void setMapProperty( Map<String, Object> mapProperty )
     {
         // Create the map the very first time
         if ( mapProperty == null )
         {
             mapProperty = new HashMap<String, Object>();
             mapProperty.put( "First Key", "First Value" );
             mapProperty.put( "Second Key", "Second Value" );
         }
         this.mapProperty = mapProperty;
     }
 
     /**
      * A mapped property that has String keys and Object values.
      */
     private Map<String, Object>mappedObjects = null;
 
     public Object getMappedObjects( String key )
     {
         // Create the map the very first time
         if ( mappedObjects == null )
         {
             mappedObjects = new HashMap<String, Object>();
             mappedObjects.put( "First Key", "First Value" );
             mappedObjects.put( "Second Key", "Second Value" );
         }
         return ( mappedObjects.get( key ) );
     }
 
     public void setMappedObjects( String key, Object value )
     {
         // Create the map the very first time
         if ( mappedObjects == null )
         {
             mappedObjects = new HashMap<String, Object>();
             mappedObjects.put( "First Key", "First Value" );
             mappedObjects.put( "Second Key", "Second Value" );
         }
         mappedObjects.put( key, value );
     }
 
     /**
      * A mapped property that has String keys and String values.
      */
     private Map<String, Object>mappedProperty = null;
 
     public String getMappedProperty( String key )
     {
         // Create the map the very first time
         if ( mappedProperty == null )
         {
             mappedProperty = new HashMap<String, Object>();
             mappedProperty.put( "First Key", "First Value" );
             mappedProperty.put( "Second Key", "Second Value" );
         }
         return ( (String) mappedProperty.get( key ) );
     }
 
     public void setMappedProperty( String key, String value )
     {
         // Create the map the very first time
         if ( mappedProperty == null )
         {
             mappedProperty = new HashMap<String, Object>();
             mappedProperty.put( "First Key", "First Value" );
             mappedProperty.put( "Second Key", "Second Value" );
         }
         mappedProperty.put( key, value );
     }
 
     /**
      * A mapped property that has String keys and int values.
      */
     private Map<String, Object>mappedIntProperty = null;
 
     public int getMappedIntProperty( String key )
     {
         // Create the map the very first time
         if ( mappedIntProperty == null )
         {
             mappedIntProperty = new HashMap<String, Object>();
             mappedIntProperty.put( "One", new Integer( 1 ) );
             mappedIntProperty.put( "Two", new Integer( 2 ) );
         }
         Integer x = (Integer) mappedIntProperty.get( key );
         return ( ( x == null ) ? 0 : x.intValue() );
     }
 
     public void setMappedIntProperty( String key, int value )
     {
         mappedIntProperty.put( key, new Integer( value ) );
     }
 
     /**
      * A nested reference to another test bean (populated as needed).
      */
     private TestBean nested = null;
 
     public TestBean getNested()
     {
         if ( nested == null )
             nested = new TestBean();
         return ( nested );
     }
 
     /**
      * Another nested reference to another test bean,
      */
     private TestBean anotherNested = null;
 
     public TestBean getAnotherNested()
     {
         return anotherNested;
     }
 
     public void setAnotherNested( TestBean anotherNested )
     {
         this.anotherNested = anotherNested;
     }
 
     /*
      * Another nested reference to a bean containing mapp properties
      */
     public class MappedTestBean
     {
         public void setValue( String key, String val )
         {
         }
 
         public String getValue( String key )
         {
             return "Mapped Value";
         }
     }
 
     private MappedTestBean mappedNested = null;
 
     public MappedTestBean getMappedNested()
     {
         if ( mappedNested == null )
         {
             mappedNested = new MappedTestBean();
         }
         return mappedNested;
     }
 
     /**
      * A String property with an initial value of null.
      */
     private String nullProperty = null;
 
     public String getNullProperty()
     {
         return ( this.nullProperty );
     }
 
     public void setNullProperty( String nullProperty )
     {
         this.nullProperty = nullProperty;
     }
 
     /**
      * A read-only String property.
      */
     private final String readOnlyProperty = "Read Only String Property";
 
     public String getReadOnlyProperty()
     {
         return ( this.readOnlyProperty );
     }
 
     /**
      * A short property.
      */
     private short shortProperty = (short) 987;
 
     public short getShortProperty()
     {
         return ( this.shortProperty );
     }
 
     public void setShortProperty( short shortProperty )
     {
         this.shortProperty = shortProperty;
     }
 
     /**
      * A String array property accessed as a String.
      */
     private String[] stringArray = { "String 0", "String 1", "String 2", "String 3", "String 4" };
 
     public String[] getStringArray()
     {
         return ( this.stringArray );
     }
 
     public void setStringArray( String[] stringArray )
     {
         this.stringArray = stringArray;
     }
 
     /**
      * A String array property accessed as an indexed property.
      */
     private final String[] stringIndexed = { "String 0", "String 1", "String 2", "String 3", "String 4" };
 
     public String getStringIndexed( int index )
     {
         return ( stringIndexed[index] );
     }
 
     public void setStringIndexed( int index, String value )
     {
         stringIndexed[index] = value;
     }
 
     private String[][] string2dArray =
         new String[][] { new String[] { "1", "2", "3" }, new String[] { "4", "5", "6" } };
 
     public String[] getString2dArray( int index )
     {
         return string2dArray[index];
     }
 
     /**
      * A String property.
      */
     private String stringProperty = "This is a string";
 
     public String getStringProperty()
     {
         return ( this.stringProperty );
     }
 
     public void setStringProperty( String stringProperty )
     {
         this.stringProperty = stringProperty;
     }
 
     /**
      * A write-only String property.
      */
     private String writeOnlyProperty = "Write Only String Property";
 
     public String getWriteOnlyPropertyValue()
     {
         return ( this.writeOnlyProperty );
     }
 
     public void setWriteOnlyProperty( String writeOnlyProperty )
     {
         this.writeOnlyProperty = writeOnlyProperty;
     }
 
     // ------------------------------------------------------ Invalid Properties
 
     /**
      * <p>
      * An invalid property that has two boolean getters (getInvalidBoolean and isInvalidBoolean) plus a String setter
      * (setInvalidBoolean). By the rules described in the JavaBeans Specification, this will be considered a read-only
      * boolean property, using isInvalidBoolean() as the getter.
      * </p>
      */
     private boolean invalidBoolean = false;
 
     public boolean getInvalidBoolean()
     {
         return ( this.invalidBoolean );
     }
 
     public boolean isInvalidBoolean()
     {
         return ( this.invalidBoolean );
     }
 
     public void setInvalidBoolean( String invalidBoolean )
     {
         if ( "true".equalsIgnoreCase( invalidBoolean ) || "yes".equalsIgnoreCase( invalidBoolean )
             || "1".equalsIgnoreCase( invalidBoolean ) )
         {
             this.invalidBoolean = true;
         }
         else
         {
             this.invalidBoolean = false;
         }
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean equals( Object obj )
     {
         if ( obj == this )
         {
             return true;
         }
         if ( obj == null )
         {
             return false;
         }
         if ( !( obj instanceof TestBean ) )
         {
             return false;
         }
 
         TestBean rhs = (TestBean) obj;
         return new EqualsBuilder()
                         .append( this.booleanProperty, rhs.booleanProperty )
                         .append( this.booleanSecond,rhs.booleanSecond )
                         .append( this.invalidBoolean,rhs.invalidBoolean )
                         .append( this.byteProperty,rhs.byteProperty )
                         .append( this.dateProperty,rhs.dateProperty )
                         .append( this.doubleProperty,rhs.doubleProperty )
                         .append( this.floatProperty,rhs.floatProperty )
                         .append( this.intProperty,rhs.intProperty )
                         .append( this.longProperty,rhs.longProperty )
                         .append( this.shortProperty,rhs.shortProperty )
                         .append( this.nullProperty,rhs.nullProperty )
                         .append( this.anotherNested, rhs.anotherNested )
                         .append( this.dateArrayProperty, rhs.dateArrayProperty )
                         .append( this.dupProperty, rhs.dupProperty )
                         .append( this.intArray, rhs.intArray )
                         .append( this.intIndexed, rhs.intIndexed )
                         .append( this.listIndexed, rhs.listIndexed )
                         .append( this.mappedIntProperty, rhs.mappedIntProperty )
                         .append( this.mappedNested, rhs.mappedNested )
                         .append( this.mappedObjects, rhs.mappedObjects )
                         .append( this.mappedProperty, rhs.mappedProperty )
                         .append( this.mapProperty, rhs.mapProperty )
                         .append( this.nested, rhs.nested )
                         .append( this.readOnlyProperty, rhs.readOnlyProperty )
                         .append( this.string2dArray, rhs.string2dArray )
                         .append( this.stringArray, rhs.stringArray)
                         .append( this.stringIndexed, rhs.stringIndexed )
                         .append( this.stringProperty, rhs.stringProperty )
                         .append( this.writeOnlyProperty, rhs.writeOnlyProperty )
                         .build();
     }
 
     // ------------------------------------------------------- Static Variables
 
     /**
      * A static variable that is accessed and updated via static methods for MethodUtils testing.
      */
     private static int counter = 0;
 
     /**
      * Return the current value of the counter.
      */
     public static int currentCounter()
     {
 
         return ( counter );
 
     }
 
     /**
      * Increment the current value of the counter by 1.
      */
     public static void incrementCounter()
     {
 
         incrementCounter( 1 );
 
     }
 
     /**
      * Increment the current value of the counter by the specified amount.
      *
      * @param amount Amount to be added to the current counter
      */
     public static void incrementCounter( int amount )
     {
 
         counter += amount;
 
     }
 
     /**
      * Increments the current value of the count by the specified amount * 2. It has the same name as the method above
      * so as to test the looseness of getMethod.
      */
     public static void incrementCounter( Number amount )
     {
         counter += 2 * amount.intValue();
     }
 
 }