// code should be unreachable with correctly implemented Futures.
      // Cancel this future and return.
      // At this point, inputFuture is cancelled and outputFuture doesn't exist, so the value of
      // mayInterruptIfRunning is irrelevant.
      cancel(false);
      return;
    } catch (ExecutionException e) {
      // Set the cause of the exception as this future's exception.

            bool,
            Doc(
                """
                By default, if no HTTP Authorization header is provided, required for
                OpenID Connect authentication, it will automatically cancel the request
                and send the client an error.

                If `auto_error` is set to `False`, when the HTTP Authorization header

  NO_ERROR(0),

  PROTOCOL_ERROR(1),

  INTERNAL_ERROR(2),

  FLOW_CONTROL_ERROR(3),

  SETTINGS_TIMEOUT(4),

  STREAM_CLOSED(5),

  FRAME_SIZE_ERROR(6),

  REFUSED_STREAM(7),

  CANCEL(8),

  COMPRESSION_ERROR(9),

  CONNECT_ERROR(0xa),

  ENHANCE_YOUR_CALM(0xb),

  INADEQUATE_SECURITY(0xc),

  HTTP_1_1_REQUIRED(0xd),
  ;

  companion object {

            - elastic
          allow-whitelist-orgs-as-admins: true
          trigger-phrase: '.*run\W+elasticsearch-ci/full-bwc.*'
          github-hooks: true
          status-context: elasticsearch-ci/full-bwc
          cancel-builds-on-update: true
          excluded-regions:
            - ^docs/.*
          white-list-labels:
            - 'test-full-bwc'
          black-list-labels:
            - '>test-mute'
    axes:
      - axis:

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

    assertThatFutureBecomesCancelled(closingFuture.finishToFuture());
  }

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

          allow-whitelist-orgs-as-admins: true
          trigger-phrase: '.*run\W+elasticsearch-ci/eql-correctness.*'
          github-hooks: true
          status-context: elasticsearch-ci/eql-correctness
          cancel-builds-on-update: true
          black-list-target-branches:
            - 6.8
          excluded-regions:
            - ^docs/.*
          black-list-labels:
            - '>test-mute'
    builders:

          allow-whitelist-orgs-as-admins: true
          trigger-phrase: '.*run\W+elasticsearch-ci/part-2-windows.*'
          github-hooks: true
          status-context: elasticsearch-ci/part-2-windows
          cancel-builds-on-update: true
          black-list-target-branches:
            - 6.8
          excluded-regions:
            - ^docs/.*
          white-list-labels:
            - 'test-windows'
          black-list-labels:

            exitCode = Constants.EXIT_FAIL;
        } finally {
            if (systemMonitorTask != null) {
                systemMonitorTask.cancel();
            }
            if (logNotificationTask != null) {
                logNotificationTask.cancel();
            }
            if (logNotificationTarget != null) {
                logNotificationTarget.flush();
            }
            destroyContainer();

            // Verify timeout occurs
            assertThrows(TimeoutException.class, () -> {
                future.get(100, TimeUnit.MILLISECONDS);
            });

            // Cancel the future
            future.cancel(true);
        } finally {
            executor.shutdownNow();
        }
    }