// transitioned to a failed state, also this means that shutDown has already
                  // been called, so we do not want to call it again.
                  return;
                }
                shutDown();
              } finally {
                lock.unlock();
              }
              notifyStopped();

    private final Callable<T> delegate;

    WrappedCallable(Callable<T> delegate) {
      this.delegate = delegate;
    }

    @Override
    public T call() throws Exception {
      return delegate.call();
    }
  }

  private static final class WrappedRunnable implements Runnable {
    private final Runnable delegate;

    WrappedRunnable(Runnable delegate) {

    void testStateConsistencyAfterOperations() {
        // When - perform various operations
        assertFalse(emptyIterator.hasNext(), "Initial hasNext check");
        assertNull(emptyIterator.next(), "Initial next call");

        emptyIterator.remove();
        assertFalse(emptyIterator.hasNext(), "hasNext after remove");
        assertNull(emptyIterator.next(), "next after remove");

        assertDoesNotThrow(() -> {

	updatedAt, err := globalBucketMetadataSys.Update(ctx, bucket, bucketSSEConfig, configData)
	if err != nil {
		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	// Call site replication hook.
	//
	// We encode the xml bytes as base64 to ensure there are no encoding
	// errors.
	cfgStr := base64.StdEncoding.EncodeToString(configData)

     *
     * @param dataset the dataset to do the calculation on, which must be non-empty, which will be
     *     cast to doubles (with any associated lost of precision), and which will not be mutated by
     *     this call (it is copied instead)
     * @return the quantile value
     */
    public double compute(Collection<? extends Number> dataset) {
      return computeInPlace(Doubles.toArray(dataset));
    }

    /**

    private static final Logger log = LoggerFactory.getLogger(SmbPipeHandleImpl.class);

    private final SmbNamedPipe pipe;
    private final boolean transact;
    private final boolean call;

    private final int openFlags;
    private final int access;
    private volatile boolean open = true;

    private SmbFileHandleImpl handle;
    private SmbPipeOutputStream output;

 *
 * When a single logical call requires multiple streams due to redirects or authorization
 * challenges, we prefer to use the same physical connection for all streams in the sequence. There
 * are potential performance and behavior consequences to this preference. To support this feature,
 * this class separates _allocations_ from _streams_. An allocation is created by a call, used for

  /**
   * {@inheritDoc}
   *
   * @throws IllegalArgumentException if the given value is already bound to a different key in this
   *     bimap. The bimap will remain unmodified in this event. To avoid this exception, call {@link
   *     #forcePut} instead.
   */
  @CanIgnoreReturnValue
  @Override
  @Nullable V put(@ParametricNullness K key, @ParametricNullness V value);

  /**

   * types (or if the type is a non-variable type, like {@code String}), then code should almost
   * never use this method, preferring instead to call {@code requireNonNull} so as to benefit from
   * its runtime check.
   *
   * <p>An example use case for this method is in implementing an {@code Iterator<T>} whose {@code

   * types (or if the type is a non-variable type, like {@code String}), then code should almost
   * never use this method, preferring instead to call {@code requireNonNull} so as to benefit from
   * its runtime check.
   *
   * <p>An example use case for this method is in implementing an {@code Iterator<T>} whose {@code