val bytes = binaryData(200)
    data.write("0264".decodeHex()).write(bytes, 0, 100)
    data.write("8064".decodeHex()).write(bytes, 100, 100)
    clientReader.processNextFrame()
    callback.assertBinaryMessage(bytes)
  }

  @Test fun twoFrameNotContinuation() {
    val bytes = binaryData(200)
    data.write("0264".decodeHex()).write(bytes, 0, 100)
    data.write("8264".decodeHex()).write(bytes, 100, 100)

      )
    val bufferA = Buffer()
    val bufferB = Buffer()
    bufferA.writeUtf8("Dodgson!\n")
    operatorA.write(0, bufferA, 9)
    bufferB.writeUtf8("You shouldn't use my name.\n")
    operatorB.write(9, bufferB, 27)
    bufferA.writeUtf8("Dodgson, we've got Dodgson here!\n")
    operatorA.write(36, bufferA, 33)
    operatorB.read(0, bufferB, 9)
    assertThat(bufferB.readUtf8()).isEqualTo("Dodgson!\n")

  private var maxFrameSize: Int = INITIAL_MAX_FRAME_SIZE
  private var closed: Boolean = false
  val hpackWriter: Hpack.Writer = Hpack.Writer(out = hpackBuffer)

  @Throws(IOException::class)
  fun connectionPreface() {
    this.withLock {
      if (closed) throw IOException("closed")
      if (!client) return // Nothing to write; servers don't send connection headers!
      if (logger.isLoggable(FINE)) {

    return object : ForwardingSink(sink) {
      @Throws(IOException::class)
      override fun write(
        source: Buffer,
        byteCount: Long,
      ) {
        val bytes = source.readByteString(byteCount)
        delegate.write(
          Buffer()
            .write(bytes.toAsciiUppercase()),
          byteCount,
        )
      }
    }
  }

      bytesLeft -= toWrite
      delegate.write(source, toWrite)
    }
  }

                    ReferenceAccess.READ -> arrayOf(KtFirSimpleNameReference(nameReferenceExpression, isRead = true))
                    ReferenceAccess.WRITE -> arrayOf(KtFirSimpleNameReference(nameReferenceExpression, isRead = false))
                    ReferenceAccess.READ_WRITE -> arrayOf(
                        KtFirSimpleNameReference(nameReferenceExpression, isRead = true),

  inner class FaultySink(sink: Sink, private val file: Path) : ForwardingSink(sink) {
    override fun write(
      source: Buffer,
      byteCount: Long,
    ) {
      if (writeFaults.contains(file)) {
        throw IOException("boom!")
      } else {
        super.write(source, byteCount)
      }
    }
  }

    client.webSocket!!.close(1000, "Hello")
    server.processNextFrame()
    // Not closed until close reply is received.
    assertThat(client.closed).isFalse()

    // Manually write an invalid masked close frame.
    server.sink.write("888760b420bb635c68de0cd84f".decodeHex()).emit()
    client.processNextFrame() // Detects error, disconnects immediately since close already sent.
    client.webSocket!!.finishReader()

pkg log/syslog (darwin-arm64), method (*Writer) Emerg(string) error
pkg log/syslog (darwin-arm64), method (*Writer) Err(string) error
pkg log/syslog (darwin-arm64), method (*Writer) Info(string) error
pkg log/syslog (darwin-arm64), method (*Writer) Notice(string) error
pkg log/syslog (darwin-arm64), method (*Writer) Warning(string) error
pkg log/syslog (darwin-arm64), method (*Writer) Write([]uint8) (int, error)

        sip := siphash.New(id[:])
        sip.Write([]byte(key))
        return int(sip.Sum64() % uint64(cardinality))
}
```

Input for the key is the object name specified in `PutObject()`, returns a unique index. This index is one of the erasure sets where the object will reside. This function is a consistent hash for a given object name i.e for a given object name the index returned is always the same.