sink.writeUtf8("client says goodbye\n")
            sink.flush()

            assertThat(source.readUtf8Line()).isEqualTo("server says goodbye")

            assertThat(source.exhausted()).isTrue()
          }
        }
        socketHandler.awaitSuccess()
      }
  }

  @Test
  fun upgrade() {
    executeAndCheckUpgrade(upgradeRequest())
  }

  @Test

          currentLabelByteIndex++
          if (publicSuffixByteIndex == publicSuffixLength) break

          if (labels[currentLabelIndex].size == currentLabelByteIndex) {
            // We've exhausted our current label. Either there are more labels to compare, in which
            // case we expect a dot as the next character. Otherwise, we've checked all our labels.
            if (currentLabelIndex == labels.size - 1) {

    try {
      while (currentTask != self) {
        taskRunner.wait()
      }
    } finally {
      serialTaskQueue.remove(yieldCompleteTask)
    }

    // If we're yielding until we're exhausted and a task run, keep going until a task doesn't run.
    if (strategy == ResumePriority.AfterOtherTasks && otherTasksStarted) {
      return yieldUntil(strategy, condition)
    }
  }

          maskCursor.seek(messageFrameBuffer.size - frameLength)
          toggleMask(maskCursor, maskKey!!)
          maskCursor.close()
        }
      }

      if (isFinalFrame) break // We are exhausted and have no continuations.

      readUntilNonControlFrame()
      if (opcode != OPCODE_CONTINUATION) {
        throw ProtocolException("Expected continuation opcode. Got: ${opcode.toHexString()}")
      }
    }

      override fun fromDer(reader: DerReader): Long {
        val peekHeader =
          reader.peekHeader()
            ?: throw ProtocolException("expected time but was exhausted at $reader")

        return when {
          peekHeader.tagClass == Adapters.UTC_TIME.tagClass &&
            peekHeader.tag == Adapters.UTC_TIME.tag -> {
            Adapters.UTC_TIME.fromDer(reader)
          }

internal inline fun ignoreIoExceptions(block: () -> Unit) {
  try {
    block()
  } catch (_: IOException) {
  }
}

internal fun Buffer.skipAll(b: Byte): Int {
  var count = 0
  while (!exhausted() && this[0] == b) {
    count++
    readByte()
  }
  return count
}

/**
 * Returns the index of the next non-whitespace character in this. Result is undefined if input

        )
      routeSelector = newRouteSelector
    }

    // List available IP addresses for the current proxy. This may block in Dns.lookup().
    if (!newRouteSelector.hasNext()) throw IOException("exhausted all routes")
    val newRouteSelection = newRouteSelector.next()
    routeSelection = newRouteSelection

    if (isCanceled()) throw IOException("Canceled")

    data.write("880203ee".decodeHex()) // Close with code 1006
    for (i in 1015..2999) {
      data.write(("8802" + format("%04X", i)).decodeHex()) // Close with code 'i'
    }
    var count = 0
    while (!data.exhausted()) {
      assertFailsWith<ProtocolException> {
        clientReader.processNextFrame()
      }.also { expected ->
        assertThat(expected.message!!)

  return result
}

internal fun idnToAscii(host: String): String? {
  val bufferA = Buffer().writeUtf8(host)
  val bufferB = Buffer()

  // 1. Map, from bufferA to bufferB.
  while (!bufferA.exhausted()) {
    val codePoint = bufferA.readUtf8CodePoint()
    if (!IDNA_MAPPING_TABLE.map(codePoint, bufferB)) return null
  }

  // 2. Normalize, from bufferB to bufferA.

  private val Request.isChunked: Boolean
    get() = "chunked".equals(header("Transfer-Encoding"), ignoreCase = true)

  /**
   * Trailers received when the response body became exhausted.
   *
   * If the response body was successfully read until the end, this is the headers that followed,
   * or empty headers if there were none that followed.
   *