with(testResults.testClass('org.gradle.TestUsingSlf4j')) {
            assertTestPassed('mySystemClassLoaderIsUsed')
            assertStderr(Matchers.containsText("ERROR via slf4j"))
            assertStderr(Matchers.containsText("WARN via slf4j"))
            assertStderr(Matchers.containsText("INFO via slf4j"))
        }
    }

    @Requires(UnitTestPreconditions.Jdk9OrLater)

        if (executionResult instanceof HtmlTestExecutionResult || outputAssociation == WITH_SUITE) {
            mixedMethods
                    .assertStderr(allOf(containsString("err.fail"), containsString("err.fail2"), containsString("err.pass"), containsString("err.pass2")))
                    .assertStderr(not(containsString("out.")))

        classResult.assertTestCaseStdout("m2", is("m2 out\n"))

        if (providesClassListener(version)) {
            classResult.assertStderr(is("beforeClass err\n"))
            classResult.assertStdout(is("beforeClass out\n"))
        } else {
            classResult.assertStderr(is(""))
            classResult.assertStdout(is(""))
        }
    }

            testClassResults*.assertTestCaseStdout(removeParentheses(testCaseName), matcher)
            this
        }

        TestClassExecutionResult assertStderr(Matcher<? super String> matcher) {
            testClassResults*.assertStderr(matcher)
            this
        }

        TestClassExecutionResult assertTestCaseStderr(String testCaseName, Matcher<? super String> matcher) {

        result.testClass("org.gradle.FooTest").assertTestOutcomes(testOutcome, testName)
        if (dryRun) {
            result.testClassByXml("org.gradle.FooTest").assertStderr(Matchers.emptyString())
        } else {
            result.testClassByXml("org.gradle.FooTest").assertStderr(Matchers.containsString("ran FooTest.${testName}!"))
        }

        where:
        pattern                   | testOutcome       | testName | buildSuccess

        result.testClass("LoggingTest").assertStderr(equalTo("This is stderr.\n"))

        when:
        executer.withArguments("-DLogLessStuff=true")
        run "test"

        then:
        result.testClass("LoggingTest").assertStdout(equalTo("stdout.\n"))
        result.testClass("LoggingTest").assertStderr(equalTo("stderr.\n"))
    }

    // TODO: remove in Gradle 9.0

            .assertTestsExecuted("some test", "some test two", "some failing test")
            .assertStdout(equalTo("""1st output message
2nd output message
"""))
            .assertStderr(equalTo("err"))

        and:
        xml == """<?xml version="1.0" encoding="UTF-8"?>

                ignoreFailures = true
            }
        """

        when:
        succeeds "check"

        then:
        testResult.testClass('SomeTest').assertStderr(CoreMatchers.containsString("some error output"))
    }

    @ToBeFixedForConfigurationCache(bottomSpecs = "XCTestTestFrameworkIntegrationTest")
    def "failing tests cause report url to be printed"() {

        TestClassExecutionResult assertTestCaseStdout(String testCaseName, Matcher<? super String> matcher) {
            throw new UnsupportedOperationException()
        }

        TestClassExecutionResult assertStderr(Matcher<? super String> matcher) {
            return assertOutput('Standard error', matcher)
        }

        private HtmlTestClassExecutionResult assertOutput(heading, Matcher<? super String> matcher) {

        def stdout = testClassNode.'system-out'[0].text();
        assertThat(stdout, matcher)
        this
    }

    TestClassExecutionResult assertStderr(Matcher<? super String> matcher) {
        def stderr = testClassNode.'system-err'[0].text();
        assertThat(stderr, matcher)
        this
    }