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

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

abstract class AbstractJUnit4IgnoreClassIntegrationTest extends AbstractJUnitIgnoreClassIntegrationTest {
    def "can handle class level ignored tests with custom runner"() {
        given:
        executer.noExtraLogging()
        file ('src/test/java/org/gradle/CustomIgnoredTest.java') << """
            package org.gradle;

            ${testFrameworkImports}
            import org.junit.runner.notification.Failure;

        def dataFile = file("stats")
        int newDaemons = 0
        try {
            for (int i = 0; i < maxBuilds; i++) {
                executer.noExtraLogging()
                executer.withBuildJvmOpts("-Xms128m", "-XX:MaxMetaspaceSize=${heapSize}", "-Xmx${heapSize}", "-Dorg.gradle.daemon.performance.logging=true")
                GradleHandle gradle = executer.start()