// function literal that calls t.Parallel.
//
// In practice, users rely on the fact that statements before the call to
// t.Parallel are synchronous. For example by declaring test := test inside the
// function literal, but before the call to t.Parallel.
//
// Therefore, we only flag references in statements that are obviously
// dominated by a call to t.Parallel. As a simple heuristic, we only consider

	"strings"
	"testing"
)

var testPanicTest = flag.String("test_panic_test", "", "TestPanic: indicates which test should panic")
var testPanicParallel = flag.Bool("test_panic_parallel", false, "TestPanic: run subtests in parallel")
var testPanicCleanup = flag.Bool("test_panic_cleanup", false, "TestPanic: indicates whether test should call Cleanup")

        args("--max-workers=4", "--parallel")
        succeeds("dependsOnWorkTask", "slowTask")

        assert endTime(":workTask").isBefore(endTime(":slowTask"))
    }

    @Requires(
        value = IntegTestPreconditions.NotConfigCached,
        reason = """Assumptions about project locking do not hold.
With CC enabled, the project is immutable so tasks run in parallel.

	"internal/testenv"
	"os"
	"os/exec"
	"runtime"
	"strconv"
	"strings"
	"testing"
	"time"
)

func TestCgoCrashHandler(t *testing.T) {
	t.Parallel()
	testCrashHandler(t, true)
}

func TestCgoSignalDeadlock(t *testing.T) {
	// Don't call t.Parallel, since too much work going on at the
	// same time can cause the testprogcgo code to overrun its
	// timeouts (issue #18598).

<% if (binding.hasVariable("daemonMemory")) { %>org.gradle.jvmargs=-Xms${binding.getVariable("daemonMemory")} -Xmx${binding.getVariable("daemonMemory")}<% } %>
<% if (binding.hasVariable("parallel")) { %>org.gradle.parallel=true<% } %>
<% if (binding.hasVariable("maxWorkers")) { %>org.gradle.workers.max=${binding.getVariable("maxWorkers")}<% } %>
compilerMemory=<% if (binding.hasVariable("compilerMemory")) { %>${binding.getVariable("compilerMemory")}<% } else { %>1g<% } %>

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

[[sec:parallel_execution]]
== Parallel projects

Gradle's parallel execution feature optimizes CPU utilization to accelerate builds by concurrently executing tasks from different projects.

    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)

	// We expect to see one "--- FAIL" line at the start
	// of the log, five lines of "parallel" logging,
	// and a final "FAIL" line at the end of the test.
	const wantLines = 7

	if len(lines) != wantLines {
		t.Fatalf("parallelTestHelper gave %d lines of output; want %d", len(lines), wantLines)
	}
	want := "helperfuncs_test.go:24: parallel"
	if got := strings.TrimSpace(lines[1]); got != want {