</tr>
            <tr>
                <td>applicationDistribution</td>
                <td>A copy spec that includes all of the contents of <literal>src/dist</literal>, copies the start scripts into <literal>bin</literal>, and copies the built jar and all dependencies into <literal>lib</literal></td>
            </tr>
            <tr>
                <td>executableDir</td>

        when:
        executer.withArgument("--continue")
        fails("broken1", "broken2", "broken3")

        then:
        failure.assertHasCause("Cannot call ${description} on task ':broken1' after task has started execution.")
        failure.assertHasCause("Cannot call ${description} on task ':broken2' after task has started execution.")

        where:
        config                                                      | description

        if (allServices.containsKey(serviceType)) {
            return Cast.uncheckedNonnullCast(allServices.get(serviceType));
        }
        List<T> all = delegate.getAll(serviceType);
        allServices.put(serviceType, all);
        return all;
    }

    @Override
    public synchronized <T> DefaultServiceLocator.ServiceFactory<T> getFactory(Class<T> serviceType) throws UnknownServiceException {

        this.strict = false;
        return this;
    }

    /**
     * Providing a scope makes the resulting {@link ServiceRegistry}
     * validate all registered services for being annotated with the given scope.
     * <p>
     * All registered services require the {@link org.gradle.internal.service.scopes.ServiceScope @ServiceScope}
     * annotation to be present and contain the given scope.
     *

    @TaskAction
    public void resolveLatestVersion() {
        System.out.println("Retrieving artifact " + getCoordinates().get() + " from " + getServerUrl().get());
        // Issue HTTP call and parse response
    }
}

    def "captures plugin application events"() {
        given:
        file("build.gradle") << "apply plugin: 'java'"

        when:
        succeeds "build"

        then:
        def plugins = operations.all(ApplyPluginBuildOperationType) {
            it.details.targetType == "project" &&
                it.details.targetPath == ":" &&
                it.details.buildPath == ":"
        }

        buildFile << """
allprojects {
    apply plugin: 'java-library'
    repositories {
        maven { url "${mavenRepo.uri}" }
    }
}

project(':first') {
    configurations.all {
        resolutionStrategy.activateDependencyLocking()
    }
    dependencies {
        api 'org:foo:[1.0,2.0)'
    }
}

project(':second') {
    dependencies {
        implementation project(':first')

    @Input
    public String getUrl() {
        return url;
    }

    @TaskAction
    public void verify() {
        getLogger().quiet("Verifying URL '{}'", url);

        // verify URL by making a HTTP call
    }
}

import java.io.Serializable;

/**
 * <p>DO NOT CHANGE THIS INTERFACE - it is part of the cross-version protocol.
 *
 * <p>Consumer compatibility: This interface is implemented by all consumer versions from 4.4.</p>
 * <p>Provider compatibility: This interface is consumed by all provider versions from 4.4.</p>
 *
 * @since 4.4
 */
public interface InternalBuildActionVersion2<T> extends InternalProtocolInterface, Serializable {
    /**

    private final static List<String> JDK11_REQUIRED = ['10.3.3'].asImmutable()
    private final static List<String> ALL = JDK8_SUPPORTED + JDK11_REQUIRED

    static List<String> getSupportedVersionsByJdk() {
        JavaVersion.current() >= JavaVersion.VERSION_11 ? ALL : JDK8_SUPPORTED
    }

    static JavaVersion getMinimumSupportedJdkVersion(VersionNumber checkstyleVersion) {