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 java.lang.String.format;
  import static java.lang.reflect.Modifier.isPublic;
  import static org.junit.Assert.assertArrayEquals;
  import static org.junit.Assert.assertEquals;
  import static org.junit.Assert.assertNotNull;
  import static org.junit.Assert.assertNull;
  import static org.junit.Assert.assertTrue;
  
  import java.lang.reflect.Constructor;
  
  import org.apache.commons.beanutils2.testbeans.TestBean;
  import org.junit.Test;
  
  public class ConstructorRegistryTestCase
  {
  
      private static final String WRONG_FOUND = "ConstructorRegistry resolved wrong constructor!";
  
      private static final String NON_FOUND = "ConstructorRegistry could not resolve constructor %s!";
  
      private final AccessibleObjectsRegistry<Constructor<?>> constructorRegistry =
          AccessibleObjectsRegistry.getConstructorsRegistry();
  
      @Test
      public void get()
      {
          Constructor<?>[] constructors = TestBean.class.getConstructors();
          for ( Constructor<?> constructor : constructors )
          {
              Constructor<?> resolved = constructorRegistry.get( false, TestBean.class, constructor.getParameterTypes() );
              assertNotNull( format( NON_FOUND, constructor ), resolved );
              assertEquals( WRONG_FOUND, constructor, resolved );
          }
      }
  
      @Test
      public void getDifferentParameter()
          throws Exception
      {
          Constructor<TestBean> floatConstructor = TestBean.class.getConstructor( float.class );
          Constructor<?> resolved = constructorRegistry.get( false, TestBean.class, Float.class );
          assertNotNull( format( NON_FOUND, floatConstructor ), resolved );
          assertEquals( WRONG_FOUND, floatConstructor, resolved );
      }
  
      @Test
      public void getExact()
      {
          Constructor<?>[] constructors = TestBean.class.getConstructors();
          for ( Constructor<?> constructor : constructors )
          {
              Constructor<?> resolved = constructorRegistry.get( true, TestBean.class, constructor.getParameterTypes() );
              assertNotNull( format( NON_FOUND, constructor ), resolved );
              assertEquals( WRONG_FOUND, constructor, resolved );
          }
      }
  
      @Test
      public void getExactDifferentParameter()
          throws Exception
      {
          Constructor<?> resolved = constructorRegistry.get( true, TestBean.class, Float.class );
          assertNull( format( "Constructor resolved constructor [%s] for parameter type Float on type TestBean although TestBean does not describe such a constructor.",
                              resolved ), resolved );
      }
  
      @Test
      public void getWithName()
      {
          // TODO does the constructorRegistry need this method? constructors don't have names.
          Constructor<?>[] constructors = TestBean.class.getConstructors();
          for ( Constructor<?> constructor : constructors )
          {
              Constructor<?> resolved = constructorRegistry.get( true, TestBean.class,
                                                                 "name is ignored by Constructors Registry",
                                                                 constructor.getParameterTypes() );
              assertNotNull( format( NON_FOUND, constructor ), resolved );
              assertEquals( WRONG_FOUND, constructor, resolved );
          }
      }
 
     @Test
     public void resolveDirectly()
         throws Exception
     {
         Constructor<?>[] constructors = TestBean.class.getConstructors();
         for ( Constructor<?> constructor : constructors )
         {
             Constructor<?> resolved =
                 constructorRegistry.resolveDirectly( TestBean.class, null, constructor.getParameterTypes() );
             assertNotNull( format( NON_FOUND, constructor ), resolved );
             assertEquals( WRONG_FOUND, constructor, resolved );
         }
     }
 
     @Test
     public void getAccessibleObjectsArrayForTestBean()
     {
         Constructor<?>[] constructors = constructorRegistry.getAccessibleObjectsArray( TestBean.class );
         assertNotNull( constructors );
         assertArrayEquals( TestBean.class.getConstructors(), constructors );
     }
 
     @Test
     public void matchesNull()
     {
         // this method always returns true
         boolean matches = constructorRegistry.matches( null, null );
         assertTrue( matches );
     }
 
     @Test
     public void matches()
     {
         // this method always returns true
         Constructor<?>[] constructors = TestBean.class.getConstructors();
         for ( Constructor<?> constructor : constructors )
         {
             boolean matches = constructorRegistry.matches( constructor, "this returns true" );
             assertTrue( matches );
         }
     }
 
     @Test
     public void getParameterTypes()
     {
         Constructor<?>[] constructors = TestBean.class.getDeclaredConstructors();
         for ( Constructor<?> constructor : constructors )
         {
             Class<?>[] typesFromRegistry = constructorRegistry.getParameterTypes( constructor );
             assertArrayEquals( constructor.getParameterTypes(), typesFromRegistry );
         }
     }
 
     @Test
     public void resolveAccessibleNull()
     {
         assertNull( constructorRegistry.resolveAccessible( Object.class, null ) );
     }
 
     @Test
     public void resolveAccessible()
     {
         Constructor<?>[] constructors = TestBean.class.getDeclaredConstructors();
         for ( Constructor<?> constructor : constructors )
         {
             Constructor<?> resolved = constructorRegistry.resolveAccessible( TestBean.class, constructor );
             if ( isPublic( constructor.getModifiers() ) )
             {
                 assertEquals( constructor, resolved );
             }
             else
             {
                 assertNull( resolved );
             }
         }
     }
 
     @Test
     public void resolveAccessiblePrivateClass()
     {
         Constructor<?>[] constructors = PrivateTestBean.class.getDeclaredConstructors();
         for ( Constructor<?> constructor : constructors )
         {
             Constructor<?> resolved = constructorRegistry.resolveAccessible( TestBean.class, constructor );
             // PrivateTestBean is a private class, so no constructor is accessible.
             assertNull( resolved );
         }
     }
 
     @SuppressWarnings( "unused" ) // class is used for tests only
     private static class PrivateTestBean
     {
 
         public PrivateTestBean()
         {
             // empty default constructor
         }
 
         private PrivateTestBean( int i )
         {
             // int constructor
         }
     }
 
 }