message1: {
                    parallel.syncAt(1)
                    parallel.syncAt(2)
                },
                message3: { parallel.syncAt(3) })
        Dispatch<String> target2 = new DispatchStub(
                message2: {
                    parallel.syncAt(2)
                    parallel.syncAt(3)
                })

        when:
        parallel.run {
            dispatch.dispatchTo(target1)

plugins {
    id('java-library')
}

// tag::parallel-4[]
// tag::parallel-calculated[]
// tag::fork-every[]
// tag::disable-reports[]
tasks.withType(Test).configureEach {
// end::parallel-4[]
// end::parallel-calculated[]
// end::fork-every[]
// end::disable-reports[]

// tag::parallel-4[]
    maxParallelForks = 4
// end::parallel-4[]

// tag::parallel-calculated[]

    private SmokeTestGradleRunner newKotlinRunner(boolean parallel, VersionNumber kotlinVersion, List<String> tasks) {
        List<String> args = []

        // Parallel workers in Kotlin is enabled by Gradle's --parallel flag. See https://youtrack.jetbrains.com/issue/KT-46401/
        // For context on why we test with parallel workers see https://github.com/gradle/gradle/pull/10404
        if (parallel) {
            args = ["--parallel"]
        }

    }

    @Requires(value = IntegTestPreconditions.NotParallelExecutor, reason = """
Don't run in parallel mode, as the expectation for the setup build are incorrect
It could potentially be worth running this in parallel mode to demonstrate the difference between
parallel and configuration cache
""")
    def "runs tasks in same project in parallel by default"() {
        server.start()

        given:
        buildFile << """

plugins {
    id("java-library")
}

// tag::parallel-4[]
// tag::parallel-calculated[]
// tag::fork-every[]
// tag::disable-reports[]
tasks.withType<Test>().configureEach {
// end::parallel-4[]
// end::parallel-calculated[]
// end::fork-every[]
// end::disable-reports[]

// tag::parallel-4[]
    maxParallelForks = 4
// end::parallel-4[]

// tag::parallel-calculated[]

        @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")

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

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

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