0 * _._
    }

    def "idle millis is 0 if daemon is busy"() {
        given:
        Runnable command = Mock()

        when:
        coordinator.runCommand(command, "some command")

        then:
        1 * command.run() >> {
            coordinator.getIdleMillis() == 0L
        }
    }

    def "idle millis is > 0 when daemon is idle"() {
        when:

	if cfg.Interval == 0 {
		cfg.Interval = defaultTCPKeepAliveInterval
	}
	if cfg.Count == 0 {
		cfg.Count = defaultTCPKeepAliveCount
	}

	if cfg.Idle == -1 {
		cfg.Idle = oldCfg.Idle
	}
	// Check out the comment on KeepAliveConfig and the illumos code:
	// https://github.com/illumos/illumos-gate/blob/0886dcadf4b2cd677c3b944167f0d16ccb243616/usr/src/uts/common/inet/tcp/tcp_opt_data.c#L786-L861

        DaemonInfo d1 = registerDaemon(Idle)
        DaemonInfo d2 = registerDaemon(Idle)

        when:
        compatible = [ d1, d2 ]

        then:
        wouldExpire(d1)
        wouldExpire(d2)
    }

    def "does not expire when there are no compatible daemons"() {
        given:
        DaemonInfo d1 = registerDaemon(Idle)
        DaemonInfo d2 = registerDaemon(Idle)
        DaemonInfo d3 = registerDaemon(Idle)

	cfg = KeepAliveConfig{
		Enable:   tcpKeepAlive != 0,
		Idle:     tcpKeepAliveIdleTime,
		Interval: tcpKeepAliveIntervalTime,
		Count:    tcpKeepAliveCount,
	}
	return
}

func verifyKeepAliveSettings(t *testing.T, fd fdType, oldCfg, cfg KeepAliveConfig) {
	const defaultTcpKeepAliveAbortThreshold = 8 * time.Minute // default value on Solaris

	if cfg.Idle == 0 {
		cfg.Idle = defaultTCPKeepAliveIdle
	}
	if cfg.Interval == 0 {

            while (!timer.hasExpired()) {
                try {
                    switch (state) {
                        case Idle:
                            LOGGER.debug("Cancel: daemon is idle now.");
                            return null;
                        case Busy:
                        case Canceled:
                        case StopRequested:

import static org.gradle.launcher.daemon.server.api.DaemonStateControl.State.Idle

class NotMostRecentlyUsedDaemonExpirationStrategyTest extends DaemonExpirationStrategyTest {

    def "does not expire when there is only one daemon"() {
        given:
        DaemonInfo d1 = registerDaemon(Idle)

        expect:
        !wouldExpire(d1)
    }

    def "expires given more than 1 daemon"() {

func setKeepAliveIdleAndIntervalAndCount(fd *netFD, idle, interval time.Duration, count int) error {
	if idle == 0 {
		idle = defaultTCPKeepAliveIdle
	}

	// The kernel expects milliseconds so round to next highest
	// millisecond.
	if idle > 0 {
		msecs := int(roundDurationUp(idle, time.Millisecond))
		err := fd.pfd.SetsockoptInt(syscall.IPPROTO_TCP, syscall.TCP_KEEPALIVE_THRESHOLD, msecs)

        when:
        registry.markState(address, Busy)

        then:
        registry.all.empty
    }

    def "mark idle ignores entry that has been removed"() {
        given:
        def address = address()

        when:
        registry.markState(address, Idle)

        then:
        registry.all.empty
    }

    def "safely removes stop events when empty"() {
        when:

    def "marks idle"() {
        given:
        updater.onStart(address)

        when:
        updater.onCompleteActivity()

        then:
        1 * registry.markState(address, Idle)
    }

    def "ignores empty cache on marking idle"() {
        given:
        updater.onStart(address)
        registry.markState(address, Idle) >> { throw new EmptyRegistryException("") }

	}

	// Subtract out all idle time from the total time. Do this after computing
	// GC time, because the background utilization is dependent on the *real*
	// total time, not the total time after idle time is subtracted.
	//
	// Idle time is counted as any time that a P is on the P idle list plus idle mark
	// time. Idle mark workers soak up time that the application spends idle.
	//