@Synchronized fun writeSuccessCount(): Int = writeSuccessCount

  @Throws(IOException::class)
  fun size(): Long = cache.size()

  /** Max size of the cache (in bytes). */
  fun maxSize(): Long = cache.maxSize

  @Throws(IOException::class)
  override fun flush() {
    cache.flush()
  }

  @Throws(IOException::class)
  override fun close() {
    cache.close()
  }

  @get:JvmName("directory")

import java.util.concurrent.TimeUnit
import kotlin.test.assertFailsWith
import okhttp3.CacheControl.Companion.parse
import okhttp3.Headers.Companion.headersOf
import org.junit.jupiter.api.Test

class CacheControlJvmTest {
  @Test
  @Throws(Exception::class)
  fun completeBuilder() {
    val cacheControl =
      CacheControl.Builder()
        .noCache()
        .noStore()
        .maxAge(1, TimeUnit.SECONDS)

internal class InsecureAndroidTrustManager(
  private val delegate: X509TrustManager,
  private val insecureHosts: List<String>,
) : X509TrustManager {
  private val checkServerTrustedMethod: Method? =
    try {
      delegate::class.java.getMethod(
        "checkServerTrusted",
        Array<X509Certificate>::class.java,
        String::class.java,
        String::class.java,
      )

import org.junit.jupiter.params.provider.ArgumentsSource

class HpackDecodeInteropTest : HpackDecodeTestBase() {
  @ParameterizedTest
  @ArgumentsSource(StoriesTestProvider::class)
  fun testGoodDecoderInterop(story: Story) {
    assumeFalse(
      story === Story.MISSING,
      "Test stories missing, checkout git submodule",
    )
    testDecoder(story)
  }

  internal class StoriesTestProvider : SimpleProvider() {

import kotlin.reflect.KClass
import okhttp3.internal.concurrent.TaskRunner
import okhttp3.internal.http2.Http2

object OkHttpDebugLogging {
  // Keep references to loggers to prevent their configuration from being GC'd.
  private val configuredLoggers = CopyOnWriteArraySet<Logger>()

  fun enableHttp2() = enable(Http2::class)

  fun enableTaskRunner() = enable(TaskRunner::class)

  fun logHandler() =

import okio.Buffer
import okio.BufferedSource
import okio.ForwardingSource
import okio.buffer

/** Rewrites the response body returned from the server to be all uppercase.  */
class UppercaseResponseInterceptor : Interceptor {
  @Throws(IOException::class)
  override fun intercept(chain: Chain): Response {
    return uppercaseResponse(chain.proceed(chain.request()))
  }

  private fun uppercaseResponse(response: Response): Response {

import okio.BufferedSink
import okio.BufferedSource
import okio.ForwardingTimeout
import okio.Sink
import okio.Source
import okio.Timeout

/**
 * A socket connection that can be used to send HTTP/1.1 messages. This class strictly enforces the
 * following lifecycle:
 *
 *  1. [Send request headers][writeRequest].
 *  2. Open a sink to write the request body. Either [known][newKnownLengthSink] or
 *     [chunked][newChunkedSink].

 * `Response` for interpreted headers. This class maintains the order of the header fields within
 * the HTTP message.
 *
 * This class tracks header values line-by-line. A field with multiple comma- separated values on
 * the same line will be treated as a field with a single value by this class. It is the caller's

/** Runs the web platform URL tests against Java URL models.  */
class WebPlatformUrlTest {
  class TestDataParamProvider : SimpleProvider() {
    override fun arguments() = ArrayList<Any>(loadTests())
  }

  /** Test how [HttpUrl] does against the web platform test suite.  */
  @ArgumentsSource(TestDataParamProvider::class)
  @ParameterizedTest
  fun httpUrl(testData: WebPlatformUrlTestData) {

      .addHandler(testHandler)
    Logger.getLogger("okhttp3")
      .addHandler(testHandler)
    Logger.getLogger(Http2::class.java.name)
      .addHandler(testHandler)
    Logger.getLogger(TaskRunner::class.java.name)
      .addHandler(testHandler)
    Logger.getLogger(OkHttpClient::class.java.name)
      .addHandler(testHandler)

    server.enqueue(MockResponse(body = "abc"))

    val request =