}

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

        // all new phases should be added after the existing ones
        List<BuildStep> lasts =
                org.values().stream().filter(b -> b.successors.isEmpty()).toList();
        List<BuildStep> firsts =
                add.values().stream().filter(b -> b.predecessors.isEmpty()).toList();
        firsts.stream()
                .filter(addNode -> !org.containsKey(addNode.name))

                    }
                })
                .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),

     */
    @Deprecated
    public void overwriteActiveProjects(List<String> activeProjectSelectors) {
        List<ProjectActivationSettings> projects =
                getProjects(pa -> pa.active()).toList();
        this.activations.removeAll(projects);
        activeProjectSelectors.forEach(this::activateOptionalProject);
    }

    /**

      assertEquals(200, response.code)
    }

    assertEquals(2, sessionIds.size)
    val directSessionIds =
      sslContext.clientSessionContext.ids
        .toList()
        .map { it.toByteString().hex() }

    if (platform.isConscrypt()) {
      if (tlsVersion == TlsVersion.TLS_1_3) {
        assertThat(sessionIds[0]).isEmpty()
        assertThat(sessionIds[1]).isEmpty()

import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

import static java.util.Comparator.comparing;
import static java.util.stream.Collectors.groupingBy;
import static java.util.stream.Collectors.toList;

/**
 * Generates the release notes i.e. list of changes that have gone into this release. They are grouped by the
 * type of change, then by team area.
 */
public class ReleaseNotesGenerator {
    /**

        .withArguments(*args, "--stacktrace", "--no-watch-fs")

    private
    fun assertArchivedFilesSeen(vararg archiveFileNames: String) {
        val rootDirFiles = projectDir.resolve("build").walk().toList()

        archiveFileNames.forEach { fileName ->
            assertTrue(rootDirFiles.any { it.name == fileName }, "File $fileName does not exist")
        }
    }

    private

     */
    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.
     *

      get() = informationalResponses_.toList()

    public var status: String
      private set

    public var code: Int
      get() {
        val statusParts = status.split(' ', limit = 3)
        require(statusParts.size >= 2) { "Unexpected status: $status" }
        return statusParts[1].toInt()
      }
      private set(value) {
        val reason =