}
        numberOfOverflows <= numberOfRuns / 10
    }

    def "file watching works with many changes between two builds"() {
        // Use 40 minutes idle timeout since the test may be running longer with an idle daemon
        executer.withDaemonIdleTimeoutSecs(2400)
        def numberOfChangedSourcesFilesPerBatch = maxFileChangesWithoutOverflow
        def numberOfChangeBatches = 500

        when:

     */
    File getDaemonRegistryDir();

    /**
     * The process id of the daemon.
     */
    Long getPid();

    /**
     * The daemon's idle timeout in milliseconds.
     */
    Integer getIdleTimeout();

    /**
     * Returns the JVM options that the daemon was started with.
     *
     * @return the JVM options that the daemon was started with

public class DaemonIdleTimeoutExpirationStrategy implements DaemonExpirationStrategy {
    private final Function<?, Long> idleTimeout;
    private final Daemon daemon;

    public static final String EXPIRATION_REASON = "after being idle";

    public DaemonIdleTimeoutExpirationStrategy(Daemon daemon, int idleTimeout, TimeUnit timeUnit) {
        this(daemon, Functions.constant(timeUnit.toMillis(idleTimeout)));
    }

            illegalState()

        private
        fun illegalState(): Nothing =
            throw IllegalStateException("Operation is not valid in ${javaClass.simpleName} state.")

        class Idle(
            private val onFirstDiagnostic: (kind: DiagnosticKind, problem: PropertyProblem) -> State
        ) : State() {

            /**
             * There's nothing to write, return null.
             */

            logFileProbe = new DaemonLogFileStateProbe(daemonLog, context)
        } else {
            logFileProbe = new DaemonLogFileStateProbe(daemonLog, context, "Daemon is busy, sleeping until state changes", "Daemon is idle, sleeping until state change")
        }
    }

    protected void waitForState(State state) {
        def timer = Time.startCountdownTimer(STATE_CHANGE_TIMEOUT)
        def lastLogState = logFileProbe.currentState

	return noRestraintRequest{}, false
}

func (noRestraint) Dump(bool) debug.QueueSetDump {
	return debug.QueueSetDump{}
}

func (noRestraintRequest) Finish(execute func()) (idle bool) {
	execute()
	return false

			if ts != nil {
				tot := ts.User + ts.System + ts.Idle + ts.Iowait + ts.Nice + ts.Steal
				cpuUserVal := math.Round(ts.User/tot*100*100) / 100
				updateResourceMetrics(cpuSubsystem, cpuUser, cpuUserVal, labels, false)
				cpuSystemVal := math.Round(ts.System/tot*100*100) / 100
				updateResourceMetrics(cpuSubsystem, cpuSystem, cpuSystemVal, labels, false)
				cpuIdleVal := math.Round(ts.Idle/tot*100*100) / 100

	cases := []struct {
		name        string
		idleTimeout string
		expected    *durationpb.Duration
	}{
		{
			"no idle timeout",
			"",
			nil,
		},
		{
			"invalid timeout",
			"invalid-30s",
			nil,
		},
		{
			"valid idle timeout 30s",
			"30s",
			durationpb.New(30 * time.Second),
		},
	}

	services := []*model.Service{

import org.gradle.launcher.daemon.server.api.DaemonStateControl;
import org.gradle.launcher.daemon.server.api.DaemonStoppedException;
import org.gradle.launcher.daemon.server.api.DaemonUnavailableException;

/**
 * Updates the daemon idle/busy status, sending a DaemonUnavailable result back to the client if the daemon is busy.
 */
public class StartBuildOrRespondWithBusy extends BuildCommandOnly {
    

        expect:
        settings.socketTimeoutMs == DEFAULT_SOCKET_TIMEOUT

        where:
        timeout << ["", "abc"]
    }

    def "uses default value if provided idle connection timeout is not valid"() {
        System.setProperty(IDLE_CONNECTION_TIMEOUT_SYSTEM_PROPERTY, timeout)
        JavaSystemPropertiesHttpTimeoutSettings settings = new JavaSystemPropertiesHttpTimeoutSettings()