/** Tests that the simple escaper treats 0-9, a-z and A-Z as safe */
  public void testSimpleEscaper() {
    UnicodeEscaper e = new PercentEscaper("", false);
    for (char c = 0; c < 128; c++) {
      if ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
        assertUnescaped(e, c);
      } else {
        assertEscaping(e, escapeAscii(c), c);
      }
    }

        SMBUtil.writeInt4(action, buffer, notifyOffset + 4);
        SMBUtil.writeInt4(8, buffer, notifyOffset + 8);
        System.arraycopy("test".getBytes("UnicodeLittleUnmarked"), 0, buffer, notifyOffset + 12, 8);

        // When
        response.readBytesWireFormat(buffer, offset);

        // Then
        List<FileNotifyInformation> notifications = response.getNotifyInformation();

pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE = 64
pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE ideal-int
pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY = 128
pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY ideal-int
pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_GUARD_CF = 16384
pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_GUARD_CF ideal-int

            return hasher.hash().asBytes();
          }
        };
    // Murmur3F, MurmurHash3 for x64, 128-bit (MurmurHash3_x64_128)
    // From http://code.google.com/p/smhasher/source/browse/trunk/main.cpp
    HashTestUtils.verifyHashFunction(hf, 128, 0x6384BA69);
  }

  public void testInvariants() {
    HashTestUtils.assertInvariants(murmur3_128());
  }

      assertEquals(HASH_FN.newHasher().putUnencodedChars(s).hash(), HASH_FN.hashUnencodedChars(s));
    }
  }

  public void testUtf8() {
    char[] charsA = new char[128];
    char[] charsB = new char[128];

    for (int i = 0; i < charsA.length; i++) {
      if (i < 100) {
        charsA[i] = 'a';
        charsB[i] = 'a';
      } else {
        // Both two-byte characters, but must be different

var x124 uint64 x124, x123 = bits.Mul64(x3, 0xa40611e3449c0f01) var x125 uint64 var x126 uint64 x125, x126 = bits.Add64(x124, x121, uint64(0x0)) var x127 uint64 var x128 uint64 x127, x128 = bits.Add64(x122, x119, uint64(fiatScalarUint1(x126))) var x129 uint64 var x130 uint64 x129, x130 = bits.Add64(x120, x117, uint64(fiatScalarUint1(x128))) var x131 uint64 var x132 uint64 x131, x132 = bits.Add64(x111, x123, uint64(0x0)) var x133 uint64 var x134 uint64 x133, x134 = bits.Add64(x113, x125, uint64(fia...

        }

        @Test
        @DisplayName("Should allow size override")
        void testSizeOverride() {
            testRequest.setEncodedSize(128);
            assertEquals(128, testRequest.size());
        }

        @Test
        @DisplayName("Should throw exception on null buffer")
        void testEncodeWithNullBuffer() {

@NullUnmarked
enum HashFunctionEnum {
  ADLER32(Hashing.adler32()),
  CRC32(Hashing.crc32()),
  GOOD_FAST_HASH_32(Hashing.goodFastHash(32)),
  GOOD_FAST_HASH_64(Hashing.goodFastHash(64)),
  GOOD_FAST_HASH_128(Hashing.goodFastHash(128)),
  GOOD_FAST_HASH_256(Hashing.goodFastHash(256)),
  MD5(Hashing.md5()),
  MURMUR3_128(Hashing.murmur3_128()),
  MURMUR3_32(Hashing.murmur3_32()),
  MURMUR3_32_FIXED(Hashing.murmur3_32_fixed()),
  SHA1(Hashing.sha1()),

          + "\u2006\u2007\u2008\u2009\u200a";
  private static final String ASCII_CHARACTERS;

  static {
    int spaceInAscii = 32;
    int sevenBitAsciiMax = 128;
    StringBuilder sb = new StringBuilder(sevenBitAsciiMax - spaceInAscii);
    for (int ch = spaceInAscii; ch < sevenBitAsciiMax; ch++) {
      sb.append((char) ch);
    }
    ASCII_CHARACTERS = sb.toString();
  }

        // When
        MessageDigest md4 = Crypto.getMD4();
        byte[] hash = md4.digest(data);

        // Then
        assertNotNull(hash);
        assertEquals(16, hash.length); // MD4 produces 128-bit hash
    }

    @Test
    @DisplayName("Should calculate MD5 hash correctly")
    void testMD5Hash() {
        // Given
        String input = "Hello World";
        byte[] data = input.getBytes();