checkThreadPoolName(thread, 1);

    Thread defaultThread = Executors.defaultThreadFactory().newThread(monitoredRunnable);
    assertEquals(defaultThread.isDaemon(), thread.isDaemon());
    assertEquals(defaultThread.getPriority(), thread.getPriority());
    assertSame(defaultThread.getThreadGroup(), thread.getThreadGroup());

    private final PipedOutputStream stdinPipe;
    private final boolean isDaemon;

    private final DurationMeasurement durationMeasurement;
    private final AtomicReference<ExecHandle> execHandleRef = new AtomicReference<>();

    public ParallelForkingGradleHandle(PipedOutputStream stdinPipe, boolean isDaemon, Action<ExecutionResult> resultAssertion, String outputEncoding, Factory<? extends AbstractExecHandleBuilder> execHandleFactory, DurationMeasurement durationMeasurement) {
        super(stdinPipe, isDaemon, resultAssertion, outputEncoding, execHandleFactory, durationMeasurement);
    }

    @Override

    checkThreadPoolName(thread, 1);

    Thread defaultThread = Executors.defaultThreadFactory().newThread(monitoredRunnable);
    assertEquals(defaultThread.isDaemon(), thread.isDaemon());
    assertEquals(defaultThread.getPriority(), thread.getPriority());
    assertSame(defaultThread.getThreadGroup(), thread.getThreadGroup());

    def "by default daemon is used"() {
        when:
        def action = convert('args')

        then:
        isDaemon action
    }

    def "daemon is used when command line option is used"() {
        when:
        def action = convert('--daemon', 'args')

        then:
        isDaemon action
    }

    def "does not use daemon when no-daemon command line option issued"() {
        given:

            allprojects {
                $disableScalaDocIfInDaemonMode
            }
        """
    }

    static String getDisableScalaDocIfInDaemonMode() {
        return !GradleContextualExecuter.isDaemon() ? "" : """
            tasks.withType(ScalaDoc) {
                doFirst {
                    throw new GradleException("Can't execute scaladoc while testing with the daemon due to permgen exhaustion")
                }

                    assert buildState.userId == services.get(${UserScopeId.name}).id.asString()

                    assert (buildState.daemonScanInfo != null) == ${GradleContextualExecuter.isDaemon()}
                }
            }
        """

        when:
        succeeds("check")

        then:
        executed(":check")

        when:
        succeeds("check")

        then:

        boolean isSatisfied() throws Exception {
            return GradleContextualExecuter.isDaemon() || GradleContextualExecuter.isNoDaemon()
        }
    }

    static final class IsDaemonExecutor implements TestPrecondition {
        @Override
        boolean isSatisfied() throws Exception {
            return GradleContextualExecuter.isDaemon()
        }
    }

    static final class NotDaemonExecutor implements TestPrecondition {

    /**
     * Checks if the thread is alive, resurrecting it if it's not.
     */
    fun poke() = synchronized(this) {
        if (thread?.isAlive != true) {
            thread = thread(name = name, isDaemon = true, block = block)
        }
    }

        )

        where:
        dsl << ['groovy', 'kotlin']
    }

    @UsesSample('scala/quickstart')
    def "can build scalaDoc with #dsl dsl"() {
        if (GradleContextualExecuter.isDaemon()) {
            // don't load scala into the daemon as it exhausts permgen
            return
        }

        TestFile projectDir = sample.dir.file(dsl)