assert !taskOutput.contains("""MyTest > testExpectation ${TestLogEvent.STANDARD_ERROR.consoleMarker}
    standard error""")
        } else {
            outputDoesNotContain("""MyTest > testExpectation ${TestLogEvent.STANDARD_OUT.consoleMarker}
    standard output""")
            outputDoesNotContain("""MyTest > testExpectation ${TestLogEvent.STANDARD_ERROR.consoleMarker}
    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));
        }
        return this;
    }

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

    private void before(TestDescriptor descriptor) {

     */
    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

    private final Amount<Q> average;
    private final Amount<Q> median;
    private final Amount<Q> max;
    private final Amount<Q> min;
    // https://en.wikipedia.org/wiki/Standard_error
    private final Amount<Q> standardError;

    public DataSeries(Iterable<? extends Amount<Q>> values) {
        for (Amount<Q> value : values) {
            if (value != null) {
                add(value);
            }
        }

    }
    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')
int testForkEvery = getProperty('testForkEvery') as Integer

    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
    }

        createLogger(LogLevel.DEBUG)

        when:
        logger.logEvent(methodDescriptor, TestLogEvent.STANDARD_ERROR, "this is a${sep}standard error${sep}event")

        then:
        textOutputFactory.toString() == "{TestEventLogger}{DEBUG}${sep}OuterSuiteClass > InnerSuiteClass > TestClass > a test STANDARD_ERROR${sep}this is a${sep}standard error${sep}event"
    }

                testLogging.exceptionFormat = 'full'
                testLogging.showStandardStreams = true
                testLogging.events "started", "skipped", "failed", "passed", "standard_out", "standard_error"
            }
        """
    }


    def "uses a test kit directory under the project build directory by default"() {
        when:
        buildFile << gradleTestKitDependency()