@Test
    @DisplayName("Should handle control characters in hexdump")
    void testHexdumpControlCharacters() {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        PrintStream ps = new PrintStream(baos);

        // Test with control characters and printable characters
        byte[] data = { 0x00, 0x01, 0x09, 0x0A, 0x0D, 0x1F, // Control characters
                0x20, 0x41, 0x42, 0x7E, // Printable characters

    }

    /**
     * Gets the fragment size.
     *
     * @return the fragment size in characters
     */
    public int getFragmentSize() {
        return fragmentSize;
    }

    /**
     * Sets the fragment size with fluent interface.
     *
     * @param fragmentSize the fragment size in characters
     * @return this HighlightInfo instance for method chaining
     */

/**
 * Returns the next index in this at or after [startIndex] that is a character from
 * [characters]. Returns the input length if none of the requested characters can be found.
 */
private fun String.indexOfElement(
  characters: String,
  startIndex: Int = 0,
): Int {
  for (i in startIndex until length) {
    if (this[i] in characters) {
      return i
    }
  }
  return length

    /**
     * Document identifier for the target document to redirect to.
     * This is required and limited to 100 characters.
     */
    @Required
    @Size(max = 100)
    public String docId;

    /**
     * Redirect target or return URL parameter.
     * This is required and limited to 10000 characters to accommodate long URLs.
     */
    @Size(max = 10000)
    @Required
    public String rt;

    /**

     *
     * @return the share this referral points to
     */
    String getShare();

    /**
     * Get the number of characters from the UNC path that were consumed by this referral
     *
     * @return the number of characters from the unc path that were consumed by this referral
     */
    int getPathConsumed();

    /**
     * Get the replacement path for this referral
     *

        assertTrue(toStringResult.contains(message));
    }

    @Test
    public void test_constructorWithScheduledJob_specialCharacters() {
        // Test with scheduled job that has special characters in toString
        ScheduledJob scheduledJob = new ScheduledJob() {
            @Override
            public String toString() {
                return "Job[name=\"Test & Job\", id='<123>']";
            }

  public void testReallySimpleFingerprints() {
    assertEquals(8581389452482819506L, fingerprint("test".getBytes(UTF_8)));
    // 32 characters long
    assertEquals(-4196240717365766262L, fingerprint(Strings.repeat("test", 8).getBytes(UTF_8)));
    // 256 characters long
    assertEquals(3500507768004279527L, fingerprint(Strings.repeat("test", 64).getBytes(UTF_8)));
  }

  public void testStringsConsistency() {

/**
 * Utility class for LDAP operations.
 */
public final class LdapUtil {

    private LdapUtil() {
    }

    /**
     * Escapes special characters in a value for use in LDAP search filters.
     * This method escapes characters that have special meaning in LDAP filter expressions
     * to prevent LDAP injection attacks.
     *
     * @param value the value to escape (null is treated as empty string)

    /**
     * Sanitizes a string for safe logging (removes control characters)
     *
     * @param input the string to sanitize
     * @return sanitized string safe for logging
     */
    public static String sanitizeForLogging(String input) {
        if (input == null) {
            return "null";
        }
        // Remove control characters and limit length

  }

  /**
   * Tests that specifying any alphanumeric characters as 'safe' causes an {@link
   * IllegalArgumentException}.
   */
  public void testBadArguments_badchars() {
    String msg = "Alphanumeric characters are always 'safe' and should not be explicitly specified";
    IllegalArgumentException expected =