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

        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:
        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")
    }

            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")
    }