} finally {
            lock.writeLock().unlock();
        }
    }

    /**
     * Get all children
     *
     * @return list of child file info
     */
    public List<FileInfo> getChildren() {
        lock.readLock().lock();
        try {
            lastAccessTime = System.currentTimeMillis();
            return new ArrayList<>(children.values());
        } finally {

    entry.updateChild("file1.txt", attrs);
    
    assertTrue(entry.hasChild("file1.txt"));
    assertEquals(1, entry.getChildren().size());
    
    // Test removal
    entry.removeChild("file1.txt");
    assertFalse(entry.hasChild("file1.txt"));
    assertEquals(0, entry.getChildren().size());
}

@Test
public void testDirectoryLeaseManager() {

    @Nullable
    default String getAttribute(@Nonnull String name) {
        return attribute(name);
    }

    @Deprecated(since = "4.0.0", forRemoval = true)
    @Nonnull
    default List<XmlNode> getChildren() {
        return children();
    }

    @Deprecated(since = "4.0.0", forRemoval = true)
    @Nullable
    default XmlNode getChild(String name) {
        return child(name);
    }

        for (DependencyNode child : root.getChildren()) {
            if (child.getArtifact() == null) {
                continue;
            }
            String childType = child.getArtifact().getProperty(ArtifactProperties.TYPE, "");
            if (!PROCESSOR_TYPE_IDS.contains(childType)) {
                continue;
            }
            for (DependencyNode transitive : child.getChildren()) {

        directoryLeaseManager.updateDirectoryCache(directoryPath, files);

        // Step 6: Verify cache is complete and populated
        assertTrue(cacheEntry.isComplete());
        assertEquals(2, cacheEntry.getChildren().size());
        assertTrue(cacheEntry.hasChild("document.txt"));
        assertTrue(cacheEntry.hasChild("subfolder"));

        // Step 7: Verify cached directory listing

        assertEquals(DirectoryCacheScope.IMMEDIATE_CHILDREN, entry.getScope());
        assertFalse(entry.isComplete());
        assertFalse(entry.hasChanges());
        assertTrue(entry.getChildren().isEmpty());
    }

    @Test
    public void testUpdateChild() {
        String childName = "file1.txt";
        long size = 1024L;
        long lastModified = System.currentTimeMillis();

        assertNotNull(cacheEntry);
        assertTrue(cacheEntry.isComplete());
        assertEquals(2, cacheEntry.getChildren().size());

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

            addEdge(parentVertex, vertex, e);
        } else {
            entry = vertex;
        }

        MetadataTreeNode[] kids = node.getChildren();
        if (kids == null || kids.length < 1) {
            return;
        }

        for (int i = 0; i < kids.length; i++) {
            MetadataTreeNode n = kids[i];

        XmlNode toXml(PlexusConfiguration config, ExpressionEvaluator evaluator) throws ExpressionEvaluationException {
            List<XmlNode> children = new ArrayList<>();
            for (PlexusConfiguration c : config.getChildren()) {
                children.add(toXml(c, evaluator));
            }
            String name = config.getName();
            Object value = evaluator.evaluate(config.getValue());

        PlexusConfiguration c = mojoDescriptor.getMojoConfiguration();

        List<XmlNode> children = new ArrayList<>();
        PlexusConfiguration[] ces = c.getChildren();
        if (ces != null) {
            for (PlexusConfiguration ce : ces) {
                String value = ce.getValue(null);
                String defaultValue = ce.getAttribute("default-value", null);