where:
        isolationMode << ISOLATION_MODES
    }

    def "workers can inject ExecOperations service and use javaexec with #isolationMode isolation"() {
        withTestMainParametersAndServices()

        fixture.workActionThatCreatesFiles.action += """
            execOperations.javaexec {
                executable org.gradle.internal.jvm.Jvm.current().getJavaExecutable()
                classpath(parameters.classpath)

    TestFile mainJavaFile

    @Override
    protected void makeExecProject() {
        buildFile.text = """
            plugins {
                id("java")
            }

            task run(type: JavaExec) {
                classpath = project.layout.files(compileJava)
                mainClass = "driver.Driver"
                args "1"
            }
        """
    }

    @Override

    ) {
        fileOperations.delete {
           it.delete(reportDir)
        }
        ByteArrayOutputStream output = new ByteArrayOutputStream()

        ExecResult result = execOperations.javaexec(new Action<JavaExecSpec>() {
            void execute(JavaExecSpec spec) {
                spec.getMainClass().set(reportGeneratorClass)
                spec.args(reportDir.path, projectName)

            task runTask(type: JavaExec) {
                args = [ "help", file("test-project"), requestedGradleVersion, requestedTargetJdk, gradle.gradleUserHomeDir, ignoreFlakyDaemonConnections ]
            }

            task buildAction(type: JavaExec) {

plugins {
    id("gradlebuild.distribution.api-java")
}

description = "Source for JavaCompile, JavaExec and Javadoc tasks, it also contains logic for incremental Java compilation"

errorprone {
    disabledChecks.addAll(
        "CheckReturnValue", // 2 occurrences
        "DoNotClaimAnnotations", // 6 occurrences
        "InconsistentCapitalization", // 1 occurrences
        "InvalidInlineTag", // 3 occurrences

            return delegate.delete(action)
        }

        override fun javaexec(closure: Closure<*>): ExecResult {
            onAccess("javaexec")
            return delegate.javaexec(closure)
        }

        override fun javaexec(action: Action<in JavaExecSpec>): ExecResult {
            onAccess("javaexec")
            return delegate.javaexec(action)
        }

            </tr>
            <tr>
                <td>copySpec</td>
            </tr>
            <tr>
                <td>sync</td>
            </tr>
            <tr>
                <td>javaexec</td>
            </tr>
            <tr>
                <td>exec</td>
            </tr>
            <tr>
                <td>setProperty</td>
            </tr>
            <tr>

                File outFile = fvd.relativePath.replaceLastName(newFileName).getFile(destDir)
                outFile.parentFile.mkdirs()

                execOps.javaexec {
                    mainClass.set(XslTransformer.name)
                    args stylesheetFile.absolutePath
                    args fvd.file.absolutePath
                    args outFile.absolutePath

        // that the JVM installation detection is cached during a build
        def configureJavaExecToUseToolchains =
            """
            apply plugin: 'jvm-toolchains'
            tasks.register('exec', JavaExec) {
                javaLauncher.set(javaToolchains.launcherFor {
                    languageVersion = JavaLanguageVersion.of(${existingJdk.javaVersion.majorVersion})
                })
                mainClass.set("None")

import org.gradle.api.plugins.jvm.internal.JvmFeatureInternal;
import org.gradle.api.provider.Provider;
import org.gradle.api.provider.ProviderFactory;
import org.gradle.api.tasks.JavaExec;
import org.gradle.api.tasks.Sync;
import org.gradle.api.tasks.TaskContainer;
import org.gradle.api.tasks.TaskProvider;
import org.gradle.api.tasks.application.CreateStartScripts;
import org.gradle.api.tasks.bundling.Jar;