public GradleException failureFor(ConfigurationInternal configuration, boolean withTaskAdvice) {
            List<ConfigurationInternal> collisions =
                byIdentity.get(VariantIdentity.from(configuration)).stream()
                    .filter(it -> !it.getName().equals(configuration.getName()))
                    .collect(Collectors.toList());

            if (collisions.isEmpty()) {
                return null;
            }

        List<Exclusion> excl = Optional.ofNullable(exclusions).orElse(Collections.emptyList()).stream()
                .map(RepositoryUtils::toExclusion)
                .collect(Collectors.toList());
        return new Dependency(result, artifact.getScope(), artifact.isOptional(), excl);
    }

    public static List<RemoteRepository> toRepos(List<ArtifactRepository> repos) {

            .filter { it.key.isCompatibleOrWeaklyIncompatible }
            .flatMap { it.value }
            .map { it.toKtSymbol(analysisContext) as KaDeclarationSymbol }
            .toList()
    }

open class ClassPathModeExceptionCollector : Stoppable {

    private
    val collection: MutableList<Exception> = synchronizedList(mutableListOf<Exception>())

    val exceptions: List<Exception>
        get() = collection.toList()

    fun collect(error: Exception) {
        collection.add(error)
    }

    override fun stop() {
        collection.clear()
    }
}

    public static class ApiSystemInfoResponse extends ApiResponse {
        protected List<Map<String, String>> envProps;
        protected List<Map<String, String>> systemProps;
        protected List<Map<String, String>> fessProps;
        protected List<Map<String, String>> bugReportProps;

        public ApiSystemInfoResponse envProps(final List<Map<String, String>> envProps) {
            this.envProps = envProps;

        }
    }

    override fun KaSession.collectSymbols(ktFile: KtFile, testServices: TestServices): SymbolsData =
        SymbolsData(getSymbolsFromScope(getScope(ktFile, testServices)).toList())

            val implementationClass = pluginProperties.getProperty("implementation-class")
            PluginEntry(id, implementationClass)
        }.toList()
    }
} catch (cause: IOException) {
    throw IllegalArgumentException(
        "Failed to extract plugin metadata from '" + jar.path + "'",
        cause
    )
}


private

        return checksumAlgorithmFactorySelector.getChecksumAlgorithmFactories().stream()
                .map(ChecksumAlgorithmFactory::getName)
                .collect(Collectors.toList());
    }

    @Override
    public ChecksumAlgorithm select(String algorithmName) {
        nonNull(algorithmName, "algorithmName");
        try {

        this.sessionId = sessionId;
        if (!cachedIncludeSet.isEmpty()) {
            try {
                getUrlFilterService().addIncludeUrlFilter(sessionId, cachedIncludeSet.stream().collect(Collectors.toList()));
            } catch (final Exception e) {
                logger.warn("Failed to add include_urls on " + sessionId, e);
            }
            cachedIncludeSet.clear();
        }

                })
                .collect(toList());
    }

    static class ScenarioBuilder {
        private String description;
        private List<String> activeRequiredProjects = emptyList();
        private List<String> activeOptionalProjects = emptyList();
        private List<String> inactiveRequiredProjects = emptyList();
        private List<String> inactiveOptionalProjects = emptyList();