if (currentRunLength > longestRunLength && currentRunLength >= 4) {
        longestRunOffset = currentRunOffset
        longestRunLength = currentRunLength
      }
      i += 2
    }
  }

  // Emit each 2-byte group in hex, separated by ':'. The longest run of zeroes is "::".
  val result = Buffer()
  var i = 0
  while (i < address.size) {
    if (i == longestRunOffset) {
      result.writeByte(':'.code)

    assertFailsWith<IllegalStateException> {
      sinkReference.get().flush()
    }
    assertFailsWith<IllegalStateException> {
      sinkReference.get().write("ghi".toByteArray())
      sinkReference.get().emit()
    }
  }

  @Test
  fun getHeadersThrows() {
    server.enqueue(MockResponse(socketPolicy = SocketPolicy.DisconnectAtStart))
    assertFailsWith<IOException> {
      getResponse(newRequest("/"))

    server.webSocket!!.finishReader()
    server.listener.assertClosed(1000, "Bye!")
  }

  @Test
  fun emptyCloseInitiatesShutdown() {
    server.sink.write("8800".decodeHex()).emit() // Close without code.
    client.processNextFrame()
    client.listener.assertClosing(1005, "")
    client.webSocket!!.finishReader()
    assertThat(client.webSocket!!.close(1000, "Bye!")).isTrue()

      }
    }
    when (selectedMethod) {
      METHOD_NO_AUTHENTICATION_REQUIRED -> {
        fromSink.writeByte(VERSION_5)
        fromSink.writeByte(selectedMethod)
        fromSink.emit()
      }
      else -> throw ProtocolException("unsupported method: $selectedMethod")
    }
  }

  private fun acceptCommand(
    fromAddress: InetAddress,
    fromSource: BufferedSource,

import okhttp3.survey.types.SuiteId

/**
 * Organizes information on SSL cipher suite inclusion and precedence for this spreadsheet.
 * https://docs.google.com/spreadsheets/d/1C3FdZSlCBq_-qrVwG1KDIzNIB3Hyg_rKAcgmSzOsHyQ/edit#gid=0
 */
class CipherSuiteSurvey(
  val clients: List<Client>,
  val ianaSuites: IanaSuites,
  val orderBy: List<SuiteId>,
) {
  fun printGoogleSheet() {
    print("name")
    for (client in clients) {

        return connection.socket()
      }
    }

    return null
  }

  private fun <E : IOException?> timeoutExit(cause: E): E {
    if (timeoutEarlyExit) return cause
    if (!timeout.exit()) return cause

    val e = InterruptedIOException("timeout")
    if (cause != null) e.initCause(cause)
    @Suppress("UNCHECKED_CAST") // E is either IOException or IOException?
    return e as E
  }

     * close that when they're done. Otherwise a handle to [file] will be leaked.
     */
    @Throws(IOException::class)
    fun edit(
      file: File,
      upstream: Source,
      metadata: ByteString,
      bufferMaxSize: Long,
    ): Relay {
      val randomAccessFile = RandomAccessFile(file, "rw")

 *  New: Publish a [bill of materials (BOM)][bom] for OkHttp. Depend on this from Gradle or Maven to
    keep all of your OkHttp artifacts on the same version, even if they're declared via transitive
    dependencies. You can even omit versions when declaring other OkHttp dependencies.

    ```kotlin
    dependencies {
       api(platform("com.squareup.okhttp3:okhttp-bom:4.4.0"))
       api("com.squareup.okhttp3:okhttp")              // No version!

      source: Buffer,
      byteCount: Long,
    ) {
      lock.assertNotHeld()

      sendBuffer.write(source, byteCount)
      while (sendBuffer.size >= EMIT_BUFFER_SIZE) {
        emitFrame(false)
      }
    }

    /**
     * Emit a single data frame to the connection. The frame's size be limited by this stream's
     * write window. This method will block until the write window is nonempty.
     */

      }

      override fun writeTo(sink: BufferedSink) {
        val uppercase = uppercase(sink)
        val bufferedSink = uppercase.buffer()
        original!!.writeTo(bufferedSink)
        bufferedSink.emit()
      }
    }
  }

  private fun uppercase(original: BufferedSink): Sink {
    return object : ForwardingSink(original) {
      override fun write(
        source: Buffer,
        byteCount: Long,