clientsManager.release(client3)

        when:
        expiration.attemptToRelease(MemoryAmount.ofGigaBytes(4).bytes)

        then:
        1 * client1.stop()
        1 * client2.stop()
        0 * client3.stop()

        and:
        reserveIdleClient(oneGbOptions) == client3
    }

    def "expires all idle daemons when requested memory is equal than what all daemons consume"() {

	i.RunComponent(name, func(stop <-chan struct{}) error {
		go func() {
			err := task(stop)
			if err != nil {
				logComponentError(name, err)
			}
		}()
		return nil
	})
}

func (i *instance) RunComponentAsyncAndWait(name string, task Component) {
	i.RunComponent(name, func(stop <-chan struct{}) error {
		i.requiredTerminations.Add(1)
		go func() {

		})
	}
}

type timer interface {
	Stop() bool
	Reset(Duration) bool
}

// tickerTimer is a Timer with Reset and Stop methods that return bools,
// to have the same signatures as Timer.
type tickerTimer struct {
	*Ticker
	stopped bool
}

func (t *tickerTimer) Stop() bool {
	pending := !t.stopped
	t.stopped = true
	t.Ticker.Stop()
	return pending
}

        thread.blockUntil.received
        server.stop()
        client.stop()

        then:
        1 * service.doStuff("1")
        1 * service.doStuff("2")
        1 * service.doStuff("3")
        1 * service.doStuff("4") >> { instant.received }

        cleanup:
        client?.stop()
        server?.stop()
    }

    def "client can send messages to server"() {

		t.Error("close stop, method exit timeout.")
	case <-signal:
		t.Log("queue return.")
	}
}

func TestClosed(t *testing.T) {
	t.Run("immediate close", func(t *testing.T) {
		stop := make(chan struct{})
		q := NewQueue(0)
		go q.Run(stop)
		close(stop)
		if err := WaitForClose(q, 10*time.Second); err != nil {
			t.Error(err)
		}
	})
	t.Run("no tasks after close", func(t *testing.T) {

        1 * asyncProcessor1.startProcessing(asyncResultProcessor)
        1 * asyncProcessor1.processTestClass(test)

        when:
        processor.stop()

        then:
        1 * asyncProcessor1.stop()
        1 * actor1.stop()
        1 * resultProcessorActor.stop()
    }

    def startsMultipleProcessorsOnDemandAndStopsAtEnd() {
        TestClassRunInfo test = Mock()
        TestClassProcessor processor1 = Mock()

        then:
        IllegalStateException e = thrown()
        e.message == 'Cannot add connection, as <hub> has been stopped.'
    }

    def "stop and request stop do nothing when already stopped"() {
        when:
        hub.stop()
        hub.stop()
        hub.requestStop()

        then:
        0 * _._
    }

// next and stop.
//
// Next returns the next value in the sequence
// and a boolean indicating whether the value is valid.
// When the sequence is over, next returns the zero V and false.
// It is valid to call next after reaching the end of the sequence
// or after calling stop. These calls will continue
// to return the zero V and false.
//
// Stop ends the iteration. It must be called when the caller is

// Run starts the controller. This must be called.
func (c *crdWatcher) Run(stop <-chan struct{}) {
	c.mutex.Lock()
	if c.stop != nil {
		// Run already called. Because we call this from client.RunAndWait this isn't uncommon
		c.mutex.Unlock()
		return
	}
	c.stop = stop
	c.mutex.Unlock()
	kube.WaitForCacheSync("crd watcher", stop, c.crds.HasSynced)
	c.queue.Run(stop)
	c.crds.ShutdownHandlers()
}

	// Regression test to ensure no race conditions during monitor shutdown
	store := memory.Make(collections.Mocks)
	m := memory.NewMonitor(store)
	stop := make(chan struct{})
	go m.Run(stop)
	m.ScheduleProcessEvent(memory.ConfigEvent{})
	close(stop)
	m.ScheduleProcessEvent(memory.ConfigEvent{})
}

func TestEventConsistency(t *testing.T) {
	store := memory.Make(collections.Mocks)