src/test/java/org/apache/maven/shared/utils/reflection/ReflectorTest.java

package org.apache.maven.shared.utils.reflection;

/*
 * 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 org.junit.Test;

import java.lang.reflect.Constructor;

import static org.hamcrest.CoreMatchers.*;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import static org.apache.maven.shared.utils.testhelpers.ExceptionHelper.*;

/**
 * @author Stephen Connolly
 */
public class ReflectorTest
{
    private final Reflector reflector = new Reflector();

    //// newInstance( Class, Object[] )

    @Test( expected = NullPointerException.class )
    public void newInstanceNullNull()
        throws Exception
    {
        reflector.newInstance( (Class<?>)null, (Object)null );
    }

    @Test
    public void newInstanceClassNull()
        throws Exception
    {
        assertThat( reflector.newInstance( Object.class, null ), is( Object.class ) );
    }

    @Test( expected = NullPointerException.class )
    public void newInstanceNullEmptyArray()
        throws Exception
    {
        reflector.newInstance( null, new Object[0] );
    }

    @Test
    public void newInstanceClassEmptyArray()
        throws Exception
    {
        assertThat( reflector.newInstance( Object.class, new Object[0] ), is( Object.class ) );
    }

    @Test( expected = ReflectorException.class )
    public void newInstanceClassInvalidSignature()
        throws Exception
    {
        reflector.newInstance( Object.class, new Object[]{ this } );
    }

    @Test( expected = ReflectorException.class )
    public void newInstancePrivateConstructor()
        throws Exception
    {
        reflector.newInstance( ReflectorTestHelper.class, new Object[0] );
    }

    @Test( expected = IllegalArgumentException.class )
    // // @ReproducesPlexusBug( "Looking up constructors by signature has an unlabelled continue, so finds the wrong constructor" )
    public void newInstancePackageConstructor()
        throws Exception
    {
        reflector.newInstance( ReflectorTestHelper.class, new Object[]{ Boolean.FALSE } );
    }

    @Test( expected = IllegalArgumentException.class )
    // // @ReproducesPlexusBug( "Looking up constructors by signature has an unlabelled continue, so finds the wrong constructor" )
    public void newInstancePackageConstructorThrowsSomething()
        throws Exception
    {
        reflector.newInstance( ReflectorTestHelper.class, new Object[]{ Boolean.TRUE } );
    }

    @Test( expected = IllegalArgumentException.class )
    // // @ReproducesPlexusBug("Looking up constructors by signature has an unlabelled continue, so finds the wrong constructor" )
    public void newInstanceProtectedConstructor()
        throws Exception
    {
        reflector.newInstance( ReflectorTestHelper.class, new Object[]{ 0 } );
    }

    @Test( expected = IllegalArgumentException.class )
    // // @ReproducesPlexusBug( "Looking up constructors by signature has an unlabelled continue, so finds the wrong constructor" )
    public void newInstanceProtectedConstructorThrowsSomething()
        throws Exception
    {
        reflector.newInstance( ReflectorTestHelper.class, new Object[]{ 1 } );
    }

    @Test
    public void newInstancePublicConstructor()
        throws Exception
    {
        assertTrue( reflector.newInstance( ReflectorTestHelper.class, new Object[]{ "" } )
                    instanceof ReflectorTestHelper );
    }

    @Test( expected = NullPointerException.class )
    public void newInstancePublicConstructorNullValue()
        throws Exception
    {
        reflector.newInstance( ReflectorTestHelper.class, new Object[]{ null } );
    }

    @Test
    public void newInstancePublicConstructorThrowsSomething()
        throws Exception
    {
        try
        {
            reflector.newInstance( ReflectorTestHelper.class, new Object[]{ "Message" } );
            fail();
        }
        catch ( ReflectorException e )
        {
            assertThat( e, hasCause( ReflectorTestHelper.HelperException.class ) );
        }
    }

    //// getSingleton( Class, Object[] )

    @Test( expected = NullPointerException.class )
    public void getSingletonNullNull()
        throws Exception
    {
        reflector.getSingleton( (Class<?>)null, (Object)null );
    }

    @Test( expected = NullPointerException.class )
    public void getSingletonClassNull()
        throws Exception
    {
        assertThat( reflector.getSingleton( (Class<?>)Object.class, (Object)null ), is( Object.class ) );
    }

