// Ignore
        }
    }

    private static String formatMessage(ErrorCode errorCode, String message) {
        if (message == null || message.isEmpty()) {
            return String.format("[%s] %s", errorCode.name(), errorCode.getDescription());
        }
        return String.format("[%s] %s: %s", errorCode.name(), errorCode.getDescription(), message);
    }

    private String extractOperationName() {

    frame.writeInt(ErrorCode.PROTOCOL_ERROR.httpCode)
    reader.nextFrame(
      requireSettings = false,
      object : BaseTestHandler() {
        override fun rstStream(
          streamId: Int,
          errorCode: ErrorCode,
        ) {
          assertThat(streamId).isEqualTo(expectedStreamId)
          assertThat(errorCode).isEqualTo(ErrorCode.PROTOCOL_ERROR)
        }
      },
    )

   */
  fun closeLater(errorCode: ErrorCode) {
    if (!closeInternal(errorCode, null)) {
      return // Already closed.
    }
    connection.writeSynResetLater(id, errorCode)
  }

  /** Returns true if this stream was closed. */
  private fun closeInternal(
    errorCode: ErrorCode,
    errorException: IOException?,
  ): Boolean {
    assertLockNotHeld()

    withLock {

   * underlying input and output streams and shuts down internal task queues.
   */
  override fun close() {
    close(ErrorCode.NO_ERROR, ErrorCode.CANCEL, null)
  }

  internal fun close(
    connectionCode: ErrorCode,
    streamCode: ErrorCode,
    cause: IOException?,
  ) {
    assertLockNotHeld()

    ignoreIoExceptions {
      shutdown(connectionCode)
    }

  fun rstStream(
    streamId: Int,
    errorCode: ErrorCode,
  ) {
    withLock {
      if (closed) throw IOException("closed")
      require(errorCode.httpCode != -1)

      frameHeader(
        streamId = streamId,
        length = 4,
        type = TYPE_RST_STREAM,
        flags = FLAG_NONE,
      )
      sink.writeInt(errorCode.httpCode)
      sink.flush()
    }
  }

    if (streamId == 0) throw IOException("TYPE_RST_STREAM streamId == 0")
    val errorCodeInt = source.readInt()
    val errorCode =
      ErrorCode.fromHttp2(errorCodeInt) ?: throw IOException(
        "TYPE_RST_STREAM unexpected error code: $errorCodeInt",
      )
    handler.rstStream(streamId, errorCode)
  }

  @Throws(IOException::class)
  private fun readSettings(
    handler: Handler,
    length: Int,

                public void onError(final String phase, final String errorCode) {
                    try {
                        sendSseEvent(writer, "error", Map.of("phase", phase, "message", errorCode, "errorCode", errorCode));
                        if (logger.isDebugEnabled()) {
                            logger.debug("SSE error event sent. phase={}, error={}", phase, errorCode);
                        }

	binary.Write(buf, binary.BigEndian, uint16(len(errorCode)))
	buf.Write(errorCode)

	return genMessage(buf.Bytes(), nil)
}

// NewErrorMessage - creates new Request Level Error Message specified in
// https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectSELECTContent.html.
func NewErrorMessage(errorCode, errorMessage string) []byte {
	return newErrorMessage([]byte(errorCode), []byte(errorMessage))
}

        // Navigate through the inheritance hierarchy to find the errorCode field
        Class<?> currentClass = response.getClass();
        Field errorCodeField = null;

        while (currentClass != null && errorCodeField == null) {
            try {
                errorCodeField = currentClass.getDeclaredField("errorCode");

        case SMB_COM_NT_TRANSACT_SECONDARY -> "SMB_COM_NT_TRANSACT_SECONDARY";
        default -> "UNKNOWN";
        };
        final String str = errorCode == 0 ? "0" : SmbException.getMessageByCode(errorCode);
        return "command=" + c + ",received=" + received + ",errorCode=" + str + ",flags=0x" + Hexdump.toHexString(flags & 0xFF, 4)