newLevels().
		// Level 1: bf=20(parallel)
		Add(20, true).
		// Level 2: bf=5(parallel)
		Add(5, true).
		// Level 3: bf=2(parallel)
		Add(2, true).
		Build().
		Run(t)
}

func TestMix(t *testing.T) {
	// Root is always run sync.
	newLevels().
		// Level 1: bf=20(parallel)
		Add(20, true).
		// Level 2: bf=5(sync)
		Add(5, false).
		// Level 3: bf=2(parallel)
		Add(2, true).
		Build().
		Run(t)

@Requires(IntegTestPreconditions.NotParallelExecutor)
class EnablingParallelExecutionIntegrationTest extends AbstractIntegrationSpec {

    def "parallel mode enabled via gradle.properties"() {
        file("gradle.properties") << "org.gradle.parallel=true"
        buildFile << "assert gradle.startParameter.parallelProjectExecutionEnabled"
        expect:
        run()
    }

    }

    def "can enable parallel execution via --parallel property"() {
        given:
        buildScript """
            task writeValue {
                doLast {
                    file("out.txt").text = gradle.startParameter.parallelProjectExecutionEnabled
                }
            }
        """

        when:
        runner("writeValue", "--parallel")

                        ${server.callFromBuild("parallel-task-done")}
                    }
                }
            """
        }
        def numWorkers = (parallelTaskCount / 2) + 2 as int

        when:
        server.expectConcurrent(numWorkers, ["parallel-task-done"] * parallelTaskCount + ["before-interrupt"] as String[])

    }

    @ToBeFixedForConfigurationCache
    def "can execute assembler tasks in parallel"() {
        given:
        withComponentForApp()
        createTaskThatRunsInParallelUsingCustomToolchainWith("assembleMainExecutableMainAsm")
        buildFile << """
            // prevent assembly and c compile tasks from running in parallel
            // this is because we don't want the c compile tasks to accidentally use

    @RunFor([
        @Scenario(type = PER_DAY, operatingSystems = [LINUX], testProjects =  ['manyProjectsNative'])
    ])
    def "clean assemble (native, parallel)"() {
        given:
        runner.tasksToRun = ["assemble"]
        runner.cleanTasks = ["clean"]
        runner.args = ["--parallel", "--max-workers=12"]

        when:
        def result = runner.run()

        then:
        result.assertCurrentVersionHasNotRegressed()

 *
 * @since 6.8
 */
public interface InternalActionAwareBuildController {
    /**
     * Can the given project model be queried in parallel for this build?
     */
    boolean getCanQueryProjectModelInParallel(Class<?> modelType);

    /**
     * Runs the given actions in parallel and returns the results. The results should be returned in the same order as the actions that produce them.
     */

    }

    @Override
    TestJvmComponent getComponent() {
        return new TestScalaComponent()
    }

    @Requires(IntegTestPreconditions.NotParallelExecutor)
    @UnsupportedWithConfigurationCache(because = "parallel by default")
    def "reuses compiler daemons within a single project across multiple builds when enabled"() {
        withSingleProjectSources()
        withPersistentScalaCompilerDaemons()

        when:

    @Override
    protected ExecutionResult toExecutionFailure(String output, String error) {
        return new ParallelExecutionResult(output, error);
    }

    /**
     * Need a different output comparator for parallel execution.
     */
    private static class ParallelExecutionResult extends OutputScrapingExecutionFailure {
        public ParallelExecutionResult(String output, String error) {
            super(output, error, true);

It means that you have to pay attention to the value entered here and make sure it still makes sense in a multi project build.
This is because parallel Gradle task execution could result in different PMD tasks from different projects running in parallel.
If multiple PMD tasks execute simultaneously in n projects, then up to a maximum of (n * `thread`) PMD threads could run at the same time.