}

          case CANCELLED:
          case INTERRUPTED:
            throw cancellationExceptionWithCause("Task was cancelled.", exception);

          default:
            throw new IllegalStateException("Error, synchronizer in invalid state: " + state);
        }
      }

      /** Checks if the state is {@link #COMPLETED}, {@link #CANCELLED}, or {@link #INTERRUPTED}. */
      boolean isDone() {

      // before the cancelled future completes, it will synchronously complete both the newFuture
      // from the cancelled operation and its own. This can cause one runnable to queue two tasks,
      // breaking the invariant this method relies on to iteratively run the next task after the
      // previous one completes.
      if (get() == RunningState.CANCELLED) {
        delegate = null;
        sequencer = null;

        if: ${{ !cancelled() && !failure() }}
        with:
          name: cache-${{ runner.os }}-full-build-${{ matrix.java }}
          retention-days: 1
          path: ${{ env.MIMIR_LOCAL }}

      - name: Upload test artifacts
        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
        if: failure() || cancelled()
        with:

   * <p>If the call {@code setFuture(delegate)} is accepted and this {@code Future} is later
   * cancelled, cancellation will be propagated to {@code delegate}. Additionally, any call to
   * {@code setFuture} after any cancellation will propagate cancellation to the supplied {@code
   * Future}.
   *
   * <p>Note that, even if the supplied future is cancelled and it causes this future to complete,

/** Measures the size of AbstractFuture implementations. */
@NullUnmarked
public class AbstractFutureFootprintBenchmark {

  enum State {
    NOT_DONE,
    FINISHED,
    CANCELLED,
    FAILED
  }

  @Param State state;
  @Param Impl impl;

  @Param({"0", "1", "5", "10"})
  int numListeners;

  @Param({"0", "1", "5", "10"})
  int numThreads;

 * A {@link ListenableFuture} whose result can be set by a {@link #set(Object)}, {@link
 * #setException(Throwable)} or {@link #setFuture(ListenableFuture)} call. It can also, like any
 * other {@code Future}, be {@linkplain #cancel cancelled}.
 *
 * <p>{@code SettableFuture} is the recommended {@code ListenableFuture} implementation when your
 * task cannot be implemented with {@link ListeningExecutorService}, the various {@link Futures}

  override fun completed(response: SimpleHttpResponse) {
  }

  override fun failed(ex: Exception) {
    println("Failed: $ex")
  }

  override fun cancelled() {
    println("Cancelled")
  }

        assertTrue(ex.getMessage().contains("Did not receive response"));
    }

    // If the request is cancelled (NTSTATUS 0xC0000120), return null
    @Test
    @DisplayName("watch() returns null when request cancelled (NTSTATUS 0xC0000120)")
    void watch_sendCancelled_returnsNull() throws Exception {
        when(handle.isValid()).thenReturn(true);

            } catch (final SmbException e) {
                if (e.getNtStatus() == 0xC0000120) {
                    // cancelled
                    log.debug("Request was cancelled", e);
                    return null;
                }
                throw e;
            }
            if (log.isTraceEnabled()) {

   * input future and that of the future returned by the chain function. That is, if the returned
   * {@code Future} is cancelled, it will attempt to cancel the other two, and if either of the
   * other two is cancelled, the returned {@code Future} will receive a callback in which it will
   * attempt to cancel itself.
   *