server.enqueue(MockResponse(body = "DEF"))
    val client2 =
      client
        .newBuilder()
        .addNetworkInterceptor(
          object : Interceptor {
            var executedCall = false

            override fun intercept(chain: Interceptor.Chain): Response {
              if (!executedCall) {
                // At this point, we have a healthy HTTP/2 connection. This call will trigger the

   * as a **network interceptor**. It will strip the `Location` header of impacted responses to
   * prevent the redirect.
   *
   * ```
   * OkHttpClient client = client.newBuilder()
   *   .addNetworkInterceptor(new LegacyRedirectInterceptor())
   *   .build();
   * ```
   */
  internal class LegacyRedirectInterceptor : Interceptor {

        "network interceptor $interceptor must call proceed() exactly once",
      )
    }
  }

  @Test
  fun networkInterceptorsCannotChangeServerAddress() {
    server.enqueue(
      MockResponse
        .Builder()
        .code(500)
        .build(),
    )
    val interceptor =
      Interceptor { chain: Interceptor.Chain ->

- Fixed a spurious `namespace not found` error in default `v1.30+` configurations when using `ValidatingAdmissionPolicy` or `MutatingAdmissionPolicy` to intercept namespaced objects in newly-created namespaces. ([#135359](https://github.com/kubernetes/kubernetes/pull/135359), [@liggitt](https://github.com/liggitt))

 * [okhttp-spring-boot](https://github.com/freefair/okhttp-spring-boot): Spring Boot starters for OkHttp
 * [okhttp-staleiferror-interceptor](https://github.com/PeelTechnologies/okhttp-staleiferror-interceptor/): serve stale responses when the server isn’t reachable.
 * [okhttp-stats](https://github.com/flipkart-incubator/okhttp-stats): Get stats like average network speed.

   */
  H2_PRIOR_KNOWLEDGE("h2_prior_knowledge"),

  /**
   * QUIC (Quick UDP Internet Connection) is a new multiplexed and secure transport atop UDP,
   * designed from the ground up and optimized for HTTP/2 semantics. HTTP/1.1 semantics are layered
   * on HTTP/2.
   *
   * QUIC is not natively supported by OkHttp, but provided to allow a theoretical interceptor that
   * provides support.
   */
  QUIC("quic"),

  /**

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater
import kotlin.reflect.KClass
import okhttp3.Call
import okhttp3.Callback
import okhttp3.EventListener
import okhttp3.Interceptor
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.Response
import okhttp3.internal.assertLockNotHeld
import okhttp3.internal.cache.CacheInterceptor
import okhttp3.internal.closeQuietly

    real-time medium.
2.  If this fails, get a third party (e.g. a mutual friend, and/or someone with
    background on the issue, but not involved in the conflict) to intercede.
3.  If you are still unable to resolve the conflict, and you believe it rises to
    harassment or another code of conduct violation, report it.

## Reporting Violations

      val test = "foobar.$exception"
      assertThat(publicSuffixDatabase.getEffectiveTldPlusOne(test)).isEqualTo(exception)
    }
  }

  @Test
  fun threadIsInterruptedOnFirstRead() {
    Thread.currentThread().interrupt()
    try {
      val result = publicSuffixDatabase.getEffectiveTldPlusOne("squareup.com")
      assertThat(result).isEqualTo("squareup.com")
    } finally {
      assertThat(Thread.interrupted()).isTrue()
    }
  }

    final double slope;
    final double yIntercept;

    @LazyInit @Nullable LinearTransformation inverse;

    RegularLinearTransformation(double slope, double yIntercept) {
      this.slope = slope;
      this.yIntercept = yIntercept;
      this.inverse = null; // to be lazily initialized
    }

    RegularLinearTransformation(double slope, double yIntercept, LinearTransformation inverse) {