.repositories(repositories.stream()
                                .map(RepositoryUtils::toRepo)
                                .map(session::getRemoteRepository)
                                .toList())
                        .coordinates(List.of(coordinates))
                        .build();
                ArtifactResolverResult res =
                        session.getService(ArtifactResolver.class).resolve(req);

        for (Element pluginElement : pluginElements) {
            Element executionsElement = pluginElement.child(EXECUTIONS).orElse(null);
            if (executionsElement != null) {
                var executionElements = executionsElement
                        .children(MavenPomElements.Elements.EXECUTION)
                        .toList();

            Element dependencies = DomUtils.findChildElement(dependencyManagement, "dependencies");
            var dependencyElements = dependencies.children("dependency").toList();
            assertEquals(1, dependencyElements.size(), "Should have only one dependency after duplicate removal");
        }

        @Test

        try (Stream<String> lines = Files.lines(atFile, StandardCharsets.UTF_8)) {
            List<String> args =
                    lines.filter(arg -> !arg.isEmpty() && !arg.startsWith("#")).toList();
            return parseArgs("atFile", args);
        } catch (ParseException e) {
            throw new IllegalArgumentException(

     */
    private boolean fixDuplicateDependenciesInSection(
            Element dependenciesElement, UpgradeContext context, String sectionName) {
        List<Element> dependencies = dependenciesElement.children(DEPENDENCY).toList();
        Map<String, Element> seenDependencies = new HashMap<>();

        List<Element> duplicates = dependencies.stream()
                .filter(dependency -> {

                }
            });
        }
    }

    @Override
    public Iterator<Lifecycle> iterator() {
        return stream().toList().iterator();
    }

    @Override
    public Stream<Lifecycle> stream() {
        return providers.stream().map(ExtensibleEnumProvider::provides).flatMap(Collection::stream);
    }

    @Override

import static java.util.Arrays.asList;
import static java.util.Collections.emptyList;
import static java.util.Collections.singletonList;
import static java.util.function.Function.identity;
import static java.util.stream.Collectors.toList;
import static org.apache.maven.execution.MavenExecutionRequest.REACTOR_MAKE_DOWNSTREAM;
import static org.apache.maven.execution.MavenExecutionRequest.REACTOR_MAKE_UPSTREAM;

                }

                BuildPlan buildPlan = plan;
                for (BuildStep step :
                        planSteps.stream().flatMap(p -> plan.steps(p.project)).toList()) {
                    for (MojoExecution execution : step.executions().toList()) {
                        buildPlan = computeForkPlan(step, execution, buildPlan);
                    }
                }

                for (BuildStep step : planSteps) {

     */
    private boolean isSubprojectsListRedundant(Element subprojectsElement, Path pomPath) {
        List<Element> subprojectElements =
                subprojectsElement.children(SUBPROJECT).toList();
        if (subprojectElements.isEmpty()) {
            return true; // Empty list is redundant
        }

        // Get the directory containing this POM
        Path parentDir = pomPath.getParent();

                paths.filter { !it.toFile().isDirectory }
                    .limit(4)
                    .map { dirPath.relativize(it).toString() }
                    .collect(Collectors.toList())
            }
        }?.filter {
            it.value.isNotEmpty()
        } ?: emptyMap()

    /**
     * Returns any temporary directories used to extract resources from jars.
     *