assertNotNull(result);
        assertEquals(16, result.length);
    }

    @Test
    void testHMACT64WithEmptyKey() {
        // Test with empty key
        byte[] emptyKey = new byte[0];
        HMACT64 hmac = new HMACT64(emptyKey);
        hmac.engineUpdate(TEST_DATA, 0, TEST_DATA.length);
        byte[] result = hmac.engineDigest();

        assertNotNull(result);
        assertEquals(16, result.length);

    public void test_append_emptyString() {
        StringBuilder buf = new StringBuilder();
        Supplier<Object> supplier = () -> "";

        monitorTarget.append(buf, "emptyKey", supplier);
        assertEquals("\"emptyKey\":\"\"", buf.toString());
    }

    // Test append with very long string
    public void test_append_veryLongString() {
        StringBuilder buf = new StringBuilder();

    @Test
    @DisplayName("Should accept empty keys")
    void testEmptyKeys() {
        // Given
        byte[] emptyKey = new byte[0];

        // When/Then
        assertDoesNotThrow(() -> {
            Smb2EncryptionContext context = new Smb2EncryptionContext(1, DialectVersion.SMB311, emptyKey, emptyKey);
            assertNotNull(context, "Context should be created with empty keys");
        }, "Should accept empty keys");

        // setObject should handle various inputs
        try {
            WebApiUtil.setObject("validKey", "validValue");
            WebApiUtil.setObject("", "emptyKey");
            WebApiUtil.setObject("nullValue", null);
            WebApiUtil.setObject(null, "nullKey");
            WebApiUtil.setObject(null, null);
        } catch (Exception e) {

  }

  protected Collection<Method> suppressForHashSet() {
    return emptySet();
  }

  protected Collection<Method> suppressForLinkedHashSet() {
    return emptySet();
  }

  protected Collection<Method> suppressForEnumSet() {
    return emptySet();
  }

  protected Collection<Method> suppressForSynchronizedNavigableSet() {
    return emptySet();
  }

    return emptySet();
  }

  private Collection<Method> suppressForEmptySortedMap() {
    return emptySet();
  }

  protected Collection<Method> suppressForSingletonMap() {
    return emptySet();
  }

  protected Collection<Method> suppressForHashMap() {
    return emptySet();
  }

  protected Collection<Method> suppressForHashtable() {
    return emptySet();
  }

  }

  protected Collection<Method> suppressForArrayDeque() {
    return emptySet();
  }

  protected Collection<Method> suppressForLinkedList() {
    return emptySet();
  }

  protected Collection<Method> suppressForArrayBlockingQueue() {
    return emptySet();
  }

  protected Collection<Method> suppressForConcurrentLinkedQueue() {
    return emptySet();
  }

  }

  protected Collection<Method> suppressForEmptyList() {
    return emptySet();
  }

  protected Collection<Method> suppressForSingletonList() {
    return emptySet();
  }

  protected Collection<Method> suppressForArraysAsList() {
    return emptySet();
  }

  protected Collection<Method> suppressForArrayList() {
    return emptySet();
  }

  protected Collection<Method> suppressForLinkedList() {

  }

  protected Collection<Method> suppressForCheckedMap() {
    return emptySet();
  }

  protected Collection<Method> suppressForCheckedSortedMap() {
    return emptySet();
  }

  protected Collection<Method> suppressForEmptyMap() {
    return emptySet();
  }

  protected Collection<Method> suppressForSingletonMap() {
    return emptySet();
  }

  protected Collection<Method> suppressForHashMap() {

    Set<Object> set = new HashSet<>();
    assertThat(union(emptySet(), emptySet()).copyInto(set)).isSameInstanceAs(set);
    assertThat(intersection(emptySet(), emptySet()).copyInto(set)).isSameInstanceAs(set);
    assertThat(difference(emptySet(), emptySet()).copyInto(set)).isSameInstanceAs(set);
    assertThat(symmetricDifference(emptySet(), emptySet()).copyInto(set)).isSameInstanceAs(set);
  }