server.expect(server.get("/custom-dist.zip").expectUserAgent(matchesNameAndVersion("Gradle Tooling API", GradleVersion.current().getVersion())).sendFile(distribution.binDistribution))

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

        when:
        toolingApi.withConnection { connection ->

            }
        }"""
        otherVersion.binDistribution.makeReadable()
        executer.withTasks('wrapper').run()

        when:
        toolingApi.withConnector { connector ->
            connector.useBuildDistribution()
        }
        toolingApi.withConnection { connection -> connection.newBuild().forTasks('check').run() }

        then:
        notThrown(Throwable)

    }
}
"""
        ByteArrayOutputStream baos = new ByteArrayOutputStream()

        when:
        toolingApi.withUserHome(userHomeDir)
        toolingApi.withConnector { connector ->
            connector.useGradleUserHomeDir(userHomeDir)
        }
        toolingApi.withConnection { connection ->
            BuildLauncher build = connection.newBuild()

            }
        """
        distro
    }

    String runWithInstallation(TestFile gradleHome) {
        toolingApi.requireIsolatedDaemons()
        toolingApi.withConnector { GradleConnector it ->
            it.useInstallation(new File(gradleHome.absolutePath))
        }
        withBuild { it.forTasks("echo") }.standardOutput
    }

    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"() {

    }

    void usingToolingConnection(File workingDir, Action<ProjectConnection> action) {
        def toolingApi = new ToolingApi(distribution, testDirectoryProvider)
        toolingApi.withConnector {
            it.forProjectDirectory(workingDir)
        }

        def systemPropertiesBeforeInvocation = new HashMap<String, Object>(System.getProperties())

        try {
            toolingApi.withConnection {

        then:
        result != null
        result.keySet() == ['test', 'a', 'b', 'c'] as Set
        result.values()*.value as Set == [':', ':a', ':b', ':b:c'] as Set

        when:
        withConnector { connector ->
            connector.searchUpwards(true)
            connector.forProjectDirectory(file("b"))
        }

        buildPluginWith("3.2.1")
        assertWorks()
    }

    private void assertWorks() {
        // So we don't try to use a classpath distribution
        toolingApi.requireDaemons()

        withConnector {
            // TestKit builds that use debug will set this to true
            it.embedded(true)
        }

        // Run the build
        withConnection { c ->

        new BuildTestFixture(projectDir).withBuildInRootDir().multiProjectBuild(projectName, subprojects, cl)
    }

    void withConnector(@DelegatesTo(GradleConnector) @ClosureParams(value = SimpleType, options = ["org.gradle.tooling.GradleConnector"]) Closure cl) {
        try {
            toolingApi.withConnector(cl)
        } catch (GradleConnectionException e) {
            caughtGradleConnectionException = e
            throw e

            include "child1", "child2", "child1:grandChild1"
            rootProject.name = 'root'
'''
        projectDir.file('child1').mkdirs()

        when:
        toolingApi.withConnector { connector ->
            connector.searchUpwards(true)
            connector.forProjectDirectory(projectDir.file('child1'))
        }
        EclipseProject child = loadToolingModel(EclipseProject)