import spock.lang.Specification

class ChainingBuildActionRunnerTest extends Specification {
    def runner1 = Mock(BuildActionRunner)
    def runner2 = Mock(BuildActionRunner)
    def runner3 = Mock(BuildActionRunner)
    def runner = new ChainingBuildActionRunner([runner1, runner2, runner3])

    def "invokes runners until a result is produced"() {
        def action = Stub(BuildAction)

    private final List<? extends BuildActionRunner> runners;

    public ChainingBuildActionRunner(List<? extends BuildActionRunner> runners) {
        this.runners = runners;
    }

    @Override
    public Result run(BuildAction action, BuildTreeLifecycleController buildController) {
        for (BuildActionRunner runner : runners) {
            Result result = runner.run(action, buildController);

  ~Coordinator();

  /// Registers a runner, i.e. a unit of running threads which is usually a
  /// QueueRunner. It takes the ownership of runner to avoid lifecycle-related
  /// problems. Note, the coordinator would not start these threads; they are
  /// supposed to be in running state when they are registered here.
  Status RegisterRunner(std::unique_ptr<RunnerInterface> runner);

import org.gradle.api.internal.tasks.testing.TestSuiteExecutionException;
import org.junit.internal.runners.JUnit38ClassRunner;
import org.junit.runner.Description;
import org.junit.runner.Request;
import org.junit.runner.RunWith;
import org.junit.runner.Runner;
import org.junit.runners.AllTests;

import java.util.List;

public class IgnoredTestDescriptorProvider {

import org.junit.internal.builders.AllDefaultPossibilitiesBuilder;
import org.junit.internal.builders.IgnoredBuilder;
import org.junit.internal.builders.JUnit4Builder;
import org.junit.runner.Runner;
import org.junit.runners.BlockJUnit4ClassRunner;
import org.junit.runners.model.RunnerBuilder;
import org.slf4j.LoggerFactory;

import java.lang.reflect.Constructor;

public class AllExceptIgnoredTestRunnerBuilder extends AllDefaultPossibilitiesBuilder {

import org.junit.Ignore
import org.junit.Test
import org.junit.internal.runners.InitializationError
import org.junit.internal.runners.JUnit38ClassRunner
import org.junit.internal.runners.JUnit4ClassRunner
import org.junit.internal.runners.SuiteMethod
import org.junit.runner.Description
import org.junit.runner.RunWith
import org.junit.runner.Runner
import org.junit.runner.notification.RunNotifier
import spock.lang.Specification

    def "creates runner before tests"() {
        Assume.assumeTrue(supportsBlockJUnit4ClassRunner)

        given:
        file('src/test/java/org/gradle/CustomRunner.java') << """
            package org.gradle;

            import java.lang.reflect.Method;
            import org.junit.runner.notification.RunNotifier;
            import org.junit.runners.BlockJUnit4ClassRunner;

        """.stripIndent()
    }

    @Issue('https://github.com/gradle/gradle/issues/2319')
    def 'can run tests in Enclosed runner'() {
        given:
        file('src/test/java/EnclosedTest.java') << """
            ${testFrameworkImports}
            import org.junit.experimental.runners.Enclosed;

            @RunWith( Enclosed.class )
            public class EnclosedTest {
                public static class InnerClass {

    void theParameterizedFiles() {
        file("src/test/java/ParameterizedFoo.java") << """
            ${testFrameworkImports}
            import org.junit.runners.Parameterized;
            import org.junit.runners.Parameterized.Parameters;
            import org.junit.runner.RunWith;
            import java.util.Arrays;
            import java.util.Collection;

            @RunWith(Parameterized.class)

import org.gradle.test.fixtures.file.TestDirectoryProvider;
import org.gradle.test.fixtures.file.TestFile;
import org.gradle.util.internal.Resources;
import org.junit.rules.MethodRule;
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.Statement;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Arrays;
import java.util.Collection;

/**