    @Test( expected = NullPointerException.class )
    public void getSingletonNullEmptyArray()
        throws Exception
    {
        reflector.getSingleton( null, new Object[0] );
    }

    @Test( expected = ReflectorException.class )
    public void getSingletonClassEmptyArray()
        throws Exception
    {
        assertThat( reflector.getSingleton( Object.class, new Object[0] ), is( Object.class ) );
    }

    @Test( expected = ReflectorException.class )
    public void getSingletonClassInvalidSignature()
        throws Exception
    {
        reflector.getSingleton( Object.class, new Object[]{ this } );
    }

    @Test( expected = ReflectorException.class )
    public void getSingletonPrivateMethod()
        throws Exception
    {
        reflector.getSingleton( ReflectorTestHelper.class, new Object[0] );
    }

    @Test( expected = IllegalArgumentException.class )
    // @ReproducesPlexusBug( "Looking up methods by signature has an unlabeled continue, so finds the wrong method" )
    public void getSingletonPackageMethod()
        throws Exception
    {
        reflector.getSingleton( ReflectorTestHelper.class, new Object[]{ Boolean.FALSE } );
    }

    @Test( expected = IllegalArgumentException.class )
    // @ReproducesPlexusBug( "Looking up methods by signature has an unlabeled continue, so finds the wrong method" )
    public void getSingletonPackageMethodThrowsSomething()
        throws Exception
    {
        reflector.getSingleton( ReflectorTestHelper.class, new Object[]{ Boolean.TRUE } );
    }

    @Test( expected = IllegalArgumentException.class )
    // @ReproducesPlexusBug( "Looking up methods by signature has an unlabeled continue, so finds the wrong method" )
    public void getSingletonProtectedMethod()
        throws Exception
    {
        reflector.getSingleton( ReflectorTestHelper.class, new Object[]{ 0 } );
    }

    @Test( expected = IllegalArgumentException.class )
    // @ReproducesPlexusBug( "Looking up methods by signature has an unlabeled continue, so finds the wrong method" )
    public void getSingletonProtectedMethodThrowsSomething()
        throws Exception
    {
        reflector.getSingleton( ReflectorTestHelper.class, new Object[]{ 1 } );
    }

    @Test
    public void getSingletonPublicMethod()
        throws Exception
    {
        assertTrue( reflector.getSingleton( ReflectorTestHelper.class, new Object[]{ "" } )
                    instanceof ReflectorTestHelper );
    }

    @Test( expected = NullPointerException.class )
    public void getSingletonPublicMethodNullValue()
        throws Exception
    {
        reflector.getSingleton( ReflectorTestHelper.class, new Object[]{ null } );
    }

    @Test
    public void getSingletonPublicMethodThrowsSomething()
        throws Exception
    {
        try
        {
            reflector.getSingleton( ReflectorTestHelper.class, new Object[]{ "Message" } );
            fail();
        }
        catch ( ReflectorException e )
        {
            assertThat( e, hasCause( ReflectorTestHelper.HelperException.class ) );
        }
    }

    @Test( expected = NullPointerException.class )
    public void getSingletonNonStaticMethod()
        throws Exception
    {
        assertTrue( reflector.getSingleton( ReflectorTestHelper.class, new Object[]{ "", Boolean.FALSE } )
                    instanceof ReflectorTestHelper );
    }

    //// invoke( Object, String, Object[] )

    @Test( expected = NullPointerException.class )
    public void invokeNullNullNull()
        throws Exception
    {
        reflector.invoke( (Object)null, (String)null, (Object)null );
    }

    @Test( expected = NullPointerException.class )
    public void invokeNullNullEmpty()
        throws Exception
    {
        reflector.invoke( null, null, new Object[0] );
    }

    @Test( expected = NullPointerException.class )
    public void invokeNullEmptyNull()
        throws Exception
    {
        reflector.invoke( (Object)null, "", (Object)null );
    }

    @Test( expected = NullPointerException.class )
    public void invokeNullEmptyEmpty()
        throws Exception
    {
        reflector.invoke( null, "", new Object[0] );
    }

