testImplementation "io.cucumber:cucumber-junit:6.8.1"
}

test {
    testLogging.showStandardStreams = true
    testLogging.events 'started', 'passed', 'skipped', 'failed', 'standardOut', 'standardError'
    reports.junitXml.required = true
    reports.html.required = true

                    quiet {
                        events "standardOut", "standardError"
                    }
                }
            }
        """

        when:
        executer.withStackTraceChecksDisabled()
        args("-q")
        fails("test")

        then:
        outputContains("""
            ${maybeParentheses('printTest')} STANDARD_OUT
                line 1
                line 2

                                testTask.configure {
                                    testLogging {
                                        quiet {
                                            events "standardOut", "standardError"
                                        }
                                    }
                                }
                            }
                        }
                    }

        TestEnum.ENUM3 == toEnum(TestEnum, "enum3")
        TestEnum.ENUM_4_1 == toEnum(TestEnum, "enum_4_1")
        TestEnum.STANDARD_OUT == toEnum(TestEnum, "Standard_Out")
        TestEnum.STANDARD_OUT == toEnum(TestEnum, "standardOut")
    }

    def "converts enum constants to themselves"() {
        expect:
        TestEnum.ENUM1 == toEnum(TestEnum, TestEnum.ENUM1)
    }

            assert !taskOutput.contains("""MyTest > testExpectation ${TestLogEvent.STANDARD_OUT.consoleMarker}
    standard output""")
            assert !taskOutput.contains("""MyTest > testExpectation ${TestLogEvent.STANDARD_ERROR.consoleMarker}
    standard error""")
        } else {
            outputDoesNotContain("""MyTest > testExpectation ${TestLogEvent.STANDARD_OUT.consoleMarker}
    standard output""")

        when:
        logger.logEvent(methodDescriptor, TestLogEvent.STANDARD_OUT, "event 1")
        logger.logEvent(methodDescriptor, TestLogEvent.STANDARD_OUT, "event 2")

        then:
        textOutputFactory.toString() == "{TestEventLogger}{INFO}${sep}OuterSuiteClass > InnerSuiteClass\
 > TestClass > a test STANDARD_OUT${sep}event 1{TestEventLogger}{INFO}event 2"
    }

        return events.contains(TestLogEvent.STANDARD_OUT) && events.contains(TestLogEvent.STANDARD_ERROR);
    }

    @Override
    public TestLogging setShowStandardStreams(boolean flag) {
        if (flag) {
            events.addAll(EnumSet.of(TestLogEvent.STANDARD_OUT, TestLogEvent.STANDARD_ERROR));
        } else {
            events.removeAll(EnumSet.of(TestLogEvent.STANDARD_OUT, TestLogEvent.STANDARD_ERROR));
        }

        if (outputEvent.getDestination() == TestOutputEvent.Destination.StdOut
                && isLoggedEventType(TestLogEvent.STANDARD_OUT)) {
            logEvent(descriptor, TestLogEvent.STANDARD_OUT, TextUtil.indent(outputEvent.getMessage(), INDENT) + "\n");
        } else if (outputEvent.getDestination() == TestOutputEvent.Destination.StdErr

    SKIPPED,

    /**
     * A test has failed. This event gets fired both for atomic and composite tests.
     */
    FAILED,

    /**
     * A test has written a message to standard out.
     */
    STANDARD_OUT,

    /**
     * A test has written a message to standard error.
     */
    STANDARD_ERROR

        testLogging {
            if (Boolean.getBoolean("reducedOutput")) {
                events "failed"
            } else {
                events "started", "skipped", "failed", "passed", "standard_out", "standard_error"
            }
        }
    <% } %>
    maxParallelForks 2