// Unit tests and fuzz tests work a little differently, so for now, these
// functions aren't consolidated. In particular, because there are no F.Run and
// F.Parallel methods, i.e., no fuzz sub-tests or parallel fuzz tests, a few
// simplifications are made. We also require that F.Fuzz, F.Skip, or F.Fail is
// called.
func fRunner(f *F, fn func(*F)) {

    /**
     * Returns an isolated listener for the registered actions, if any. The listener makes it impossible for
     * the actions to carry any shared mutable state across projects and can be safely executed in parallel.
     */
    @Nullable
    ProjectEvaluationListener isolateFor(Gradle owner);

    /**
     * Discards any registered actions. This doesn't affect any {@link #isolateFor(Gradle) previously returned isolated listeners}.

        then:
        failure.assertHasCause 'failure in c'

        and:
        jarsBuilt 'd'
        jarsNotBuilt 'a', 'b', 'c'
    }

    // 'c' + 'd' _may_ be built with parallel executer
    // test can't handle parallel task execution
    @Requires(IntegTestPreconditions.NotParallelOrConfigCacheExecutor)
    def "project dependency a->[b,c] and c->d and b fails"() {
        projectDependency from: 'a', to: ['b', 'c']

        if (!isRoot) {
            return null
        }
        """
        org.gradle.jvmargs=-Xms${config.daemonMemory} -Xmx${config.daemonMemory} -Dfile.encoding=UTF-8
        org.gradle.parallel=${config.parallel}
        org.gradle.workers.max=${config.maxWorkers}
        compilerMemory=${config.compilerMemory}
        testRunnerMemory=${config.testRunnerMemory}
        testForkEvery=${config.testForkEvery}

        then:
        customGradleUserHome.exists()
        project.gradle.startParameter.gradleUserHomeDir == customGradleUserHome
    }

    def "can be used in parallel"() {
        def threads = 5
        def startSignal = new CountDownLatch(1)
        def doneSignal = new CountDownLatch(threads)

        when:
        threads.times {
            new Thread({

Accessors for org.gradle.api.tasks.javadoc.Javadoc.maxMemory don't use symmetrical @Nullable
Accessors for org.gradle.api.tasks.testing.Test.forkEvery don't use symmetrical @Nullable
Accessors for org.gradle.api.tasks.testing.testng.TestNGOptions.parallel don't use symmetrical @Nullable
Accessors for org.gradle.caching.http.HttpBuildCache.url don't use symmetrical @Nullable

            buildOperationExecutor,
            "localhost")
        reportGenerator.xmlWriter = Mock(JUnitXmlResultWriter)
        return reportGenerator
    }

    def "writes results - #numThreads parallel thread(s)"() {
        generator = generatorWithMaxThreads(numThreads)

        def fooTest = new TestClassResult(1, 'FooTest', 100)
            .add(new TestMethodResult(1, "foo"))

== 5. `WorkerExecutor`

link:{javadocPath}/org/gradle/workers/WorkerExecutor.html[`WorkerExecutor`] is a service that allows you to perform parallel execution of tasks using worker processes.
This is particularly useful for tasks that perform CPU-intensive or long-running operations, as it allows them to be executed in parallel, improving build performance.

	{"gobuild7.input", "gobuild7.golden", idempotent},
}

func TestFiles(t *testing.T) {
	t.Parallel()
	for _, e := range data {
		source := filepath.Join(dataDir, e.source)
		golden := filepath.Join(dataDir, e.golden)
		mode := e.mode
		t.Run(e.source, func(t *testing.T) {
			t.Parallel()
			check(t, source, golden, mode)
			// TODO(gri) check that golden is idempotent

        # Wait for each of the parallel node upgrades to finish.
        for pid in "${pids[@]}"; do
          wait "$pid"
          ret_code_sum=$(( ret_code_sum + $? ))
        done
        # Return even if at least one of the node upgrades failed.
        if [[ ${ret_code_sum} != 0 ]]; then
          echo "== Some of the ${node_upgrade_parallelism} parallel node upgrades failed. =="
          return ${ret_code_sum}