entry.currentEditor = Editor(entry)
      }

      secondSpace == -1 && firstSpace == READ.length && line.startsWith(READ) -> {
        // This work was already done by calling lruEntries.get().
      }

      else -> throw IOException("unexpected journal line: $line")
    }
  }

  /**

        .status("HTTP/1.1 200 Fantastic")
    transferKind.setBody(mockResponse, "I love puppies but hate spiders", 1)
    server.enqueue(mockResponse.build())

    // Make sure that calling skip() doesn't omit bytes from the cache.
    val request = Request.Builder().url(server.url("/")).build()
    val response1 = client.newCall(request).execute()
    val in1 = response1.body.source()

    val reader = BufferedReader(InputStreamReader(connection.inputStream, UTF_8))
    assertThat(connection.responseCode).isEqualTo(HttpURLConnection.HTTP_OK)
    assertThat(reader.readLine()).isEqualTo("hello world")
    val request = server.takeRequest()
    assertThat(request.requestLine).isEqualTo("GET / HTTP/1.1")
    assertThat(request.headers["Accept-Language"]).isEqualTo("en-US")

import org.junit.rules.TestRule
import org.junit.runner.Description
import org.junit.runners.model.Statement

/**
 * A log handler that records which log messages were published so that a calling test can make
 * assertions about them.
 */
class TestLogHandler(
  private val logger: Logger,
) : TestRule, BeforeEachCallback, AfterEachCallback {

import java.util.concurrent.LinkedBlockingQueue
import java.util.logging.Logger
import okhttp3.ExperimentalOkHttpApi

/**
 * Default dispatcher that processes a script of responses. Populate the script by calling [enqueueResponse].
 */
@ExperimentalOkHttpApi
open class QueueDispatcher : Dispatcher() {
  protected val responseQueue: BlockingQueue<MockResponse> = LinkedBlockingQueue()
  private var failFastResponse: MockResponse? = null

with OkHttp 3.x: must use `object :` with OkHttp 4.x:

Kotlin calling OkHttp 3.x:

```kotlin
val client = OkHttpClient.Builder()
    .dns { hostname -> InetAddress.getAllByName(hostname).toList() }
    .build()
```

Kotlin calling OkHttp 4.x:

```kotlin
val client = OkHttpClient.Builder()
    .dns(object : Dns {

27CC          ; valid                  ;      ; NV8    # 5.1  LONG DIVISION
27CD          ; valid                  ;      ; NV8    # 6.1  MATHEMATICAL FALLING DIAGONAL
27CE..27CF    ; valid                  ;      ; NV8    # 6.0  SQUARED LOGICAL AND..SQUARED LOGICAL OR

      rawSource.use {
        val source = rawSource.buffer()
        val urlLine = source.readUtf8LineStrict()
        // Choice here is between failing with a correct RuntimeException
        // or mostly silently with an IOException
        url = urlLine.toHttpUrlOrNull() ?: throw IOException("Cache corruption for $urlLine").also {
          Platform.get().log("cache corruption", WARN, it)
        }

    val reader = BufferedReader(InputStreamReader(inputStream, StandardCharsets.UTF_8))
    assertThat(connection.getResponseCode()).isEqualTo(HttpURLConnection.HTTP_OK)
    assertThat(reader.readLine()).isEqualTo("hello world")
    val request = server.takeRequest()
    assertThat(request.requestLine).isEqualTo("GET / HTTP/1.1")
    assertThat(request.getHeader("Accept-Language")).isEqualTo("en-US")

HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
logging.setLevel(Level.BASIC);
OkHttpClient client = new OkHttpClient.Builder()
  .addInterceptor(logging)
  .build();
```

You can change the log level at any time by calling `setLevel()`.

To log to a custom location, pass a `Logger` instance to the constructor.
```java
HttpLoggingInterceptor logging = new HttpLoggingInterceptor(new Logger() {
  @Override public void log(String message) {