val retryOnConnectionFailure: Boolean = client.retryOnConnectionFailure()
    val callTimeoutMillis: Int = client.callTimeoutMillis()
    val connectTimeoutMillis: Int = client.connectTimeoutMillis()
    val readTimeoutMillis: Int = client.readTimeoutMillis()
    val writeTimeoutMillis: Int = client.writeTimeoutMillis()
    val pingIntervalMillis: Int = client.pingIntervalMillis()
  }

  @Test @Disabled
  fun pushPromise() {

      hitCount++
    }
  }

  @Synchronized internal fun trackConditionalCacheHit() {
    hitCount++
  }

  @Synchronized fun networkCount(): Int = networkCount

  @Synchronized fun hitCount(): Int = hitCount

  @Synchronized fun requestCount(): Int = requestCount

  private inner class RealCacheRequest(
    private val editor: DiskLruCache.Editor,
  ) : CacheRequest {

  }

  private class FakeSocket(
    private val localAddress: InetAddress,
    private val localPort: Int,
    private val remoteAddress: InetAddress = localAddress,
    private val remotePort: Int = 1234,
  ) : Socket() {
    override fun getInetAddress() = remoteAddress

    override fun getLocalAddress() = localAddress

    override fun getLocalPort() = localPort

        String host, int port, InetAddress localHost, int localPort) throws IOException {
      return configureSocket((SSLSocket) delegate.createSocket(host, port, localHost, localPort));
    }

    @Override public Socket createSocket(InetAddress host, int port) throws IOException {
      return configureSocket((SSLSocket) delegate.createSocket(host, port));
    }

    @Override public Socket createSocket(

import okhttp3.Protocol
import okhttp3.Response
import okio.IOException

/** An HTTP response status line like "HTTP/1.1 200 OK". */
class StatusLine(
  @JvmField val protocol: Protocol,
  @JvmField val code: Int,
  @JvmField val message: String,
) {
  override fun toString(): String {
    return buildString {
      if (protocol == Protocol.HTTP_1_0) {
        append("HTTP/1.0")
      } else {
        append("HTTP/1.1")

  @get:JvmName("maxAgeSeconds") val maxAgeSeconds: Int,
  /**
   * The "s-maxage" directive is the max age for shared caches. Not to be confused with "max-age"
   * for non-shared caches, As in Firefox and Chrome, this directive is not honored by this cache.
   */
  @get:JvmName("sMaxAgeSeconds") val sMaxAgeSeconds: Int,
  val isPrivate: Boolean,
  val isPublic: Boolean,

  /** All headers. */
  val headers: Headers,
  /**
   * The sizes of the chunks of this request's body, or an empty list if the request's body
   * was empty or unchunked.
   */
  val chunkSizes: List<Int>,
  /** The total size of the body of this POST request (before truncation).*/
  val bodySize: Long,
  /** The body of this POST request. This may be truncated. */
  val body: Buffer,
  /**

   * send [http2ErrorCode] after the response body or trailers. For HTTP/1 this will close the
   * socket after the response body or trailers.
   */
  class DoNotReadRequestBody(
    val http2ErrorCode: Int = 0,
  ) : SocketPolicy

  /** Don't trust the client during the SSL handshake. */
  object FailHandshake : SocketPolicy

  /**
   * Shutdown the socket input after sending the response. For testing bad behavior.

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.testing

object PlatformVersion {
  val majorVersion: Int by lazy {
    when (val jvmSpecVersion = getJvmSpecVersion()) {
      "1.8" -> 8
      else -> jvmSpecVersion.toInt()
    }
  }

  fun getJvmSpecVersion(): String {

     * `input` does not have a scheme that starts at `pos`.
     */
    private fun schemeDelimiterOffset(
      input: String,
      pos: Int,
      limit: Int,
    ): Int {
      if (limit - pos < 2) return -1

      val c0 = input[pos]
      if ((c0 < 'a' || c0 > 'z') && (c0 < 'A' || c0 > 'Z')) return -1 // Not a scheme start char.