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

        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();

            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 {

        // 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

        byte[] encrypted2 = storage.encryptCredentials(plaintext.clone());

        // Should produce different ciphertexts due to random IV
        assertFalse(Arrays.equals(encrypted1, encrypted2), "Different encryptions should produce different ciphertexts");

        // But both should decrypt to same plaintext
        char[] decrypted1 = storage.decryptCredentials(encrypted1);

        assertEquals(32, derived3.length, "Derived key should have correct length");

        assertFalse(Arrays.equals(derived1, derived2), "Different labels should produce different keys");
        assertFalse(Arrays.equals(derived1, derived3), "Different contexts should produce different keys");
    }

    @Test
    public void testStoreNullKey() {

        final ExtractData result = zipExtractor.getText(in, null);

        assertNotNull(result);
        assertNotNull(result.getContent());
        assertTrue("Empty archive should produce empty content", result.getContent().trim().isEmpty());
    }

    /**
     * Test that empty TAR archive is handled gracefully.
     */

        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;

            NegTokenInit original = new NegTokenInit(mechs, flags, mechToken, mic);
            byte[] firstEncoding = original.toByteArray();

            // Multiple round-trips should produce identical results
            NegTokenInit parsed1 = new NegTokenInit(firstEncoding);
            byte[] secondEncoding = parsed1.toByteArray();

            NegTokenInit parsed2 = new NegTokenInit(secondEncoding);

        for (int i = 0; i < orderedDialects.length; i++) {
            assertEquals(orderedDialects[i], SMBUtil.readInt2(buffer, 24 + i * 2));
        }
    }

    @Test
    @DisplayName("Test multiple encode calls produce identical output")
    void testMultipleEncodeCallsIdentical() {
        ValidateNegotiateInfoRequest request =