/**
     * Copies the settings from this executer to the given executer.
     *
     * @param executer The executer to copy to
     * @return The passed in executer
     */
    GradleExecuter copyTo(GradleExecuter executer);

    /**
     * Where possible, starts the Gradle build process in debug mode with the provided options.
     */
    GradleExecuter startBuildProcessInDebugger(Action<JavaDebugOptionsInternal> action);

import org.gradle.exemplar.executor.CommandExecutor;
import org.gradle.integtests.fixtures.AvailableJavaHomes;
import org.gradle.integtests.fixtures.executer.ExecutionFailure;
import org.gradle.integtests.fixtures.executer.ExecutionResult;
import org.gradle.integtests.fixtures.executer.GradleContextualExecuter;
import org.gradle.integtests.fixtures.executer.GradleDistribution;

import org.gradle.integtests.fixtures.executer.AbstractGradleExecuter
import org.gradle.integtests.fixtures.executer.ExecutionFailure
import org.gradle.integtests.fixtures.executer.ExecutionResult
import org.gradle.integtests.fixtures.executer.GradleDistribution
import org.gradle.integtests.fixtures.executer.OutputScrapingExecutionFailure
import org.gradle.integtests.fixtures.executer.OutputScrapingExecutionResult

    }

    GradleExecuter version(GradleDistribution dist) {
        def executer = dist.executer(temporaryFolder, IntegrationTestBuildContext.INSTANCE)
        if (gradleUserHomeDir) {
            executer.withGradleUserHomeDir(gradleUserHomeDir)
        }
        executer.inDirectory(testDirectory)
        executers << executer
        return executer
    }

        """

        when:
        openJpmsModulesForConfigurationCache()
        if (continuous) {
            executer.withArgument('waitForExpiration')
            executer.withArgument('--continuous')
        } else {
            executer.withArgument('waitForExpiration')
        }
        executer.run()

        then:

        when:
        executer.requireDaemon()
        def allArgs = executer.getAllArgs()

        then:
        allArgs.contains("--daemon")
        !allArgs.contains("--no-daemon")
    }

    def "when requireDaemon is not called, arguments should contain --no-daemon"() {
        when:
        def allArgs = executer.getAllArgs()

        then:
        !allArgs.contains("--daemon")

    private final TaskExecutionGraph taskExecutionGraph;
    private final TaskExecuter executer;

    public SkipTaskWithNoActionsExecuter(TaskExecutionGraph taskExecutionGraph, TaskExecuter executer) {
        this.taskExecutionGraph = taskExecutionGraph;
        this.executer = executer;
    }

    @Override
    public TaskExecuterResult execute(TaskInternal task, TaskStateInternal state, TaskExecutionContext context) {

import groovy.transform.CompileStatic
import groovy.transform.PackageScope
import org.gradle.integtests.fixtures.executer.ExecutionFailure
import org.gradle.integtests.fixtures.executer.ExecutionResult
import org.gradle.integtests.fixtures.executer.GradleDistribution
import org.gradle.integtests.fixtures.executer.GradleExecuter
import org.gradle.test.fixtures.file.TestDirectoryProvider
import org.spockframework.util.NotThreadSafe

        """

        when:
        executer.withArguments(ENABLE_CLI)
        fetchModel(SomeToolingModel, "help")

        then:
        notExecuted("help")
        fixture.assertStateStored {
            projectsConfigured(":buildSrc", ":")
            modelsCreated(":")
        }

        when:
        executer.withArguments(ENABLE_CLI)
        fetchModel(SomeToolingModel, ":dummyTask")

        then:
        outputContains("Test executor initialized Native services: false")
        outputContains("Build inside a test executor initialized Native services: true")
        outputContains("Build inside a test executor uses Native services: true")
    }

    def "daemon with different native services flag is not reused"() {
        given:
        executer.requireDaemon()
        executer.requireIsolatedDaemons()

        when: