classpath = sourceSets.main.runtimeClasspath
                        mainClass = 'Main'
                    }
                }
            }
        """

        when:
        executer.withConsole(consoleType)
        succeeds("run")

        then:
        def output = result.groupedOutput.task(':run').output
        output.contains(EXPECTED_OUTPUT)

        given:
        file(JAVA_TEST_FILE_PATH) << javaTestClass {
            'throw new RuntimeException("expected");'
        }

        when:
        executer.withConsole(consoleType)
        fails(TEST_TASK_NAME)

        then:
        def taskOutput = getTaskOutput(result)
        matchesTaskOutput(taskOutput, testLogEventRegex(TestLogEvent.FAILED.consoleMarker))
    }

            .withTestConsoleAttached()
            .withConsole(console)
            .run()

        System.out.println("AFTER OUT")
        System.err.println("AFTER ERR")

        def result2 = executer
            .inDirectory(temporaryFolder.testDirectory)
            .withTasks("help")
            .withTestConsoleAttached()
            .withConsole(console)
            .run()

        then:

    protected void interactiveExecution() {
        executer.withStdinPipe().withForceInteractive(true)
    }

    protected void withRichConsole(boolean enabled) {
        if (enabled) {
            executer.withConsole(ConsoleOutput.Rich)
        }
    }

    protected void withParallel() {
        executer.withArgument('--parallel')
    }

    private static final String TEST_CLASS_1 = 'Test1'
    private static final String TEST_CLASS_2 = 'Test2'

    @Rule
    BlockingHttpServer server = new BlockingHttpServer()

    def setup() {
        executer.withConsole(ConsoleOutput.Rich)
        executer.withArguments('--parallel', "--max-workers=$MAX_WORKERS")
        server.start()
    }

    def "omits parallel test execution if TestNG version does not emit class listener events"() {

    def "Generating Gradle API jar is logged with rich console"() {
        given:
        executer.withTestConsoleAttached()
        executer.withConsole(ConsoleOutput.Rich)
        buildFile << """
            configurations {
                gradleImplDeps
            }

            dependencies {
                gradleImplDeps gradleApi()
            }

    private static final String SERVER_RESOURCE_2 = 'test-2'

    @Rule
    BlockingHttpServer server = new BlockingHttpServer()

    def setup() {
        executer.withTestConsoleAttached()
        executer.withConsole(ConsoleOutput.Rich)
        executer.withArguments('--parallel', "--max-workers=$MAX_WORKERS")
        server.start()
    }

    }

    @Requires(IntegTestPreconditions.NotParallelExecutor)
    def "fail fast console output shows test class in work-in-progress"() {
        given:
        executer.withConsole(ConsoleOutput.Rich).withArguments('--parallel', "--max-workers=$DEFAULT_MAX_WORKERS")
        buildFile.text = generator.initBuildFile()
        generator.withFailingTest()
        generator.withNonfailingTest()

abstract class AbstractConsoleConfigurationProgressFunctionalTest extends AbstractIntegrationSpec {
    @Rule
    BlockingHttpServer server = new BlockingHttpServer()
    GradleHandle gradle

    def setup() {
        executer.withConsole(consoleType)
        server.start()
    }

    abstract ConsoleOutput getConsoleType()

    def "shows work in progress as projects are configured"() {
        createDirs("a", "b", "c", "d")

    static ConsoleAttachment consoleAttachment

    def setup() {
        executer.withTestConsoleAttached(consoleAttachment)
        executer.beforeExecute {
            it.withConsole(consoleType)
        }
    }

    boolean errorsShouldAppearOnStdout() {
        // If both stdout and stderr is attached to the console, they are merged together