println("[GK] Close gate")
                            gateKeeper.close()
                        } else if (command == "stop") {
                            println("[GK] stop")
                            stop = true
                        } else {
                            println("[GK] ? " + command)
                        }
                    }
                }

						return
					}
				case <-stop:
					await.Stop()
					return
				}
				await.Stop()
			}
		} else {
			// no items, wait for Push or stop
			select {
			case t := <-d.enqueue:
				d.mu.Lock()
				d.queue.Push(t)
				d.mu.Unlock()
			case <-stop:
				return
			}
		}
	}
}

func TestCRDWatcherRace(t *testing.T) {
	stop := test.NewStop(t)
	c := kube.NewFakeClient()
	ctl := c.CrdWatcher()
	vsCalls := atomic.NewInt32(0)

	// Race callback and CRD creation
	go func() {
		if ctl.KnownOrCallback(gvr.VirtualService, func(s <-chan struct{}) {
			assert.Equal(t, s, stop)
			// Happened async
			vsCalls.Inc()
		}) {
			// Happened sync
			vsCalls.Inc()

    def setup() {
        createForwarder()
    }

    def "cancel is forwarded when received before stop"() {
        when:
        cancellationToken.cancel()
        forwarder.stop()

        then:
        receiveCancel()
    }

    def "cancel is ignored after stop"() {
        when:
        forwarder.stop()
        cancellationToken.cancel()

        then:
        0 * dispatch._
    }

	}, nil, nil, nil, "default", false, nil, s, mcc)
	assert.NoError(t, mcc.Run(stop))
	go mockserviceController.Run(stop)
	clientset.RunAndWait(stop)
	kube.WaitForCacheSync("test", stop, mcc.HasSynced)
	_ = s.Start(stop)

	verifyControllers(t, mc, 1, "create local controller")

	// Create the multicluster secret. Sleep to allow created remote
	// controller to start and callback add function to be called.

						// as we create them only after acquiring the leader lock
						// Note: stop here should be the overall pilot stop, NOT the leader election stop. We are
						// basically lazy loading the informer, if we stop it when we lose the lock we will never
						// recreate it again.
						client.RunAndWait(clusterStopCh)
						nc.Run(leaderStop)
					})

	meshWatcher := mesh.NewTestWatcher(&meshconfig.MeshConfig{})
	stop := test.NewStop(t)
	discoveryNamespacesFilter := filter.NewDiscoveryNamespacesFilter(
		kclient.New[*v1.Namespace](client),
		meshWatcher,
		stop,
	)
	kube.SetObjectFilter(client, discoveryNamespacesFilter)
	nc := NewNamespaceController(client, watcher)
	client.RunAndWait(stop)
	go nc.Run(stop)
	retry.UntilOrFail(t, nc.queue.HasSynced)

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import "test/a"

func main() {
	stop := start()
	defer stop()
}

func start() func() {
	return a.Start().Stop

import org.gradle.initialization.BuildCancellationToken;

public interface DaemonStateControl {
    /**
     * <p>Requests that the daemon stop, but wait until the daemon is idle. The stop will happen asynchronously, and this method does not block.
     *
     * <p>The daemon will stop accepting new work, so that subsequent calls to {@link #runCommand} will fail with {@link DaemonUnavailableException}.
     */
    void requestStop(String reason);

        ['--foreground', '--daemon']    | true
    }

    def "can convert stop option - #options"() {
        when:
        def converted = convert(options)

        then:
        converted.stop == stop

        where:
        options    | stop
        []         | false
        ['--stop'] | true
    }

    def "can convert status option - #options"() {
        when: