// 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);
        }

    public Property<String> getName() {
        return name;
    }

    @Override
    public Property<String> getUrl() {
        return url;
    }

    @Override
    public Property<String> getDistribution() {
        return distribution;
    }

    @Override
    public Property<String> getComments() {
        return comments;
    }

    }

    @Override
    public boolean matches(String criteria) {
        return GradleVersion.version(criteria).equals(distribution.getVersion());
    }

    public GradleDistribution getDistribution() {
        return distribution;
    }

    public String getIgnored() {
        return ignored;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {

        }
        executer.inDirectory(rootDir).withTasks("clean", "jar").run();
    }

    private boolean isGradleExecuterVersionLessThan(String version) {
        return executer.getDistribution().getVersion().compareTo(GradleVersion.version(version)) < 0;
    }

    final ToolingApi toolingApi = new ToolingApi(distribution, temporaryFolder)
    final GradleDistribution otherVersion = new ReleasedVersionDistributions().getDistribution(GradleVersion.version("0.9.2"))
    final URI distroZip = otherVersion.binDistribution.toURI()

    def setup() {
        toolingApi.withConnector { connector -> connector.useDistribution(distroZip) }

    }

    @Override
    protected Collection<Execution> createDistributionExecutionsFor(GradleDistributionTool versionedTool) {
        GradleDistribution distribution = versionedTool.getDistribution()
        return [new PreviousVersionExecution(distribution, isEnabled(distribution))]
    }

    protected boolean isEnabled(GradleDistribution previousVersion) {

    }

    protected GradleContextualExecuter createExecuter() {
        return new GradleContextualExecuter(distribution, testDirectoryProvider, getBuildContext());
    }

    protected GradleDistribution getDistribution() {
        return distribution;
    }

    protected GradleExecuter getExecuter() {
        return executer;
    }

    protected TestNameTestDirectoryProvider getTestDirectoryProvider() {

    protected Collection<Execution> createExecutionsFor(GradleDistributionTool versionedTool) {
        if (versionedTool.getIgnored() != null) {
            return Collections.singleton(new IgnoredVersion(versionedTool.getDistribution(), versionedTool.getIgnored()));
        } else {
            return createDistributionExecutionsFor(versionedTool);
        }
    }