abstract String getTestFrameworkJUnit3Dependencies()

    @Override
    String getTestFrameworkSuiteImports() {
        return """
            import org.junit.runner.RunWith;
            import org.junit.runners.Suite;
        """.stripIndent()
    }

    @Override
    String getTestFrameworkSuiteAnnotations(String classes) {
        return """
            @RunWith(Suite.class)

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.testkit.runner

import org.gradle.testkit.runner.fixtures.PluginUnderTest

class GradleRunnerManualPluginClasspathInjectionIntegrationTest extends BaseGradleRunnerIntegrationTest {

    def plugin = new PluginUnderTest(file("plugin"))

    /*

    )
    def "visiting zip trees"() {
        given:
        runner.tasksToRun = ['visitZip']
        runner.addBuildMutator { createArchive(it, "archive.zip") { contents, output -> contents.zipTo(output) } }

        when:
        def result = runner.run()

        then:
        result.assertCurrentVersionHasNotRegressed()
    }

    @RunFor(

        buildFile << """
plugins {
    id('${pluginId.value}')
}
"""

        when:
        def runner = GradleRunner.create()
        runner.forwardOutput()
        runner.withPluginClasspath()
        runner.withArguments("greeting")
        runner.withProjectDir(projectDir)
        def result = runner.build()

        then:
        result.output.contains("Hello from plugin '${pluginId.value}'")
    }

            "  id('${pluginId.value}')" +
            "}");

        // Run the build
        GradleRunner runner = GradleRunner.create();
        runner.forwardOutput();
        runner.withPluginClasspath();
        runner.withArguments("greeting");
        runner.withProjectDir(projectDir);
        BuildResult result = runner.build();

        // Verify the result

    def delegate = Mock(BuildActionRunner)
    def buildAction = Stub(BuildAction)
    def buildOperationProgressEventEmitter = Mock(BuildOperationProgressEventEmitter)

    def runner = new FileSystemWatchingBuildActionRunner(
        buildOperationProgressEventEmitter,
        watchingHandler,
        deploymentRegistry,
        Stub(StatStatistics.Collector),
        Stub(FileHasherStatistics.Collector),

    def setup() {
        runner.minimumBaseVersion = "4.0"
    }

    def "build with #parallelWorkers parallel workers"() {
        given:
        runner.tasksToRun = ['build']
        runner.warmUpRuns = 5
        runner.runs = 10

        runner.args += ["-Dorg.gradle.parallel=${parallelWorkers ? true : false}"]
        if (parallelWorkers) {
            runner.args += ["--max-workers=$parallelWorkers".toString()]

 * limitations under the License.
 */

package org.gradle.smoketests

import org.gradle.test.fixtures.file.TestFile
import org.gradle.testkit.runner.BuildResult
import org.gradle.testkit.runner.TaskOutcome
import spock.lang.Issue

class TestRetryPluginSmokeTest extends AbstractSmokeTest {
    def setup() {
        sourceFile()
        testSourceFile()
        buildFile << """

package org.gradle.kotlin.dsl.samples.androidstudio

import android.support.test.InstrumentationRegistry
import android.support.test.runner.AndroidJUnit4

import org.junit.Test
import org.junit.runner.RunWith

import org.junit.Assert.*

/**
 * Instrumented test, which will execute on an Android device.
 *
 * See [testing documentation](http://d.android.com/tools/testing).
 */
@RunWith(AndroidJUnit4::class)

        def version = AGP_VERSIONS.latestStableOrRC
        configureForAgpVersion(runner, version)
        version
    }

    private static void configureForAgpVersion(CrossVersionPerformanceTestRunner runner, String agpVersion) {
        runner.args.add("-DagpVersion=${agpVersion}")

        def javaVersion = AGP_VERSIONS.getMinimumJavaVersionFor(agpVersion)