assertNotNull(children2, "Wildcard children iterator should not be null");
            assertNotNull(children3, "Name filter children iterator should not be null");
            assertNotNull(children4, "Resource filter children iterator should not be null");
            assertSame(mockIterator, children1, "Should return expected iterator");

func (e *dataUsageEntry) addChild(hash dataUsageHash) {
	if _, ok := e.Children[hash.Key()]; ok {
		return
	}
	if e.Children == nil {
		e.Children = make(dataUsageHashMap, 1)
	}
	e.Children[hash.Key()] = struct{}{}
}

// Create a clone of the entry.
func (e dataUsageEntry) clone() dataUsageEntry {
	// We operate on a copy from the receiver.
	if e.Children != nil {
		ch := make(dataUsageHashMap, len(e.Children))

     *
     * @param children
     *            The child nodes. Must not be {@literal null}.
     * @param buf
     *            The string buffer. Must not be {@literal null}.
     */
    public static void appendChildren(final NodeList children, final StringBuilder buf) {
        assertArgumentNotNull("children", children);
        assertArgumentNotNull("buf", buf);

        invalidateChildren(path);
    }
    
    private void invalidateChildren(String parentPath) {
        Set<String> children = parentChildMap.get(parentPath);
        if (children != null) {
            for (String child : children) {
                DirectoryCacheEntry entry = leaseManager.getCacheEntry(child);
                if (entry != null) {
                    entry.invalidate();

     *
     * @param name the name for the new node
     * @param children the list of child nodes
     * @return a new XmlNode instance
     * @throws NullPointerException if name is null
     */
    static XmlNode newInstance(String name, List<XmlNode> children) {
        return newBuilder().name(name).children(children).build();
    }

    /**

        lock.writeLock().lock();
        try {
            FileInfo existing = children.get(childName);
            FileInfo newInfo = new FileInfo(childName, size, lastModified, isDirectory, attributes, creationTime, lastAccessTime);

            if (existing == null || !existing.matches(size, lastModified, attributes)) {
                children.put(childName, newInfo);
                hasChanges = true;

        // Add multiple children
        entry.updateChild("file1.txt", 1024L, 1000L, false, 0x20, 500L, 800L);
        entry.updateChild("file2.txt", 2048L, 2000L, false, 0x20, 600L, 900L);
        entry.updateChild("dir1", 0L, 3000L, true, 0x10, 700L, 1000L);

        List<DirectoryCacheEntry.FileInfo> children = entry.getChildren();
        assertEquals(3, children.size());

     */
    @Override
    void close();

    /**
     * Fetch all children
     *
     * @return an iterator over the child resources
     * @throws CIFSException if an error occurs accessing the resource
     */
    CloseableIterator<SmbResource> children() throws CIFSException;

    /**
     * Fetch children matching pattern, server-side filtering
     *
     * <p>

    idx++;

    if (c != '?' && c != ',') {
      while (idx < encodedLen) {
        // Read all the children
        idx += doParseTrieToBuilder(stack, encoded, idx, builder);

        if (encoded.charAt(idx) == '?' || encoded.charAt(idx) == ',') {
          // An extra '?' or ',' after a child node indicates the end of all children of this node.
          idx++;
          break;
        }
      }
    }

        // Verify the cached files have correct names
        List<DirectoryCacheEntry.FileInfo> children = cacheEntry.getChildren();
        assertTrue(children.stream().anyMatch(f -> "file1.txt".equals(f.getName())));
        assertTrue(children.stream().anyMatch(f -> "dir1".equals(f.getName())));
    }

    @Test
    public void testUpdateDirectoryCache() throws IOException {