2019-10-03T09:33:08.990+0200 [DEBUG] [org.gradle.execution.plan.DefaultPlanExecutor] Task worker [Thread[main,5,main]] finished, busy: 0.0 secs, idle: 0.021 secs
\u001B[0K
\u001B[0K

// timer precision to keep the timer error acceptable.
const osRelaxMinNS = 0

var haveHighResSleep = true

// osRelax is called by the scheduler when transitioning to and from
// all Ps being idle.
func osRelax(relax bool) {}

// enableWER is called by setTraceback("wer").
// Windows Error Reporting (WER) is only supported on Windows.
func enableWER() {}

// winlibcall is not implemented on non-Windows systems,

	return t.closeIdle
}

func (t *Transport) QueueForIdleConnForTesting() {
	t.queueForIdleConn(nil)
}

// PutIdleTestConn reports whether it was able to insert a fresh
// persistConn for scheme, addr into the idle connection pool.
func (t *Transport) PutIdleTestConn(scheme, addr string) bool {
	c, _ := net.Pipe()
	key := connectMethodKey{"", scheme, addr, false}

	if t.MaxConnsPerHost > 0 {

		gp:       getg(),
		returned: false,
	}
	events = append(events, e)

	if !eventHandler() {
		// If we did not handle a window event, the idle timeout was triggered, so we can clear it.
		clearIdleTimeout()
	}

	// wait until all goroutines are idle
	e.returned = true
	gopark(nil, nil, waitReasonZero, traceBlockGeneric, 1)

	events[len(events)-1] = nil
	events = events[:len(events)-1]

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

class DefaultDaemonConnectorTest extends Specification {

    def javaHome = new File("tmp")
    def connectTimeoutSecs = 1
    def daemonCounter = 0

    class OutgoingConnectorStub implements OutgoingConnector {

        given:
        def operation = new ProgressOperation(null, null, new OperationIdentifier(1), null)

        expect:
        statusBarFormatter.format(operation).first().text == "> IDLE"
        statusBarFormatter.format(operation).first().style == StyledTextOutput.Style.Normal
    }

    def 'dispatches message to an idle target'() {
        when:
        dispatch.dispatchTo(target1)
        dispatch.dispatch('message1')
        dispatch.dispatch('message2')
        dispatch.stop()

        then:
        1 * target1.dispatch('message1')
        then:
        1 * target1.dispatch('message2')
    }

    def 'dispatch does not block while no idle target available'() {
        given:

	maxIdleTime       time.Duration          // maximum amount of time a connection may be idle before being closed
	cleanerCh         chan struct{}
	waitCount         int64 // Total number of connections waited for.
	maxIdleClosed     int64 // Total number of connections closed due to idle count.
	maxIdleTimeClosed int64 // Total number of connections closed due to idle time.

     */
    void stop();

    String getDisplayName();

    /**
     * Requests cancellation on the current operation and send a 'stop when idle' message to the daemon.
     */
    void disconnect();

        }
        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: