def build = action.build()
            build.withCancellationToken(cancel.token())
            collectOutputs(build)
            build.run(resultHandler)
            sync.waitForAllPendingCalls(resultHandler)
            cancel.cancel()
            sync.releaseAll()
            resultHandler.finished()
        }

                }
            }
        """

        when:
        withConnection {
            def builder = it.model(List)
            builder.withArguments("--parallel")
            collectOutputs(builder)
            return builder.get()
        }

        then:

            }
        """

        when:
        toolingApi.withConnection { ProjectConnection connection ->
            ModelBuilder<GradleProject> modelBuilder = connection.model(GradleProject.class)
            collectOutputs(modelBuilder)
            modelBuilder.forTasks([':other-build:sub:doSomething'])
            modelBuilder.get()
        }

        then:
        stdout.toString().contains("do something")
    }

        when:

        List<String> result = withConnection { connection ->
            def builder = connection.action(new AccessIncludedBuildProjectBuildAction())
            collectOutputs(builder)
            builder.run()
        }

        then:
        result == ['module-a', 'module-c']
    }

            builder.tap(configurator)
            collectOutputs(builder)
            builder.get()
        }
    }

    def <T> T loadValidatedToolingModel(Class<T> modelClass, @DelegatesTo(ModelBuilder<T>) Closure configurator = {}) {
        def result = loadToolingLeanModel(modelClass, configurator)
        validateOutput()
        result
    }

    void collectOutputs(LongRunningOperation op) {

        def build = basicBuildConfiguration(connection)
        build.run()
    }

    private BuildLauncher basicBuildConfiguration(ProjectConnection connection) {
        def build = connection.newBuild()
        collectOutputs(build)
        build.forTasks(DUMMY_TASK_NAME)
        build
    }

    private String getOutput() {
        stdout.toString()
    }

        ])

        when:
        def eclipseModels = withConnection { con ->
            def builder = con.action(new SupplyRuntimeAndLoadCompositeEclipseModels(workspace))
            collectOutputs(builder)
            builder.run()
        }

        then:
        eclipseModels.collect {
            collectProjects(it)
        }.flatten().collect {
            it.name

        expect:
        server.expectConcurrent(1, 'root', 'a', 'b')
        def models = withConnection {
            def action = action(new ActionRunsNestedActions())
            collectOutputs(action)
            action.addArguments(args)
            action.run()
        }

        !models.mayRunInParallel
        models.projects.path == [':', ':a', ':b']

        where:
        args << [

        output.contains(BAR.answerOutput())
    }

    private void runBuildWithStandardInput(ProjectConnection connection, String answer1, String answer2) {
        def build = connection.newBuild()
        collectOutputs(build)
        build.forTasks(DUMMY_TASK_NAME)

        def stdin = new PipedInputStream()
        def stdinWriter = new PipedOutputStream(stdin)

        build.standardInput = stdin

                    .withArguments(["--continuous", "-I", initScript.absolutePath])
                    .forTasks(tasks as String[])
                    .withCancellationToken(token)

                collectOutputs(launcher)

                customizeLauncher(launcher)

                launcher.run(buildResult)
                T t = underBuild.call()
                cancellationTokenSource.cancel()