for (final Future<Integer> future : futures) {
                future.get();
            }
        } catch (final InterruptedException e) {
            // Interrupted while waiting
        } catch (final ExecutionException e) {
            // Execution failed
        } finally {
            executor.shutdown();
            try {

   *
   * <p>If a task is {@linkplain Thread#interrupt interrupted} while a task is running:
   *
   * <ol>
   *   <li>execution will not stop until the task queue is empty.
   *   <li>tasks will begin execution with the thread marked as not interrupted - any interruption
   *       applies only to the task that was running at the point of interruption.
   *   <li>if the thread was interrupted before the SequentialExecutor's worker begins execution,

    // at the bottom and throw a timeoutexception.
    long timeoutNanos = unit.toNanos(timeout); // we rely on the implicit null check on unit.
    long remainingNanos = timeoutNanos;
    if (Thread.interrupted()) {
      throw new InterruptedException();
    }
    @RetainedLocalRef Object localValue = valueField;
    if (localValue != null & notInstanceOfDelegatingToFuture(localValue)) {

    // at the bottom and throw a timeoutexception.
    long timeoutNanos = unit.toNanos(timeout); // we rely on the implicit null check on unit.
    long remainingNanos = timeoutNanos;
    if (Thread.interrupted()) {
      throw new InterruptedException();
    }
    @RetainedLocalRef Object localValue = valueField;
    if (localValue != null & notInstanceOfDelegatingToFuture(localValue)) {

   * @return the value associated with {@code key}; <b>must not be null</b>
   * @throws Exception if unable to load the result
   * @throws InterruptedException if this method is interrupted. {@code InterruptedException} is
   *     treated like any other {@code Exception} in all respects except that, when it is caught,
   *     the thread's interrupt status is set
   */

                }
                parentThread.join(millis);
            } catch (final InterruptedException e) {
                logger.warn("Crawler thread was interrupted while waiting for termination: thread={}, sessionId={}", parentThread.getName(),
                        crawlerContext.sessionId, e);
                Thread.currentThread().interrupt();
            }
        }
    }

    AtomicBoolean terminated = new AtomicBoolean();
    // we need to keep this in a flag because t.isInterrupted() returns false after t.join()
    AtomicBoolean interrupted = new AtomicBoolean();
    // we need to use another thread because it will be interrupted and thus using
    // the current one, owned by JUnit, would make the test fail
    Thread thread =
        new Thread(
            new Runnable() {

              socket.setReceiveBufferSize(SOCKET_BUFFER_SIZE)
              return socket
            }
          },
        ).build()
  }

  @AfterEach
  fun tearDown() {
    Thread.interrupted() // Clear interrupted state.
  }

  @Test
  fun interruptWritingRequestBody() {
    server.enqueue(MockResponse())
    server.start()
    val call =
      client.newCall(
        Request
          .Builder()

   * 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.
   */
  private static final class ListenableFutureAdapter<V extends @Nullable Object>

    AtomicBoolean terminated = new AtomicBoolean();
    // we need to keep this in a flag because t.isInterrupted() returns false after t.join()
    AtomicBoolean interrupted = new AtomicBoolean();
    // we need to use another thread because it will be interrupted and thus using
    // the current one, owned by JUnit, would make the test fail
    Thread thread =
        new Thread(
            new Runnable() {