};
            gccToolChain.getCppCompiler().withArguments(m32args);
            gccToolChain.getcCompiler().withArguments(m32args);
            gccToolChain.getObjcCompiler().withArguments(m32args);
            gccToolChain.getObjcppCompiler().withArguments(m32args);
            gccToolChain.getLinker().withArguments(m32args);
            gccToolChain.getAssembler().withArguments(m32args);

        }
    }

    def "TestLauncher configuration ignored when configuration cache entry is reused in older Gradle versions"() {
        when:
        launchTests { TestLauncher launcher ->
            launcher.withArguments("--configuration-cache")
            launcher.withTestsFor { TestSpecs specs ->
                specs.forTaskPath(':secondTest').includePackage('example2')
            }
        }

        then:

        dependsOn gradle.includedBuild('buildC').task(':succeeds')
        dependsOn gradle.includedBuild('buildB').task(':succeeds')
    }
"""
        executer.withArguments(CONTINUE_COMMAND_LINE_OPTION)
        fails(buildA, ":delegate")

        then:
        failure.assertHasFailures(1)
        assertTaskExecutedOnce(":buildB", ":fails")

                .withProjectDir(testProjectDir)
                .withArguments(task, '--stacktrace')
                .withPluginClasspath()
                .build()
    }

    def runTaskWithFailure(String task) {
        return GradleRunner.create()
                .withProjectDir(testProjectDir)
                .withArguments(task, '--stacktrace')
                .withPluginClasspath()
                .buildAndFail()

    def "null or empty arguments have the same meaning"() {
        when:
        op.withArguments(null as List)

        then:
        op.consumerOperationParameters.arguments == null

        when:
        op.withArguments([])

        then:
        op.consumerOperationParameters.arguments == null

        when:
        op.withArguments()

        then:
        op.consumerOperationParameters.arguments == null

        def build1 = executer.withStackTraceChecksDisabled().withArguments("-d").withTasks("lock").start()
        def build2 = executer.withStackTraceChecksDisabled().withArguments("-d").withTasks("lock").start()
        def build3 = executer.withStackTraceChecksDisabled().withArguments("-d").withTasks("lock").start()
        poll(120) {
            assert requestReceived

        buildFile << """
            plugins.apply(my.MyPlugin)
        """
        file("a/build.gradle") << """
            plugins.apply(my.MyPlugin)
        """

        when:
        executer.withArguments(ENABLE_CLI)
        def models = runPhasedBuildAction(new FetchPartialCustomModelForEachProject(), new FetchCustomModelForEachProject())

        then:
        def messages = models.left
        messages.size() == 2

        then:
        def previousJavaHome = getPrintedJavaHome(result)
        previousJavaHome.startsWith(jdkDir)

        and:
        jdkRepository.expectHead()

        when:

                .withProjectDir(testProjectDir)
                .withArguments(task, '--stacktrace')
                .withPluginClasspath()
                .build()
    }

    def runTaskWithFailure(String task) {
        return GradleRunner.create()
                .withProjectDir(testProjectDir)
                .withArguments(task, '--stacktrace')
                .withPluginClasspath()
                .buildAndFail()

        given:
        server.expect("configure-root")
        server.expectConcurrent("model-root", "configure-a", "configure-b")
        server.expectConcurrent("model-a", "model-b")

        when:
        executer.withArguments(ENABLE_CLI)
        def model = runBuildAction(new FetchCustomModelForEachProjectInParallel())

        then:
        model.size() == 3
        model[0].message == "It works from project :"