}
            builder.endObject();
            return builder;
        }, XContentType.JSON)) {
            message = ((ByteArrayOutputStream) out).toString(Constants.UTF_8);
            if (StringUtil.isBlank(message)) {
                message = "{}";
            }
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**

        assertEquals(workstation, type3.getWorkstation());
    }

    @Test
    @DisplayName("Should parse Type 3 message from byte array")
    void testType3MessageFromBytes() throws Exception {
        // Given - Create a Type 3 message and convert to bytes
        Type2Message type2 = createMockType2Message();

    /**
     * Creates an SMB exception with detailed context
     *
     * @param message the error message
     * @param errorCode the SMB error code
     * @param severity the error severity
     * @param category the error category
     */
    public SmbException(String message, int errorCode, Severity severity, Category category) {
        super(message);
        this.errorCode = errorCode;
        this.severity = severity;

     *
     * @param statusCode The HTTP status code
     * @param message The error message
     */
    public static void setError(final int statusCode, final String message) {
        LaRequestUtil.getOptionalRequest().ifPresent(req -> req.setAttribute(WEB_API_EXCEPTION, new WebApiException(statusCode, message)));
    }

    /**

    /**
     * Sent by the server in the Type 2 message to indicate that it is
     * including a Target Information block in the message. The Target
     * Information block is used in the calculation of the NTLMv2 response.
     */
    int NTLMSSP_NEGOTIATE_TARGET_INFO = 0x00800000;

    /**
     * Indicates that the NTLM version is included in the message.
     */
    int NTLMSSP_NEGOTIATE_VERSION = 0x2000000;

                    "Should return correct message for error 1");
            assertEquals("DCERPC_BIND_ERR_PROPOSED_TRANSFER_SYNTAXES_NOT_SUPPORTED", getResultMessageMethod.invoke(null, 2),
                    "Should return correct message for error 2");
            assertEquals("DCERPC_BIND_ERR_LOCAL_LIMIT_EXCEEDED", getResultMessageMethod.invoke(null, 3),
                    "Should return correct message for error 3");
        }

        @Test

  internal var headerValue: String?,
) {
  @JvmName("-deprecated_noCache")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "noCache"),
    level = DeprecationLevel.ERROR,
  )
  fun noCache(): Boolean = noCache

  @JvmName("-deprecated_noStore")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "noStore"),
    level = DeprecationLevel.ERROR,
  )

    AndroidCertificateChainCleaner.buildIfSupported(trustManager) ?: super.buildCertificateChainCleaner(trustManager)

  override fun log(
    message: String,
    level: Int,
    t: Throwable?,
  ) {
    if (level == WARN) {
      Log.w(Tag, message, t)
    } else {
      Log.i(Tag, message, t)
    }
  }

  companion object {
    val isSupported: Boolean = isAndroid && Build.VERSION.SDK_INT >= 29

        if (cause instanceof ClSQLException) {
            return ((ClSQLException) cause).getSql();
        }
        return "";
    }

    /**
     * Returns the real message.
     *
     * @param cause the underlying exception
     * @return the real message
     */
    protected static String getRealMessage(final SQLException cause) {
        final StringBuilder buf = new StringBuilder(256);

            pacString.check(testString);
        }, "A PACDecodingException should be thrown for a non-empty string with a zero pointer.");

        // Verify the exception message
        assertEquals("Non-empty string", exception.getMessage(), "The exception message is not correct.");
    }

    /**
     * Tests the {@link PacUnicodeString#check(String)} method with a string of incorrect length.
     */
    @Test