.filter(p -> p.getFileName().toString().endsWith(".pom"))
                    .collect(Collectors.toList());
        }
    }

    @Benchmark
    public int readWithStax(AdditionState state) throws IOException, XMLStreamException {
        int i = 0;
        for (Path pom : state.poms) {
            try (InputStream is = Files.newInputStream(pom)) {

        }
    }
}

@OptIn(KaAnalysisNonPublicApi::class)
fun List<KtFile>.collectReachableInlineDelegatedPropertyAccessors(): List<KtFile> {
    if (isEmpty()) return this

    val allFiles = mutableSetOf<KtFile>()
    allFiles.addAll(this)
    allFiles.collectReachableInlineDelegatedPropertyAccessors()
    return allFiles.toList()
}

internal class InlineDelegatedPropertyAccessorsAnalyzer(

        ).stream().map(this::findJvms).flatMap(List::stream);
        return Stream.concat(openJdkInstallations, jvms)
            .map(javaHome -> InstallationLocation.autoDetected(new File(javaHome), getSourceName()))
            .collect(Collectors.toSet());
    }

    private List<String> find(String sdkSubkey, String path, String value) {
        try {
            List<String> versions = getVersions(sdkSubkey);

    }

    private static List<RequestExtra> modifiedExtras(RequestExtrasContainer originalExtras) {
        return Stream.of(
            originalExtras.getAll().stream().filter(it -> !(it instanceof WithExtensionReferencesExtra)),
            Stream.<RequestExtra>of(new WithExtensionReferencesExtra.ProducedSynthetically())
        ).flatMap(Function.identity()).collect(Collectors.toList());
    }

            return Optional.empty();
        }

        List<MavenProject> sortedProjects = result.getTopologicallySortedProjects();

        boolean hasNoSuccess =
                sortedProjects.stream().noneMatch(project -> result.getBuildSummary(project) instanceof BuildSuccess);

        if (hasNoSuccess) {
            return Optional.empty();
        }

        List<String> remainingProjects = sortedProjects.stream()

        assertTrue(events.containViolation());
        assertThat(events.getViolating().size()).isEqualTo(2);
        List<String> descriptions = events.getViolating().stream().map(ArchUnitFixtureTest::eventDescription).collect(Collectors.toList());
        assertThat(descriptions).containsExactlyInAnyOrder(

            .projectDependenciesIdentifiers()
            .map { project(it.projectPath) }
            .withJavaBasePlugin()
            .allSourceSetsRoots()
            .map { it.relativeTo(rootDir).path }
            .toList()
    }

    private
    fun Sequence<ResolvedComponentResult>.projectDependenciesIdentifiers() =
        mapNotNull { it.id as? ProjectComponentIdentifier }

    private

        super(testClass);
    }

    protected List<Sample> getChildren() {
        List<Sample> allSamples = super.getChildren();
        return allSamples.stream()
            .filter(s -> sampleIdFilter().test(s.getId()))
            .collect(Collectors.toList());
    }

    private final List<TaskIdentity> finalizers;

    public DefaultPlannedTask(
        TaskIdentity taskIdentity,
        List<? extends NodeIdentity> nodeDependencies,
        List<TaskIdentity> mustRunAfter,
        List<TaskIdentity> shouldRunAfter,
        List<TaskIdentity> finalizers
    ) {
        this.taskIdentity = taskIdentity;
        this.nodeDependencies = nodeDependencies;
        this.mustRunAfter = mustRunAfter;

        super(distribution, testDirectoryProvider)
    }

    void withToolingApiJvmArgs(String... args) {
        jvmArgs.addAll(args.toList())
    }

    @Override
    void assertCanExecute() throws AssertionError {
    }

    @Override
    protected ExecutionResult doRun() {
        def output = new ByteArrayOutputStream()