expect:
        all.size() == 2
        idle.size() == 2
        notIdle.empty

        when:
        markState(address(10), Busy)

        then:
        all.size() == 2
        idle.size() == 1
        notIdle.size() == 1

        when:
        markState(address(20), Busy)

        then:
        all.size() == 2
        idle.empty
        notIdle.size() == 2

        when:

	"k8s.io/client-go/dynamic"
)

func TestChangeCRD(t *testing.T) {
	tearDown, config, _, err := fixtures.StartDefaultServer(t)
	if err != nil {
		t.Fatal(err)
	}
	defer tearDown()
	config.QPS = 1000
	config.Burst = 1000
	apiExtensionsClient, err := clientset.NewForConfig(config)
	if err != nil {
		t.Fatal(err)
	}
	dynamicClient, err := dynamic.NewForConfig(config)
	if err != nil {
		t.Fatal(err)
	}

		// We are running a one-off command locally, so we don't need to worry too much about rate limiting
		// Bumping this up greatly decreases install time
		config.QPS = 50
		config.Burst = 100
	})
	if err != nil {
		return nil, err
	}
	return kube.NewCLIClient(kube.NewClientConfigForRestConfig(rc), kube.WithRevision(revision))
}

func NewCLIContext(rootFlags *RootFlags) Context {

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 {
    
    private static final Logger LOGGER = Logging.getLogger(StartBuildOrRespondWithBusy.class);

    }

    public void onStartActivity() {
        LOGGER.info("Marking the daemon as busy, address: {}", connectorAddress);
        try {
            daemonRegistry.markState(connectorAddress, Busy);
        } catch (DaemonRegistry.EmptyRegistryException e) {
            LOGGER.warn("Cannot mark daemon as busy because the registry is empty.");
        }
    }

    public void onCompleteActivity() {

import org.gradle.launcher.daemon.server.api.DaemonStateControl
import org.gradle.internal.time.MockClock
import spock.lang.Specification

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

abstract class DaemonExpirationStrategyTest extends Specification {
    DaemonRegistry registry

    def setup() {
        // Start with a new registry on each test.
        registry = new EmbeddedDaemonRegistry()

									action: "b",
								},
								{
									status: "x",
									action: "y",
								},
							},
						},
						{source: "c"},
					},
				},
			},
		},

		// Ubuntu Trusty w/ avahi-daemon, libavahi-* etc installed.
		{
			name: "ubuntu_trusty_avahi",
			in:   ubuntuTrustyAvahi,
			want: &nssConf{
				sources: map[string][]nssSource{
					"passwd": {{source: "compat"}},

    def loader = new SynchronizedToolingImplementationLoader(target)

    def "blocks and reports progress when busy"() {
        when:
        start {
            loader.create(distro, factory, _ as InternalBuildProgressListener, params, cancellationToken)
        }
        async {
            thread.blockUntil.busy
            loader.create(distro, factory, _ as InternalBuildProgressListener, params, cancellationToken)
        }

	setEventStreamHeaders(w)

	// Listen Publisher and peer-listen-client uses nonblocking send and hence does not wait for slow receivers.
	// Use buffered channel to take care of burst sends or slow w.Write()
	mergeCh := make(chan []byte, globalAPIConfig.getRequestsPoolCapacity()*len(globalEndpoints.Hostnames()))
	localCh := make(chan event.Event, globalAPIConfig.getRequestsPoolCapacity())

import org.gradle.launcher.daemon.server.api.DaemonStateControl.State
import org.gradle.util.GradleVersion

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