}

    /**
     * Attempt to reconnect a handle
     * @param path the file path
     * @param cause the original exception that triggered reconnection
     * @return a future that completes with the reconnected handle info or fails
     */
    public CompletableFuture<HandleInfo> reconnectHandle(String path, Exception cause) {
        HandleInfo info = handleManager.getHandleForReconnect(path);

  /**
   * Returns the value associated with {@code key} in this cache, first loading that value if
   * necessary. No observable state associated with this cache is modified until loading completes.
   *
   * <p>If another call to {@link #get} or {@link #getUnchecked} is currently loading the value for
   * {@code key}, simply waits for that thread to finish and returns its loaded value. Note that

    this.future = future;

    future.addListener(this, directExecutor());
  }

  @Override
  public void run() {
    countDownLatch.countDown();
  }

  /**
   * Verify that the listener completes in a reasonable amount of time, and Asserts that the future
   * returns the expected data.
   *
   * @throws Throwable if the listener isn't called or if it resulted in a throwable or if the

import static java.lang.annotation.RetentionPolicy.RUNTIME;

/**
 * Indicates that annotated component should be instantiated before mojo execution starts and discarded after mojo
 * execution completes.
 *
 * @since 3.1.2
 */
@Target({TYPE})
@Retention(RUNTIME)
@ScopeAnnotation

        when(session.getTransport()).thenReturn(transport);
        assertSame(transport, session.getTransport());
        verify(session).getTransport();
    }

    // Happy path: connect to logon share completes without exception
    @Test
    @DisplayName("treeConnectLogon performs call without exception")
    void treeConnectLogon_happy() throws SmbException {
        // doNothing by default

  /**
   * An adapter to turn a {@link Future} into a {@link ListenableFuture}. This will wait on the
   * future to finish, and when it completes, run the listeners. This implementation will wait on
   * the source future indefinitely, so if the source future never completes, the adapter will never
   * complete either.
   *
   * <p>If the delegate future is interrupted or throws an unexpected unchecked exception, the
   * listeners will not be invoked.

import static java.lang.annotation.RetentionPolicy.RUNTIME;

/**
 * Indicates that annotated component should be instantiated before session execution starts
 * and discarded after session execution completes.
 *
 * @since 3.2.0
 */
@Target({TYPE})
@Retention(RUNTIME)
@ScopeAnnotation

import static java.lang.annotation.RetentionPolicy.RUNTIME;

/**
 * Indicates that annotated component should be instantiated before session execution starts
 * and discarded after session execution completes.
 * <p>
 * A {@code org.apache.maven.api.Session} object is available in the scope of this annotation.
 *
 * @since 4.0.0
 */
@Scope
@Documented
@Retention(RUNTIME)
@Target({TYPE, METHOD})

          .build(),
      )
    call1.execute().use { response -> response.body.string() }

    listener.shouldClose = true
    // Large headers are a likely reason the servers would cut off the connection before it completes sending
    // request headers.
    // 431 "Request Header Fields Too Large"
    val largeHeaders =
      Headers
        .Builder()
        .apply {
          repeat(32) {

    extends AbstractFuture.TrustedFuture<OutputT> {
  // Lazily initialized the first time we see an exception; not released until all the input futures
  // & this future completes. Released when the future releases the reference to the running state
  private @Nullable Set<Throwable> seenExceptions = null;
  private int remaining;

  AggregateFutureState(int remainingFutures) {