OkHttp 4.x Change Log
=====================

## Version 4.12.0

_2023-10-16_

 *  Fix: Don't hang taking headers for HTTP 103 responses.

 *  Fix: Recover gracefully when a cache entry's certificate is corrupted.

 *  Fix: Fail permanently when there's a failure loading the bundled public suffix database.
    This is the dataset that powers `HttpUrl.topPrivateDomain()`.

    `keepAliveDuration` but do not count against the pool-wide `maxIdleConnections` limit.

    This feature increases the client's traffic and the load on the server. Talking to your server's
    operators before adopting it.

 *  New in okhttp-android: `HttpLoggingInterceptor.androidLogging()` and
    `LoggingEventListener.androidLogging()` write HTTP calls or events to Logcat.

    parts.nextPart()!!
    val partMno = parts.nextPart()!!
    assertThat(partMno.body.readUtf8()).isEqualTo("mnop")

    assertThat(parts.nextPart()).isNull()
  }

  @Test fun `cannot read part after calling nextPart`() {
    val multipart =
      """
      |--simple boundary
      |
      |abcd
      |efgh
      |ijkl
      |--simple boundary
      |
      |mnop
      |--simple boundary--

   * up the necessary in-memory cache information.
   *
   * The initialization time may vary depending on the journal file size and the current actual
   * cache size. The application needs to be aware of calling this function during the
   * initialization phase and preferably in a background worker thread.
   *
   * Note that if the application chooses to not call this method to initialize the cache. By

 * deterministic.
 *
 * This class ensures that at most one thread is running at a time. This is initially the JUnit test
 * thread, which yields its execution privilege while calling [runTasks], [runNextTask], or
 * [advanceUntil]. These functions don't return until the task threads are all idle.
 *
 * Task threads release their execution privilege in these ways:
 *

    }

    if (queue.futureTasks.isNotEmpty()) {
      readyQueues.add(queue)
    }
  }

  /**
   * Returns an immediately-executable task for the calling thread to execute, sleeping as necessary
   * until one is ready. If there are no ready queues, or if other threads have everything under

 *
 * Both this class and [Response] implement [Closeable]. Closing a response simply
 * closes its response body. If you invoke [Call.execute] or implement [Callback.onResponse] you
 * must close this body by calling any of the following methods:
 *
 * * `Response.close()`
 * * `Response.body().close()`
 * * `Response.body().source().close()`
 * * `Response.body().charStream().close()`
 * * `Response.body().byteStream().close()`

        this.url = url
      }

    /**
     * Sets the URL target of this request.
     *
     * @throws IllegalArgumentException if [url] is not a valid HTTP or HTTPS URL. Avoid this
     *     exception by calling [HttpUrl.parse]; it returns null for invalid URLs.
     */
    open fun url(url: String): Builder {
      return url(canonicalUrl(url).toHttpUrl())
    }

    /**
     * Sets the URL target of this request.

    assertThat(request.tag(String::class.java)).isSameAs(stringTag)
    assertThat(request.tag(Long::class.javaObjectType)).isSameAs(longTag)
  }

  /** Confirm that we don't accidentally share the backing map between objects. */
  @Test
  fun tagsAreImmutable() {
    val builder =
      Request.Builder()
        .url("https://square.com")
    val requestA = builder.tag(String::class.java, "a").build()

    bytesIn.writeByte(0x3F) // Dynamic table size update (size = 55).
    bytesIn.writeByte(0x18)
    hpackReader!!.readHeaders()
    assertThat(hpackReader!!.headerCount).isEqualTo(1)
  }

  /** Header table backing array is initially 8 long, let's ensure it grows.  */
  @Test
  fun dynamicallyGrowsBeyond64Entries() {
    // Lots of headers need more room!
    hpackReader = Hpack.Reader(bytesIn, 16384, 4096)