import java.util.List;

public class InstantiatingAction<DETAILS> implements Action<DETAILS> {
    private final ConfigurableRules<DETAILS> rules;
    private final Instantiator instantiator;
    private final ExceptionHandler<DETAILS> exceptionHandler;
    private final Action<DETAILS>[] reusableRules;

    @SuppressWarnings("unchecked")

        rules.add(new InstantiatingAction<>(DefaultConfigurableRules.of(DefaultConfigurableRule.of(rule, configureAction, isolatableFactory)),
            instantiator, new ExceptionHandler<>(rule)));
    }

    @Override
    public void add(final Class<? extends AttributeCompatibilityRule<T>> rule) {
        rules.add(new InstantiatingAction<>(DefaultConfigurableRules.of(DefaultConfigurableRule.of(rule)),

            }
        }
        resolveState.componentMetadataSupplier >> new InstantiatingAction<ComponentMetadataSupplierDetails>(
            DefaultConfigurableRules.of(DefaultConfigurableRule.of(TestSupplier)),
            TestUtil.instantiatorFactory().inject(),
            Stub(InstantiatingAction.ExceptionHandler)
        )

        when:

            }
        }
        rule = new InstantiatingAction<>(
            DefaultConfigurableRules.of(DefaultConfigurableRule.of(ruleClass)),
            instantiator,
            shouldNotFail()
        )
    }


    InstantiatingAction.ExceptionHandler<ComponentMetadataContext> shouldNotFail() {
        return new InstantiatingAction.ExceptionHandler<ComponentMetadataContext>() {
            @Override

import org.gradle.api.artifacts.component.ComponentArtifactIdentifier;
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.artifact.ResolvableArtifact;
import org.gradle.internal.action.InstantiatingAction;

import javax.annotation.Nullable;
import java.util.Map;

/**
 * A repository of module components.
 *
 * @param <T> the component resolution result type
 */

            WithServiceInjected
        )
        rule = new InstantiatingAction<Details>(new DefaultConfigurableRules([rule1, rule2]), implicitInputsCapturingInstantiator, shouldNotFail())
    }

    InstantiatingAction.ExceptionHandler<Details> shouldNotFail() {
        return new InstantiatingAction.ExceptionHandler<Details>() {
            @Override

    }


    private static <T> InstantiatingAction<T> createRuleAction(final Instantiator instantiator, final ConfigurableRule<T> rule) {
        return new InstantiatingAction<>(DefaultConfigurableRules.of(rule), instantiator, (target, throwable) -> {
            throw UncheckedException.throwAsUncheckedException(throwable);
        });

        }

        def supplier = new InstantiatingAction<ComponentMetadataSupplierDetails>(DefaultConfigurableRules.of(Stub(ConfigurableRule)), TestUtil.instantiatorFactory().inject(), Stub(InstantiatingAction.ExceptionHandler))
        def lister = new InstantiatingAction<ComponentMetadataListerDetails>(DefaultConfigurableRules.of(Stub(ConfigurableRule)), TestUtil.instantiatorFactory().inject(), Stub(InstantiatingAction.ExceptionHandler))

import org.gradle.util.TestUtil
import spock.lang.Specification

import javax.inject.Inject

class InstantiatingActionTest extends Specification {

    final shouldNotFail = new InstantiatingAction.ExceptionHandler() {
        @Override
        void handleException(Object target, Throwable throwable) {
            throw new AssertionError("Expected test to pass, but failed with an exception", throwable)
        }

        this.rules.add(new InstantiatingAction<>(DefaultConfigurableRules.of(DefaultConfigurableRule.of(rule, configureAction, isolatableFactory)),
            instantiator, new ExceptionHandler<>(rule)));
    }

    @Override
    public void add(final Class<? extends AttributeDisambiguationRule<T>> rule) {
        this.rules.add(new InstantiatingAction<>(DefaultConfigurableRules.of(DefaultConfigurableRule.of(rule)),