void testStringConstructor() {
        SmbException ex = new SmbException("custom message");
        assertEquals("custom message", ex.getMessage());
        assertEquals(NtStatus.NT_STATUS_UNSUCCESSFUL, ex.getNtStatus());
    }

    /**
     * Verify that the message + rootCause constructor stores the root.
     */
    @Test
    @DisplayName("Message + root cause stores root cause")
    void testStringAndThrowableConstructor() {

    }

    /**
     * The packet type of this DCERPC message
     */
    protected int ptype = -1;
    /**
     * The flags for this DCERPC message
     */
    protected int flags = 0;
    /**
     * The total length of this DCERPC message
     */
    protected int length = 0;
    /**
     * The call ID for matching requests and responses
     */
    protected int call_id = 0;
    /**

            final String message = e.getMessage();
            assertTrue("Error message should contain var path: " + message, message.contains(varDir.toFile().getCanonicalPath()));
            assertTrue("Error message should contain webapp path: " + message, message.contains(webappDir.toFile().getCanonicalPath()));
            assertTrue("Error message should contain conf path: " + message, message.contains(confDir.toFile().getCanonicalPath()));

      "Code $code is reserved and may not be used."
    } else {
      null
    }

  fun validateCloseCode(code: Int) {
    val message = closeCodeExceptionMessage(code)
    require(message == null) { message!! }
  }

  fun acceptHeader(key: String): String = (key + ACCEPT_MAGIC).encodeUtf8().sha1().base64()

     * @param validationMessagesLambda lambda function that adds validation messages
     * @return concatenated string of localized validation messages separated by spaces
     */
    protected String getMessage(final VaMessenger<FessMessages> validationMessagesLambda) {
        final FessMessages messages = new FessMessages();
        validationMessagesLambda.message(messages);

                                missingParentPom.getException(),
                                artifact);
                    }

                    String message;

                    if (isMissingPom(e)) {
                        message = "Missing POM for " + artifact.getId();
                    } else if (isNonTransferablePom(e)) {
                        throw new ArtifactMetadataRetrievalException(

        return createSession(userId);
    }

    /**
     * Adds a message to a session.
     *
     * @param sessionId the session ID
     * @param message the message to add
     * @return true if the message was added, false if the session was not found
     */
    public boolean addMessage(final String sessionId, final ChatMessage message) {
        final ChatSession session = getSession(sessionId);

      <property name="format" value="serialVersionUID" />
      <property name="message" value="Do not declare serialVersionUID." />
      <property name="ignoreComments" value="true" />
    </module>
    <module name="RegexpSinglelineJava">
      <property name="format" value="java\.io\.Serializable;" />
      <property name="message" value="References java.io.Serializable." />
      <property name="ignoreComments" value="true" />

class SmbComLogoffAndXTest {

    @Test
    @DisplayName("constructor accepts null andx")
    void constructorWithNullAndx() {
        SmbComLogoffAndX msg = new SmbComLogoffAndX(null);
        assertNotNull(msg, "Message must not be null after construction");
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 5, -1, 10 })
    @DisplayName("writeParameterWordsWireFormat always returns 0")

    }

    private LogEvent createLogEvent(final Level level, final String loggerName, final String message) {
        return Log4jLogEvent.newBuilder() //
                .setLoggerName(loggerName) //
                .setLevel(level) //
                .setMessage(new SimpleMessage(message)) //
                .setTimeMillis(System.currentTimeMillis()) //
                .build();
    }

    @Test