return new InProcessGradleExecuter(getDistribution(), getTestDirectoryProvider(), gradleVersion, buildContext);
            case noDaemon:
                return new NoDaemonGradleExecuter(getDistribution(), getTestDirectoryProvider(), gradleVersion, buildContext);
            case parallel:
                return new ParallelForkingGradleExecuter(getDistribution(), getTestDirectoryProvider(), gradleVersion, buildContext);

                    }
                }
            }
        }
    }

    @Override
    protected void transformInvocation(GradleInvocation invocation) {
        if (getDistribution().isSupportsSpacesInGradleAndJavaOpts()) {

                .useGradleUserHomeDir(userDir).forProjectDirectory(projectDir).connect()

        then:
        result == connection

        and:
        1 * distributionFactory.getDistribution(gradleDist) >> distribution
        1 * connectionFactory.create(distribution, { it.gradleUserHomeDir == userDir }, connector) >> connection
    }

    def canSpecifyAGradleInstallationToUse() {

            public boolean isSatisfiedBy(GradleDistribution element) {
                return element.getVersion().compareTo(firstSupported) >= 0;
            }
        });
    }

    public GradleDistribution getDistribution(final GradleVersion gradleVersion) {
        return findFirst(getAll(), new Spec<GradleDistribution>() {
            @Override
            public boolean isSatisfiedBy(GradleDistribution element) {

        explodedZipDir.zipTo(new TestFile(zipDestination))
        explodedZipDir.deleteDir();
    }

    def "installs distribution and reuses on subsequent access"() {
        given:
        _ * pathAssembler.getDistribution(configuration) >> localDistribution
        _ * localDistribution.distributionDir >> distributionDir
        _ * localDistribution.zipFile >> zipDestination

        when:

    }

    /**
     * Determines the local locations for the distribution to use given the supplied configuration.
     */
    public LocalDistribution getDistribution(WrapperConfiguration configuration) {
        String baseName = getDistName(configuration.getDistribution());
        String distName = removeExtension(baseName);
        String rootDirName = rootDirName(distName, configuration);

    }

    public File createDist(final WrapperConfiguration configuration) throws Exception {
        final URI distributionUrl = configuration.getDistribution();

        final PathAssembler.LocalDistribution localDistribution = pathAssembler.getDistribution(configuration);
        final File distDir = localDistribution.getDistributionDir();
        final File localZipFile = localDistribution.getZipFile();

// tag::distributionDirInput[]
abstract class DistributionLocationProvider implements CommandLineArgumentProvider {  // <1>
    @InputDirectory
    @PathSensitive(PathSensitivity.RELATIVE)  // <2>
    abstract DirectoryProperty getDistribution()

    @Override
    Iterable<String> asArguments() {
        ["-Ddistribution.location=${distribution.get().asFile.absolutePath}"]  // <3>
    }
}

tasks.named('integTest') {
    jvmArgumentProviders.add(

    Property<String> getName();

    /**
     * The URL of this license.
     */
    Property<String> getUrl();

    /**
     * The distribution of this license.
     */
    Property<String> getDistribution();

    /**
     * The comments of this license.
     */
    Property<String> getComments();

    }

    @Override
    protected List<String> getAllArgs() {
        List<String> args = new ArrayList<String>();
        args.addAll(super.getAllArgs());
        if (getDistribution().getVersion().compareTo(GradleVersion.version("2.3")) <= 0) {
            args.add("--parallel-threads=4");
        } else {
            args.add("--parallel");
            maybeSetMaxWorkers(args);
        }