@Scenario(type = PER_COMMIT, operatingSystems = LINUX, testProjects = ["largeJavaMultiProject", "largeMonolithicJavaProject"], iterationMatcher = '.*parallel false.*'),
    ])
    def "up-to-date assemble (parallel #parallel)"() {
        given:
        runner.tasksToRun = ['assemble']
        runner.args += ["-Dorg.gradle.parallel=$parallel"]

        when:

)
class ParallelBuildPerformanceTest extends AbstractCrossBuildPerformanceTest {

    def "clean assemble with 4 parallel workers"() {
        given:
        runner.testGroup = "parallel builds"
        runner.buildSpec {
            displayName("parallel")
            invocation {
                args("-Dorg.gradle.parallel=true", "--max-workers=4")
            }
        }
        runner.baseline {
            displayName("serial")

		if got := recover(); got != want {
			t.Fatalf("expected panic; got %#v want %q", got, want)
		}
	}()

	t.Parallel()

	t.Setenv("GO_TEST_KEY_1", "value")
}

func TestSetenvWithParallelParentBeforeSetenv(t *testing.T) {
	t.Parallel()

	t.Run("child", func(t *testing.T) {
		defer func() {

# Run parallel chatty tests. Assert on CONT or NAME lines. This test makes sure that
# multiple parallel outputs have the appropriate CONT lines between them.
go test -parallel 3 chatty_parallel -v

stdout '=== RUN   TestInterruptor/interruption\n=== (CONT|NAME)  TestLog\n    chatty_parallel_test.go:28: this is the second TestLog log\n--- PASS: Test(Log|Interruptor) \([0-9.]{4}s\)'

-- go.mod --
module chatty_parallel

go 1.18
-- chatty_parallel_test.go --

    reason = "always runs in parallel, our mac currently lacks proper toolchain installations")
abstract class AbstractNativeSoftwareModelParallelIntegrationTest extends AbstractNativeParallelIntegrationTest {
    abstract HelloWorldApp getApp()

    @ToBeFixedForConfigurationCache
    def "can execute link executable tasks in parallel"() {
        given:
        withComponentForApp()

	Run(fn func(t TestContext))
	// RunParallel runs this test in parallel with other children of the same parent test/suite. Under the hood,
	// this relies on Go's t.Parallel() and will, therefore, have the same behavior.
	//
	// A parallel test will run in parallel with siblings that share the same parent test. The parent test function
	// will exit before the parallel children are executed. It should be noted that if the parent test is prevented

        models.projects.path == [':', ':a', ':b']

        where:
        args << [
            ["--no-parallel"],
            ["--parallel", "-Dorg.gradle.internal.tooling.parallel=false"]
        ]
    }

    @TargetGradleVersion(">=3.4 <6.8")
    def "nested actions do not run in parallel when target Gradle version does not support it"() {
        given:
        setupBuildWithDependencyResolution()

                                                bool is_fetch_op) const;

  // Returns the parallel ids of the op.
  ParallelIdsMap GetParallelIdsMap(Operation* op);

  // Converts from read/write state that relates ops with the same parallel id
  // to a set of last accesses for use with other parallel ids. Reads/writes
  // between parallel ids are conservatively approximated as writes.

	t.Logf("LOG: %s", t.Name())
}

func TestParallelFailingA(t *testing.T) {
	t.Parallel()
	t.Errorf("FAIL - %s", t.Name())
}

func TestParallelFailingB(t *testing.T) {
	t.Parallel()
	t.Errorf("FAIL - %s", t.Name())
}

func TestParallelFailingSubtestsA(t *testing.T) {
	t.Parallel()
	t.Run("TestFailingSubtestsA1", func(t *testing.T) {
		t.Errorf("FAIL - %s", t.Name())
	})

            status, TF_INVALID_ARGUMENT,
            absl::StrCat(
                "Got a non-parallel tensor ",
                tensorflow::unwrap(absl::get<TFE_TensorHandle*>(input))
                    ->DebugString(),
                " as input to a parallel operation. First pack non-parallel "
                "tensors for each device into a parallel tensor explicitly.")
                .c_str());
        return absl::nullopt;
      }