import mockwebserver3.internal.RecordedRequest
import mockwebserver3.internal.decodeRequestLine
import okhttp3.Headers
import okhttp3.Headers.Companion.headersOf
import okio.Buffer
import okio.ByteString
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Timeout

@Timeout(30)
class RecordedRequestTest {
  private val headers: Headers = Headers.EMPTY

  @Test fun testIPv4() {
    val socket =

    assertThat(responseString).isEmpty()
  }

  private fun ByteString.zstdCompress(): ByteString {
    val result = Buffer()
    result.zstdCompress().buffer().use {
      it.write(this@zstdCompress)
    }
    return result.readByteString()
  }

  private fun ByteString.gzipCompress(): ByteString {
    val result = Buffer()
    (result as Sink).gzip().buffer().use {

HSPLokio/ByteString;->equals(Ljava/lang/Object;)Z
HSPLokio/ByteString;->getSize$okio()I
HSPLokio/ByteString;->hashCode()I
HSPLokio/ByteString;->indexOf$default(Lokio/ByteString;Lokio/ByteString;IILjava/lang/Object;)I
HSPLokio/ByteString;->indexOf([BI)I
HSPLokio/ByteString;->internalArray$okio()[B
HSPLokio/ByteString;->internalGet$okio(I)B
HSPLokio/ByteString;->rangeEquals(ILokio/ByteString;II)Z

  /**
   * Returns the response as a [ByteString].
   *
   * This method loads entire response body into memory. If the response body is very large this
   * may trigger an [OutOfMemoryError]. Prefer to stream the response body if this is a
   * possibility for your response.
   */
  @Throws(IOException::class)
  fun byteString() = consumeSource(BufferedSource::readByteString) { it.size }

import java.io.RandomAccessFile
import okhttp3.internal.closeQuietly
import okhttp3.internal.concurrent.Lockable
import okhttp3.internal.concurrent.notifyAll
import okio.Buffer
import okio.ByteString
import okio.ByteString.Companion.encodeUtf8
import okio.Source
import okio.Timeout

/**
 * Replicates a single upstream source into multiple downstream sources. Each downstream source

import okhttp3.tls.internal.der.ObjectIdentifiers.SUBJECT_ALTERNATIVE_NAME
import okhttp3.tls.internal.der.TbsCertificate
import okhttp3.tls.internal.der.Validity
import okio.ByteString
import okio.ByteString.Companion.decodeBase64
import okio.ByteString.Companion.toByteString

/**
 * A certificate and its private key. These are some properties of certificates that are used with
 * TLS:
 *

import java.io.FileDescriptor
import java.io.FileInputStream
import java.io.IOException
import okhttp3.internal.checkOffsetAndCount
import okhttp3.internal.chooseCharset
import okio.BufferedSink
import okio.ByteString
import okio.FileSystem
import okio.Path
import okio.source

abstract class RequestBody {
  /** Returns the Content-Type header for this body. */
  abstract fun contentType(): MediaType?

  /**

      throw ProtocolException("malformed bit string")
    }
    val unusedBitCount = source.readByte().toInt() and 0xff
    val byteString = source.readByteString(bytesLeft)
    return BitString(byteString, unusedBitCount)
  }

  fun readOctetString(): ByteString {
    if (bytesLeft == -1L || constructed) {
      throw ProtocolException("constructed octet strings not supported for DER")
    }

import okhttp3.internal.ws.WebSocketProtocol.OPCODE_TEXT
import okhttp3.internal.ws.WebSocketProtocol.validateCloseCode
import okio.BufferedSink
import okio.BufferedSource
import okio.ByteString
import okio.ByteString.Companion.encodeUtf8
import okio.ByteString.Companion.toByteString
import okio.Socket

class RealWebSocket(
  taskRunner: TaskRunner,
  /** The application's original request unadulterated by web socket headers. */

package okhttp3.internal.http2.hpackjson

import okhttp3.internal.http2.Header
import okio.ByteString

/**
 * Representation of an individual case (set of headers and wire format). There are many cases for a
 * single story.  This class is used reflectively with Moshi to parse stories.
 */
data class Case(
  val seqno: Int = 0,
  val wire: ByteString? = null,
  val headers: List<Map<String, String>>,
) : Cloneable {