then:
        1 * delegate.processTestClass(test2)
        then:
        1 * delegate.stop()
        0 * _._
    }

    def "stopNow does nothing after stop completed"() {
        when:
        processor.startProcessing(resultProcessor)
        processor.processTestClass(test1)
        processor.stop()

        then:
        1 * factory.create() >> delegate

        //iterate and stop all daemons
        int numStopped = 0;
        while (connection != null && !timer.hasExpired()) {
            try {
                seen.add(connection.getDaemon().getUid());
                LOGGER.debug("Requesting daemon {} stop now", connection.getDaemon());

	}
}

func TestNoDefaultRevision(t *testing.T) {
	stop := make(chan struct{})
	client := kube.NewFakeClient()
	w := NewDefaultWatcher(client, "default")
	client.RunAndWait(stop)
	go w.Run(stop)
	// if have no default tag for some reason, should return ""
	expectRevision(t, w, "")
	close(stop)
}

func TestDefaultRevisionChanges(t *testing.T) {
	stop := test.NewStop(t)
	client := kube.NewFakeClient()

			}
		}
	}()
	return g
}

func (g *generator) Stop() Result {
	// Trigger the generator to stop.
	close(g.stop)

	// Wait for the generator to exit.
	t := time.NewTimer(g.StopTimeout)
	select {
	case <-g.stopped:
		t.Stop()
		if g.result.TotalRequests == 0 {
			g.t.Fatal("no requests completed before stopping the traffic generator")
		}
		return g.result
	case <-t.C:

            parallel.syncAt(3)
        }

        dispatch.stop()

        then:
        target1.receivedMessages == ['message1', 'message3']
        target2.receivedMessages == ['message2']
    }

    def 'can stop from multiple threads'() {
        when:
        dispatch.dispatchTo(target1)

        parallel.start {
            dispatch.stop()
        }
        parallel.start {
            dispatch.stop()

		if !kube.WaitForCacheSync("cluster"+string(c.ID), c.stop, h.HasSynced) {
			log.Warnf("remote cluster %s failed to sync handler", c.ID)
			return
		}
	}

	c.initialSync.Store(true)
}

// Stop closes the stop channel, if is safe to be called multi times.
func (c *Cluster) Stop() {
	select {
	case <-c.stop:
		return
	default:
		close(c.stop)
	}
}

func (c *Cluster) HasSynced() bool {

	//
	// Only the consumer should call Stop(), not the producer. If the producer
	// errors and needs to stop the watch prematurely, it should instead send
	// an error event and close the result channel.
	Stop()

	// ResultChan returns a channel which will receive events from the event
	// producer. If an error occurs or Stop() is called, the producer must
	// close this channel and release any resources used by the watch.

        },
        "japanese_stop": {
          "type":       "stop",
          "stopwords_path": "${fess.dictionary.path}ja/stopwords.txt"
        },
        "korean_stop": {
          "type":       "stop",
          "stopwords_path": "${fess.dictionary.path}ko/stopwords.txt"
        },
        "latvian_stop": {
          "type":       "stop",
          "stopwords_path": "${fess.dictionary.path}lv/stopwords.txt"

        1 * connection.receive() >> new Success(null)
        1 * connection.dispatch({it instanceof Finished})
        1 * connection.stop()
        1 * connection2.dispatch({it instanceof Stop})
        1 * connection2.receive() >> new Success(null)
        1 * connection2.dispatch({it instanceof Finished})
        1 * connection2.stop()
        0 * _
    }

    def "stops each connection at most once"() {

					// 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.
					s.kubeClient.RunAndWait(stop)
					log.Infof("Starting ingress controller")
					ingressSyncer.Run(leaderStop)
				}).
				Run(stop)
			return nil
		})
	}