// tag::value-source[]
abstract class GitVersionValueSource : ValueSource<String, ValueSourceParameters.None> {
    @get:Inject
    abstract val execOperations: ExecOperations

    override fun obtain(): String {
        val output = ByteArrayOutputStream()
        execOperations.exec {
            commandLine("git", "--version")
            standardOutput = output
        }

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 {

        fixture.workActionThatCreatesFiles.extraFields += """
            org.gradle.process.ExecOperations execOperations
        """
        fixture.workActionThatCreatesFiles.constructorArgs = "org.gradle.process.ExecOperations execOperations"
        fixture.workActionThatCreatesFiles.constructorAction = "this.execOperations = execOperations"
        fixture.testParameterType.fields += [
            classpath: "ConfigurableFileCollection",

abstract class RemoteProject extends DefaultTask {

    private final FileSystemOperations fsOps
    private final ExecOperations execOps

    @Inject
    RemoteProject(FileSystemOperations fsOps, ExecOperations execOps) {
        this.fsOps = fsOps
        this.execOps = execOps
    }

    /**
     * URI of the git repository.
     *

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

    @get:Inject
    abstract val execOperations: ExecOperations

    init {
        debugReportGeneration.convention(false)
        outputs.doNotCacheIf("Debug enabled") { debugReportGeneration.get() }
    }

    @TaskAction
    fun generateReport() {
        val reporter = PerformanceReporter(execOperations, fileOperations)
        reporter.report(

    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;

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


class ObjectExtensionServiceInjectionIntegrationTest extends AbstractIntegrationSpec {
    // Document current behaviour

        buildFile << """
            interface Services {
                @javax.inject.Inject ExecOperations getExec()
            }

            task run {
                dependsOn jar
                def execOperations = project.objects.newInstance(Services).exec
                doLast {
                    execOperations.javaexec { action ->
                        action.classpath = files(jar) + configurations.runtimeClasspath

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