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

    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:

      log.put("uncaught exception: $throwable")
    }

  private val threadFactory =
    ThreadFactory { runnable ->
      Thread(runnable, "TaskRunnerRealBackendTest").apply {
        isDaemon = true
        uncaughtExceptionHandler = loggingUncaughtExceptionHandler
      }
    }

  private val backend = TaskRunner.RealBackend(threadFactory)
  private val taskRunner = TaskRunner(backend)

            Thread[] ts = new Thread[tg.activeCount()];
            tg.enumerate(ts);

            for (Thread active : ts) {
                String name = active.getName();
                boolean daemon = active.isDaemon();
                assertTrue(daemon, name + " is no daemon Thread.");
            }
        }

        assertTrue(seen, "Could not find ThreadGroup: " + DefaultArtifactResolver.DaemonThreadCreator.THREADGROUP_NAME);

        return !getSystemPropertyExecuter().forks;
    }

    public static boolean isNoDaemon() {
        return getSystemPropertyExecuter() == Executer.noDaemon;
    }

    public static boolean isDaemon() {
        return !(isNoDaemon() || isEmbedded());
    }

    public static boolean isLongLivingProcess() {
        return !isNoDaemon();
    }

    public static boolean isParallel() {

    public boolean isBackground() {
        return background;
    }

    public void setBackground(final boolean background) {
        this.background = background;
    }

    public boolean isDaemon() {
        return daemon;
    }

    public void setDaemon(final boolean daemon) {
        this.daemon = daemon;
    }

    /*
     * (non-Javadoc)
     *