tasks.register('cleanupTest')
        '''

        when:
        withConnection { ProjectConnection connection ->
            TestLauncher testLauncher = connection.newTestLauncher()
            collectOutputs(testLauncher)

            testLauncher.forTasks("setupTest")
                        .withTestsFor(s -> s.forTaskPath(":test")
                        .includeMethod('MyTest', 'pass'))

        setup:
        // port is assigned but not connected
        def port = jdwpClient.port

        when:
        withConnection { connection ->
            connection.newTestLauncher()
                .withJvmTestClasses("example.MyTest")
                .debugTestsOn(port)
                .run()
        }

        then:
        thrown(BuildException)
    }

                doLast {
                    System.out.println 'foo'
                }
            }
        """

        when:
        withConnection {
            TestLauncher testLauncher = newTestLauncher()
            testLauncher.forTasks(':foo').run()
        }

        then:
        result.assertTaskExecuted(':foo')
    }

    }

    BuildLauncher newBuild() {
        new ToolingApiBuildLauncher(projectConnection.newBuild(), stdout, stderr)
    }

    TestLauncher newTestLauncher() {
        new ToolingApiTestLauncher(projectConnection.newTestLauncher(), stdout, stderr)
    }

    <T> ModelBuilder<T> model(Class<T> modelType) {
        new ToolingApiModelBuilder(projectConnection.model(modelType), stdout, stderr)
    }

        def sync = server.expectAndBlock("registered")
        def resultHandler = new TestResultHandler()

        when:
        withConnection { ProjectConnection connection ->
            def build = connection.newTestLauncher()
            build.withJvmTestClasses("Broken")
            build.withCancellationToken(cancel.token())
            build.run(resultHandler)
            sync.waitForAllPendingCalls(resultHandler)

public class TestClientTest{
    @org.junit.Test public void test(){
    }
}'''
        withConnection { ProjectConnection connection ->
            def launcher = connection.newTestLauncher().withJvmTestClasses("TestClientTest")
            launcher.standardOutput = outputStream
            launcher.run()
        }
    }

    // since 6.1
    def notifyDaemonsAboutChangedPaths() {
        build()

    }

    @Override
    public BuildLauncher newBuild() {
        return new DefaultBuildLauncher(connection, parameters);
    }

    @Override
    public TestLauncher newTestLauncher() {
        return new DefaultTestLauncher(connection, parameters);
    }

    @Override
    public <T> ModelBuilder<T> model(Class<T> modelType) {
        if (!modelType.isInterface()) {

    private String runTaskAndTestClassUsing(boolean debugMode) {
        def stdout = new ByteArrayOutputStream()
        withConnection { ProjectConnection connection ->
            def testLauncher = connection.newTestLauncher()
                .withTaskAndTestClasses(':app:test', Arrays.asList('TestClass1'))
                .setStandardOutput(stdout)
            if (debugMode) {

        projectDir.file("gradle.properties").writeProperties("org.gradle.java.home": jdk.javaHome.absolutePath)

        when:
        toolingApi.withConnection { ProjectConnection connection ->
            connection.newTestLauncher().withJvmTestClasses("SomeTest").run()
        }

        then:
        GradleConnectionException e = thrown()
        e.message.startsWith("Could not execute tests using ")

    }

    def "tooling api reports an error when running tests using a gradle version does not implement the tooling api"() {
        when:
        toolingApi.withConnection { ProjectConnection connection -> connection.newTestLauncher().withJvmTestClasses("class").run() }

        then:
        UnsupportedVersionException e = thrown()