@SuppressWarnings("unchecked")
    Entry<String, String>[] array = (Entry<String, String>[]) new Entry<?, ?>[entries.length];
    int i = 0;
    for (Object o : entries) {
      @SuppressWarnings("unchecked")
      Entry<String, String> e = (Entry<String, String>) o;
      array[i++] = e;
    }
    return create(array);
  }

  protected abstract ListMultimap<String, String> create(Entry<String, String>[] entries);

  @Override

    @SuppressWarnings("unchecked")
    Entry<String, String>[] array = (Entry<String, String>[]) new Entry<?, ?>[entries.length];
    int i = 0;
    for (Object o : entries) {
      @SuppressWarnings("unchecked")
      Entry<String, String> e = (Entry<String, String>) o;
      array[i++] = e;
    }
    return create(array);
  }

  protected abstract SetMultimap<String, String> create(Entry<String, String>[] entries);

  @Override

    }

    /**
     * The unique identifier of the protected words dictionary entry being edited.
     * This is a required field for identifying which dictionary entry to update.
     */
    @Required
    @ValidateTypeFailure
    public Long id;

    /**
     * Returns a display-friendly identifier combining the dictionary ID and entry ID.
     * This method creates a composite identifier for UI display purposes.
     *

  @CollectionSize.Require(absent = ZERO)
  public void testRemovePropagatesToAsMapEntrySet() {
    List<Entry<K, V>> entries = copyToList(multimap().entries());
    for (Entry<K, V> entry : entries) {
      resetContainer();

      K key = entry.getKey();
      V value = entry.getValue();

      Iterator<Entry<K, Collection<V>>> asMapItr = multimap().asMap().entrySet().iterator();
      Collection<V> collection = null;

		return
	}

	// Check for abandoned entries.
	found := make(map[string]struct{}, len(d.Cache))

	// Mark all children recursively
	var mark func(entry dataUsageEntry)
	mark = func(entry dataUsageEntry) {
		for k := range entry.Children {
			found[k] = struct{}{}
			if ch, ok := d.Cache[k]; ok {
				mark(ch)
			}
		}
	}
	found[top] = struct{}{}
	mark(*topE)

                  @Override
                  protected SortedMap<String, String> create(Entry<String, String>[] entries) {
                    NavigableMap<String, String> map = new SafeTreeMap<>(Ordering.natural());
                    for (Entry<String, String> entry : entries) {
                      map.put(entry.getKey(), entry.getValue());
                    }
                    return map;
                  }

            // Create multiple entries
            for (int i = 0; i < 10; i++) {
                DfsReferralDataImpl entry = createInitializedDfsReferralDataImpl();
                String key = "key-" + i;
                entry.setKey(key);
                entry.setCacheMap(cache);
                entry.replaceCache();
            }

            // Verify all entries
            assertEquals(10, cache.size());

        assertEquals(0, bytesRead);
    }

    @Test
    @DisplayName("Test decode with non-aligned next entry offset throws exception")
    void testDecodeNonAlignedNextOffset() {
        byte[] buffer = new byte[100];
        // Write non-aligned next entry offset (not divisible by 4)
        SMBUtil.writeInt4(7, buffer, 0); // 7 is not aligned to 4 bytes

            log.error("Failed to apply name filter", e);
            return false;
        }
    }

    /**
     * Advances to the next file entry in the enumeration.
     *
     * @param last whether this is the last attempt to advance
     * @return the next file entry, or null if no more entries
     * @throws CIFSException if an error occurs during enumeration
     */

    map.put("bar", 3);
    Iterator<Entry<String, Integer>> entries = map.entries().iterator();
    Entry<String, Integer> entry = entries.next();
    assertEquals("bar", entry.getKey());
    assertEquals(1, (int) entry.getValue());
    entry = entries.next();
    assertEquals("foo", entry.getKey());
    assertEquals(2, (int) entry.getValue());
    entry.setValue(4);
    entry = entries.next();