// pool, which should remain clean for subsequent tests.
        .connectionPool(ConnectionPool())
        .addNetworkInterceptor(
          Interceptor { chain: Interceptor.Chain? ->
            val response =
              chain!!.proceed(
                chain.request(),
              )
            responsesNotClosed.add(response)
            response

dependencies {
  implementation "org.bouncycastle:bcprov-jdk15on:1.65"
}
```

 *  Upgrade: [Kotlin 1.4.10][kotlin_1_4_10]. We now use Kotlin 1.4.x [functional
    interfaces][fun_interface] for `Authenticator`, `Interceptor`, and others.
 *  Upgrade: Build with Conscrypt 2.5.1.


## Version 4.8.1

_2020-08-06_

 *  Fix: Don't crash in `HeldCertificate.Builder` when creating certificates on older versions of

    )
  }

  if (androidBuild) {
    sourceSets["androidTest"].java.srcDirs(
      "../okhttp-brotli/src/test/java",
      "../okhttp-dnsoverhttps/src/test/java",
      "../okhttp-logging-interceptor/src/test/java",
      "../okhttp-sse/src/test/java"
    )
  }

  compileOptions {
    targetCompatibility(JavaVersion.VERSION_11)
    sourceCompatibility(JavaVersion.VERSION_11)
  }

  testOptions {

      throw new AssertionError(e);
    }
  }

  static void verifyThreadWasNotInterrupted() {
    assertFalse(Thread.currentThread().isInterrupted());
  }

  static void clearInterrupt() {
    Thread.interrupted();
  }

  /**
   * Retrieves the result of a {@code Future} known to be done but uses the {@code get(long,
   * TimeUnit)} overload in order to test that method.
   */

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() {

         * Interrupted exceptions are caught and logged at debug level.
         */
        public void awaitTermination() {
            try {
                join();
            } catch (final InterruptedException e) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Interrupted.", e);
                }
            }
        }

                    return true;
                }

            } catch (InterruptedException e) {
                log.debug("RDMA recovery interrupted");
                Thread.currentThread().interrupt();
                break;
            } catch (Exception recoveryError) {

    } catch (TwoArgConstructorException expected) {
      assertThat(expected).hasCauseThat().isInstanceOf(InterruptedException.class);
      assertTrue(Thread.currentThread().isInterrupted());
    } finally {
      Thread.interrupted();
    }
  }

  public void testGetCheckedUntimed_cancelled() throws TwoArgConstructorException {
    SettableFuture<String> future = SettableFuture.create();
    future.cancel(true);
    assertThrows(

    }

    private static void joinThread(final Thread thread) {
        try {
            thread.join();
        } catch (final InterruptedException e) {
            log.warn("Thread join interrupted", e);
            // Restore interrupted status
            Thread.currentThread().interrupt();
        }
    }

    private static boolean isAllDigits(final String hostname) {
        for (int i = 0; i < hostname.length(); i++) {

    Thread.currentThread().interrupt();
    try {
      assertEquals("foo", getUnchecked(immediateFuture("foo")));
      assertTrue(Thread.currentThread().isInterrupted());
    } finally {
      Thread.interrupted();
    }
  }

  public void testGetUnchecked_cancelled() {
    SettableFuture<String> future = SettableFuture.create();
    future.cancel(true);