`Exactly so,' said the Hatter:  `as the things get used up.'

  `But what happens when you come to the beginning again?' Alice
ventured to ask.

  `Suppose we change the subject,' the March Hare interrupted,
yawning.  `I'm getting tired of this.  I vote the young lady
tells us a story.'

  `I'm afraid I don't know one,' said Alice, rather alarmed at
the proposal.

            try {
                latch.await();
            } catch (InterruptedException e) {
                result.addErrorArtifactException(
                        new ArtifactResolutionException("Resolution interrupted", rootArtifact, e));
            }
        }

        // We want to send the root artifact back in the result but we need to do this after the other dependencies
        // have been resolved.

            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new IOException("Interrupted waiting for send credit", e);
            }
        }
        
        if (!rdmaConnection.canSend()) {
            throw new IOException("Timeout waiting for RDMA send credit");
        }
    }
    

   * Returns a future that delegates to another but will finish early (via a {@link
   * TimeoutException} wrapped in an {@link ExecutionException}) if the specified duration expires.
   *
   * <p>The delegate future is interrupted and cancelled if it times out.
   *
   * @param delegate The future to delegate to.
   * @param time when to time out the future
   * @param scheduledExecutor The executor service to enforce the timeout.

                executorService.awaitTermination(60, TimeUnit.SECONDS);
            } catch (final InterruptedException e) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Interrupted.", e);
                }
            } finally {
                executorService.shutdownNow();
            }
        }
    }

    /**

            }
            wait() // Wait until we receive a WINDOW_UPDATE.
          }
        } catch (e: InterruptedException) {
          Thread.currentThread().interrupt() // Retain interrupted status.
          throw InterruptedIOException()
        }

        toWrite = minOf(byteCount, writeBytesMaximum - writeBytesTotal).toInt()
        toWrite = minOf(toWrite, writer.maxDataLength())

 * in a few ways:
 *
 * <ul>
 *   <li>Each task may be associated with a different executor.
 *   <li>Tasks may be of type {@code AsyncCallable}.
 *   <li>Running tasks <i>cannot</i> be interrupted. (Note that {@code newSequentialExecutor} does
 *       not return {@code Future} objects, so it doesn't support interruption directly, either.

     *
     * @param consumer Consumer function to configure the bulk request builder
     * @return true if all bulk operations were successful, false otherwise
     * @throws InterruptedRuntimeException if the operation is interrupted
     * @throws SearchEngineClientException if the bulk update fails
     */
    public boolean bulkUpdate(final Consumer<BulkRequestBuilder> consumer) {

 *  Fix: Reverse suppression of connect exceptions. When both a call and its retry fail, we now
    throw the initial exception which is most likely to be actionable.
 *  Fix: Retain interrupted state when throwing `InterruptedIOException`. A single interrupt should
    now be sufficient to break out an in-flight OkHttp call.
 *  Fix: Don't drop a call to `EventListener.callEnd()` when the response body is consumed inside an

                    return this.treeHandle;

                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                    throw new SmbException("Connection retry interrupted", ie);
                } catch (CIFSException retryException) {
                    log.debug("Connection retry also failed", retryException);
                    throw e; // Throw original exception
                }