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

import org.gradle.testing.fixture.TestNGCoverage
import spock.lang.Issue

class TestNGUpToDateCheckIntegrationTest extends AbstractIntegrationSpec {

    def setup() {
        executer.noExtraLogging()
        file('src/test/java/SomeTest.java') << '''
            public class SomeTest {
                @org.testng.annotations.Test(groups = {"group to include"})
                public void pass() {}
            }

        then:
        stopsSingleDaemon()
    }

    def "reports exact number of daemons stopped and keeps console output clean"() {
        given:
        executer.noExtraLogging()
        executer.run()

        when:
        def out = executer.withArguments("--stop").run().normalizedOutput

        then:
        out == '''Stopping Daemon(s)
1 Daemon stopped
'''

class TestNGClassIntegrationTest extends MultiVersionIntegrationSpec {

    private final static String STARTED = 'Started'
    private final static String FINISHED = 'Finished'

    def setup() {
        executer.noExtraLogging()
        TestNGCoverage.enableTestNG(buildFile, version)

        buildFile << """

            test {
                useTestNG()
                addTestListener(new TestListener() {

import spock.lang.Issue

@Issue("GRADLE-1009")
abstract class AbstractTestOutputListenerIntegrationTest extends AbstractTestingMultiVersionIntegrationTest {
    def setup() {
        executer.noExtraLogging()
    }

    def "can use standard output listener for tests"() {
        given:
        file("src/test/java/SomeTest.java") << """
            ${testFrameworkImports}

            public class SomeTest {

// because the methods are chained with 'methodDependsOn'
class TestNGConsoleLoggingIntegrationTest extends AbstractIntegrationSpec {

    def setup() {
        executer.noExtraLogging()

        buildFile << """
            apply plugin: "groovy"

            ${mavenCentralRepository()}

            dependencies {
                implementation "org.codehaus.groovy:groovy:2.4.10"

import org.gradle.testing.fixture.AbstractTestingMultiVersionIntegrationTest

abstract class AbstractIncrementalTestIntegrationTest extends AbstractTestingMultiVersionIntegrationTest {
    def setup() {
        executer.noExtraLogging()
        executer.withRepositoryMirrors()
        buildFile << """
            apply plugin: 'java'

            ${mavenCentralRepository()}

            dependencies {

import spock.lang.Ignore

class MultiProjectContinuousIntegrationTest extends AbstractContinuousIntegrationTest {

    def upstreamSource, downstreamSource

    def setup() {
        executer.noExtraLogging()
        settingsFile << "include 'upstream', 'downstream'"
        buildFile << """
            subprojects {
                apply plugin: 'java-library'
                ${mavenCentralRepository()}
            }

abstract class AbstractJUnitConsoleLoggingIntegrationTest extends AbstractTestingMultiVersionIntegrationTest {
    TestFile testFile = file('src/test/java/org/gradle/SomeTest.java')

    def setup() {
        executer.noExtraLogging()
        testFile << """
            package org.gradle;

            ${testFrameworkImports}

            public class SomeTest {
                @Test
                public void goodTest() {}