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

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

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

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