// tag::inject-task-constructor[]
abstract class CustomTask @Inject constructor(
    private val message: String,
    private val number: Int
) : DefaultTask()
// end::inject-task-constructor[]

{
    @TaskAction
    fun run() =
        println("$message $number")
}

// tag::on-task-container[]
tasks.register<CustomTask>("myTask", "hello", 42)

    }

    def "uses exact match constructor when constructors could be ambiguous with multiple parameters"() {
        when:
        // HasSeveralParameters has 3 constructors
        // 1 with 3 parameters and 2 with 4 parameters
        // the constructor with 3 parameters is a subset of the 4 parameter constructor

    /**
     * Allows this selector to veto the parameters to use with the given constructor.
     */
    void vetoParameters(ClassGenerator.GeneratedConstructor<?> constructor, Object[] parameters);

    /**
     * Locates the constructor that should be used to create instances of the given type with the given params.
     *

    public MetadataResolutionException() {
        // TODO Auto-generated constructor stub
    }

    public MetadataResolutionException(String message) {
        super(message);
        // TODO Auto-generated constructor stub
    }

    public MetadataResolutionException(Throwable cause) {
        super(cause);
        // TODO Auto-generated constructor stub
    }

 *
 * @constructor Create a new connection pool with tuning parameters appropriate for a single-user
 * application. The tuning parameters in this pool are subject to change in future OkHttp releases.
 * Currently this pool holds up to 5 idle connections which will be evicted after 5 minutes of
 * inactivity.
 */
class ConnectionPool internal constructor(
  internal val delegate: RealConnectionPool,
) {

     */
    public static <T> T newInstance(Class<T> c) {
        try {
            Constructor<T> constructor = c.getDeclaredConstructor();
            constructor.setAccessible(true);
            return constructor.newInstance();
        } catch (Throwable e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

    /**

     * The returned {@link Instantiator} is lenient when there is a missing {@link javax.inject.Inject} annotation or null constructor parameters,
     * for backwards compatibility.
     *
     * <p>Use for any model types for which no user provided constructor values or services need to be injected. This is a convenience for {@link #decorateLenientScheme()} and will also be retired.
     */

        try {
            Constructor<?> constructor = timeout.onlyIf().getConstructors()[0];
            int paramCount = constructor.getParameterCount();
            Object[] param = new Object[paramCount];
            for (int i = 0; i < paramCount; i++) {
                param[i] = this;
            }
            if (((Closure<Boolean>) constructor.newInstance(param)).call()) {
                runnable.run();

    }

    @Override
    public void add(Constructor<?> constructor, String problem) {
        String description = MethodDescription.name(ModelType.of(constructor.getDeclaringClass()).getDisplayName())
                .takes(constructor.getGenericParameterTypes())
                .toString();
        problems.add("Constructor " + description + " is not valid: " + problem);
    }

    public String format() {

      $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'