valueAndCloser.closeAsync();
    }
    super.waitUntilClosed(closingFuture);
  }

  @Override
  void cancelFinalStepAndWait(ClosingFuture<TestCloseable> closingFuture) {
    assertThat(closingFuture.cancel(false)).isTrue();
    ValueAndCloser<?> unused = finishToValueAndCloser(closingFuture);
    waitUntilClosed(closingFuture);
    futureCancelled.countDown();
  }

    long r = 0;
    List<Facade<Integer>> list = new ArrayList<>(reps);
    for (int i = 0; i < reps; i++) {
      final Facade<Integer> localFuture = impl.newFacade();
      list.add(localFuture);
      localFuture.cancel(false);
    }
    for (int i = 0; i < reps; i++) {
      Facade<Integer> facade = list.get(i);
      try {
        facade.get();
        r++;
      } catch (CancellationException e) {
        r += 2;
      }

  /*
   * We access this field racily but safely. For discussion of a similar situation, see the comments
   * on the fields of TimeoutFuture. This field is slightly different from the fields discussed
   * there: cancel() never reads this field, only writes to it. That makes the race here completely
   * harmless, rather than just 99.99% harmless.
   */
  @CheckForNull @LazyInit private List<@Nullable Present<V>> values;

  CollectionFuture(

	if err != nil {
		// invalid worker size.
		return err
	}

	ctx, cancel := context.WithCancel(ctx)

	results := make(chan itemOrErr[ObjectInfo], 100)
	if err := api.Walk(ctx, r.Bucket, r.Prefix, results, WalkOptions{
		Marker: lastObject,
		Filter: selectObj,
	}); err != nil {
		cancel()
		// Do not need to retry if we can't list objects on source.
		return err
	}
	failed := false

     * キャンセルされているかどうかを返します。
     *
     * @return キャンセルされているか
     */
    public boolean isCanceled() {
        return status == CANCELED;
    }

    /**
     * キャンセルします。
     */
    public void cancel() {
        status = CANCELED;
    }

    /**
     * 止まっているかどうか返します。
     *
     * @return 止まっているかどうか
     */
    public boolean isStopped() {
        return status == STOPPED;
    }

    /**

/**
 * 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}

    // Play it back.
    connect(peer, PushObserver.CANCEL, Http2Connection.Listener.REFUSE_INCOMING_STREAMS)

    // Verify the peer received what was expected.
    val rstStream = peer.takeFrame()
    assertThat(rstStream.type).isEqualTo(Http2.TYPE_RST_STREAM)
    assertThat(rstStream.streamId).isEqualTo(2)
    assertThat(rstStream.errorCode).isEqualTo(ErrorCode.CANCEL)
  }

  /**

func (r BatchJobExpire) Notify(ctx context.Context, body io.Reader) error {
	if r.NotificationCfg.Endpoint == "" {
		return nil
	}

	ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
	defer cancel()

	req, err := http.NewRequestWithContext(ctx, http.MethodPost, r.NotificationCfg.Endpoint, body)
	if err != nil {
		return err
	}

	if r.NotificationCfg.Token != "" {

/**
 * 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}

    } finally {
      Thread.interrupted();
    }
  }

  public void testGetCheckedUntimed_cancelled() throws TwoArgConstructorException {
    SettableFuture<String> future = SettableFuture.create();
    future.cancel(true);
    assertThrows(
        CancellationException.class, () -> getChecked(future, TwoArgConstructorException.class));
  }

  public void testGetCheckedUntimed_executionExceptionChecked() {