}

  /**
   * Returns the least value present in {@code array}.
   *
   * @param array a <i>nonempty</i> array of {@code short} values
   * @return the value present in {@code array} that is less than or equal to every other value in
   *     the array
   * @throws IllegalArgumentException if {@code array} is empty
   */
  @GwtIncompatible(
      "Available in GWT! Annotation is to avoid conflict with GWT specialization of base class.")

    Integer javaVersion = Ints.tryParse(JAVA_SPECIFICATION_VERSION.value());
    if (javaVersion != null && javaVersion >= 9) {
      return;
    }
    // Obviously this isn't guaranteed in every environment, but it works well enough for now:
    assertTrue(lazyStackTraceIsLazy());
  }

  @J2ktIncompatible
  @GwtIncompatible // lazyStackTrace(Throwable)
  public void testLazyStackTrace() {

    }

    /**
     * Returns an array of available data store names discovered from plugin JAR files.
     * This method implements a time-based caching mechanism that refreshes the list
     * every 60 seconds to balance performance with up-to-date plugin discovery.
     *
     * @return array of data store names sorted alphabetically, never null
     */
    public String[] getDataStoreNames() {

import okhttp3.tls.internal.TlsUtil.localhost
import okio.Buffer
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.Disabled
import org.junit.jupiter.api.Test

/**
 * Access every declaration that is deprecated with [DeprecationLevel.ERROR]. Although new Kotlin
 * code shouldn't use these, they're necessary for clients migrating from OkHttp 3.x and this test

      }
      return ((SortedMap<C, V>) backingRowMap).lastKey();
    }

    transient @Nullable SortedMap<C, V> wholeRow;

    // If the row was previously empty, we check if there's a new row here every time we're queried.
    void updateWholeRowField() {
      if (wholeRow == null || (wholeRow.isEmpty() && backingMap.containsKey(rowKey))) {
        wholeRow = (SortedMap<C, V>) backingMap.get(rowKey);
      }
    }

   *
   * <p><b>Note:</b> This method ignores how often any element might appear in {@code c}, and only
   * cares whether or not an element appears at all. If you wish to remove one occurrence in this
   * multiset for every occurrence in {@code c}, see {@link Multisets#removeOccurrences(Multiset,
   * Multiset)}.
   *
   * <p>This method refines {@link Collection#removeAll} to further specify that it <b>may not</b>

 *       {@code AsyncCallable}) to complete, without interrupting it (and without calling {@code
 *       cancel} on the {@code Future}). So beware: <i>Even if you cancel every preceding {@code
 *       Future} returned by this class, the next task may still have to wait.</i>.
 *   <li>Once an {@code AsyncCallable} returns a {@code Future}, this class considers that task to

   *
   * <p>The returned set isn't threadsafe or serializable, even if {@code unfiltered} is.
   *
   * <p>Many of the filtered set's methods, such as {@code size()}, iterate across every element in
   * the underlying set and determine which elements satisfy the filter. When a live view is
   * <i>not</i> needed, it may be faster to copy {@code Iterables.filter(unfiltered, predicate)} and
   * use the copy.

   * intended to be used as a metric: smaller headers are more efficient to encode and transmit.
   */
  fun byteCount(): Long {
    // Each header name has 2 bytes of overhead for ': ' and every header value has 2 bytes of
    // overhead for '\r\n'.
    var result = (namesAndValues.size * 2).toLong()

    for (i in 0 until namesAndValues.size) {
      result += namesAndValues[i].length.toLong()
    }

 * before the {@link Service} reaches the {@linkplain State#RUNNING RUNNING} state. The set of legal
 * transitions form a <a href="http://en.wikipedia.org/wiki/Directed_acyclic_graph">DAG</a>,
 * therefore every method of the listener will be called at most once. N.B. The {@link State#FAILED}
 * and {@link State#TERMINATED} states are terminal states, once a service enters either of these
 * states it cannot ever leave them.
 *