}

    def "is instantiated with null project constructor parameter value"() {
        when:
        new DefaultLibraryBinaryIdentifier(null, 'foo', 'api')

        then:
        Throwable t = thrown(AssertionError)
        t.message == 'project path cannot be null'
    }

    def "is instantiated with null library constructor parameter value"() {
        when:

    }

    def "can construct a custom task with constructor arguments"() {
        given:
        buildFile << CUSTOM_TASK_WITH_CONSTRUCTOR_ARGS
        buildFile << "tasks.create('myTask', CustomTask, 'hello', 42)"

        when:
        run 'myTask'

        then:
        outputContains("hello 42")
    }

    def "can construct a custom task with constructor arguments as #description via Map"() {
        given:

      $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.CodeFragment
      CONSTRUCTOR visibility:public <> () returnType:<root>.CodeFragment [primary]
        BLOCK_BODY
          DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
      FUN name:run visibility:public modality:FINAL <> (p0:<root>.Test) returnType:kotlin.Unit

import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.CoreMatchers.sameInstance;
import static org.junit.Assert.assertThat;

import java.lang.reflect.Constructor;

import org.codelibs.core.beans.BeanDesc;
import org.codelibs.core.beans.ConstructorDesc;
import org.junit.Test;

/**
 * @author koichik
 *
 */
public class ConstructorDescTest {

    /**

            public class FooTest {
                static { System.out.println("static out"); System.err.println("static err"); }

                public FooTest() {
                    System.out.println("constructor out"); System.err.println("constructor err");
                }

                @BeforeClass public static void beforeClass() {
                    System.out.println("beforeClass out"); System.err.println("beforeClass err");

    }

    def 'invoking a closure constructor with a specific owner replaces the metaclass of the delegate'() {
        given:
        def transformedClosureClass = instrumentedClasses.instrumentedClosure {
            test()
        }
        def constructor = transformedClosureClass.class.getDeclaredConstructor(Object.class, Object.class)

        when:

      $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.CodeFragment
      CONSTRUCTOR visibility:public <> () returnType:<root>.CodeFragment [primary]
        BLOCK_BODY
          DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
      FUN name:run visibility:public modality:FINAL <> (p0:kotlin.String, p1:<root>.Foo) returnType:kotlin.Int

    CLASS CLASS name:Foo modality:FINAL visibility:public superTypes:[kotlin.Any]
      $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Foo
      CONSTRUCTOR visibility:public <> () returnType:<root>.Foo [primary]
        BLOCK_BODY
          DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'

      $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.CodeFragment
      CONSTRUCTOR visibility:public <> () returnType:<root>.CodeFragment [primary]
        BLOCK_BODY
          DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
      FUN name:run visibility:public modality:FINAL <> (p0:<root>.Ctx1, p1:<root>.Ctx2) returnType:kotlin.Int

     */
    public static ParameterizedClassDesc createParameterizedClassDesc(final Constructor<?> constructor, final int index,
            final Map<TypeVariable<?>, Type> map) {
        assertArgumentNotNull("constructor", constructor);
        assertArgumentNotNull("map", map);

        return createParameterizedClassDesc(constructor.getGenericParameterTypes()[index], map);
    }

    /**