writer.onOutput(1, 2, output(StdOut, "[out-6]"))
        writer.close()
        def reader = output.reader()

        then:
        collectOutput(reader, 1, 1, StdOut) == "[out-2][out-5]"
        collectOutput(reader, 1, 1, StdErr) == "[out-4]"
        collectOutput(reader, 1, 2, StdOut) == "[out-6]"

        cleanup:
        reader.close()
    }

        modules.useLargeJars()

        when:
        def events = ProgressEvents.create()
        withConnection { ProjectConnection connection ->
            def build = connection.newBuild()
            collectOutputs(build)
            build.addProgressListener(events, OperationType.FILE_DOWNLOAD)
                .run()
        }

        then:
        events.operations.size() == 8
        events.trees == events.operations

                .projectsLoaded(new FailAction(), projectsLoadedHandler)
                .buildFinished(new ActionShouldNotBeCalled(), buildFinishedHandler)
                .build()

            collectOutputs(action)
            action.run()
        }

        then:
        BuildActionFailureException e = thrown()
        e.message == "The supplied phased action failed with an exception."

            models.add(model)
            finished.countDown()
        } as ResultHandler

        withConnection {
            def builder = it.action(new ModelStreamingBuildAction())
            collectOutputs(builder)
            builder.setStreamedValueListener(listener)
            builder.run(handler)
            finished.await()
        }

        then:
        models.size() == 3

        and:

    def "does not configure build when action does not query any models"() {
        setupBuild()

        when:
        def model = withConnection {
            def executer = action(new NoOpAction())
            collectOutputs(executer)
            executer.run()
        }

        then:
        model == "result"

        and:
        assertHasConfigureSuccessfulLogging()
        result.assertNotOutput(prefix)
    }

            tasks.register('cleanupTest')
        '''

        when:
        withConnection { ProjectConnection connection ->
            TestLauncher testLauncher = connection.newTestLauncher()
            collectOutputs(testLauncher)

            testLauncher.forTasks("setupTest")
                        .withTestsFor(s -> s.forTaskPath(":test")
                        .includeMethod('MyTest', 'pass'))

        when:
        withConnection { connection ->
            TestLauncher launcher = connection.newTestLauncher().withTests(descriptor)
            collectOutputs(launcher)
            launcher.run()
        }

        then:
        outputContains("BUILD SUCCESSFUL")
    }

            """
        }

        when:
        withConnection {
            def executer = action(new FetchIdeaProject())
            executer.withArguments("--warning-mode", "all")
            collectOutputs(executer)
            executer.run()
        }

        then:
        !stdout.toString().contains("was resolved without accessing the project in a safe manner")

        and:

        when:
        def events = ProgressEvents.create()
        withConnection { ProjectConnection connection ->
            def build = connection.newBuild()
            collectOutputs(build)
            build.addProgressListener(events, OperationType.FILE_DOWNLOAD)
                .run()
        }

        then:
        events.operations.size() == 3

            }
        """

        when:
        toolingApi.withConnection { ProjectConnection connection ->
            def buildAction = connection.action(new LoadCompositeModel(GradleProject))
            collectOutputs(buildAction)
            buildAction.forTasks([':other-build:sub:doSomething'])
            buildAction.run()
        }

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