.tlsVersions(TlsVersion.TLS_1_2)
        .supportsTlsExtensions(true)
        .build()
    assertThat(tlsSpec.cipherSuites!!.toList())
      .containsExactly(CipherSuite.TLS_RSA_WITH_RC4_128_MD5)
    assertThat(tlsSpec.tlsVersions!!.toList())
      .containsExactly(TlsVersion.TLS_1_2)
    assertThat(tlsSpec.supportsTlsExtensions).isTrue()
  }

  @Test
  fun tlsBuilder_defaultCiphers() {

     */
    default List<org.apache.maven.api.model.Profile> getActiveProfilesV4(
            Collection<org.apache.maven.api.model.Profile> profiles,
            ProfileActivationContext context,
            ModelProblemCollector problems) {
        return getActiveProfiles(profiles.stream().map(Profile::new).collect(Collectors.toList()), context, problems)
                .stream()

            return symbols
        }

        private fun KaSession.findMatchingCallableSymbols(classSymbol: KaClassOrObjectSymbol): List<KaCallableSymbol> {
            val declaredSymbols = classSymbol.getCombinedDeclaredMemberScope()
                .getCallableSymbols(callableId.callableName).toList()

            if (declaredSymbols.isNotEmpty()) {
                return declaredSymbols
            }

        this.data = IntStream.range(0, points.size())
            .mapToObj(index -> Arrays.<Number>asList(index, points.get(index)))
            .collect(Collectors.toList());
    }

    public String getLabel() {
        return label;
    }

    public List<List<Number>> getData() {
        return data;
    }

        this.readers = Collections.unmodifiableList(
                new ArrayList<>(readers.stream().filter(Objects::nonNull).collect(Collectors.toList())));
        Key key = new Key(this.readers);
        this.repository = new WorkspaceRepository(key.getContentType(), key);
    }

    public List<WorkspaceReader> getReaders() {
        return readers;
    }

    public void addReader(WorkspaceReader workspaceReader) {

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class TableBuilder {

    public static List<List<String>> build() {
        List<MyProductRelease> releases = DataRetriever.retrieve().getReleases();
        return build(releases);
    }

    protected static List<List<String>> build(List<MyProductRelease> releases) {

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