    @Test( expected = NullPointerException.class )
    public void invokeObjectNullNull()
        throws Exception
    {
        reflector.invoke( new Object(), (String)null, (Object)null );
    }

    @Test( expected = NullPointerException.class )
    public void invokeObjectNullEmpty()
        throws Exception
    {
        reflector.invoke( new Object(), null, new Object[0] );
    }

    @Test( expected = ReflectorException.class )
    public void invokeObjectEmptyNull()
        throws Exception
    {
        reflector.invoke( new Object(), "", null );
    }

    @Test( expected = ReflectorException.class )
    public void invokeObjectEmptyEmpty()
        throws Exception
    {
        reflector.invoke( new Object(), "", new Object[0] );
    }

    @Test
    public void invokeObjectValidNull()
        throws Exception
    {
        Object object = new Object();
        assertThat( reflector.invoke( object, "hashCode", null ), is( (Object) object.hashCode() ) );
    }

    @Test
    public void invokeObjectValidEmpty()
        throws Exception
    {
        Object object = new Object();
        assertThat( reflector.invoke( object, "hashCode", new Object[0] ),
                    is( (Object) object.hashCode() ) );
    }

    @Test( expected = ReflectorException.class )
    public void invokeObjectValidWrongSignature()
        throws Exception
    {
        reflector.invoke( new Object(), "hashCode", new Object[]{ this } );
    }

    @Test( expected = ReflectorException.class )
    public void invokePrivateMethod()
        throws Exception
    {
        class CoT
        {
            @SuppressWarnings( "unused" )
            private Object doSomething()
            {
                return "Done";
            }
        }
        assertThat( reflector.invoke( new CoT(), "doSomething", new Object[0] ), is( (Object) "Done" ) );
    }

    @Test( expected = ReflectorException.class )
    public void invokePackageMethod()
        throws Exception
    {
        class CoT
        {
            @SuppressWarnings( "unused" )
            Object doSomething()
            {
                return "Done";
            }
        }
        assertThat( reflector.invoke( new CoT(), "doSomething", new Object[0] ), is( (Object) "Done" ) );
    }

    @Test( expected = ReflectorException.class )
    public void invokeProtectedMethod()
        throws Exception
    {
        class CoT
        {
            @SuppressWarnings( "unused" )
            protected Object doSomething()
            {
                return "Done";
            }
        }
        assertThat( reflector.invoke( new CoT(), "doSomething", new Object[0] ), is( (Object) "Done" ) );
    }

    @Test
    public void invokePublicMethod()
        throws Exception
    {
        class CoT
        {
            @SuppressWarnings( "unused" )
            public Object doSomething()
            {
                return "Done";
            }
        }
        assertThat( reflector.invoke( new CoT(), "doSomething", new Object[0] ), is( (Object) "Done" ) );
    }

    //// getStaticField( Class, String )

    @Test( expected = NullPointerException.class )
    public void getStaticFieldNullNull()
        throws Exception
    {
        reflector.getStaticField( null, null );
    }

    @Test( expected = NullPointerException.class )
    public void getStaticFieldNullEmpty()
        throws Exception
    {
        reflector.getStaticField( null, "" );
    }

    @Test( expected = NullPointerException.class )
    public void getStaticFieldObjectNull()
        throws Exception
    {
        reflector.getStaticField( Object.class, null );
    }

    @Test
    public void getStaticFieldObjectEmpty()
        throws Exception
    {
        try
        {
            reflector.getStaticField( Object.class, "" );
            fail();
        }
        catch ( ReflectorException e )
        {
            assertThat( e, hasCause( NoSuchFieldException.class ) );
        }
    }

    @Test
    public void getStaticFieldPrivateField()
        throws Exception
    {
        try
        {
            reflector.getStaticField( ReflectorTestHelper.class, "PRIVATE_STATIC_STRING" );
            fail();
        }
        catch ( ReflectorException e )
        {
            assertThat( e, hasCause( NoSuchFieldException.class ) );
        }
    }

    @Test
    public void getStaticFieldPackageField()
        throws Exception
    {
        try
        {
            reflector.getStaticField( ReflectorTestHelper.class, "PACKAGE_STATIC_STRING" );
            fail();
        }
        catch ( ReflectorException e )
        {
            assertThat( e, hasCause( NoSuchFieldException.class ) );
        }
    }

