// A 4n+1 length string is never legal base64().
    assertFailsToDecode(base64(), "12345", "Invalid input length 5");
    // These have a combination of invalid length, unrecognized characters and wrong padding.
    assertFailsToDecode(base64(), "AB=C", "Unrecognized character: =");
    assertFailsToDecode(base64(), "A=BCD", "Invalid input length 5");
    assertFailsToDecode(base64(), "?", "Invalid input length 1");

    @DisplayName("Should handle invalid NetBIOS name quickly")
    @Timeout(value = 1, unit = TimeUnit.SECONDS) // Very short timeout
    void testGetNbtByNameInvalid() {
        // When/Then - Should fail quickly with invalid characters
        assertThrows(Exception.class, () -> {
            nameServiceClient.getNbtByName("INVALID@#$%NAME");
        }, "Should throw exception for invalid NetBIOS name");
    }

    @Test

        assertEquals(unicodeFileName, decodedName);
        assertEquals(20 + nameLength, bytesWritten);
    }

    @Test
    @DisplayName("Test with special characters in filename")
    void testWithSpecialCharactersInFilename() throws SMBProtocolDecodingException {
        String specialFileName = "file!@#$%^&*().txt";

    }

    @Test
    @DisplayName("Should handle notification with Unicode characters")
    void testUnicodeFilenames() throws Exception {
        // Given
        byte[] buffer = new byte[512];
        int offset = 0;

        setHeaderStart(response, 64);

        String unicodeName = "文件名.txt"; // Chinese characters
        byte[] fileNameBytes = unicodeName.getBytes("UnicodeLittleUnmarked");

        assertEquals(rootCause, exception.getCause().getCause());
    }

    public void test_constructor_withSpecialCharactersInMessage() {
        // Test constructor with special characters in message
        String message = "Error with special chars: \n\t\r\"'<>&";
        SearchEngineClientException exception = new SearchEngineClientException(message);

        assertNotNull(exception);

import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.CharMatcher.NamedFastMatcher;
import java.util.BitSet;

/**
 * An immutable version of CharMatcher for smallish sets of characters that uses a hash table with
 * linear probing to check for matches.
 *
 * @author Christopher Swenson
 */
@GwtIncompatible // no precomputation is done in GWT
final class SmallCharMatcher extends NamedFastMatcher {

// It returns a single-use iterator.
func SplitAfterSeq(s, sep []byte) iter.Seq[[]byte] {
	return splitSeq(s, sep, len(sep))
}

// FieldsSeq returns an iterator over subslices of s split around runs of
// whitespace characters, as defined by [unicode.IsSpace].
// The iterator yields the same subslices that would be returned by [Fields](s),
// but without constructing a new slice containing the subslices.
func FieldsSeq(s []byte) iter.Seq[[]byte] {

     */
    protected Map<String, String> fieldRuleMap = new LinkedHashMap<>();

    /** Flag to enable or disable trimming of whitespace characters. */
    protected boolean trimSpaceEnabled = true;

    /**
     * The charset name for the output.
     */
    protected String charsetName = Constants.UTF_8;

    /**

 * Represents a DCE/RPC UUID (Universally Unique Identifier).
 * This class provides methods for UUID string parsing and binary conversion.
 */
public class UUID extends rpc.uuid_t {

    /**
     * Convert hexadecimal characters to binary integer
     *
     * @param arr the character array containing hex digits
     * @param offset the starting position in the array
     * @param length the number of hex digits to convert

  private fun loggerTag(loggerName: String): String {
    // We need to handle long logger names before they hit Log.
    // java.lang.IllegalArgumentException: Log tag "okhttp3.mockwebserver.MockWebServer" exceeds limit of 23 characters
    return knownLoggers[loggerName] ?: loggerName.take(23)
  }

  fun enable() {
    try {
      for ((logger, tag) in knownLoggers) {
        enableLogging(logger, tag)
      }