def "output is received when toggle is off"() {
        when:
        executer.noExtraLogging()
        succeeds "help"

        then:
        outputContains(":help")
    }

    def "output is not received when toggle is on"() {
        when:
        executer.withBuildJvmOpts("-D$LogToClient.DISABLE_OUTPUT=true").noExtraLogging()
        succeeds "help"

        then:
        outputDoesNotContain(":help")

        String initScript = new File(loggingDir, 'init.gradle').absolutePath
        List<String> allArgs = logLevel.args + ['-I', initScript]

        when:
        executer.noExtraLogging().inDirectory(loggingDir).withArguments(allArgs)
        run "log"
        then:
        logLevel.checkOuts(result)

        where:
        level << ['quiet', 'lifecycle', 'info', 'debug']
    }

    // https://github.com/junit-team/junit4/issues/1066
    // So this test was adjusted accordingly.
    def "supports assumptions in JUnit4 rules"() {
        given:
        executer.noExtraLogging()
        file('src/test/java/org/gradle/SkippingRuleTests.java') << """
            package org.gradle;

            import org.junit.FixMethodOrder;
            import org.junit.Rule;

abstract class AbstractJUnitIgnoreClassIntegrationTest extends AbstractTestingMultiVersionIntegrationTest {

    def "can handle class level ignored tests"() {
        given:
        executer.noExtraLogging()
        file('src/test/java/org/gradle/IgnoredTest.java') << """
            package org.gradle;

            ${testFrameworkImports}

            ${ignoreOrDisabledAnnotation}

        when: "run with quiet"
        executer.withArguments("-q")
        succeeds('test')

        then:
        outputDoesNotContain('output from foo')

        when: "run with lifecycle"
        executer.noExtraLogging()
        succeeds('cleanTest', 'test')

        then:
        outputContains('output from foo')
    }

abstract class AbstractJUnitAssumptionsIntegrationTest extends AbstractTestingMultiVersionIntegrationTest {
    def "supports assumptions"() {
        given:
        executer.noExtraLogging()
        file('src/test/java/org/gradle/TestWithAssumptions.java').text = """
            package org.gradle;

            ${testFrameworkImports}

            public class TestWithAssumptions {

import static org.gradle.testing.fixture.JUnitCoverage.LATEST_JUPITER_VERSION

class JUnitPlatformIntegrationSpec extends AbstractIntegrationSpec {
    def setup() {
        executer.noExtraLogging()
        buildScriptWithJupiterDependencies("""
            test {
                useJUnitPlatform()
            }
        """)
    }

import org.gradle.integtests.fixtures.TestNGExecutionResult

class TestNGProducesOldReportsIntegrationTest extends AbstractIntegrationSpec {
    def setup() {
        executer.noExtraLogging()
    }

    def "always produces the new xml reports"() {
        given:
        file("src/test/java/org/MixedMethodsTest.java") << """package org;
import org.testng.*;
import org.testng.annotations.*;

    @Rule public final TestResources resources = new TestResources(temporaryFolder)

    def setup() {
        executer.noExtraLogging()
        executer.withRepositoryMirrors()
    }

    private void addEmptyTestClass(String testName) {
        file("src/test/java/${testName}.java") << """
            ${testFrameworkImports}

            project(':B') {
                configurations.create('default')
                dependencies.add("default", project(':C'))
            }
        """

        when:
        executer.noExtraLogging()
        run "dependencies"

        then:
        output.contains """
conf
+--- project :A FAILED
\\--- project :B
     \\--- project :C FAILED
"""
    }