import org.junit.Rule

@Requires(IntegTestPreconditions.NotParallelExecutor)
// no point, always runs in parallel
class ParallelDependencyResolutionIntegrationTest extends AbstractHttpDependencyResolutionTest {
    @Rule BlockingHttpServer blockingServer = new BlockingHttpServer()

    def setup() {
        executer.withArgument('--parallel')

	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:

        return workerLeaseService(true, maxWorkers)
    }

    WorkerLeaseService workerLeaseService(boolean parallel, int maxWorkers = 1) {
        def service = new DefaultWorkerLeaseService(coordinationService, new DefaultWorkerLimits(maxWorkers))
        service.startProjectExecution(parallel)
        return service
    }

    TestTrackedResourceLock resourceLock(String displayName, boolean locked, boolean hasLock = false) {