*/
    public void configureKeyRotation(long intervalMillis) {
        this.keyRotationIntervalMillis = intervalMillis;

        // Cancel existing rotation task if any
        if (rotationTask != null) {
            rotationTask.cancel(false);
        }

        // Schedule new rotation task
        if (intervalMillis > 0) {

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

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

    last: Boolean,
  ): Boolean

  /** Indicates the reason why this stream was canceled. */
  fun onReset(
    streamId: Int,
    errorCode: ErrorCode,
  )

  companion object {
    @JvmField val CANCEL: PushObserver = PushObserverCancel()

    private class PushObserverCancel : PushObserver {
      override fun onRequest(
        streamId: Int,
        requestHeaders: List<Header>,
      ): Boolean = true

    long r = 0;
    List<Facade<Integer>> list = new ArrayList<>(reps);
    for (int i = 0; i < reps; i++) {
      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;
      }

		Path:   pathJoin(healthCheckPathPrefix, healthCheckLivenessPath),
	}

	httpClient := &http.Client{
		Transport: globalInternodeTransport,
	}

	ctx, cancel := context.WithTimeout(GlobalContext, timeout)
	defer cancel()

	req, err := http.NewRequestWithContext(ctx, http.MethodGet, serverURL.String(), nil)
	if err != nil {
		return err
	}
	// Indicate that the liveness check for a peer call

on:
  pull_request:
    branches:
      - master

# This ensures that previous jobs for the PR are canceled when the PR is
# updated.
concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref }}
  cancel-in-progress: true

permissions:
  contents: read

jobs:
  replication-test:
    name: Advanced Tests with Go ${{ matrix.go-version }}
    runs-on: ubuntu-latest

    strategy:
      matrix:

    assertThatFutureBecomesCancelled(closingFuture.finishToFuture());
  }

  @Override
  void cancelFinalStepAndWait(ClosingFuture<TestCloseable> closingFuture) {
    assertThat(closingFuture.finishToFuture().cancel(false)).isTrue();
    waitUntilClosed(closingFuture);
    futureCancelled.countDown();
  }

     *
     * @return whether the task has been canceled
     */
    public boolean isCanceled() {
        return status == CANCELED;
    }

    /**
     * Cancels the task.
     */
    public void cancel() {
        status = CANCELED;
    }

    /**
     * Returns whether the task is stopped.
     *
     * @return whether the task is stopped
     */
    public boolean isStopped() {

    val response1 = call1.execute()
    waitForDataFrames(Http2Connection.OKHTTP_CLIENT_WINDOW_SIZE)

    // Cancel the call and discard what we've buffered for the response body. This should free up
    // the connection flow-control window so new requests can proceed.
    call1.cancel()
    assertThat(
      response1.body.source().discard(1, TimeUnit.SECONDS),
      "Call should not have completed successfully.",

      AbstractFutureBenchmarks.awaitWaiting(thread);
    }
    switch (state) {
      case NOT_DONE:
        break;
      case FINISHED:
        f.set(null);
        break;
      case CANCELLED:
        f.cancel(false);
        break;
      case FAILED:
        f.setException(new Exception());
        break;
    }
    return f;
  }