def "parallel #parallel execution with #threadCount threads, #maxWorkers workers fails fast"() {
        given:
        buildFile.text = generator.initBuildFile(maxWorkers)
        buildFile << """
            test {
                useTestNG() {
                    parallel = '$parallel'
                    threadCount = $threadCount
                }
            }

        msgs.add("*****************************************************************");
        msgs.add("* Your build is requesting parallel execution, but project      *");
        msgs.add("* contains the following plugin(s) that have goals not marked   *");
        msgs.add("* as @threadSafe to support parallel building.                  *");
        msgs.add("* While this /may/ work fine, please look for plugin updates    *");

        }

        when:
        executer.withArguments("--parallel", "--max-workers=2")
        run('test')

        then:
        noExceptionThrown()
    }

    // TODO:configuration-cache test currently flaky since cc might run tests in parallel
    @Requires(value = IntegTestPreconditions.NotConfigCached, reason = "cc might cause tests to run in parallel")

        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;

        then:
        succeeds('resolve', '--parallel', '--max-workers=4')

        when:
        // Wait for each project to list versions concurrently
        httpServer.expectConcurrent("A", "B", "C", "D")
        // Only one project should list versions
        repo.expectListVersions()

        then:
        succeeds('resolve', '--parallel', '--max-workers=4')
    }

<% if (binding.hasVariable("daemonMemory")) { %>org.gradle.jvmargs=-Xms${binding.getVariable("daemonMemory")} -Xmx${binding.getVariable("daemonMemory")}<% } %>
<% if (binding.hasVariable("parallel")) { %>org.gradle.parallel=true<% } %>

// two component devices, running `x = TPUReplicatedInput(inputs=[a, b])` on the
// parallel device creates a parallel tensor `x` with `a` on the first of
// `underlying_devices` and `b` on the second. Running `a_unpacked, b_unpacked =
// TPUReplicatedOutput(input=x, num_replicas=2)` un-packs the parallel tensor
// into its components.
//
// The filled `device` struct and the allocated `device_info` struct may be

        runner.args = ['-PuseHttp', "-PhttpPort=${serverPort}", "-Dorg.gradle.parallel=false"]

        when:
        def result = runner.run()

        then:
        result.assertCurrentVersionHasNotRegressed()

        cleanup:
        stopServer()
    }

    def "merge exclude rules (parallel)"() {
        startServer()

        given:
        runner.tasksToRun = ['resolveDependencies']

    }

    def "resolve large dependency graph (parallel = #parallel, locking = #locking)"() {
        startServer()

        given:
        runner.tasksToRun = ['resolveDependencies']
        runner.args = ['-PuseHttp', "-PhttpPort=${serverPort}", '-PnoExcludes']
        if (parallel) {
            runner.args += '--parallel'
        }
        if (locking) {
            runner.args += '-PuseLocking'

)

func TestCheckPtr(t *testing.T) {
	// This test requires rebuilding packages with -d=checkptr=1,
	// so it's somewhat slow.
	if testing.Short() {
		t.Skip("skipping test in -short mode")
	}

	t.Parallel()
	testenv.MustHaveGoRun(t)

	exe, err := buildTestProg(t, "testprog", "-gcflags=all=-d=checkptr=1")
	if err != nil {
		t.Fatal(err)
	}

	testCases := []struct {
		cmd  string
		want string
	}{