.withObjectFactory(TestUtil.objectFactory())
            .build()

    def javaexec() {
        File testFile = tmpDir.file("someFile")
        List files = ClasspathUtil.getClasspath(getClass().classLoader).asFiles

        when:
        ExecResult result = factory.javaexec { spec ->
            spec.classpath(files as Object[])
            spec.mainClass = SomeMain.name

    def 'Jvm arguments are empty by default'() {
        when:
        def task = project.tasks.create("run", JavaExec)

        then:
        task.jvmArgs != null
        task.jvmArgs.isEmpty()
    }

    def 'fails if custom executable does not exist'() {
        def task = project.tasks.create("run", JavaExec)
        def invalidExecutable = temporaryFolder.file("invalid")

        when:

Method <org.gradle.api.tasks.JavaExec.getCommandLine()> does not have raw return type assignable to org.gradle.api.provider.Provider in (JavaExec.java:0)
Method <org.gradle.api.tasks.JavaExec.getDebug()> does not have raw return type assignable to org.gradle.api.provider.Property in (JavaExec.java:0)
Method <org.gradle.api.tasks.JavaExec.getDebugOptions()> does not have raw return type assignable to org.gradle.api.provider.Provider in (JavaExec.java:0)

        exec().groovy               | "exec.init.gradle"
        javaexec().groovy           | "exec.init.gradle"
        processBuilder().groovy     | "exec.init.gradle"
        stringArrayExecute().groovy | "exec.init.gradle"
        runtimeExec().groovy        | "exec.init.gradle"
        exec().kotlin               | "exec.init.gradle.kts"
        javaexec().kotlin           | "exec.init.gradle.kts"

class JacocoPluginSpec extends AbstractProjectBuilderSpec {
    def setup() {
        project.apply plugin: 'jacoco'
    }

    def 'jacoco applied to specific JavaExec task'() {
        given:
        JavaExec task = project.tasks.create('exec', JavaExec)
        when:
        project.jacoco.applyTo(task)
        then:
        task.extensions.getByType(JacocoTaskExtension) != null
    }

import org.gradle.process.ExecOperations

import javax.inject.Inject

import static org.gradle.internal.cc.impl.fixtures.ExternalProcessFixture.exec
import static org.gradle.internal.cc.impl.fixtures.ExternalProcessFixture.javaexec
import static org.gradle.internal.cc.impl.fixtures.ExternalProcessFixture.processBuilder

class ProcessInTransformIntegrationTest extends AbstractProcessIntegrationTest {

            ''')
        }
            execInjectedTaskAction.execClasspath.from(project.sourceSets['main'].runtimeClasspath)

            // JavaExec

            task javaexecTask(type: JavaExec) {
                def testFile = file("${'$'}buildDir/${'$'}name")
                classpath(sourceSets.main.output.classesDirs)
                mainClass = 'org.gradle.TestMain'

by executing the `run` task (type: link:{javadocPath}/org/gradle/api/tasks/JavaExec.html[JavaExec]). This will compile the main source set, and launch a new JVM with its classes (along with all runtime dependencies) as the classpath and using the specified main class. You can launch the application in debug mode with `gradle run --debug-jvm` (see link:{javadocPath}/org/gradle/api/tasks/JavaExec.html#setDebug-boolean-[JavaExec.setDebug(boolean)]).

Since Gradle 4.9, the command line arguments...

    @Override
    public ExecResult exec(Action<? super ExecSpec> action) {
        return processOperations.exec(action);
    }

    @Override
    public ExecResult javaexec(Action<? super JavaExecSpec> action) {
        return processOperations.javaexec(action);
    }

        javaexec().groovy           | "included/settings.gradle"
        processBuilder().groovy     | "included/settings.gradle"
        stringArrayExecute().groovy | "included/settings.gradle"
        runtimeExec().groovy        | "included/settings.gradle"
        exec().kotlin               | "included/settings.gradle.kts"
        javaexec().kotlin           | "included/settings.gradle.kts"