*
 * @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.
     *

            }
        }.get()

        then:
        1 * execOperations.exec(_) >> { Action<? super ExecSpec> action -> action.execute(spec) }
        spec.getCommandLine() == ["echo", "hello"]
        spec.environment == System.getenv()
    }

    def "full environment is propagated to execOperations"() {
        given:
        def spec = specFactory.newExecAction()

        when:

 *     }
 *
 *     private final ExecOperations execOperations;
 *
 *     {@literal @}Inject
 *     FFPlay(ExecOperations execOperations) {
 *         this.execOperations = execOperations;
 *     }
 *
 *     {@literal @}Override
 *     public void execute(Parameters parameters) throws Exception {
 *         execOperations.exec(spec -> {
 *             spec.commandLine(

            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() {

import org.gradle.process.ExecOperations
import org.gradle.process.ExecResult
import org.gradle.process.JavaExecSpec

import javax.inject.Inject

/**
 * A reported which generates HTML performance report based on the JUnit XML.
 */
@CompileStatic
class PerformanceReporter {
    private final FileSystemOperations fileOperations
    private final ExecOperations execOperations

    @Inject

        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()
    )

    private final ExecOperations execOperations;
    private final String name;

    private final String executable;
    private final boolean useLegacyGpg;
    private final File homeDir;
    private final File optionsFile;
    private final String keyName;
    private final String passphrase;

    interface Services {
        @Inject
        ExecOperations getExecOperations();
    }

            return !command.isEmpty() ? command.get(0) : "";
        }
    }

    private final ExecOperations execOperations;

    @Inject
    public ProcessOutputValueSource(ExecOperations execOperations) {
        this.execOperations = execOperations;

        if (hasFullEnvironment() && hasAdditionalEnvVars()) {
            throw new IllegalArgumentException(