/// Returns true iff all the registered runners have been stopped.
  bool AllRunnersStopped();

  /// Requests all running threads to stop.
  Status RequestStop();

  /// Returns true if its RequestStop() has been called.
  bool ShouldStop();

  /// Joins all threads, returns OK or the first reported and unexpected status.
  Status Join();

        then:
        instant.action1Done > instant.action2Done
    }

    def "can stop multiple times"() {
        when:
        lifecycle.stop()
        lifecycle.stop()
        lifecycle.requestStop()
        lifecycle.requestStop()
        lifecycle.stop()

        then:
        noExceptionThrown()
    }

    def "throws exception when attempting to use service after it has stopped"() {
        when:

    }

    def "requestStop stops immediately when idle"() {
        expect:
        idle

        when:
        coordinator.requestStop("REASON")

        then:
        stopped
        coordinator.willRefuseNewCommands
    }

    def "requestStop stops after current command has completed"() {
        Runnable command = Mock()

      std::bind(&WaitForStopThread, &coord, &about_to_wait, &done));
  about_to_wait.WaitForNotification();
  Env::Default()->SleepForMicroseconds(1000 * 1000);
  EXPECT_FALSE(done.HasBeenNotified());

  TF_EXPECT_OK(coord.RequestStop());
  done.WaitForNotification();
  EXPECT_TRUE(coord.ShouldStop());
}

class MockQueueRunner : public RunnerInterface {
 public:
  explicit MockQueueRunner(Coordinator* coord) {
    coord_ = coord;

    }

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

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

        parallel.waitForAll()
        dispatch.stop()

        then:
        noExceptionThrown()
    }

            }
            workerProcess.start()
        }

        then:
        1 * execHandle.addListener(_)
        1 * execHandle.start()
        1 * acceptor.requestStop()
    }

    def startThrowsExceptionOnConnectTimeoutAndCleansUp() {
        when:
        workerProcess.setExecHandle(execHandle)
        workerProcess.startAccepting(acceptor)

            LOGGER.debug("Requesting daemon stop after processing {}", execution.getCommand());
            // Does not take effect until after execution has completed
            execution.getDaemonStateControl().requestStop("");
        }
        execution.proceed();
    }

                return address;
            }

            @Override
            public void requestStop() {
                CompositeStoppable.stoppable(serverSocket).stop();
            }

            @Override
            public void stop() {
                requestStop();
                executor.stop();
            }
        };
    }

    private class Receiver implements Runnable {

        def dispatcher = hub.getOutgoing("channel", String)
        dispatcher.dispatch("message 1")
        dispatcher.dispatch("message 2")

        when:
        operation.requestStop {
            hub.requestStop()
        }
        hub.stop()

        then:
        1 * listener.messageDiscarded("message 1") >> {
            thread.block()
            instant.message1Handled
        }

    @Override
    public void stop() {
        CompositeStoppable.stoppable(lifecycle, executor, actionExecutor).stop();
    }

    @Override
    public void disconnect() {
        lifecycle.requestStop();
        executor.requestStop();
        actionExecutor.disconnect();
    }

    @Override
    public <T> void run(final ConsumerAction<? extends T> action, final ResultHandlerVersion1<? super T> handler) {