"""

        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:

import org.gradle.integtests.fixtures.executer.ArtifactBuilder
import org.gradle.integtests.fixtures.executer.ExecutionFailure
import org.gradle.integtests.fixtures.executer.ExecutionResult
import org.gradle.integtests.fixtures.executer.GradleBackedArtifactBuilder
import org.gradle.integtests.fixtures.executer.GradleContextualExecuter
import org.gradle.integtests.fixtures.executer.GradleDistribution

    val defaultExecuter = "embedded"

    // For all the other executers, add an executer specific task
    testType.executers.forEach { executer ->
        val taskName = "$executer${prefix.capitalize()}Test"
        val testTask = createTestTask(taskName, executer, sourceSet, testType) {}
        if (executer == defaultExecuter) {
            // The test task with the default executer runs with 'check'

        file("c/build.gradle") << """
            plugins.apply(my.MyPlugin)
        """
        file("d/build.gradle") << """
            plugins.apply(my.MyPlugin)
        """

        when:
        executer.withArguments(ENABLE_CLI)
        def model = runBuildAction(new FetchCustomModelForEachProject())

        then:
        model.size() == 4
        model[0].message == "project :a classpath = 2"

        when:
        executer.withArguments(ENABLE_CLI)
        def model3 = runBuildAction(new FetchCustomModelForEachProject())

        then:
        fixture.assertStateLoaded()

        and:
        model3.size() == 1
        model3[0].message == "It works from project :"


        when:
        executer.withArguments(ENABLE_CLI)

        def build1 = executer.withStackTraceChecksDisabled().withArguments("-d").withTasks("lock").start()
        def build2 = executer.withStackTraceChecksDisabled().withArguments("-d").withTasks("lock").start()
        def build3 = executer.withStackTraceChecksDisabled().withArguments("-d").withTasks("lock").start()
        poll(120) {

        file("b/build.gradle") << """
            myExtension.message = "project b"
        """
        file("c/build.gradle") << """
            plugins.apply(my.MyPlugin)
        """

        when:
        executer.withArguments(ENABLE_CLI, WARN_PROBLEMS_CLI_OPT)
        def model = runBuildAction(new FetchCustomModelForEachProject())

        then:
        model.size() == 3
        model[0].message == "project a"

        ideaModel.name == "root"

        when:
        executer.withArguments(ENABLE_CLI)
        fetchModel(IdeaProject)

        then:
        fixture.assertStateLoaded()
    }

    def "can fetch BasicIdeaProject model for root and re-fetch cached"() {
        settingsFile << """
            rootProject.name = 'root'
        """

        when:
        executer.withArguments(ENABLE_CLI)

        """
        buildFile << """
            plugins.apply(my.MyPlugin)
        """
        file("a/build.gradle") << """
            plugins.apply(my.MyPlugin)
        """

        when:
        executer.withArguments(ENABLE_CLI)
        def models = runPhasedBuildAction(new FetchPartialCustomModelForEachProject(), new FetchCustomModelForEachProject())

        then:
        def messages = models.left