    @Test
    public void getStaticFieldProtectedField()
        throws Exception
    {
        try
        {
            reflector.getStaticField( ReflectorTestHelper.class, "PROTECTED_STATIC_STRING" );
            fail();
        }
        catch ( ReflectorException e )
        {
            assertThat( e, hasCause( NoSuchFieldException.class ) );
        }
    }

    @Test
    public void getStaticFieldPublicField()
        throws Exception
    {
        assertThat( reflector.getStaticField( ReflectorTestHelper.class, "PUBLIC_STATIC_STRING" ),
                    is( (Object) "public static string" ) );
    }

    //// getField( Object, String )

    @Test( expected = NullPointerException.class )
    public void getFieldNullNull()
        throws Exception
    {
        reflector.getField( null, null );
    }

    @Test( expected = NullPointerException.class )
    public void getFieldNullEmpty()
        throws Exception
    {
        reflector.getField( null, "" );
    }

    @Test( expected = NullPointerException.class )
    public void getFieldObjectNull()
        throws Exception
    {
        reflector.getField( new Object(), null );
    }

    @Test
    public void getFieldObjectEmpty()
        throws Exception
    {
        try
        {
            reflector.getField( new Object(), "" );
            fail();
        }
        catch ( ReflectorException e )
        {
            assertThat( e, hasCause( NoSuchFieldException.class ) );
        }
    }

    @Test
    public void getFieldCoTValuePrivateField()
        throws Exception
    {
        final String expected = "gotIt";
        class CoT
        {
            @SuppressWarnings( "unused" )
            private String value = expected;
        }
        try
        {
            assertThat( reflector.getField( new CoT(), "value" ), is( (Object) expected ) );
            fail();
        }
        catch ( ReflectorException e )
        {
            assertThat( e, hasCause( IllegalAccessException.class ) );
        }
    }

    @Test
    public void getFieldCoTValuePackageField()
        throws Exception
    {
        final String expected = "gotIt";
        class CoT
        {
            @SuppressWarnings( "unused" )
            String value = expected;
        }
        assertThat( reflector.getField( new CoT(), "value" ), is( (Object) expected ) );
    }

    @Test
    public void getFieldCoTValueProtectedField()
        throws Exception
    {
        final String expected = "gotIt";
        class CoT
        {
            @SuppressWarnings( "unused" )
            protected String value = expected;
        }
        assertThat( reflector.getField( new CoT(), "value" ), is( (Object) expected ) );
    }

    @Test
    public void getFieldCoTValuePublicField()
        throws Exception
    {
        final String expected = "gotIt";
        class CoT
        {
            @SuppressWarnings( "unused" )
            public String value = expected;
        }
        assertThat( reflector.getField( new CoT(), "value" ), is( (Object) expected ) );
    }

    //// getField( Object, String, boolean )

    @Test( expected = NullPointerException.class )
    public void getFieldNullNullFalse()
        throws Exception
    {
        reflector.getField( null, null, false );
    }

    @Test( expected = NullPointerException.class )
    public void getFieldNullEmptyFalse()
        throws Exception
    {
        reflector.getField( null, "", false );
    }

    @Test( expected = NullPointerException.class )
    public void getFieldObjectNullFalse()
        throws Exception
    {
        reflector.getField( new Object(), null, false );
    }

    @Test
    public void getFieldObjectEmptyFalse()
        throws Exception
    {
        try
        {
            reflector.getField( new Object(), "", false );
            fail();
        }
        catch ( ReflectorException e )
        {
            assertThat( e, hasCause( NoSuchFieldException.class ) );
        }
    }

    @Test
    public void getFieldCoTValueFalsePrivateField()
        throws Exception
    {
        final String expected = "gotIt";
        class CoT
        {
            @SuppressWarnings( "unused" )
            private String value = expected;
        }
        try
        {
            assertThat( reflector.getField( new CoT(), "value", false ), is( (Object) expected ) );
            fail();
        }
        catch ( ReflectorException e )
        {
            assertThat( e, hasCause( IllegalAccessException.class ) );
        }
    }

