* </pre>
 *
 * the access check would fail because the direct ACE has an access mask
 * of <code>0x001200A9</code> which doesn't have the
 * <code>FILE_WRITE_DATA</code> bit on (bit <code>0x00000002</code>). Actually, this isn't quite correct. If
 * <code>WNET\alice</code> is in the local <code>Administrators</code> group the access check
 * will succeed because the inherited ACE allows local <code>Administrators</code>

   * detail is invisible to the caller, but subtle use of certain APIs may depend on these internal
   * structures.
   *
   * We make such subtle calls in [okhttp3.internal.ws.MessageInflater] because we try to read a
   * compressed stream that is terminated in a web socket frame even though the DEFLATE stream is
   * not terminated.
   *

  fun setContext() {
    // Ensure we aren't succeeding because of another test
    Platform.resetForTests()
    PlatformRegistry.applicationContext = null
  }

  @Test
  fun testWithoutContext() {
    val httpUrl = "https://www.google.co.uk".toHttpUrl()
    assertFailure { httpUrl.topPrivateDomain() }.all {
      hasMessage("Unable to load PublicSuffixDatabase.list resource.")
      cause().isNotNull().all {
        hasMessage(

[OkHttp 3.10][OkHttp310]
------------------------

_2018-02-24_

Remove two rarely-used cipher suites from the default set. This tracks a [Chromium change][chromium_change] to remove these cipher suites because they are fragile and rarely-used.

##### MODERN_TLS / COMPATIBLE_TLS cipher suites

 * TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
 * TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
 * TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384

   * `new Integer` (as we do) instead of `Integer.valueOf`. However, under J2KT, `new Integer`
   * gets translated back to `Integer.valueOf` because that is the only thing J2KT can support. And
   * anyway, it's nice to avoid `Integer.valueOf` because the Android toolchain optimizes multiple
   * `Integer.valueOf` calls into one! So we stick with the deprecated `Integer` constructor.
   */

      Cell<R, C, V> cell = cellList.get(i);
      R rowKey = cell.getRowKey();
      C columnKey = cell.getColumnKey();
      V value = cell.getValue();

      /*
       * These requireNonNull calls are safe because we construct the maps to hold all the provided
       * cells.
       */
      cellRowIndices[i] = requireNonNull(rowIndex.get(rowKey));
      Map<C, V> thisRow = requireNonNull(rows.get(rowKey));

   * remove()}. Otherwise, all optional operations are supported. Null row keys, columns keys, and
   * values are not supported.
   *
   * <p>Lookups by row key are often faster than lookups by column key, because the data is stored
   * in a {@code Map<R, Map<C, V>>}. A method call like {@code column(columnKey).get(rowKey)} still
   * runs quickly, since the row key is provided. However, {@code column(columnKey).size()} takes

  private static <E extends Comparable<? super E>> SortedSet<E> nullCheckedTreeSet(E[] elements) {
    SortedSet<E> set = newTreeSet();
    for (E element : elements) {
      // Explicit null check because TreeSet wrongly accepts add(null) when empty.
      set.add(checkNotNull(element));
    }
    return set;
  }

  public static class ContiguousSetGenerator extends AbstractContiguousSetGenerator {
    @Override

      return this.value == that.value;
    }
    return false;
  }

  @Override
  public int hashCode() {
    throw new UnsupportedOperationException();
  }

  // needed because otherwise Object.toString() calls hashCode()
  @Override
  public String toString() {
    return "DontHashMe" + value;
  }

  @Override
  public int compareTo(UnhashableObject o) {

 */
package okhttp3

import okio.IOException

interface Callback {
  /**
   * Called when the request could not be executed due to cancellation, a connectivity problem or
   * timeout. Because networks can fail during an exchange, it is possible that the remote server
   * accepted the request before the failure.
   */
  fun onFailure(
    call: Call,
    e: IOException,
  )

  /**