stopped
        0 * _._
    }

    def "await idle timeout does nothing when already stopped"() {
        given:
        coordinator.stop()

        when:
        def result = coordinator.awaitStop()

        then:
        stopped
        result == DaemonStopState.Clean
    }

    def "runs actions when command is run"() {
        Runnable command = Mock()

        when:

            }
            stateCoordinator = this.stateCoordinator;
        } finally {
            lifecycleLock.unlock();
        }

        return stateCoordinator.awaitStop();
    }

    public DaemonStateCoordinator getStateCoordinator() {
        return stateCoordinator;
    }

    private static class DaemonExpirationPeriodicCheck implements Runnable {

        idleTimer = Time.startTimer();
        updateCancellationToken();
    }

    private void setState(State state) {
        this.state = state;
        condition.signalAll();
    }

    DaemonStopState awaitStop() {
        lock.lock();
        try {
            while (true) {
                try {
                    switch (state) {
                        case Idle:
                        case Busy:

  let arguments = (ins
    I64ArrayAttr:$indices
  );

  let results = (outs
    Variadic<TFTensorType>:$results
  );

  let assemblyFormat = "attr-dict `:` type($results)";
}

def AwaitOp: TensorflowMlrt_Op<"await", [Pure]> {
  let summary = "Await a tensor from a !mlrt.future";

  let description = [{
    Await a tensor from a !mlrt.future.