    @Test
    public void getFieldCoTValueFalsePackageField()
        throws Exception
    {
        final String expected = "gotIt";
        class CoT
        {
            @SuppressWarnings( "unused" )
            String value = expected;
        }
        assertThat( reflector.getField( new CoT(), "value", false ), is( (Object) expected ) );
    }

    @Test
    public void getFieldCoTValueFalseProtectedField()
        throws Exception
    {
        final String expected = "gotIt";
        class CoT
        {
            @SuppressWarnings( "unused" )
            protected String value = expected;
        }
        assertThat( reflector.getField( new CoT(), "value", false ), is( (Object) expected ) );
    }

    @Test
    public void getFieldCoTValueFalsePublicField()
        throws Exception
    {
        final String expected = "gotIt";
        class CoT
        {
            @SuppressWarnings( "unused" )
            public String value = expected;
        }
        assertThat( reflector.getField( new CoT(), "value", false ), is( (Object) expected ) );
    }

    @Test( expected = NullPointerException.class )
    public void getFieldNullNullTrue()
        throws Exception
    {
        reflector.getField( null, null, true );
    }

    @Test( expected = NullPointerException.class )
    public void getFieldNullEmptyTrue()
        throws Exception
    {
        reflector.getField( null, "", true );
    }

    @Test( expected = NullPointerException.class )
    public void getFieldObjectNullTrue()
        throws Exception
    {
        reflector.getField( new Object(), null, true );
    }

    @Test
    public void getFieldObjectEmptyTrue()
        throws Exception
    {
        try
        {
            reflector.getField( new Object(), "", true );
            fail();
        }
        catch ( ReflectorException e )
        {
            assertThat( e, hasCause( NoSuchFieldException.class ) );
        }
    }

    @Test
    public void getFieldCoTValueTruePrivateField()
        throws Exception
    {
        final String expected = "gotIt";
        class CoT
        {
            @SuppressWarnings( "unused" )
            private String value = expected;
        }
        assertThat( reflector.getField( new CoT(), "value", true ), is( (Object) expected ) );
    }

    @Test
    public void getFieldCoTValueTruePackageField()
        throws Exception
    {
        final String expected = "gotIt";
        class CoT
        {
            @SuppressWarnings( "unused" )
            String value = expected;
        }
        assertThat( reflector.getField( new CoT(), "value", true ), is( (Object) expected ) );
    }

    @Test
    public void getFieldCoTValueTrueProtectedField()
        throws Exception
    {
        final String expected = "gotIt";
        class CoT
        {
            @SuppressWarnings( "unused" )
            protected String value = expected;
        }
        assertThat( reflector.getField( new CoT(), "value", true ), is( (Object) expected ) );
    }

    @Test
    public void getFieldCoTValueTruePublicField()
        throws Exception
    {
        final String expected = "gotIt";
        class CoT
        {
            @SuppressWarnings( "unused" )
            public String value = expected;
        }
        assertThat( reflector.getField( new CoT(), "value", true ), is( (Object) expected ) );
    }

    //// invokeStatic( Class, String, Object[] )

    @Test( expected = NullPointerException.class )
    public void invokeStaticNullNullNull()
        throws Exception
    {
        reflector.invokeStatic( (Class<?>)null, (String)null, (Object)null );
    }

    @Test( expected = NullPointerException.class )
    public void invokeStaticClassNullNull()
        throws Exception
    {
        assertThat( reflector.invokeStatic( Object.class, (String)null, (Object)null ), is( Object.class ) );
    }

    @Test( expected = NullPointerException.class )
    public void invokeStaticNullNullEmptyArray()
        throws Exception
    {
        reflector.invokeStatic( null, null, new Object[0] );
    }

    @Test( expected = NullPointerException.class )
    public void invokeStaticClassNullEmptyArray()
        throws Exception
    {
        assertThat( reflector.invokeStatic( Object.class, null, new Object[0] ), is( Object.class ) );
    }

    @Test( expected = NullPointerException.class )
    public void invokeStaticNullEmptyNull()
        throws Exception
    {
        reflector.invokeStatic( (Class<?>)null, "", (Object)null );
    }

    @Test( expected = ReflectorException.class )
    public void invokeStaticClassEmptyNull()
        throws Exception
    {
        reflector.invokeStatic( Object.class, "", null );
    }

