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

        outputContains "FINISH [Gradle Test Run :test] [Gradle Test Run :test]\n"
        result.output.readLines().find { it.matches "START \\[Gradle Test Executor \\d+] \\[Gradle Test Executor \\d+]" }
        result.output.readLines().find { it.matches "FINISH \\[Gradle Test Executor \\d+] \\[Gradle Test Executor \\d+]" }
        outputContains "START [Test suite 'Gradle suite'] [Gradle suite]\n"

    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'

        // If the context's default exector is set to async, re-using that in
        // each thread would cause collectives to deadlock. For consistency we
        // create a new sync executor for every thread.
        //
        // TODO(allenl): We should have an async API that works with the
        // parallel device.
        device_(device),
        executor_(

        )
    }

    def "doesn't do anything if rule is null"() {
        def id = new Id('Alicia')

        when:
        executor.execute(id, null, detailsToResult, onCacheMiss, cachePolicy)

        then:
        0 * _
    }

    def "executes the rule without caching if the rule is not cacheable"() {
        withNonCacheableToUpperCaseRule()
        def id = new Id('Alicia')

        when:

    private final SyncPoint syncPoint = new SyncPoint();

    /**
     * Creates an Executor which the test can control.
     */
    protected ExecutorService getExecutor() {
        if (executor == null) {
            executor = new ExecutorImpl();
        }
        return executor;
    }

    /**
     * Creates an ExecutorFactory for the test to use.
     */

    DefaultBuildOperationQueue(boolean allowAccessToProjectState, WorkerLeaseService workerLeases, Executor executor, QueueWorker<T> queueWorker) {
        this.allowAccessToProjectState = allowAccessToProjectState;
        this.workerLeases = workerLeases;
        this.executor = executor;
        this.queueWorker = queueWorker;
    }

    @Override
    public void add(final T operation) {
        lock.lock();

        //

        assertEquals(16, executions.size());

        assertEquals("clean:clean", executions.get(0).getMojoDescriptor().getFullGoalName());
        assertEquals("it:xpp3-writer", executions.get(1).getMojoDescriptor().getFullGoalName());
        assertEquals("it:java", executions.get(2).getMojoDescriptor().getFullGoalName());
        assertEquals("it:xpp3-reader", executions.get(3).getMojoDescriptor().getFullGoalName());

            // Broken in 5.12.1, fixed in 5.13
            assert containsLinesThatMatch(result.output,
                "Gradle Test Executor \\d+ -> static out",
                "Gradle Test Executor \\d+ -> static err",
                "Gradle Test Executor \\d+ -> constructor out",
                "Gradle Test Executor \\d+ -> constructor err"
            )
        }

        outputContains expectedOutput('The Foo Test')

        /**