}

    private void runBuild(String task, Action<BuildLauncher> config = {}) {
        withConnection {
                def launcher = newBuild()
                    .forTasks(task)
                    .addProgressListener(events, EnumSet.of(OperationType.TASK))
                config.execute(launcher)
                launcher.run()
        }
    }

        TestOperationCollector collector = new TestOperationCollector()
        withConnection { connection ->
            def build = connection.newBuild()
            build.addProgressListener(collector)
            build.forTasks(":other-build:sub:test").run()
        }
        TestOperationDescriptor descriptor = collector.descriptors.find { it.name == "myTestMethod" }

        when:
        withConnection { connection ->

    }

    private void runCacheableBuild(listener, String task = "cacheable") {
        withConnection {
            ProjectConnection connection ->
                connection.newBuild().withArguments("--build-cache").forTasks(task).addProgressListener(listener, EnumSet.of(OperationType.GENERIC, OperationType.TASK)).run()
        }
    }

    int maybeIncludeLocalBuildOperations(int expectedNumber) {
        hasLocalBuildCacheOperations()

        events
    }

    private Object runBuild(String task, ProgressListener listener, Set<OperationType> operationTypes) {
        withConnection {
            newBuild()
                .forTasks(task)
                .addProgressListener(listener, operationTypes)
                .run()
        }
    }

    def prepareTaskTypeUsingWorker() {

        }
    }

    @Override
    public TestLauncher debugTestsOn(int port) {
        this.debugOptions.setPort(port);
        return this;
    }

    @Override
    public TestLauncher forTasks(String... tasks) {
        this.isRunDefaultTasks = tasks.length == 0;
        for (String task : tasks) {
            taskSpecs.add(new DefaultTaskSpec(task));
        }
        return this;
    }

    }

    private void runBuild(String... tasks) {
        events.clear()
        withConnection {
            ProjectConnection connection ->
                connection.newBuild()
                    .forTasks(tasks)
                    .addProgressListener(events, EnumSet.of(OperationType.TASK))
                    .run()
        }
    }

    private TaskSkippedResult taskSkippedResult(String path) {

        }
    }

    private Object runBuild(String task, Set<OperationType> operationTypes = EnumSet.allOf(OperationType)) {
        withConnection {
            newBuild()
                .forTasks(task)
                .addProgressListener(events, operationTypes)
                .run()
        }
    }

        given:
        buildFile << """
            class Bean { Project p1 }

            class FooTask extends DefaultTask {
                private final bean = new Bean()
                FooTask() { bean.p1 = project }
                @TaskAction void run() {}
            }

            task foo(type: FooTask)
        """

        when:
        run ENABLE_CLI_OPT, WARN_PROBLEMS_CLI_OPT, "foo"

                        ByteArrayOutputStream err = new ByteArrayOutputStream();

                        connection.newBuild()
                            .forTasks("help")
                            .setStandardOutput(out)
                            .setStandardError(err)
                            .setJavaHome(javaHome)
                            .run();

            def error = new ByteArrayOutputStream()
            def args = executer.allArgs
            args.remove("--no-daemon")

            model = connection.model(type)
                .forTasks(tasks)
                .withArguments(args)
                .setStandardOutput(new TeeOutputStream(output, System.out))
                .setStandardError(new TeeOutputStream(error, System.err))
                .get()