hmac.engineUpdate(TEST_DATA, 0, TEST_DATA.length);
        byte[] result2 = hmac.engineDigest();

        // Should produce the same result
        assertArrayEquals(result1, result2);
    }

    @Test
    void testDifferentKeysProduceDifferentResults() {
        // Test that different keys produce different results
        byte[] key1 = "key1".getBytes();
        byte[] key2 = "key2".getBytes();

        byte[] signingKey2 = Smb3KeyDerivation.deriveSigningKey(dialect, sessionKey, preauthIntegrity);

        // Then - should produce identical results
        assertArrayEquals(signingKey1, signingKey2, "Same input should produce same output");
    }

    @Test
    @DisplayName("Should handle empty session key")
    void testDeriveKeys_EmptySessionKey() {
        // Given

        // Assert
        assertArrayEquals(expected, actual, "NT hash must match known test vector");
    }

    @Test
    @DisplayName("getNTHash: verify different passwords produce different hashes")
    void testGetNTHash_differentPasswords() {
        // Arrange
        String password1 = "password";
        String password2 = "Password";

        // Act

        MessageDigest hmac = Crypto.getHMACT64(key);
        byte[] result = hmac.digest(data);

        // Then
        assertNotNull(result);
        assertTrue(result.length > 0, "HMAC-T64 should produce non-empty result");
    }

    @Test
    @DisplayName("Should perform RC4 encryption/decryption")
    void testRC4() throws Exception {
        // Given
        byte[] key = "testkey123456789".getBytes(); // 16 bytes

            if (input == null || input.isEmpty()) {
                assertEquals(0, result.length, "Null or empty input should produce empty array");
            } else {
                assertTrue(result.length > 0, "Non-empty input should produce non-empty array");
            }
        }
    }

    @Nested
    @DisplayName("Unicode and ASCII Encoding")
    class UnicodeAndASCIITests {

  private EmptyImmutableListMultimap() {
    super(ImmutableMap.<Object, ImmutableList<Object>>of(), 0);
  }

  /*
   * TODO(b/242884182): Figure out why this helps produce the same class file when we compile most
   * of common.collect a second time with the results of the first compilation on the classpath. Or
   * just back this out once we stop doing that (which we'll do after our internal GWT setup

   * the order of entries.
   *
   * @param keyFunction the function used to produce the key for each value
   * @throws NullPointerException if any element of this iterable is {@code null}, or if {@code
   *     keyFunction} produces {@code null} for any key
   * @since 14.0
   */
  @SuppressWarnings("nullness") // Unsafe, but we can't do much about it now.

   * the order of entries.
   *
   * @param keyFunction the function used to produce the key for each value
   * @throws NullPointerException if any element of this iterable is {@code null}, or if {@code
   *     keyFunction} produces {@code null} for any key
   * @since 14.0
   */
  @SuppressWarnings("nullness") // Unsafe, but we can't do much about it now.

        byte[] buffer2 = new byte[200];
        int encoded2 = request2.encode(buffer2, 0);
        assertEquals(request2.size(), encoded2);
    }

    @Test
    @DisplayName("Test multiple encodes produce same result")
    void testMultipleEncodesProduceSameResult() {
        // Setup
        String pipeName = "RepeatedEncode";
        long timeout = 3000L;

            when(dc.toString()).thenReturn("DC");

            NtlmChallenge nc = new NtlmChallenge(challenge, dc);
            String result = nc.toString();

            // With size = 6 * 2 = 12, should produce "000F107F80FF"
            assertTrue(result.contains("000F107F80FF"));
        }

        @Test
        @DisplayName("Large challenge array is handled correctly")
        void testLargeChallengeArray() {