and:
        toolingApi.withConnector {
            it.useDistribution(URI.create("http://localhost:${server.port}/custom-dist.zip"))
        }

        when:
        toolingApi.withConnection { connection ->
            BuildLauncher launcher = connection.newBuild().forTasks("help")

        URI gradleDist = new URI('http://server/dist.zip')
        File userDir = new File('user-dir')

        when:
        def result = connector
                .useDistribution(gradleDist)
                .useGradleUserHomeDir(userDir).forProjectDirectory(projectDir).connect()

        then:
        result == connection

        and:

        return ConnectorServices.createCancellationTokenSource();
    }

    /**
     * Specifies which Gradle installation to use. This replaces any value specified using {@link #useDistribution(URI)}, {@link #useGradleVersion(String)}, or {@link #useBuildDistribution()}.
     * Defaults to a project-specific Gradle version.
     *
     * @param gradleHome The Gradle installation directory.
     * @return this

        public UriGradleProvider(URI uri) {
            this.uri = uri;
        }

        @Override
        public void applyTo(GradleConnector gradleConnector) {
            gradleConnector.useDistribution(uri);
        }

        @Override
        public void applyTo(GradleRunner gradleRunner) {
            gradleRunner.withGradleDistribution(uri);
        }
    }

    final URI distroZip = otherVersion.binDistribution.toURI()

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

    def "tooling api reports an error when requesting a model using a gradle version that does not implement the tooling api"() {
        when:

    gradleInstallation.run {
        when (this) {
            is GradleInstallation.Local -> useInstallation(dir)
            is GradleInstallation.Remote -> useDistribution(uri)
            is GradleInstallation.Version -> useGradleVersion(number)
            is GradleInstallation.Embedded -> (this@useGradleFrom as DefaultGradleConnector).apply {
                embedded(true)

    public GradleConnector useGradleVersion(String gradleVersion) {
        distribution = distributionFactory.getDistribution(gradleVersion);
        return this;
    }

    @Override
    public GradleConnector useDistribution(URI gradleDistribution) {
        distribution = distributionFactory.getDistribution(gradleDistribution);
        return this;
    }

    public GradleConnector useClasspathDistribution() {

        buildFile << "assert gradle.gradleVersion == '${otherVersion.version.version}'"

        when:
        toolingApi.withConnector { connector ->
            connector.useDistribution(otherVersion.binDistribution.toURI())
        }
        GradleProject model = toolingApi.withConnection { connection -> connection.getModel(GradleProject.class) }

        then:
        model != null
    }