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."

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

        then:
        outputContains("BUILD SUCCESSFUL")
    }

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

    }

    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 {