    @Test( expected = NullPointerException.class )
    public void invokeStaticNullEmptyEmptyArray()
        throws Exception
    {
        reflector.invokeStatic( null, "", new Object[0] );
    }

    @Test( expected = ReflectorException.class )
    public void invokeStaticClassEmptyEmptyArray()
        throws Exception
    {
        assertThat( reflector.invokeStatic( Object.class, "", new Object[0] ), is( Object.class ) );
    }

    @Test( expected = IllegalArgumentException.class )
    // @ReproducesPlexusBug( "Looking up methods by signature has an unlabelled continue, so finds the wrong method" )
    public void invokeStaticClassInvalidSignature()
        throws Exception
    {
        reflector.invokeStatic( ReflectorTestHelper.class, "getInstance", new Object[]{ this } );
    }

    @Test( expected = ReflectorException.class )
    public void invokeStaticPrivateMethod()
        throws Exception
    {
        reflector.invokeStatic( ReflectorTestHelper.class, "getInstance", new Object[0] );
    }

    @Test( expected = IllegalArgumentException.class )
    // @ReproducesPlexusBug( "Looking up methods by signature has an unlabelled continue, so finds the wrong method" )
    public void invokeStaticPackageMethod()
        throws Exception
    {
        reflector.invokeStatic( ReflectorTestHelper.class, "getInstance", new Object[]{ Boolean.FALSE } );
    }

    @Test( expected = IllegalArgumentException.class )
    // @ReproducesPlexusBug( "Looking up methods by signature has an unlabelled continue, so finds the wrong method" )
    public void invokeStaticPackageMethodThrowsSomething()
        throws Exception
    {
        reflector.invokeStatic( ReflectorTestHelper.class, "getInstance", new Object[]{ Boolean.TRUE } );
    }

    @Test( expected = IllegalArgumentException.class )
    // @ReproducesPlexusBug( "Looking up methods by signature has an unlabelled continue, so finds the wrong method" )
    public void invokeStaticProtectedMethod()
        throws Exception
    {
        reflector.invokeStatic( ReflectorTestHelper.class, "getInstance", new Object[]{ 0 } );
    }

    @Test( expected = IllegalArgumentException.class )
    // @ReproducesPlexusBug( "Looking up methods by signature has an unlabelled continue, so finds the wrong method" )
    public void invokeStaticProtectedMethodThrowsSomething()
        throws Exception
    {
        reflector.invokeStatic( ReflectorTestHelper.class, "getInstance", new Object[]{ 1 } );
    }

    @Test
    public void invokeStaticPublicMethod()
        throws Exception
    {
        assertTrue( reflector.invokeStatic( ReflectorTestHelper.class, "getInstance", new Object[]{ "" } )
                    instanceof ReflectorTestHelper );
    }

    @Test( expected = NullPointerException.class )
    public void invokeStaticPublicMethodNullValue()
        throws Exception
    {
        reflector.invokeStatic( ReflectorTestHelper.class, "getInstance", new Object[]{ null } );
    }

    @Test
    public void invokeStaticPublicMethodThrowsSomething()
        throws Exception
    {
        try
        {
            reflector.invokeStatic( ReflectorTestHelper.class, "getInstance", new Object[]{ "Message" } );
            fail();
        }
        catch ( ReflectorException e )
        {
            assertThat( e, hasCause( ReflectorTestHelper.HelperException.class ) );
        }
    }

    @Test( expected = NullPointerException.class )
    public void invokeStaticNonStaticMethod()
        throws Exception
    {
        assertTrue(
            reflector.invokeStatic( ReflectorTestHelper.class, "getInstance", new Object[]{ "", Boolean.FALSE } )
            instanceof ReflectorTestHelper );
    }

    //// getConstructor( Class, Class[] )

    @Test( expected = NullPointerException.class )
    public void getConstructorNullNull()
        throws Exception
    {
        reflector.getConstructor( (Class<?>)null, (Class<?>)null );
    }

    @Test( expected = NullPointerException.class )
    public void getConstructorNullEmpty()
        throws Exception
    {
        reflector.getConstructor( null, new Class[0] );
    }

