}
                })
                .map(Method::getName)
                .toList();

        List<String> overriddenMethods = Stream.of(FileToRawModelMerger.class.getDeclaredMethods())
                .map(Method::getName)
                .filter(m -> m.startsWith("merge"))
                .collect(Collectors.toList());

        assertTrue(
                overriddenMethods.containsAll(methodNames),

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

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

            this.whiteList.put(project, null);
        }
        this.sortedProjects = projectDependencyGraph.getSortedProjects().stream()
                .filter(this.whiteList::containsKey)
                .toList();
    }

    /**
     * @since 3.5.0
     */
    @Override
    public List<MavenProject> getAllProjects() {
        return this.projectDependencyGraph.getAllProjects();
    }

    @Override

        }
        return clazz.cast(o);
    }

    public static <U, V> List<V> map(Collection<U> list, Function<U, V> mapper) {
        return list.stream().map(mapper).filter(Objects::nonNull).collect(Collectors.toList());
    }

                    appendJson("search-field", searchFieldMap, buf).append(',');
                    final Map<String, List<String>> requestHeaderMap = entity.getRequestHeaderList()
                            .stream()
                            .collect(Collectors.groupingBy(Pair::getFirst, Collectors.mapping(Pair::getSecond, Collectors.toList())));

        return asJson(new ApiResult.ApiConfigsResponse<ListBody>()
                .settings(Stream.of(dictFiles).map(this::createListBody).collect(Collectors.toList()))
                .status(ApiResult.Status.OK)
                .result());
    }

    /**
     * Creates a ListBody from a DictionaryFile for API responses.
     *

        mojos = new ArrayList<>();

        if (goals != null && !goals.isEmpty()) {
            String[] mojoGoals = goals.split(",");
            mojos = Arrays.stream(mojoGoals).map(fromGoalIntoLifecycleMojo).collect(Collectors.toList());
        }
    }

    private final Function<String, LifecycleMojo> fromGoalIntoLifecycleMojo = s -> {
        LifecycleMojo lifecycleMojo = new LifecycleMojo();
        lifecycleMojo.setGoal(s.trim());

        this.attributes = this.node.attributes().entrySet().stream()
                .filter(a -> a.getKey().equals(qname.getName()) || "*".equals(qname.getName()))
                .collect(Collectors.toList());
    }

    @Override
    public NodePointer getNodePointer() {
        if (position == 0) {
            setPosition(1);
        }

      client
        .newBuilder()
        .protocols(protocols.toList())
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).hostnameVerifier(RecordingHostnameVerifier())
        .build()
    server.useHttps(handshakeCertificates.sslSocketFactory())
    server.protocols = protocols.toList()
  }

  private fun upgradeRequest() =
    Request(