}
        }

        processChanges()
    }

    private checkForDaemonsStateChange() {
        def busy = registry.notIdle.size()
        def idle = registry.idle.size()

        def currentState = new DaemonsState(busy, idle)
        if (!lastDaemonsState.matches(currentState)) {
            putOnChangeQueue(currentState)
            lastDaemonsState = currentState

		Enable:   true,
		Idle:     20 * time.Second,
		Interval: -1,
		Count:    10,
	},
	{
		Enable:   true,
		Idle:     20 * time.Second,
		Interval: 10 * time.Second,
		Count:    -1,
	},
	{
		Enable:   true,
		Idle:     -1,
		Interval: -1,
		Count:    10,
	},
	{
		Enable:   true,
		Idle:     -1,
		Interval: 10 * time.Second,
		Count:    -1,
	},
	{
		Enable:   true,
		Idle:     20 * time.Second,

 */
package org.gradle.launcher.daemon.testing

/**
 * Represents the number of given busy and idle daemons in a registry at a particular time.
 */
class DaemonsState {
    final int busy
    final int idle

    DaemonsState(int busy, int idle) {
        this.busy = Math.max(busy, 0)
        this.idle = Math.max(idle, 0)
    }

    static getWildcardState() {
        new DaemonsState()
    }

	offset := 2 + e[0]&lengthMask // size of header + fold string

	nFirst := (e[1] >> lengthBits) & lengthMask
	if nTitle := e[1] & lengthMask; nTitle != noChange {
		if nFirst != noChange {
			e = e[nFirst:]
		}
		return c.writeString(e[offset : offset+nTitle])
	}
	if ct == cLower && nFirst != noChange {
		// Use the uppercase version instead.
		return c.writeString(e[offset : offset+nFirst])
	}

	DefaultCACertPath = "C:/etc/kubernetes/pki/ca.crt"
	// DefaultContainerRuntimeURLScheme defines default socket url prefix
	DefaultContainerRuntimeURLScheme = "npipe"

func isExistingSocket(path string) bool {
	u, err := url.Parse(path)
	if err != nil {
		// should not happen, since we are trying to access known / hardcoded sockets
		return false
	}

	// the dial path must be without "npipe://"
	_, err = winio.DialPipe(u.Path, nil)
	if err != nil {
		return false
	}

	return true

	nBranchStmt
	nCallExpr
	nCaseClause
	nChanType
	nCommClause
	nComment
	nCommentGroup
	nCompositeLit
	nDeclStmt
	nDeferStmt
	nEllipsis
	nEmptyStmt
	nExprStmt
	nField
	nFieldList
	nFile
	nForStmt
	nFuncDecl
	nFuncLit
	nFuncType
	nGenDecl
	nGoStmt
	nIdent
	nIfStmt
	nImportSpec
	nIncDecStmt
	nIndexExpr
	nIndexListExpr
	nInterfaceType
	nKeyValueExpr
	nLabeledStmt

		if err := setKeepAliveIdle(c.fd, config.Idle); err != nil {
			return &OpError{Op: "set", Net: c.fd.net, Source: c.fd.laddr, Addr: c.fd.raddr, Err: err}
		}
		if err := setKeepAliveInterval(c.fd, config.Interval); err != nil {
			return &OpError{Op: "set", Net: c.fd.net, Source: c.fd.laddr, Addr: c.fd.raddr, Err: err}
		}
	} else if err := setKeepAliveIdleAndInterval(c.fd, config.Idle, config.Interval); err != nil {

                doFirst {
                    def all = services.get(WorkerDaemonFactory.class).clientsManager.allClients.size()
                    def idle = services.get(WorkerDaemonFactory.class).clientsManager.idleClients.size()
                    println "Existing worker daemons: \${idle} idle out of \${all} total"
                }
            }
        """

        when:
        succeeds "runInWorker1"

        and:

     *
     * Execution of the work may begin immediately.
     *
     * Work submitted using {@link WorkerExecutor#processIsolation()} will execute in an idle daemon that meets the requirements set
     * in the {@link ProcessWorkerSpec}.  If no idle daemons are available, a new daemon will be started.  Any errors
     * will be thrown from {@link #await()} or from the surrounding task action if {@link #await()} is not used.
     */