executer.withBuildJvmOpts("-Dfile.encoding=CP1250")
        succeeds("javadoc")
        then:
        file("build/docs/javadoc/index.html").text.contains("<title>? ? ? ?</title>")
        file("build/tmp/javadoc/javadoc.options").text.contains("-windowtitle '? ? ? ?'")
        result.assertTaskNotSkipped(":javadoc")

        when:
        executer.withBuildJvmOpts("-Dfile.encoding=UTF-8")

            }
        """

        expect:
        for(int i = 0; i < 35; i++) {
            myTask.text = myTask.text.replace("runAction$i", "runAction${i + 1}")
            executer.withBuildJvmOpts("-Xmx256m", "-XX:+HeapDumpOnOutOfMemoryError")
            assert succeeds("myTask")
        }
    }

    def "old build script classloaders are collected"() {
        given:
        buildFile << """

        } else {
            executer.withBuildJvmOpts(args)
        }
    }

    void configureServerAndClientCerts(GradleExecuter executer) {
        def args = getServerAndClientCertArgs()
        if (GradleContextualExecuter.embedded) {
            args.each {
                executer.withArgument(it)
            }
        } else {
            executer.withBuildJvmOpts(args)
        }
    }

        executer.noExtraLogging()
        succeeds "help"

        then:
        outputContains(":help")
    }

    def "output is not received when toggle is on"() {
        when:
        executer.withBuildJvmOpts("-D$LogToClient.DISABLE_OUTPUT=true").noExtraLogging()
        succeeds "help"

        then:
        outputDoesNotContain(":help")
        outputDoesNotContain("BUILD SUCCESSFUL")
    }

        def build = executer.withTasks("block").start()
        block.waitForAllPendingCalls()

        daemons.daemon.assertBusy()
        executer.useOnlyRequestedJvmOpts()
        executer.withBuildJvmOpts('-Xmx128m')
        executer.run()

        when:
        def out = executer.withArguments("--status").run().normalizedOutput

        then:
        daemons.daemons.size() == 2

        executerForCacheInspection(*arguments).run()

    protected
    fun buildWithDaemonHeapSize(heapMb: Int, vararg arguments: String): ExecutionResult =
        executerForCacheInspection(*arguments)
            .withBuildJvmOpts("-Xms${heapMb}m", "-Xmx${heapMb}m")
            .run()

    private
    fun executerForCacheInspection(vararg arguments: String): GradleExecuter =
        gradleExecuterFor(
            arrayOf(

                }
            }
        """.stripIndent()

        when:
        executer
            .requireDaemon()
            .requireIsolatedDaemons()
            .withBuildJvmOpts("-Duser.language=tr", "-Duser.country=TR")
            .withTasks("help")
            .run()

        then:
        noExceptionThrown()
    }

        m2.allowAll()
        m3.pom.expectGetBroken()
        m4.allowAll()

        expect:
        //TODO: fix dependency resolution results usage in this test and remove this flag
        executer.withBuildJvmOpts("-Dorg.gradle.configuration-cache.internal.task-execution-access-pre-stable=true")

        if (expression == "getFirstLevelModuleDependencies { true }") {

                }
            }
        """

        when:
        //TODO this fails in CI (for unknown reasons) with project access checks based on configuration barrier
        executer.withBuildJvmOpts("-Dorg.gradle.configuration-cache.internal.task-execution-access-pre-stable=true")
        succeeds("sysHeaders")

        then:
        def dirs = outputFile.readLines()
        !dirs.empty

     *
     * @param jvmOpts the JVM opts
     * @return this executer
     */
    GradleExecuter withBuildJvmOpts(String... jvmOpts);

    /**
     * See {@link #withBuildJvmOpts(String...)}.
     */
    GradleExecuter withBuildJvmOpts(Iterable<String> jvmOpts);

    /**
     * Activates the build cache
     *
     * @return this executer
     */