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

    }

    private <T> T fetchSchemaModel(Class<T> modelType) {
        toolingApi.withConnection() { connection ->
            ModelBuilder<T> modelBuilder = connection.model(modelType)
            collectOutputs(modelBuilder)
            modelBuilder.get()
        }
    }

    private static boolean documentIsEquivalentTo(
        String expectedDocumentText,

        withConnection {
            def launcher = newBuild()
                .forTasks(task)
                .addProgressListener(events, operationTypes)
            collectOutputs(launcher)
            config.execute(launcher)
            launcher.run()
        }
    }

        TestLauncher testLauncher = connection.newTestLauncher()
            .withCancellationToken(cancellationToken)
            .addProgressListener(events, OperationType.TASK, OperationType.TEST)

        collectOutputs(testLauncher)

        configurationClosure.call(testLauncher)

        events.clear()
        if (resultHandler == null) {
            testLauncher.run()
        } else {