import ${ExecOperations.name};
            import ${Inject.name};
            import ${Plugin.name};
            import ${Project.name};
            ${snippets.imports}

            public abstract class SneakyPlugin implements Plugin<Project> {
                @Inject
                protected abstract ExecOperations getExecOperations();

                @Override

plugins {
    id 'java-base'
}


abstract class TaskThatRequiresJavaExecutable extends DefaultTask {

    @Internal
    abstract RegularFileProperty getJavaExecutable()

    @Inject
    protected abstract ExecOperations getExecOps()

    @TaskAction
    void action() {
        def outputBytes = new ByteArrayOutputStream()
        execOps.exec {
            executable = javaExecutable.get().asFile.absolutePath

// tag::value-source[]
abstract class GitVersionValueSource implements ValueSource<String, ValueSourceParameters.None> {
    @Inject
    abstract ExecOperations getExecOperations()

    String obtain() {
        ByteArrayOutputStream output = new ByteArrayOutputStream()
        execOperations.exec {
            it.commandLine "git", "--version"
            it.standardOutput = output
        }

}


abstract class TaskThatRequiresJavaExecutable : DefaultTask() {

    @get:Internal
    abstract val javaExecutable: RegularFileProperty

    @get:Inject
    protected abstract val execOps: ExecOperations

    @TaskAction
    fun action() {
        val outputBytes = ByteArrayOutputStream()
        execOps.exec {
            executable = javaExecutable.get().asFile.absolutePath
            args = listOf("-version")

                        args "hello", "world"
                    }
                }
            }

            task runWithExecOperations {
                dependsOn jar
                def execOps = services.get(ExecOperations)
                def cp = files(jar)
                doLast {
                    execOps.javaexec {
                        classpath = cp
                        args "hello", "world"
                    }

    interface Params : BuildServiceParameters {
        val rootProjectDir: DirectoryProperty
    }

    @get:Inject
    abstract val execOperations: ExecOperations

    private
    val suspiciousDaemons = ConcurrentHashMap<String, MutableSet<String>>()

    private
    val daemonPids = ConcurrentHashMap.newKeySet<String>()

    private

import org.gradle.api.Action;
import org.gradle.api.internal.ProcessOperations;
import org.gradle.process.ExecOperations;
import org.gradle.process.ExecResult;
import org.gradle.process.ExecSpec;
import org.gradle.process.JavaExecSpec;


public class DefaultExecOperations implements ExecOperations {

    private final ProcessOperations processOperations;

        return new TransformFixture(
            """
            import ${Inject.name};
            import ${ExecOperations.name};
            ${snippets.imports}
            """,

            """
            @Inject
            public abstract ExecOperations getExecOperations();
            """,

            snippets.body
        )
    }

import org.gradle.api.model.ObjectFactory
import org.gradle.api.provider.ProviderFactory
import org.gradle.integtests.fixtures.AbstractIntegrationSpec
import org.gradle.internal.execution.ExecutionEngine
import org.gradle.process.ExecOperations

import javax.inject.Inject

class PluginServiceInjectionIntegrationTest extends AbstractIntegrationSpec {

    def "can apply a plugin with @Inject services constructor arg"() {
        buildFile """

     * If you need to make the action visible to the DSL, use {@link org.gradle.process.ExecOperations} instead.
     */
    ExecAction newExecAction();

    /**
     * Creates a {@link JavaExecAction} that is not decorated. Use this when the action is not made visible to the DSL.
     * If you need to make the action visible to the DSL, use {@link org.gradle.process.ExecOperations} instead.
     */
    JavaExecAction newJavaExecAction();