collectRequest.addRepository(newTestRepository());

        CollectResult collectResult = system.collectDependencies(session, collectRequest);

        List<DependencyNode> nodes = collectResult.getRoot().getChildren();
        assertEquals(2, nodes.size());
        checkUtSimpleArtifactDependencies(
                nodes.get(0).getDependency(), nodes.get(1).getDependency());
    }

    @Test

        Node node = Mockito.mock(Node.class);
        Mockito.when(resolverResult.getRoot()).thenReturn(node);
        Node child = Mockito.mock(Node.class);
        Mockito.when(node.getChildren()).thenReturn(List.of(child));

        services.addAll(List.of(
                new DefaultRequestCacheFactory(),
                new DefaultArtifactCoordinatesFactory(),

        }
    }

    private Set<String> getUnknownParameters(MojoExecution mojoExecution, Set<String> parameters) {
        return stream(mojoExecution.getConfiguration().getChildren())
                .map(Xpp3Dom::getName)
                .filter(name -> !parameters.contains(name))
                .collect(Collectors.toSet());
    }

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

        }

        @Override
        public ProblemCollector<ModelProblem> getProblemCollector() {
            return null;
        }

        @Override
        public List<? extends ModelBuilderResult> getChildren() {
            return List.of();
        }
    }

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

        if (entry == null || !entry.isComplete()) {
            return null;
        }

        List<SmbFile> files = new ArrayList<>();
        for (DirectoryCacheEntry.FileInfo fileInfo : entry.getChildren()) {
            try {
                // Create SmbFile objects from cached info
                SmbFile file = createSmbFileFromCache(directoryPath, fileInfo);
                files.add(file);

        } 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 {

                artifact.setDependencyTrail(nodeTrail);
                artifacts.add(artifact);
            }

            toArtifacts(artifacts, node.getChildren(), nodeTrail, filter);
        }
    }

    public static Artifact toArtifact(org.apache.maven.artifact.Artifact artifact) {
        if (artifact == null) {
            return null;
        }

                PlexusConfiguration httpHeaders = config.getChild("httpHeaders", false);
                if (httpHeaders != null) {
                    PlexusConfiguration[] properties = httpHeaders.getChildren("property");
                    if (properties != null && properties.length > 0) {
                        headers = new HashMap<>();
                        for (PlexusConfiguration property : properties) {