return artifacts.stream().map(Artifact::getArtifactName).collect(Collectors.toList());
    }

    private List<IvyArtifactName> fromMavenDescriptor(MavenDependencyDescriptor descriptor) {
        IvyArtifactName artifact = descriptor.getDependencyArtifact();
        if(artifact != null) {
            return Collections.singletonList(artifact);
        }

    }

    private List<Object> getModels(BuildToolingModelController controller, List<Project> targets, String modelName, @Nullable ToolingModelParameterCarrier parameter) {
        List<Supplier<Object>> fetchActions = targets.stream()
            .map(targetProject -> (Supplier<Object>) () -> fetchModel(modelName, controller, (ProjectInternal) targetProject, parameter))
            .collect(toList());

        }
        this
    }

    def hasDescendantsInOrder(String... relativePaths) {
        def expectedOrder = CollectionUtils.toList(relativePaths)
        def actualOrder = CollectionUtils.toList(filesByRelativePath.keySet())
        assertEquals(actualOrder, expectedOrder)
        this
    }

    def containsDescendants(String... relativePaths) {

                       .collect(Collectors.toList()),
            newFacets));
    }

    /**
     * Removes incompatible facets from a list of facets.
     * <p>
     * Currently removes the facet "jst.utility" when the facet "jst.ejb" is present.
     *
     * @param facets, a list of facets
     * @return the modified facet list
     */
    List<Facet> replaceInconsistentFacets(List<Facet> facets) {

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

        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("+")) {

        }
    }

    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());

    }

import java.util.Deque

class RecordingCookieJar : CookieJar {
  private val requestCookies: Deque<List<Cookie>> = ArrayDeque()
  private val responseCookies: Deque<List<Cookie>> = ArrayDeque()

  fun enqueueRequestCookies(vararg cookies: Cookie) {
    requestCookies.add(cookies.toList())
  }

  fun takeResponseCookies(): List<Cookie> {
    return responseCookies.removeFirst()
  }