// define any required OkHttp artifacts without version
       implementation("com.squareup.okhttp3:okhttp")
       implementation("com.squareup.okhttp3:logging-interceptor")
    }
```

Maven and JVM Projects
----------------------

OkHttp is published as a Kotlin Multiplatform project. While Gradle handles this automatically,

  fun synchronousCallAccessors() {
    val ready = CountDownLatch(2)
    val waiting = CountDownLatch(1)
    client =
      client
        .newBuilder()
        .addInterceptor(
          Interceptor { chain: Interceptor.Chain? ->
            try {
              ready.countDown()
              waiting.await()
            } catch (e: InterruptedException) {
              throw AssertionError()
            }

   * provides support.
   */
  QUIC("quic"),

  /**
   * HTTP/3 is the third and upcoming major version of the Hypertext Transfer Protocol used to
   * exchange information. HTTP/3 runs over QUIC, which is published as RFC 9000.
   *
   * HTTP/3 is not natively supported by OkHttp, but provided to allow a theoretical interceptor
   * that provides support.
   */

    // at the bottom and throw a timeoutexception.
    long timeoutNanos = unit.toNanos(timeout); // we rely on the implicit null check on unit.
    long remainingNanos = timeoutNanos;
    if (Thread.interrupted()) {
      throw new InterruptedException();
    }
    @RetainedLocalRef Object localValue = valueField;
    if (localValue != null & notInstanceOfDelegatingToFuture(localValue)) {

 * the proxy. This proxy connection is called a "TLS Tunnel" and is specified by
 * [RFC 2817][1]. The HTTP CONNECT request that creates this tunnel connection is special: it
 * does not participate in any [interceptors][Interceptor] or [event listeners][EventListener]. It
 * doesn't include the motivating request's HTTP headers or even its full URL; only the target
 * server's hostname is sent to the proxy.
 *

              socket.setReceiveBufferSize(SOCKET_BUFFER_SIZE)
              return socket
            }
          },
        ).build()
  }

  @AfterEach
  fun tearDown() {
    Thread.interrupted() // Clear interrupted state.
  }

  @Test
  fun interruptWritingRequestBody() {
    server.enqueue(MockResponse())
    server.start()
    val call =
      client.newCall(
        Request
          .Builder()

// https://github.com/square/okhttp/issues/8901
//sourceSets {
//  test {
//    java.srcDirs(
//      "../okhttp-brotli/src/test/java",
//      "../okhttp-dnsoverhttps/src/test/java",
//      "../okhttp-logging-interceptor/src/test/java",
//      "../okhttp-sse/src/test/java",
//    )
//  }
//}

dependencies {
  implementation(projects.okhttp)

  testImplementation(projects.mockwebserver3Junit5)

   * @return the value associated with {@code key}; <b>must not be null</b>
   * @throws Exception if unable to load the result
   * @throws InterruptedException if this method is interrupted. {@code InterruptedException} is
   *     treated like any other {@code Exception} in all respects except that, when it is caught,
   *     the thread's interrupt status is set
   */

    // at the bottom and throw a timeoutexception.
    long timeoutNanos = unit.toNanos(timeout); // we rely on the implicit null check on unit.
    long remainingNanos = timeoutNanos;
    if (Thread.interrupted()) {
      throw new InterruptedException();
    }
    @RetainedLocalRef Object localValue = valueField;
    if (localValue != null & notInstanceOfDelegatingToFuture(localValue)) {

import java.util.List;
import java.util.logging.Handler;
import java.util.logging.LogRecord;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * Tests may use this to intercept messages that are logged by the code under test. Example:
 *
 * <pre>
 *   TestLogHandler handler;
 *
 *   protected void setUp() throws Exception {
 *     super.setUp();
 *     handler = new TestLogHandler();