given:
        int testCount = maxConcurrency * 2
        println "Max-concurrency: $maxConcurrency"
        println "Test-count: $testCount"

        and:
        withBlockingJUnitTests(testCount)
        buildFile << """
            test {
                maxParallelForks = $maxParallelForks
                forkEvery = $forkEvery
            }

        this.scanForTestClasses = scanForTestClasses;
        this.testClassesDirs = testClassesDirs;
        this.path = path;
        this.identityPath = identityPath;
        this.forkEvery = forkEvery;
        this.javaForkOptions = javaForkOptions;
        this.maxParallelForks = maxParallelForks;
        this.previousFailedTestClasses = previousFailedTestClasses;
        this.testIsModule = testIsModule;
    }

    ) {
        this.usingJUnitPlatform = usingJUnitPlatform;
        this.forkEvery = forkEvery;
        this.isDryRun = isDryRun;
        this.filters = filters;
        this.forkOptions = forkOptions;
        this.candidateClassFiles = candidateClassFiles;
        this.inputFileProperties = inputFileProperties;
        this.outputFileProperties = outputFileProperties;
    }

    @Override

     */
    public void setForkEvery(long forkEvery) {
        if (forkEvery < 0) {
            throw new IllegalArgumentException("Cannot set forkEvery to a value less than 0.");
        }
        this.forkEvery = forkEvery;
    }

    /**
     * Sets the maximum number of test classes to execute in a forked test process.
     * <p>

        return """
            apply plugin: 'java'

            ${RepoScriptBlockUtil.mavenCentralRepository()}

            dependencies {
                $testFrameworkDependencies
            }

            tasks.withType(Test) {
                maxParallelForks = $maxWorkers
                forkEvery = $forkEvery
            }

        '--fail-fast'     | ['test', '--fail-fast']    | ''
    }

    def "ensure fail fast with forkEvery #forkEvery, maxWorkers #maxWorkers, omittedTests #testOmitted"() {
        given:
        buildFile.text = generator.initBuildFile(maxWorkers, forkEvery)
        def resourceForTest = generator.withFailingTests(testOmitted + 1)

// end::parallel-4[]

// tag::parallel-calculated[]
    maxParallelForks = (Runtime.getRuntime().availableProcessors() / 2).coerceAtLeast(1)
// end::parallel-calculated[]

// tag::fork-every[]
    forkEvery = 100
// end::fork-every[]

// tag::disable-reports[]
    reports.html.required = false
    reports.junitXml.required = false
// end::disable-reports[]

// tag::parallel-4[]
// tag::parallel-calculated[]

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

// tag::parallel-calculated[]
    maxParallelForks = Runtime.runtime.availableProcessors().intdiv(2) ?: 1
// end::parallel-calculated[]

// tag::fork-every[]
    forkEvery = 100
// end::fork-every[]

// tag::disable-reports[]
    reports.html.required = false
    reports.junitXml.required = false
// end::disable-reports[]

// tag::parallel-4[]
// tag::parallel-calculated[]

        buildFile << """
            tasks.withType(Test).configureEach {
                forkEvery = null
            }
        """

        when:
        executer.expectDocumentedDeprecationWarning("Setting Test.forkEvery to null. This behavior has been deprecated. " +
            "This will fail with an error in Gradle 9.0. Set Test.forkEvery to 0 instead. " +

    options.forkOptions.memoryMaximumSize=compilerMemory
}
tasks.withType(Test) {
    minHeapSize = testRunnerMemory
    maxHeapSize = testRunnerMemory
    maxParallelForks = 4
    forkEvery = testForkEvery
}

<% if (groovyProject) { %>
apply plugin: 'groovy'
dependencies {
    implementation 'org.codehaus:groovy:groovy-all:2.4.15'
}
<% } %>

<% if (scalaProject) { %>