assertThat(cache.asMap().keySet()).containsNoneIn(removalNotifications.keySet());
    threadPool.shutdown();
    threadPool.awaitTermination(300, SECONDS);
  }

  /**
   * Calls get() repeatedly from many different threads, and tests that all of the removed entries
   * (removed because of size limits or expiration) trigger appropriate removal notifications.
   */
  @J2ktIncompatible
  @GwtIncompatible // QueuingRemovalListener

If a self-signed certificate is being used, the certificate can be added to MinIO's certificates directory, so it can be trusted by the server.

#### DNS SRV Records

import okhttp3.internal.toHeaders
import okio.Buffer
import okio.BufferedSource
import okio.ByteString

/**
 * A socket connection to a remote peer. A connection hosts streams which can send and receive
 * data.
 *
 * Many methods in this API are **synchronous:** the call is completed before the method returns.
 * This is typical for Java but atypical for HTTP/2. This is motivated by exception transparency:

	// A non-nil error value will be returned as RemoteErr(msg) to client.
	StatelessHandlerFn func(ctx context.Context, payload []byte, resp chan<- []byte) *RemoteErr

	// StatelessHandler is handlers for one to many requests,
	// where responses may be dropped.
	// Stateless requests provide no incoming stream and there is no flow control
	// on outgoing messages.
	StatelessHandler struct {
		Handle StatelessHandlerFn

 *
 * <p>We recommend using <a href="https://github.com/classgraph/classgraph/wiki">ClassGraph</a>
 * instead of {@code ClassPath}. ClassGraph improves upon {@code ClassPath} in several ways,
 * including addressing many of its limitations. Limitations of {@code ClassPath} include:
 *
 * <ul>
 *   <li>It looks only for files and JARs in URLs available from {@link URLClassLoader} instances or

  @Override
  boolean retainAll(Collection<?> c);

  /**
   * {@inheritDoc}
   *
   * <p>Elements that occur multiple times in the multiset will be passed to the {@code Consumer}
   * correspondingly many times, though not necessarily sequentially.
   */
  @Override
  default void forEach(Consumer<? super E> action) {
    checkNotNull(action);
    entrySet()
        .forEach(
            entry -> {

 * the rest not null -- and the test fails if no expected exception is thrown. {@code
 * NullPointerTester} uses best effort to pick non-null default values for many common JDK and Guava
 * types, and also for interfaces and public classes that have public parameter-less constructors.
 * When the non-null default value for a particular parameter type cannot be provided by {@code

   * the underlying collection.
   *
   * <p>The returned collection isn't threadsafe or serializable, even if {@code unfiltered} is.
   *
   * <p>Many of the filtered collection's methods, such as {@code size()}, iterate across every
   * element in the underlying collection and determine which elements satisfy the filter. When a

import java.util.function.Function;
import java.util.function.ToIntFunction;
import java.util.stream.Collector;
import org.jspecify.annotations.Nullable;

/**
 * A {@link SortedMultiset} whose contents will never change, with many other important properties
 * detailed at {@link ImmutableCollection}.
 *
 * <p><b>Warning:</b> as with any sorted collection, you are strongly advised not to use a {@link

 * </ul>
 *
 * <p><b>Note:</b> In general, {@code ByteSource} is intended to be used for "file-like" sources
 * that provide streams that are:
 *
 * <ul>
 *   <li><b>Finite:</b> Many operations, such as {@link #size()} and {@link #read()}, will either
 *       block indefinitely or fail if the source creates an infinite stream.