@Rule
    BlockingHttpServer server = new BlockingHttpServer()

    def setup() {
        executer.withConsole(ConsoleOutput.Rich)
        executer.withArguments('--parallel', "--max-workers=$MAX_WORKERS")
        server.start()
    }

    def "omits parallel test execution if TestNG version does not emit class listener events"() {
        given:
        buildFile << """
            plugins {
                id 'java-library'

// A hard-to-spot variant of this form is common in parallel tests:
//
//	func Test(t *testing.T) {
//	    for _, test := range tests {
//	        t.Run(test.name, func(t *testing.T) {
//	            t.Parallel()
//	            use(test) // incorrect, and a data race
//	        })
//	    }
//	}
//
// The t.Parallel() call causes the rest of the function to execute
// concurrent with the loop [<go1.22].

         """
    }

    def "link task is executed in parallel"() {
        createTaskThatRunsInParallelUsingCustomToolchainWith("linkDebug")

        when:
        succeeds "assemble", "parallelTask"

        then:
        assertTaskIsParallel("linkDebug")
    }

    def "compile task is executed in parallel"() {
        createTaskThatRunsInParallelUsingCustomToolchainWith("compileDebugSwift")

        file("suite.xml") << """<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite name="AwesomeSuite" parallel="tests" thread-count="${threadCount}">
  $suiteXml
</suite>"""
    }

    @Issue("GRADLE-3190")
    def "runs with multiple parallel threads"() {
        given:
        createTests(200, 20)

        when:
        run("test")

        then:

		os.Exit(1)
	}
	fmt.Println(pwd)
}

func TestCredentialNoSetGroups(t *testing.T) {
	if runtime.GOOS == "android" {
		maySkipHelperCommand("echo")
		t.Skip("unsupported on Android")
	}
	t.Parallel()

	u, err := user.Current()
	if err != nil {
		t.Fatalf("error getting current user: %v", err)
	}

	uid, err := strconv.Atoi(u.Uid)
	if err != nil {

	}
	// The msan tests require support for the -msan option.
	if !compilerRequiredTsanVersion(goos, goarch) {
		t.Skipf("skipping on %s/%s; compiler version for -tsan option is too old.", goos, goarch)
	}

	t.Parallel()
	requireOvercommit(t)
	config := configure("thread")
	config.skipIfCSanitizerBroken(t)

	mustRun(t, config.goCmd("build", "std"))

	cases := []struct {
		src          string
		needsRuntime bool
	}{

                <artifactId>maven-surefire-plugin</artifactId>
                <!--<version>2.5</version>-->
                <!--<configuration>-->
                    <!--<parallel>classes</parallel>-->
                    <!--<threadCount>4</threadCount>-->
                <!--</configuration>-->
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>

# tests seed values and the worker tests mutated values on the fuzz target.

[short] skip
env GOCACHE=$WORK/cache

go test -fuzz=FuzzA -fuzztime=100x -parallel=1 -log=fuzz
go run check_logs.go fuzz fuzz.worker

# TODO(b/181800488): remove -parallel=1, here and below. For now, when a
# crash is found, all workers keep running, wasting resources and reducing
# the number of executions available to the minimizer, increasing flakiness.

    def "can execute compile windows resource tasks in parallel"() {
        given:
        withComponentsForAppAndSharedLib()
        createTaskThatRunsInParallelUsingCustomToolchainWith("compileMainLibSharedLibraryMainLibRc")
        buildFile << """
            // prevent windows resource and cpp compile tasks from running in parallel
            // this is because we don't want the cpp compile tasks to accidentally use 

	t.Run("overview", func(t *testing.T) {
		t.Parallel()

		time.Sleep(1 * time.Millisecond) // Give the other handlers time to race.

		resp, err := http.Get(srv.URL)
		if err == nil {
			io.Copy(io.Discard, resp.Body)
			resp.Body.Close()
		} else {
			t.Error(err)
		}
	})

	t.Cleanup(func() {
		// The subtests spawned by WalkDir run in parallel. When they complete, this