System.out.println(message);
        assertContains(message, "ErrorCode=7650");
        assertContains(message, "SQLState=fooState");
        assertContains(message, "some reason");
        assertContains(message, "ErrorCode=7660");
        assertContains(message, "SQLState=barState");
        assertContains(message, "hoge reason");
        assertContains(message, "ErrorCode=7670");
        assertContains(message, "SQLState=bazState");

        // Arrange
        int access = 0x01;
        int errorCode = 0xC0000022; // Example error code (STATUS_ACCESS_DENIED)
        // Simulate RPC error
        doAnswer(invocation -> {
            MsrpcSamrOpenDomain rpc = invocation.getArgument(0);
            rpc.retval = errorCode; // Simulate error
            return null;

     */
    @Test
    void testConstructorWithError_knownCode() {
        int errorCode = DcerpcError.DCERPC_FAULT_ACCESS_DENIED;
        DcerpcException exception = new DcerpcException(errorCode);

        assertEquals(errorCode, exception.getErrorCode(), "Error code should match the input.");
        assertTrue(exception.getMessage().contains("DCERPC_FAULT_ACCESS_DENIED"),

   * 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)
    }

      this.data = source.readByteString(length.toLong()).toByteArray()
    }

    override fun rstStream(
      streamId: Int,
      errorCode: ErrorCode,
    ) {
      check(type == -1)
      this.type = Http2.TYPE_RST_STREAM
      this.streamId = streamId
      this.errorCode = errorCode
    }

    override fun ping(
      ack: Boolean,
      payload1: Int,
      payload2: Int,
    ) {

    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 test_errorCodeGeneration() {
        long timestamp = System.currentTimeMillis();
        String errorCode = "error_code:" + Long.toHexString(timestamp);

        assertTrue(errorCode.startsWith("error_code:"));
        assertTrue(errorCode.length() > 11); // "error_code:" is 11 chars
    }

    // Test with different exception types
    public void test_exceptionTypes() {

                throw new IOException("Invalid payload size: " + size);
            }
            final int errorCode = Encdec.dec_uint32le(BUF, 9) & 0xFFFFFFFF;
            if (resp.command == ServerMessageBlock.SMB_COM_READ_ANDX && (errorCode == 0 || errorCode == 0x80000005)) { // overflow indicator normal for pipe
                final SmbComReadAndXResponse r = (SmbComReadAndXResponse) resp;

        // Arrange
        String server = "testServer";
        int access = 123;
        int errorCode = 12345;

        doAnswer(invocation -> {
            MsrpcLsarOpenPolicy2 rpc = invocation.getArgument(0);
            rpc.retval = errorCode; // Simulate RPC error
            return null;
        }).when(mockDcerpcHandle).sendrecv(any(MsrpcLsarOpenPolicy2.class));

    }

    /**
     * @return the errorCode
     */
    @Override
    public final int getErrorCode() {
        return this.errorCode;
    }

    /**
     * Sets the error code for this message block
     * @param errorCode
     *            the errorCode to set
     */
    public final void setErrorCode(final int errorCode) {
        this.errorCode = errorCode;
    }

    /**