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

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

        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

            }
        """

        when:
        args "-q"
        fails "test"

        then:
        outputContains("""
Gradle test > org.gradle.TestNGStandardOutputTest.printTest STANDARD_OUT
    line 1
    line 2
    line 3
        """)
    }

    @Issue("https://github.com/gradle/gradle/issues/25857")

    }

    def "allows standardStreams to be turned on and off"() {
        when:
        logging.setShowStandardStreams(true)

        then:
        logging.showStandardStreams
        logging.events == [STANDARD_OUT, STANDARD_ERROR] as Set

        when:
        logging.setShowStandardStreams(false)

        then:
        !logging.showStandardStreams
        logging.events == [] as Set
    }

    }
    jvmArgs '-XX:+HeapDumpOnOutOfMemoryError'
    <% if (binding.hasVariable("fullTestLogging")) { %>
        testLogging {
            events "started", "skipped", "failed", "passed", "standard_out", "standard_error"
        }
    <% } %>
}

String compilerMemory = getProperty('compilerMemory')
String testRunnerMemory = getProperty('testRunnerMemory')