*/
    boolean problemsOverflow();

    /**
     * Reports a problem: always maintains the counters, but whether problem is preserved in memory, depends on
     * implementation and its configuration.
     *
     * @param problem the problem to report
     * @return {@code true} if passed problem is preserved by this call.
     */

        // Then
        assertEquals(CRYPTO_ERROR_MESSAGE, exception.getMessage(), "Crypto message should be preserved");
        assertSame(cause, exception.getCause(), "Crypto cause should be preserved");
    }

    }

    @ParameterizedTest(name = "Message-only ctor preserves message: [{0}]")
    @MethodSource("messages")
    void messageConstructor_setsMessageAndNullCause(String message) {
        // Arrange & Act
        SMBProtocolDowngradeException ex = new SMBProtocolDowngradeException(message);

        // Assert - message preserved, cause null
        assertEquals(message, ex.getMessage());

    @DisplayName("Message-only constructor: preserves provided message; null cause")
    void messageOnlyConstructor_preservesMessage(String message) {
        // Arrange & Act
        SMBProtocolDecodingException ex = new SMBProtocolDecodingException(message);

        // Assert message and cause
        assertEquals(message, ex.getMessage(), "Message should be preserved as provided");

        // Execute
        final InvalidQueryException exception = new InvalidQueryException(messageCode, message, middleCause);

        // Verify cause chain is preserved
        assertEquals(middleCause, exception.getCause());
        assertEquals(rootCause, exception.getCause().getCause());
    }

    public void test_emptyMessage() {
        // Setup

        assertEquals("single", result[0]);

        // Single quoted value - quotes preserved
        value = "\"single quoted\"";
        result = KuromojiCSVUtil.parse(value);
        assertEquals(1, result.length);
        assertEquals("\"single quoted\"", result[0]);

        // Single empty value - quotes preserved
        value = "\"\"";
        result = KuromojiCSVUtil.parse(value);

        assertThrows(IOException.class, () -> new NegTokenTarg(bad), "Malformed byte[] should cause IOException");
    }

    @Test
    @DisplayName("mechanism token empty array – preserved after round‑trip")
    void testEmptyMechanismToken() throws IOException {
        NegTokenTarg nt = new NegTokenTarg();
        nt.setResult(NegTokenTarg.REQUEST_MIC);

   * the XML specification.
   *
   * <p>This escaper does not escape non-ASCII characters to their numeric character references
   * (NCR). Any non-ASCII characters appearing in the input will be preserved in the output.
   * Specifically "\r" (carriage return) is preserved in the output, which may result in it being
   * silently converted to "\n" when the XML is parsed.
   *
   * <p>This escaper does not treat surrogate pairs specially and does not perform Unicode

        assertTrue(ts.contains(ex.getMessage()), "toString should contain the detail message");
    }

    @ParameterizedTest(name = "Message preserved: [{0}]")
    @MethodSource("messages")
    @DisplayName("Message constructor preserves provided messages, including null/edge cases")
    void messageConstructor_preservesMessage(String msg) {
        // Arrange & Act

		},
		// Non parsable ip is assumed to be hostame and gets preserved
		// as the left most elements, regardless of IP based sorting.
		{
			ipList:       []string{"hostname", "127.0.0.1", "192.168.1.106"},
			sortedIPList: []string{"hostname", "192.168.1.106", "127.0.0.1"},
		},
		// Non parsable ip is assumed to be hostname, with a mixed input of ip and hostname.
		// gets preserved and moved into left most elements, regardless of