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

                    }
                }
            }
        """

        when:
        server.expectConcurrent("log1", "log2", "log3")
        executer.withArgument("--parallel")
        // run build in another process to avoid interference from logging from test fixtures
        result = executer.withTasks("log").start().waitForFinish()

        then:
        result.groupedOutput.taskCount == 3

        when:
        def properties = properties("-Dorg.gradle.parallel=true")
        def layout = layout(properties)
        gradleHome.file("gradle.properties") << "org.gradle.workers.max=12"
        def result = converter.convert(properties, layout)
        result = result.merge(["org.gradle.workers.max": "4", "org.gradle.parallel": "false"])

        then:

# had an execution limit, causing it to deadlock and sit in the coordinator
# loop indefinitely, failing to exit once the limit had been exhausted.

go test -fuzz=FuzzA -fuzztime=100x -parallel=1

-- go.mod --
module m

go 1.16
-- fuzz_test.go --
package fuzz_test

import (
	"fmt"
	"testing"
)

func FuzzA(f *testing.F) {
	f.Add([]byte("seed"))
	i := 0

// license that can be found in the LICENSE file.

//go:build unix

package exec_test

import (
	"os"
	"os/exec"
	"testing"
)

func TestLookPathUnixEmptyPath(t *testing.T) {
	// Not parallel: uses Chdir and Setenv.

	tmp := t.TempDir()
	chdir(t, tmp)

	f, err := os.OpenFile("exec_me", os.O_CREATE|os.O_EXCL, 0700)
	if err != nil {
		t.Fatal("OpenFile failed: ", err)
	}
	err = f.Close()

import (
	"fmt"
	"internal/testenv"
	"os"
	"path/filepath"
	"runtime"
	"testing"
)

const executable_EnvVar = "OSTEST_OUTPUT_EXECPATH"

func TestExecutable(t *testing.T) {
	testenv.MustHaveExec(t)
	t.Parallel()

	ep, err := os.Executable()
	if err != nil {
		t.Fatalf("Executable failed: %v", err)
	}
	// we want fn to be of the form "dir/prog"
	dir := filepath.Dir(filepath.Dir(ep))
	fn, err := filepath.Rel(dir, ep)

package gradlebuild.basics.testing

import org.gradle.api.tasks.testing.Test


enum class TestType(val prefix: String, val executers: List<String>) {
    INTEGRATION("integ", listOf("embedded", "forking", "noDaemon", "parallel", "configCache", "isolatedProjects")),
    CROSSVERSION("crossVersion", listOf("embedded", "forking"))
}


fun Test.includeSpockAnnotation(fqcn: String) {

	defer sl.Stop()

	select {
	case <-sl.C:
	case <-ctx.Done():
		return ctx.Err()
	}

	return nil
}

func TestCacheCtx(t *testing.T) {
	cache := New[time.Time]()
	t.Parallel()
	cache.InitOnce(2*time.Second, Opts{},
		func(ctx context.Context) (time.Time, error) {
			return time.Now(), slowCaller(ctx)
		},
	)

	ctx, cancel := context.WithCancel(context.Background())

        when:
        args "--parallel"
        succeeds 'clean', 'build'

        then:
        result.assertTaskOrder(
            any(
                exact(':a:clean', ':a:compileJava'),
                exact(':b:clean', ':b:compileJava'),
                exact(':a:compileJava', ':b:compileJava')
            )
        )

        when:
        args "--parallel"
        succeeds 'build', 'clean'

        when:
        fails("check")

        then:
        failure.assertHasDescription("Background job failed!")
    }

    def "background jobs can run in parallel with tasks on #numWorkers workers"(int numWorkers) {
        httpServer.start()

        given:
        buildFile << """
            def executors = $executors

            task check {