e.message == 'Cannot create outgoing dispatch, as <hub> has been stopped.'
    }

    def "cannot add handler after stop started"() {
        when:
        hub.requestStop()
        hub.addHandler("channel", new Object())

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

    def "cannot add connection after stop started"() {

// See the License for the specific language governing permissions and
// limitations under the License.

package queue

import (
	"fmt"
	"time"
)

// WaitForClose blocks until the Instance has stopped processing tasks or the timeout expires.
// If the timeout is zero, it will wait until the queue is done processing.
// WaitForClose an error if the timeout expires.
func WaitForClose(q Instance, timeout time.Duration) error {

   */
  @CanIgnoreReturnValue
  public Stopwatch stop() {
    long tick = ticker.read();
    checkState(isRunning, "This stopwatch is already stopped.");
    isRunning = false;
    elapsedNanos += tick - startTick;
    return this;
  }

  /**
   * Sets the elapsed time for this stopwatch to zero, and places it in a stopped state.
   *

    def fixture = new TestDeploymentFixture()

    def setup() {
        fixture.writeToProject(projectDir)
        buildTimeout = 30
    }

    def "deployment is stopped when continuous build is cancelled" () {
        when:
        runBuild(["runDeployment"]) {
            succeeds()
            def key = fixture.keyFile.text
            fixture.assertDeploymentIsRunning(key)

            }
            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)

        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);
    }