}

  static class MyServerExampleWithFrq implements Closeable {
    private static final FinalizableReferenceQueue frq = new FinalizableReferenceQueue();

    private static final Set<Reference<?>> references = Sets.newConcurrentHashSet();

    private final ServerSocket serverSocket;

    private MyServerExampleWithFrq() throws IOException {
      this.serverSocket = new ServerSocket(0);

@Immutable(containerOf = "B")
@GwtIncompatible
// TODO(b/278589132): Remove the redundant "@NonNull" on B once it's no longer required by J2KT.
public final class ImmutableClassToInstanceMap<B>
    extends ForwardingMap<Class<? extends @NonNull B>, B>
    implements ClassToInstanceMap<B>, Serializable {

  private static final ImmutableClassToInstanceMap<Object> EMPTY =
      new ImmutableClassToInstanceMap<>(ImmutableMap.of());

  /**

  // The replacement array (see ArrayBasedEscaperMap).
  private final char[][] replacements;
  // The number of elements in the replacement array.
  private final int replacementsLength;
  // The first character in the safe range.
  private final char safeMin;
  // The last character in the safe range.
  private final char safeMax;

  /**

public class RdmaTransport implements SmbTransportInternal {
    private static final Logger log = LoggerFactory.getLogger(RdmaTransport.class);

    private final SmbTransportInternal delegate;
    private final RdmaProvider rdmaProvider;
    private final RdmaBufferManager bufferManager;
    private final RdmaStatistics statistics;
    private RdmaConnection rdmaConnection;
    private final Object connectionLock = new Object();

    /**

   */
  protected final void validateEndpoints(EndpointPair<?> endpoints) {
    checkNotNull(endpoints);
    checkArgument(isOrderingCompatible(endpoints), ENDPOINTS_MISMATCH);
  }

  protected final boolean isOrderingCompatible(EndpointPair<?> endpoints) {
    return endpoints.isOrdered() == this.isDirected();
  }

  @Override
  public final boolean equals(@Nullable Object obj) {

   */
  private static final class GetCheckedTypeValidatorHolder {
    static final GetCheckedTypeValidator BEST_VALIDATOR = getBestValidator();

    enum WeakSetValidator implements GetCheckedTypeValidator {
      INSTANCE;

      /*
       * Static final fields are presumed to be fastest, based on our experience with

    FinalizableReference.register(referent, finalizerRan);
    return new WeakReference<>(referent);
  }

  private static final class FinalizableReference extends FinalizablePhantomReference<Object> {
    static final FinalizableReferenceQueue referenceQueue = new FinalizableReferenceQueue();
    static final Set<FinalizableReference> references = newConcurrentHashSet();

    static void register(Object referent, CountDownLatch latch) {

 * manage collections of search results and crawled documents.
 *
 */
public class DocList extends ArrayList<Map<String, Object>> {

    /** Serial version UID for serialization */
    private static final long serialVersionUID = 1L;

    /** Total content size of all documents in this list */
    private long contentSize = 0;

    /** Total processing time for all documents in this list */

 */
@NullUnmarked
@GwtIncompatible
@J2ktIncompatible
public abstract class AbstractChainedListenableFutureTest<T> extends TestCase {
  protected static final int EXCEPTION_DATA = -1;
  protected static final int VALID_INPUT_DATA = 1;
  protected static final Exception EXCEPTION = new Exception("Test exception");

  protected SettableFuture<Integer> inputFuture;
  protected ListenableFuture<T> resultFuture;

import java.util.Iterator;
import org.jspecify.annotations.Nullable;

/** An ordering that uses the reverse of a given order. */
@GwtCompatible
final class ReverseOrdering<T extends @Nullable Object> extends Ordering<T>
    implements Serializable {
  final Ordering<? super T> forwardOrder;

  ReverseOrdering(Ordering<? super T> forwardOrder) {
    this.forwardOrder = checkNotNull(forwardOrder);
  }

  @Override