}

  @Override
  public Entry<String, String> aboveSamplesGreater() {
    return mapEntry("~~ b", "above view");
  }

  @Override
  public Iterable<Entry<String, String>> order(List<Entry<String, String>> insertionOrder) {
    return orderEntriesByKey(insertionOrder);
  }

  @Override
  protected abstract SortedMap<String, String> create(Entry<String, String>[] entries);

  @Override

   *
   * <p>Callers must ensure that the source {@code iterators} are in non-descending order as this
   * method does not sort its input.
   *
   * <p>For any equivalent elements across all {@code iterators}, elements are returned in the order
   * of their source iterators. That is, if element A from iterator 1 and element B from iterator 2

 * or to force a specific known IP address.
 *
 * Implementations of this interface must be safe for concurrent use.
 */
fun interface Dns {
  /**
   * Returns the IP addresses of `hostname`, in the order they will be attempted by OkHttp. If a
   * connection to an address fails, OkHttp will retry the connection with the next address until
   * either a connection is made, the set of IP addresses is exhausted, or a limit is exceeded.

 * elementsToInsert}, the elements to be passed to {@code set()} and {@code add()} calls; {@code
 * features}, the features supported by the iterator; and {@code expectedElements}, the elements the
 * iterator should return in order.
 *
 * <p>The items in {@code elementsToInsert} will be repeated if {@code steps} is larger than the
 * number of provided elements.
 *
 * @author Chris Povirk
 */
@GwtCompatible
@NullMarked

  public Entry<K, V>[] createArray(int length) {
    return (Entry<K, V>[]) new Entry<?, ?>[length];
  }

  /** Returns the original element list, unchanged. */
  @Override
  public List<Entry<K, V>> order(List<Entry<K, V>> insertionOrder) {
    return insertionOrder;
  }

import com.google.common.annotations.J2ktIncompatible;
import java.util.Collections;
import java.util.Set;
import org.jspecify.annotations.Nullable;

/**
 * Encapsulates the constraints that a class under test must satisfy in order for a tester method to
 * be run against that class.
 *
 * @author George van den Driessche
 */
@GwtCompatible
public final class TesterRequirements {
  private final Set<Feature<?>> presentFeatures;

    this.nextOrNull = firstOrNull;
  }

  /**
   * Returns the element that follows {@code previous}, or returns {@code null} if no elements
   * remain. This method is invoked during each call to {@link #next()} in order to compute the
   * result of a <i>future</i> call to {@code next()}.
   */
  protected abstract @Nullable T computeNext(T previous);

  @Override
  public final boolean hasNext() {
    return nextOrNull != null;

 * it as a {@code GwtIncompatible} annotation. And for {@code Futures.catching}, we need the GWT
 * compiler to autostrip the normal server method in order to expose the special, inherited GWT
 * version.
 */
@GwtCompatible
final class Partially {
  /**
   * The presence of this annotation on an API indicates that the method <i>may</i> be used with the

        // Total size: 152 bytes
        byte[] buffer = new byte[Smb2ChannelCapabilities.NETWORK_INTERFACE_INFO_SIZE];
        ByteBuffer bb = ByteBuffer.wrap(buffer).order(ByteOrder.LITTLE_ENDIAN);

        // Next field (4 bytes) - offset to next entry (0 for last entry)
        bb.putInt(0);

        // InterfaceIndex (4 bytes)
        bb.putInt(interfaceIndex);

            doColumn("urlId");
        }

        public void columnDocId() {
            doColumn("docId");
        }

        public void columnOrder() {
            doColumn("order");
        }

        public void columnQueryId() {
            doColumn("queryId");
        }

        public void columnQueryRequestedAt() {
            doColumn("queryRequestedAt");
        }