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.Argument.argument;
  import static org.apache.commons.beanutils2.BeanUtils.on;
  import static org.junit.Assert.assertEquals;
  import static org.junit.Assert.assertNotNull;
  
  import org.apache.commons.beanutils2.testbeans.AbstractTestBean;
  import org.apache.commons.beanutils2.testbeans.TestBean;
  import org.apache.commons.beanutils2.testbeans.ThrowingExceptionBean;
  import org.junit.Rule;
  import org.junit.Test;
  import org.junit.rules.ExpectedException;
  
  /**
   * <p>
   * Test case for <code>ClassAccessor</code>
   * </p>
   */
  public class ConstructorsTestCase
  {
  
      @Rule
      public ExpectedException thrown = ExpectedException.none();
  
      // ------------------------------------------------ Individual Test Methods
  
      @Test
      public void invokeConstructor()
          throws Exception
      {
          {
              TestBean obj = on( TestBean.class ).invokeConstructor( argument( "TEST" ) ).get();
              assertNotNull( obj );
              assertEquals( "TEST", obj.getStringProperty() );
          }
          {
              TestBean obj = on( TestBean.class ).invokeConstructor( argument( new Float( 17.3f ) ) ).get();
              assertNotNull( obj );
              assertEquals( 17.3f, obj.getFloatProperty(), 0.0f );
          }
      }
  
      @Test( expected = NoSuchConstructorException.class )
      public void invokeConstructorWithInvalidArgument()
          throws Exception
      {
          on( TestBean.class ).invokeConstructor( argument( (byte) 6 ) ).get();
      }
  
      @Test( expected = NullPointerException.class )
      public void invokeConstructorWithNull()
          throws Exception
      {
          on( TestBean.class ).invokeConstructor( (Argument<?>) null );
      }
  
      @Test
      public void invokeConstructorWithArgArray()
          throws Exception
      {
          TestBean obj = on( TestBean.class ).invokeConstructor( argument( new Float( 17.3f ) ), argument( "TEST" ) ).get();
          assertNotNull( obj );
          assertEquals( 17.3f, obj.getFloatProperty(), 0.0f );
          assertEquals( "TEST", obj.getStringProperty() );
      }
  
      @Test( expected = NoSuchConstructorException.class )
      public void invokeConstrucotrWithInvalidArgArray()
          throws Exception
      {
          on( TestBean.class ).invokeConstructor( argument( (byte) 17 ), argument( "TEST" ) ).get();
      }
  
      @Test( expected = NullPointerException.class )
      public void invokeConstructorWithNullArray()
          throws Exception
      {
          on( TestBean.class ).invokeConstructor( null, null, null );
      }
 
     @Test
     public void invokeConstructorWithTypeArray()
         throws Exception
     {
         {
             TestBean obj = on( TestBean.class ).invokeConstructor( argument( Boolean.TYPE, Boolean.TRUE ),
                                                                    argument( String.class, "TEST" ) ).get();
             assertNotNull( obj );
             assertEquals( true, obj.getBooleanProperty() );
             assertEquals( "TEST", obj.getStringProperty() );
         }
         {
             TestBean obj = on( TestBean.class ).invokeConstructor( argument( Boolean.class, Boolean.TRUE ),
                                                                    argument( String.class, "TEST" ) ).get();
             assertNotNull( obj );
             assertEquals( true, obj.isBooleanSecond() );
             assertEquals( "TEST", obj.getStringProperty() );
         }
     }
 
     @Test( expected = NoSuchConstructorException.class )
     public void invokeConstructorWithInvalidTypeArray() throws Exception
     {
         on( TestBean.class ).invokeConstructor( argument( String.class, "TEST" ),
                                                 argument( Boolean.TYPE, Boolean.TRUE )).get();
     }
 
     @Test
     public void invokeExactConstructor()
         throws Exception
     {
         {
             TestBean obj = on( TestBean.class ).invokeExactConstructor( argument( "TEST" ) ).get();
             assertNotNull( obj );
             assertEquals( "TEST", obj.getStringProperty() );
         }
         {
             TestBean obj = on( TestBean.class ).invokeExactConstructor( argument( Boolean.TRUE ) ).get();
             assertNotNull( obj );
 
             assertEquals( true, obj.isBooleanSecond() );
         }
     }
 
     @Test( expected = NoSuchConstructorException.class )
     public void invokeExactConstructorWithInvalidArgument()
         throws Exception
     {
         on( TestBean.class ).invokeExactConstructor( argument( new Float( 17.3f ) ) ).get();
     }
 
     @Test( expected = NullPointerException.class )
     public void invokeExactConstructorWithNull()
         throws Exception
     {
         on( TestBean.class ).invokeExactConstructor( (Argument<?>) null );
     }
 
     @Test
     public void invokeExactConstructorWithArgArray()
         throws Exception
     {
         TestBean obj = on( TestBean.class ).invokeExactConstructor( argument( Boolean.TRUE ),
                                                                     argument( "TEST" ) ).get();
         assertNotNull( obj );
         assertEquals( true, obj.isBooleanSecond() );
         assertEquals( "TEST", obj.getStringProperty() );
     }
 
     @Test( expected = NoSuchConstructorException.class )
     public void invokeExactConstructorWithInvalidArgArray() throws Exception
     {
         on( TestBean.class ).invokeExactConstructor( argument( new Float( 17.3f ) ),argument( "TEST" ) ).get();
     }
 
     @Test( expected = NullPointerException.class )
     public void invokeExactConstructorWithNullArray()
         throws Exception
     {
         on( TestBean.class ).invokeExactConstructor( null, null, null );
     }
 
     @Test
     public void invokeExactConstructorWithTypeArray()
         throws Exception
     {
         {
             TestBean obj = on( TestBean.class ).invokeExactConstructor( argument( Boolean.TYPE, Boolean.TRUE ),
                                                                         argument( String.class, "TEST" ) ).get();
             assertNotNull( obj );
             assertEquals( true, obj.getBooleanProperty() );
             assertEquals( "TEST", obj.getStringProperty() );
         }
         {
             TestBean obj = on( TestBean.class ).invokeExactConstructor( argument( Boolean.class, Boolean.TRUE ),
                                                                         argument( String.class, "TEST" ) ).get();
             assertNotNull( obj );
             assertEquals( true, obj.isBooleanSecond() );
             assertEquals( "TEST", obj.getStringProperty() );
         }
         {
             TestBean obj = on( TestBean.class ).invokeExactConstructor( argument( Float.TYPE, new Float( 17.3f ) ),
                                                                         argument( String.class, "TEST" ) ).get();
             assertNotNull( obj );
 
             assertEquals( 17.3f, obj.getFloatProperty(), 0.0f );
             assertEquals( "TEST", obj.getStringProperty() );
         }
     }
 
     @Test( expected = NoSuchConstructorException.class )
     public void invokeExactConstructorWithInvalidTypeArray()
         throws Exception
     {
         on( TestBean.class ).invokeExactConstructor( argument( Float.class, new Float( 17.3f ) ),
                                                      argument( String.class, "TEST" ) ).get();
     }
 
     @Test( expected = ConstructorInvocationException.class )
     public void invokeConstructorThatThrowsException()
         throws Exception
     {
         on( ThrowingExceptionBean.class ).invokeConstructor( argument( RuntimeException.class,
                                                                            new RuntimeException() ) );
     }
 
     @Test( expected = ConstructorInvocationException.class )
     public void invokeExactConstructorThatThrowsException()
         throws Exception
     {
         on( ThrowingExceptionBean.class ).invokeExactConstructor( argument( RuntimeException.class,
                                                                                 new RuntimeException() ) );
     }
 
     // FIXME Why don't we see a ConstructorNotAccessibleException?
     @Test( expected = NoSuchConstructorException.class )
     public void invokePrivateConstructor()
         throws Exception
     {
         on( ThrowingExceptionBean.class ).invokeConstructor( argument( Integer.class, Integer.valueOf( 4711 ) ) );
     }
 
     // FIXME Why don't we see a ConstructorNotAccessibleException?
     @Test( expected = NoSuchConstructorException.class )
     public void invokeProtectedConstructor()
         throws Exception
     {
         on( ThrowingExceptionBean.class ).invokeConstructor( argument( Short.class, Short.valueOf( (short) 4711 ) ) );
     }
 
     // FIXME Why don't we see a ConstructorNotAccessibleException?
     @Test( expected = NoSuchConstructorException.class )
     public void invokeDefaultConstructor()
         throws Exception
     {
         on( ThrowingExceptionBean.class ).invokeConstructor( argument( Byte.class, Byte.valueOf( (byte) 4711 ) ) );
     }
 
     @Test
     public void invokeConstructorOnAbstract()
         throws Exception
     {
         thrown.expect( BeanInstantiationException.class );
         thrown.expectMessage( "abstract" );
         on( AbstractTestBean.class ).invokeConstructor();
     }
 
     @Test
     public void invokeConstructorOnInterface()
         throws Exception
     {
         thrown.expect( BeanInstantiationException.class );
         thrown.expectMessage( "interface" );
         on( ClassAccessor.class ).invokeConstructor();
     }
 
     @Test
     public void invokeConstructorOnArray()
         throws Exception
     {
         thrown.expect( BeanInstantiationException.class );
         thrown.expectMessage( "array" );
         on( String[].class ).invokeConstructor();
     }
 
     @Test
     public void invokeConstructorOnPrimitive()
         throws Exception
     {
         thrown.expect( BeanInstantiationException.class );
         thrown.expectMessage( "primitive" );
         on( int.class ).invokeConstructor();
     }
 
     @Test
     public void invokeConstructorOnVoid()
         throws Exception
     {
         thrown.expect( BeanInstantiationException.class );
         thrown.expectMessage( "void" );
         on( void.class ).invokeConstructor();
     }
 
     @Test( expected = NoSuchConstructorException.class )
     public void newInstanceWithoutDefaultConstructor()
     {
         on( NoDefaultConstructor.class ).newInstance();
     }
 
     public static class NoDefaultConstructor
     {
 
         NoDefaultConstructor( int i )
         {
             // do nothing here
         }
     }
 
 }