def launcher = new DefaultTestLauncher(executor, Stub(ConnectionParameters))

    def "adding tests does not affect an operation in progress"() {
        given:
        launcher.withJvmTestClasses("test")
        when:
        launcher.run()

        then:
        1 * executor.run(_, _) >> { ConsumerAction action, ResultHandlerVersion1 handler ->
            action.run(connection)

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

    def "can launch tests in debug mode"() {

        setup: "add testcase that should not be executed"
        withFailingTest()

        when:
        launchTests { TestLauncher testLauncher ->
            testLauncher.withJvmTestClasses("example.MyTest")
            testLauncher.withJvmTestClasses("example2.MyOtherTest")
        }
        then:
        assertTaskExecuted(":test")
        assertTaskExecuted(":secondTest")

        return this;
    }

    @Override
    public TestLauncher withJvmTestClasses(String... classNames) {
        withJvmTestClasses(Arrays.asList(classNames));
        return this;
    }

    @Override
    public TestLauncher withJvmTestClasses(Iterable<String> testClasses) {

    }

    def "executes all test methods if class and method is declared"() {
        when:
        launchTests { TestLauncher launcher ->
            launcher.withJvmTestClasses("example.MyTest")
            launcher.withJvmTestMethods("example.MyTest", "foo")
        }

        then:
        assertTestExecuted(className: "example.MyTest", methodName: "foo", task: ":test")

        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)
            cancel.cancel()
            sync.releaseAll()

     */
    TestLauncher withJvmTestClasses(String... testClasses);


    /**
     * <p>Adds tests to be executed declared by class name.</p>
     *
     * <p>This method ignores tests defined in included builds.</p>
     *
     * @param testClasses The class names of the tests to be executed.
     * @return this
     * @since 2.6
     */
    TestLauncher withJvmTestClasses(Iterable<String> testClasses);

    /**

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

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

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

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