@Throws(InterruptedException::class)
  fun writePingAndAwaitPong() {
    writePing()
    awaitPong()
  }

  /** For testing: sends a ping to be awaited with [awaitPong]. */
  @Throws(InterruptedException::class)
  fun writePing() {
    withLock {
      awaitPingsSent++
    }

    // 0x4f 0x4b 0x6f 0x6b is "OKok".
    writePing(false, AWAIT_PING, 0x4f4b6f6b)
  }

  /** For testing: awaits a pong. */

  /** Send a ping with the supplied [payload]. */
  @Throws(IOException::class)
  fun writePing(payload: ByteString) {
    writeControlFrame(OPCODE_CONTROL_PING, payload)
  }

  /** Send a pong with the supplied [payload]. */
  @Throws(IOException::class)
  fun writePong(payload: ByteString) {
    writeControlFrame(OPCODE_CONTROL_PONG, payload)
  }

  /**

              "${pingIntervalMillis}ms (after ${failedPing - 1} successful ping/pongs)",
          ),
        isWriter = true,
      )
      return
    }

    try {
      writer.writePing(ByteString.EMPTY)
    } catch (e: IOException) {
      failWebSocket(e = e, isWriter = true)
    }
  }

  fun failWebSocket(
    e: Exception,
    response: Response? = null,

    connection.withLock {
      if (!connection.isHealthy(System.nanoTime())) {
        throw ConnectionShutdownException()
      }
    }
    connection.writePing()
    connection.shutdown(ErrorCode.PROTOCOL_ERROR)
    assertThat(connection.openStreamCount()).isEqualTo(1)
    connection.awaitPong() // Prevent the peer from exiting prematurely.

            dos.writeInt(Integer.reverseBytes(3)); // 3 buffers
            dos.writeInt(Integer.reverseBytes(PacConstants.PAC_VERSION));

            // Write buffer entries
            dos.writeInt(Integer.reverseBytes(PacConstants.LOGON_INFO));
            dos.writeInt(Integer.reverseBytes(10));
            dos.writeLong(Long.reverseBytes(100));

        Encdec.enc_uint16be((short) v, tmp, 0);
        write(tmp, 0, 2);
    }

    @Override
    public final void writeInt(final int v) throws SmbException {
        Encdec.enc_uint32be(v, tmp, 0);
        write(tmp, 0, 4);
    }

    @Override
    public final void writeLong(final long v) throws SmbException {
        Encdec.enc_uint64be(v, tmp, 0);
        write(tmp, 0, 8);
    }

    @Override

      frameHeader(
        streamId = 0,
        length = 8,
        type = TYPE_PING,
        flags = if (ack) FLAG_ACK else FLAG_NONE,
      )
      sink.writeInt(payload1)
      sink.writeInt(payload2)
      sink.flush()
    }
  }

  /**
   * Tell the peer to stop creating streams and that we last processed `lastGoodStreamId`, or zero
   * if no streams were processed.
   *

    val totalRuleBytes: Int,
    val totalExceptionRuleBytes: Int,
  ) {
    fun writeOut(sink: BufferedSink) {
      with(sink) {
        writeInt(totalRuleBytes)
        for (domain in sortedRules) {
          write(domain).writeByte(NEWLINE)
        }
        writeInt(totalExceptionRuleBytes)
        for (domain in sortedExceptionRules) {
          write(domain).writeByte(NEWLINE)
        }
      }
    }
  }

        long MILLISECONDS_BETWEEN_1970_AND_1601 = 11644473600000L;
        writeLong(buffer, 0, (create + MILLISECONDS_BETWEEN_1970_AND_1601) * 10000L);
        writeLong(buffer, 8, (lastAccess + MILLISECONDS_BETWEEN_1970_AND_1601) * 10000L);
        writeLong(buffer, 16, (lastWrite + MILLISECONDS_BETWEEN_1970_AND_1601) * 10000L);
        writeLong(buffer, 24, (change + MILLISECONDS_BETWEEN_1970_AND_1601) * 10000L);

            // Multiple dynamic table size updates!
            writeInt(smallestHeaderTableSizeSetting, PREFIX_5_BITS, 0x20)
          }
          emitDynamicTableSizeUpdate = false
          smallestHeaderTableSizeSetting = Integer.MAX_VALUE
          writeInt(maxDynamicTableByteCount, PREFIX_5_BITS, 0x20)
        }

        for (i in 0 until headerBlock.size) {