    @SuppressWarnings( "rawtypes" )
    @Test( expected = NullPointerException.class )
    public void getConstructorObjectNull()
        throws Exception
    {
        assertThat( reflector.getConstructor( Object.class, (Class<?>)null ),
                    is( (Constructor) Object.class.getDeclaredConstructor() ) );
    }

    @SuppressWarnings( "rawtypes" )
    @Test
    public void getConstructorObjectEmpty()
        throws Exception
    {
        assertThat( reflector.getConstructor( Object.class),
                    is( (Constructor) Object.class.getDeclaredConstructor() ) );
    }

    @SuppressWarnings( "rawtypes" )
    @Test( expected = ReflectorException.class )
    // @ReproducesPlexusBug( "Looking up methods by signature has an unlabelled continue, so finds the wrong method" )
    public void getConstructorPrivate()
        throws Exception
    {
        assertThat( reflector.getConstructor( ReflectorTestHelper.class),
                    is( (Constructor) ReflectorTestHelper.class.getDeclaredConstructor() ) );
    }

    @SuppressWarnings( "rawtypes" )
    @Test
    public void getConstructorPackage()
        throws Exception
    {
        assertThat( reflector.getConstructor( ReflectorTestHelper.class, Boolean.class),
                    not( is( (Constructor) ReflectorTestHelper.class.getDeclaredConstructor( Boolean.class ) ) ) );
    }

    @SuppressWarnings( "rawtypes" )
    @Test
    public void getConstructorProtected()
        throws Exception
    {
        assertThat( reflector.getConstructor( ReflectorTestHelper.class, Integer.class),
                    not( is( (Constructor) ReflectorTestHelper.class.getDeclaredConstructor( Integer.class ) ) ) );
    }

    @SuppressWarnings( "rawtypes" )
    @Test
    public void getConstructorPublic()
        throws Exception
    {
        assertThat( reflector.getConstructor( ReflectorTestHelper.class, String.class),
                    is( (Constructor) ReflectorTestHelper.class.getDeclaredConstructor( String.class ) ) );
    }

    //// getObjectProperty( Object, String )

    @Test( expected = ReflectorException.class )
    public void getObjectPropertyNullNull()
        throws Exception
    {
        reflector.getObjectProperty( null, null );
    }

    @Test( expected = ReflectorException.class )
    public void getObjectPropertyNullEmpty()
        throws Exception
    {
        reflector.getObjectProperty( null, "" );
    }

    @Test( expected = ReflectorException.class )
    public void getObjectPropertyObjectNull()
        throws Exception
    {
        reflector.getObjectProperty( new Object(), null );
    }

    @Test( expected = ReflectorException.class )
    public void getObjectPropertyObjectEmpty()
        throws Exception
    {
        reflector.getObjectProperty( new Object(), "" );
    }

    @Test
    // @ReproducesPlexusBug( "Should only access public properties" )
    public void getObjectPropertyViaPrivateField()
        throws Exception
    {
        class CoT
        {
            @SuppressWarnings( "unused" )
            private int value = 42;
        }
        assertThat( reflector.getObjectProperty( new CoT(), "value" ), is( (Object) 42 ) );
    }

    @Test
    // @ReproducesPlexusBug( "Should only access public properties" )
    public void getObjectPropertyViaPackageField()
        throws Exception
    {
        class CoT
        {
            @SuppressWarnings( "unused" )
            int value = 42;
        }
        assertThat( reflector.getObjectProperty( new CoT(), "value" ), is( (Object) 42 ) );
    }

    @Test
    // @ReproducesPlexusBug( "Should only access public properties" )
    public void getObjectPropertyViaProtectedField()
        throws Exception
    {
        class CoT
        {
            @SuppressWarnings( "unused" )
            protected int value = 42;
        }
        assertThat( reflector.getObjectProperty( new CoT(), "value" ), is( (Object) 42 ) );
    }

    @Test
    public void getObjectPropertyViaPublicField()
        throws Exception
    {
        class CoT
        {
            @SuppressWarnings( "unused" )
            public int value = 42;
        }
        assertThat( reflector.getObjectProperty( new CoT(), "value" ), is( (Object) 42 ) );
    }

