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.apache.commons.beanutils2.BeanUtils.on;
  import static org.junit.Assert.assertArrayEquals;
  import static org.junit.Assert.assertEquals;
  import static org.junit.Assert.assertNull;
  import static org.junit.Assert.assertTrue;
  
  import java.util.HashMap;
  import java.util.Map;
  
  import org.apache.commons.beanutils2.testbeans.TestBean;
  import org.junit.After;
  import org.junit.Before;
  import org.junit.Test;
  
  public class PopulateTestCase
  {
  
      private TestBean target;
      private TestBean defaults;
  
      private Map<String, Object> properties;
  
      @Before
      public void setUp()
      {
          target = new TestBean();
          defaults = new TestBean();
          properties = new HashMap<String, Object>();
      }
  
      @After
      public void tearDown()
      {
          target = null;
          defaults = null;
          properties = null;
      }
  
      @Test
      public void populateEmptry()
          throws Exception
      {
          on( target ).populate( properties );
          assertTrue( target.equals( defaults ) );
      }
  
      @Test( expected = NullPointerException.class )
      public void populateNull()
          throws Exception
      {
          on( target ).populate( null );
      }
  
      @Test
      public void populateWithNullKey()
          throws Exception
      {
          properties.put( null, new Object() );
          on( target ).populate( properties );
          assertTrue( target.equals( defaults ) );
      }
  
      @Test
      public void populateNullValue()
          throws Exception
      {
          target.setStringProperty( "Hello World!" );
          properties.put( "stringProperty", null );
          on( target ).populate( properties );
          assertNull( target.getStringProperty() );
      }
  
      @Test
      public void populateUnknownKey()
          throws Exception
      {
          properties.put( "unkown", "String value" );
          on( target ).populate( properties );
          assertEquals( defaults, target ) ;
      }
 
     @Test( expected = IllegalArgumentException.class )
     public void populateNullToPrimitive()
         throws Exception
     {
         properties.put( "intProperty", null );
         on( target ).populate( properties );
     }
 
     @Test
     public void populatePropertyArrays()
         throws Exception
     {
         setUpArrayProperties();
         on( target ).populate( properties );
         validateArrayPropertiesOnTarget();
     }
 
     private void setUpArrayProperties()
     {
         int intArray[] = new int[] { 123, 456, 789 };
         String stringArray[] = new String[] { "New String 0", "New String 1" };
         properties.put( "intArray", intArray );
         properties.put( "stringArray", stringArray );
     }
 
     private void validateArrayPropertiesOnTarget()
     {
         int[] expectedInts = (int[]) properties.get( "intArray" );
         assertArrayEquals( expectedInts, target.getIntArray() );
 
         String[] expectedStrings = (String[]) properties.get( "stringArray" );
         assertArrayEquals( expectedStrings, target.getStringArray() );
     }
 
     @Test
     public void populateScalar()
         throws Exception
     {
         setUpScalarProperties();
         on( target ).populate( properties );
         validateScalarPropertiesOnTarget();
     }
 
     private void setUpScalarProperties()
     {
         properties.put( "booleanProperty", false );
         // booleanSecond is left at default value
         properties.put( "byteProperty", (byte) 111 );
         properties.put( "doubleProperty", 432.0 );
         // floatProperty is left at default value
         properties.put( "intProperty", 543 );
         properties.put( "longProperty", 123456789l );
         properties.put( "nullProperty", "Non-null value" );
         properties.put( "shortProperty", (short) 654 );
         // stringProperty is left at default value
         properties.put( "writeOnlyProperty", "New writeOnlyProperty value" );
         properties.put( "readOnlyProperty", "New readOnlyProperty value" );
     }
 
     private void validateScalarPropertiesOnTarget()
     {
         boolean expectedBoolean = (Boolean) properties.get( "booleanProperty" );
         // was left at default value
         boolean expectedBooleanSecond = defaults.isBooleanSecond();
         byte expectedByte = (Byte) properties.get( "byteProperty" );
         double expectedDouble = (Double) properties.get( "doubleProperty" );
         // was left at default
         float expectedFloat = defaults.getFloatProperty();
         int expectedInt = (Integer) properties.get( "intProperty" );
         long expectedLong = (Long) properties.get( "longProperty" );
         String expectedNull = (String) properties.get( "nullProperty" );
         short expectedShort = (Short) properties.get( "shortProperty" );
         String expectedString = defaults.getStringProperty();
         String expectedWriteOnly = (String) properties.get( "writeOnlyProperty" );
         String expectedReadOnly = defaults.getReadOnlyProperty();
 
         assertEquals( "booleanProperty has the wrong value!", expectedBoolean, target.getBooleanProperty() );
         assertEquals( "booleanSecond has the wrong value!", expectedBooleanSecond, target.isBooleanSecond() );
         assertEquals( "byteProperty has the wrong value!", expectedByte, target.getByteProperty() );
         assertEquals( "doubleProperty has the wrong value!", expectedDouble, target.getDoubleProperty(), 0.005 );
         assertEquals( "floatProperty has the wrong value!", expectedFloat, target.getFloatProperty(), (float) 0.005 );
         assertEquals( "intProperty has the wrong value!", expectedInt, target.getIntProperty() );
         assertEquals( "longProperty has the wrong value!", expectedLong, target.getLongProperty() );
         assertEquals( "nullProperty has the wrong value!", expectedNull, target.getNullProperty() );
         assertEquals( "shortProperty has the wrong value!", expectedShort, target.getShortProperty() );
         assertEquals( "stringProperty has the wrong value!", expectedString, target.getStringProperty() );
         assertEquals( "writeOnlyProperty has the wrong value!", expectedWriteOnly,
                       target.getWriteOnlyPropertyValue() );
         assertEquals( "readOnlyProperty has the wrong value!", expectedReadOnly,
                       target.getReadOnlyProperty() );
     }
 
     /**
      * Makes sure that read only properties are ignored
      */
     @Test
     public void populateReadOnly()
         throws Exception
     {
         properties.put( "readOnlyProperty", "Some Value" );
         on( target ).populate( properties );
         assertTrue( target.equals( defaults ) );
     }
 
     /**
      * Makes sure, that ignoring read only property does not cause writable properties to be ignored
      */
     @Test
     public void populateReadOnlyAndOther()
         throws Exception
     {
         properties.put( "readOnlyProperty", "Some value" );
         properties.put( "stringProperty", "Some other value" );
         on( target ).populate( properties );
 
         defaults.setStringProperty( "Some other value" );
         assertTrue( target.equals( defaults ) );
     }
 }