when:

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

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

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