    @Test( expected = ReflectorException.class )
    public void getObjectPropertyViaPrivateGetter()
        throws Exception
    {
        class CoT
        {
            private final int _value = 42;

            @SuppressWarnings( "unused" )
            private int getValue()
            {
                return _value;
            }
        }
        reflector.getObjectProperty( new CoT(), "value" );
    }

    @Test( expected = ReflectorException.class )
    public void getObjectPropertyViaPackageGetter()
        throws Exception
    {
        class CoT
        {
            private final int _value = 42;

            @SuppressWarnings( "unused" )
            int getValue()
            {
                return _value;
            }
        }
        reflector.getObjectProperty( new CoT(), "value" );
    }

    @Test( expected = ReflectorException.class )
    public void getObjectPropertyViaProtectedGetter()
        throws Exception
    {
        class CoT
        {
            private final int _value = 42;

            @SuppressWarnings( "unused" )
            protected int getValue()
            {
                return _value;
            }
        }
        reflector.getObjectProperty( new CoT(), "value" );
    }

    @Test
    public void getObjectPropertyViaPublicGetter()
        throws Exception
    {
        class CoT
        {
            private final int _value = 42;

            @SuppressWarnings( "unused" )
            public int getValue()
            {
                return _value;
            }
        }
        assertThat( reflector.getObjectProperty( new CoT(), "value" ), is( (Object) 42 ) );
    }

    //// getMethod( Class, String, Class[] )

    @Test( expected = NullPointerException.class )
    public void getMethodNullNullNull()
        throws Exception
    {
        reflector.getMethod( (Class<?>)null, (String)null, (Class<?>)null );
    }

    @Test( expected = NullPointerException.class )
    public void getMethodNullNullEmpty()
        throws Exception
    {
        reflector.getMethod( null, null, new Class[0] );
    }

    @Test( expected = NullPointerException.class )
    public void getMethodObjectNullNull()
        throws Exception
    {
        reflector.getMethod( Object.class, (String)null, (Class<?>)null );
    }

    @Test( expected = NullPointerException.class )
    public void getMethodObjectNullEmpty()
        throws Exception
    {
        reflector.getMethod( Object.class, null, new Class[0] );
    }

    @Test( expected = NullPointerException.class )
    public void getMethodNullEmptyNull()
        throws Exception
    {
        reflector.getMethod( (Class<?>)null, "", (Class<?>)null );
    }

    @Test( expected = NullPointerException.class )
    public void getMethodNullEmptyEmpty()
        throws Exception
    {
        reflector.getMethod( null, "", new Class[0] );
    }

    @Test( expected = NullPointerException.class )
    public void getMethodObjectEmptyNull()
        throws Exception
    {
        reflector.getMethod( Object.class, "", (Class<?>)null );
    }

    @Test( expected = ReflectorException.class )
    public void getMethodObjectEmptyEmpty()
        throws Exception
    {
        reflector.getMethod( Object.class, "", new Class[0] );
    }

    @Test( expected = ReflectorException.class )
    // @ReproducesPlexusBug( "Looking up methods by signature has an unlabelled continue, so finds the wrong method" )
    public void getMethodPrivate()
        throws Exception
    {
        assertThat( reflector.getMethod( ReflectorTestHelper.class, "getInstance", new Class[0] ),
                    is( ReflectorTestHelper.class.getDeclaredMethod( "getInstance" ) ) );
    }

    @Test
    public void getMethodPackage()
        throws Exception
    {
        assertThat( reflector.getMethod( ReflectorTestHelper.class, "getInstance", new Class[]{ Boolean.class } ),
                    not( is( ReflectorTestHelper.class.getDeclaredMethod( "getInstance", Boolean.class ) ) ) );
    }

    @Test
    public void getMethodProtected()
        throws Exception
    {
        assertThat( reflector.getMethod( ReflectorTestHelper.class, "getInstance", new Class[]{ Integer.class } ),
                    not( is( ReflectorTestHelper.class.getDeclaredMethod( "getInstance", Integer.class ) ) ) );
    }

    @Test
    public void getMethodPublic()
        throws Exception
    {
        assertThat( reflector.getMethod( ReflectorTestHelper.class, "getInstance", new Class[]{ String.class } ),
                    is( ReflectorTestHelper.class.getDeclaredMethod( "getInstance", String.class ) ) );
    }

}