12: "user defined signal 2",
	13: "broken pipe",
	14: "alarm clock",
	15: "terminated",
	16: "stack fault",
	17: "child exited",
	18: "continued",
	19: "stopped (signal)",
	20: "stopped",
	21: "stopped (tty input)",
	22: "stopped (tty output)",
	23: "urgent I/O condition",
	24: "CPU time limit exceeded",
	25: "file size limit exceeded",
	26: "virtual timer expired",
	27: "profiling timer expired",

            }
            if (numIncompatible > 0) {
                reasons.add(numIncompatible + " incompatible");
            }
            if (numStopped > 0) {
                reasons.add(numStopped + " stopped");
            }

            return STARTING_DAEMON_MESSAGE + ", "
                + Joiner.on(" and ").join(reasons) + " Daemon" + (totalUnavailableDaemons > 1 ? "s" : "")
                + NOT_REUSED_MESSAGE;

     * complete. Note that the action may have completed by the time this method returns.
     *
     * @throws IllegalStateException When this connection has been stopped or is stopping.
     */
    <T> void run(ConsumerAction<? extends T> action, ResultHandlerVersion1<? super T> handler);

    /**
     * Stops this connection, blocking until all operations on the connection have completed.

	if ready.check() {
		t.Errorf("unexpected ready state %v", ready.check())
	}
	// can not set to true if is stopped
	ready.set(true)
	if ready.check() {
		t.Errorf("unexpected ready state %v", ready.check())
	}
	err := ready.wait(context.Background())
	if err == nil {
		t.Errorf("expected error waiting on a stopped state")
	}
}

func Test_newReadyCancelPending(t *testing.T) {
	errCh := make(chan error, 10)

	{20, "SIGWINCH", "window Size Change"},
	{21, "SIGURG", "urgent Socket Condition"},
	{22, "SIGIO", "pollable Event"},
	{23, "SIGSTOP", "stopped (signal)"},
	{24, "SIGTSTP", "stopped (user)"},
	{25, "SIGCONT", "continued"},
	{26, "SIGTTIN", "stopped (tty input)"},
	{27, "SIGTTOU", "stopped (tty output)"},
	{28, "SIGVTALRM", "virtual Timer Expired"},
	{29, "SIGPROF", "profiling Timer Expired"},

        given:
        actor.stop()

        when:
        proxy.doStuff('param')

        then:
        IllegalStateException e = thrown()
        e.message == 'This actor has been stopped.'
    }

    def cannotDispatchToNonBlockingActorAfterItHasBeenStopped() {
        def actor = factory.createActor(target)
        def proxy = actor.getProxy(TargetObject.class)

        given:

		i += resp.Count
	}
}

// newWorkerForTest creates and starts a worker process for testing or
// benchmarking. The worker process calls RunFuzzWorker, which responds to
// RPC messages until it's stopped. The process is stopped and cleaned up
// automatically when the test is done.
func newWorkerForTest(tb testing.TB) *worker {
	tb.Helper()
	c, err := newCoordinator(CoordinateFuzzingOpts{

                }
            }
        }
        drainTo.addAll(queue);
        queue.clear();
    }

    public void stop() {
        owner.stopped(this);
    }

        return new ThreadHandleImpl(thread);
    }

    private void testThreadStarted(Thread thread) {
        lock.lock();
        try {
            if (stopped) {
                throw new IllegalStateException("Cannot start new threads, as this test case has been stopped.");
            }
            LOGGER.debug("Started {}", thread);
            active.add(thread);
            condition.signalAll();
        } finally {

	// used to lock the observedRecord
	observedRecordLock sync.Mutex

	metrics leaderMetricsAdapter
}

// Run starts the leader election loop. Run will not return
// before leader election loop is stopped by ctx or it has
// stopped holding the leader lease
func (le *LeaderElector) Run(ctx context.Context) {
	defer runtime.HandleCrash()
	defer func() {
		le.config.Callbacks.OnStoppedLeading()
	}()

	if !le.acquire(ctx) {