*
 * @since 6.0
 */
@ServiceScope({Scope.Build.class, Scope.Project.class})
public interface ExecOperations {

    /**
     * Executes the specified external process.
     * The given action is used to configure an {@link ExecSpec}, which is then used to run an external process.
     *

            import ${DefaultTask.name};
            import ${ExecOperations.name};
            import ${Inject.name};
            import ${TaskAction.name};
            ${snippets.imports}

            public abstract class SneakyTask extends DefaultTask {
                @Inject
                protected abstract ExecOperations getExecOperations();

                public SneakyTask() {

        final ExecOperations execOperations
        interface Parameters extends ValueSourceParameters {
            ListProperty<String> getCommand()
        }

        @Inject
        ExecValueSource(ExecOperations execOperations) {
            this.execOperations = execOperations
        }

        @Override
        ExecResult obtain() {

// tag::exec-op-inject[]
abstract class MyExecOperationsTask extends DefaultTask {
    private ExecOperations execOperations

    @Inject //@javax.inject.Inject
    MyExecOperationsTask(ExecOperations execOperations) {
        this.execOperations = execOperations
    }

    @TaskAction
    void doTaskAction() {
        execOperations.exec {
            commandLine 'ls', '-la'
        }
    }
}

    def configurationTimeBarrier = Mock(ConfigurationTimeBarrier)
    def execOperations = Mock(ExecOperations)
    def valueSourceProviderFactory = new DefaultValueSourceProviderFactory(
        listenerManager,
        TestUtil.instantiatorFactory(),
        isolatableFactory,
        Mock(GradleProperties),
        TestUtil.calculatedValueContainerFactory(),
        execOperations,
        TestUtil.services()
    )

import org.gradle.api.services.BuildService
import org.gradle.api.services.BuildServiceParameters
import org.gradle.process.ExecOperations
import java.util.Timer
import javax.inject.Inject
import kotlin.concurrent.timerTask


abstract class PrintStackTracesOnTimeoutBuildService @Inject constructor(private val execOperations: ExecOperations) : BuildService<PrintStackTracesOnTimeoutBuildService.Params>, AutoCloseable {

 * <pre>
 * public abstract class MyValueSource implements ValueSource&lt;String, ValueSourceParameters.None&gt; {
 *     private final ExecOperations execOperations;
 *
 *     {@literal @}Inject
 *     public MyValueSource(ExecOperations execOperations) {
 *         this.execOperations = execOperations;
 *     }
 *
 *     {@literal @}Override
 *     {@literal @}Nullable
 *     public String obtain() {

    private final IsolatableFactory isolatableFactory;
    private final GradleProperties gradleProperties;
    private final CalculatedValueFactory calculatedValueFactory;
    private final ExecOperations execOperations;
    private final AnonymousListenerBroadcast<ValueListener> valueBroadcaster;
    private final AnonymousListenerBroadcast<ComputationListener> computationBroadcaster;

                def runClasspath = run.classpath
                def runMain = run.mainClass
                def runArgs = run.args
                def execOps = services.get(ExecOperations)
                doLast {
                    execOps.javaexec {
                        if (runExecutable) {
                           executable = runExecutable
                        }

            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