headers = Headers.of(mapOf("" to ""))
    val size: Int = headers.size()
  }

  @Test @Disabled
  fun httpLoggingInterceptor() {
    val interceptor = HttpLoggingInterceptor()
    val level = interceptor.getLevel()
  }

  @Test @Disabled
  fun httpUrl() {
    val httpUrl: HttpUrl = HttpUrl.get("")
    val url: URL = httpUrl.url()
    val uri: URI = httpUrl.uri()

  private var client =
    clientTestRule
      .newClientBuilder()
      .writeTimeout(Duration.ofMillis(500))
      .readTimeout(Duration.ofMillis(500))
      .addInterceptor(
        Interceptor { chain: Interceptor.Chain ->
          val response = chain.proceed(chain.request())
          // Ensure application interceptors never see a null body.
          assertThat(response.body).isNotNull()
          response

    server.enqueue(MockResponse())
    val connection = AtomicReference<Connection?>()
    client =
      client
        .newBuilder()
        .addNetworkInterceptor(
          Interceptor { chain: Interceptor.Chain? ->
            connection.set(chain!!.connection())
            chain.proceed(chain.request())
          },
        ).build()
    dns["san.com"] = Dns.SYSTEM.lookup(server.hostName).subList(0, 1)

<manifest xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools"
          package="okhttp.okhttp3">

  <uses-permission android:name="android.permission.INTERNET"/>

  <application>
    <provider
      android:name="androidx.startup.InitializationProvider"
      android:authorities="${applicationId}.androidx-startup"
      android:exported="false"
      tools:node="merge">

    // Create a client with artificial delays.
    client =
      client
        .newBuilder()
        .addInterceptor(
          Interceptor { chain: Interceptor.Chain ->
            try {
              Thread.sleep(applicationInterceptorDelay)
              return@Interceptor chain.proceed(chain.request())
            } catch (e: InterruptedException) {
              throw InterruptedIOException()
            }

    }

  val request = Request("http://google.com/robots.txt".toHttpUrl())

  @Test
  fun testHttpLoggingInterceptor() {
    val interceptor =
      HttpLoggingInterceptor().apply {
        level = HttpLoggingInterceptor.Level.BASIC
      }

    val client = clientBuilder.addInterceptor(interceptor).build()

    try {
      client.newCall(request).execute()
    } catch (uhe: UnknownHostException) {
      // expected
    }

  public void testGetUnchecked_success() {
    assertEquals("foo", getUnchecked(immediateFuture("foo")));
  }

  @J2ktIncompatible
  @GwtIncompatible // Thread.interrupt
  public void testGetUnchecked_interrupted() {
    Thread.currentThread().interrupt();
    try {
      assertEquals("foo", getUnchecked(immediateFuture("foo")));
      assertTrue(Thread.currentThread().isInterrupted());
    } finally {

  public void testGetUnchecked_success() {
    assertEquals("foo", getUnchecked(immediateFuture("foo")));
  }

  @J2ktIncompatible
  @GwtIncompatible // Thread.interrupt
  public void testGetUnchecked_interrupted() {
    Thread.currentThread().interrupt();
    try {
      assertEquals("foo", getUnchecked(immediateFuture("foo")));
      assertTrue(Thread.currentThread().isInterrupted());
    } finally {

  }

  /**
   * Await an interrupt, then clear the interrupt status. Similar to {@code
   * assertTrue(Thread.interrupted())} except that this version tolerates late interrupts.
   */
  private static void assertInterrupted() {
    try {
      /*
       * The sleep() will end immediately if we've already been interrupted or
       * wait patiently for the interrupt if not.
       */

import jakarta.servlet.ServletResponse;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

/**
 * Servlet filter for processing web API requests.
 * This filter intercepts HTTP requests and delegates processing to appropriate web API managers.
 */
public class WebApiFilter implements Filter {

    /**
     * Default constructor.
     */
    public WebApiFilter() {