output.println();
    }

    private static List<JvmToolchainMetadata> invalidToolchains(List<JvmToolchainMetadata> toolchains) {
        return toolchains.stream().filter(t -> !isValidToolchain(t)).collect(Collectors.toList());
    }

    private static List<JvmToolchainMetadata> validToolchains(Collection<JvmToolchainMetadata> toolchains) {

                .proxies(request.getProxies().stream().map(Proxy::getDelegate).collect(Collectors.toList()))
                .servers(request.getServers().stream().map(Server::getDelegate).collect(Collectors.toList()))
                .mirrors(request.getMirrors().stream().map(Mirror::getDelegate).collect(Collectors.toList()))
                .profiles(request.getProfiles().stream()
                        .map(Profile::getDelegate)

        super(criterion -> () -> {
            return fileStore.search(criterion).stream().map(LocallyAvailableResource::getFile).collect(Collectors.toList());
        }, checksumService);
    }

            return new MyProductReleaseList(Arrays.stream(versions).map(r -> new MyProductRelease(
                r.version, releaseNotesURL(r.version))).collect(Collectors.toList()));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    private static String releaseNotesURL(String version) {
        if (version.contains("+")) {

                .orElse(null);
    }

    public List<MavenProject> getSortedProjects() {
        return sortedProjects;
    }

    public boolean hasMultipleProjects() {
        return sortedProjects.size() > 1;
    }

    public List<String> getDependents(String id) {
        return graph.getVertex(id).getParents().stream().map(Vertex::getLabel).collect(Collectors.toList());
    }

        return methodElement.getAnnotation(InterceptInherited.class) != null;
    }

    private static List<ParameterInfo> extractParameters(ExecutableElement methodElement) {
        List<ParameterInfo> list = new ArrayList<>();
        List<? extends VariableElement> parameters = methodElement.getParameters();
        for (int i = 0; i < parameters.size(); i++) {

    server.useHttps(handshakeCertificates.sslSocketFactory())

    defaultEnabledCipherSuites =
      handshakeCertificates.sslSocketFactory().defaultCipherSuites.toList()
    defaultSupportedCipherSuites =
      handshakeCertificates.sslSocketFactory().supportedCipherSuites.toList()
  }

  @Test
  fun testDefaultHandshakeCipherSuiteOrderingTls12Restricted() {
    // We are avoiding making guarantees on ordering of secondary Platforms.

        File file = new File("f1")
        TestFileCollection collection = new TestFileCollection(file)

        expect:
        collection as Collection == toList(file)
        collection as Set == toLinkedSet(file)
        collection as List == toList(file)
    }

    void toFileTreeReturnsSingletonTreeForEachFileInCollection() {
        File file = testDir.createFile("f1")
        File file2 = testDir.createFile("f2")

        }
    }

    override fun getEnumEntries(classSymbol: KaNamedClassOrObjectSymbol): List<KaEnumEntrySymbol> {
        require(classSymbol.classKind == KaClassKind.ENUM_CLASS)
        return with(analysisSession) {
            classSymbol.getStaticDeclaredMemberScope().getCallableSymbols().filterIsInstance<KaEnumEntrySymbol>().toList()
        }
    }

    }

    @Override
    public List<DependencyModel> obtain() {
        String bundle = getParameters().getBundleName().get();
        DefaultVersionCatalog config = getParameters().getConfig().get();
        BundleModel bundleModel = config.getBundle(bundle);
        return bundleModel.getComponents().stream()
            .map(config::getDependencyData)
            .collect(Collectors.toList());

    }