}

    @Requires(value = IntegTestPreconditions.NotParallelExecutor, reason = """
Don't run in parallel mode, as the expectation for the setup build are incorrect
It could potentially be worth running this in parallel mode to demonstrate the difference between
parallel and configuration cache
""")
    def "runs tasks in same project in parallel by default"() {
        server.start()

        given:
        buildFile << """

        models.projects.path == [':', ':a', ':b']

        where:
        args << [
            ["--no-parallel"],
            ["--parallel", "-Dorg.gradle.internal.tooling.parallel=false"]
        ]
    }

    @TargetGradleVersion(">=3.4 <6.8")
    def "nested actions do not run in parallel when target Gradle version does not support it"() {
        given:
        setupBuildWithDependencyResolution()

        boolean groupByInstances,
        boolean isDryRun
    ) {
        this.filter = filter;
        this.defaultSuiteName = defaultSuiteName;
        this.defaultTestName = defaultTestName;
        this.parallel = parallel;
        this.threadCount = threadCount;
        this.suiteThreadPoolSize = suiteThreadPoolSize;
        this.useDefaultListener = useDefaultListener;
        this.threadPoolFactoryClass = threadPoolFactoryClass;

            includeGroups == source.includeGroups
            excludeGroups == source.excludeGroups
            configFailurePolicy == source.configFailurePolicy
            listeners == source.listeners
            parallel == source.parallel
            threadCount == source.threadCount
            suiteThreadPoolSize.get() == source.suiteThreadPoolSize.get()
            useDefaultListeners == source.useDefaultListeners

	}

	t.Run("simple add and remove", func(t *testing.T) {
		t.Parallel()
		p := NewPushQueue()
		defer p.ShutDown()
		p.Enqueue(proxies[0], &model.PushRequest{})
		p.Enqueue(proxies[1], &model.PushRequest{})

		ExpectDequeue(t, p, proxies[0])
		ExpectDequeue(t, p, proxies[1])
	})

	t.Run("remove too many", func(t *testing.T) {
		t.Parallel()
		p := NewPushQueue()
		defer p.ShutDown()

    VersionNumber kotlinPluginVersion

    def "kotlin android on android-kotlin-example using #dsl DSL (kotlin=#kotlinPluginVersion, agp=#androidPluginVersion, workers=#parallel)"(String kotlinPluginVersion, String androidPluginVersion, boolean parallel) {
        given:
        AndroidHome.assertIsSet()
        AGP_VERSIONS.assumeAgpSupportsCurrentJavaVersionAndKotlinVersion(androidPluginVersion, kotlinPluginVersion)

                    }
                }
            }
        """
    }

    @ToBeFixedForIsolatedProjects(because = "allprojects")
    def "tasks run in parallel when no max usages specified"() {
        given:
        withParallelThreads(2)

        buildFile << """
            def service = gradle.sharedServices.registerIfAbsent("exclusive", BuildService) {}

		t.Fatalf("Stat %q (looking for size %d): %s", path, size, err)
	}
	if dir.Size() != size {
		t.Errorf("Stat %q: size %d want %d", path, dir.Size(), size)
	}
}

func TestReadFile(t *testing.T) {
	t.Parallel()

	filename := "rumpelstilzchen"
	contents, err := ReadFile(filename)
	if err == nil {
		t.Fatalf("ReadFile %s: error expected, none found", filename)
	}

	filename = "read_test.go"

//          which represents the first branch of replicate group 0 and
//          the first branch of parallel group 0.
// Second instance of "tf.OpC" after flattening will have
//          `_parallel_execution_ids = "r0:1,p0:0"`
//          which represents the second branch of replicate group 0 and
//          the first branch of parallel group 0.
// First instance of "tf.OpD" after flattening will have

        public static final String GRADLE_PROPERTY = "org.gradle.parallel";

        public ParallelOption() {
            super(GRADLE_PROPERTY, BooleanCommandLineOptionConfiguration.create("parallel", "Build projects in parallel. Gradle will attempt to determine the optimal number of executor threads to use.", "Disables parallel execution to build projects."));
        }

        @Override