} else {
            labelList = labelTypeItemList.stream()
                    .filter(item -> matchLocale(requestLocale, item.getLocale()) && virtualHostKey.equals(item.getVirtualHost()))
                    .collect(Collectors.toList());
        }

        final List<Map<String, String>> itemList = new ArrayList<>();

      assertEquals(200, response.code)
    }

    assertEquals(2, sessionIds.size)
    val directSessionIds =
      sslContext.clientSessionContext.ids
        .toList()
        .map { it.toByteString().hex() }

    if (platform.isConscrypt()) {
      if (tlsVersion == TlsVersion.TLS_1_3) {
        assertThat(sessionIds[0]).isEmpty()
        assertThat(sessionIds[1]).isEmpty()

                        && !rootProject.getDefaultGoal().isEmpty())) {
            tasks = Stream.of(rootProject.getDefaultGoal().split("\\s+"))
                    .filter(g -> !g.isEmpty())
                    .collect(Collectors.toList());
        }

        return calculateTaskSegments(session, tasks);
    }

    @Override
    public List<TaskSegment> calculateTaskSegments(MavenSession session, List<String> tasks)

                        .map(doc -> getStringValue(doc, "doc_id"))
                        .filter(StringUtil::isNotBlank)
                        .collect(Collectors.toList());
                return RelevanceEvaluationResult.fallbackAllRelevant(allDocIds);
            }
            final RelevanceEvaluationResult result = parseEvaluationResponse(response.getContent(), searchResults);

import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.inject.Inject;

import static java.util.Comparator.naturalOrder;
import static java.util.stream.Collectors.toList;
import static java.util.stream.Collectors.toSet;

/**
 * Orchestrates the steps required to generate or update various release notes files.
 */
public class GenerateReleaseNotesTask extends DefaultTask {

        return allProviders.stream()
                .filter(RdmaProvider::isAvailable)
                .map(RdmaProvider::getProviderName)
                .collect(java.util.stream.Collectors.toList());
    }

      enabledProtocols = javaNames(*tlsVersions)
    }

  private fun assertEnabledProtocols(
    socket: SSLSocket,
    vararg required: TlsVersion,
  ) {
    assertThat(socket.enabledProtocols.toList()).containsExactlyInAnyOrder(*javaNames(*required))
  }

  private fun javaNames(vararg tlsVersions: TlsVersion) = tlsVersions.map { it.javaName }.toTypedArray()

    }

  /** Returns a [toString] consistent with [Map], with elements in insertion order. */
  override fun toString(): String =
    generateSequence<LinkedTags<*>>(seed = this) { it.next as? LinkedTags<*> }
      .toList()
      .reversed()
      .joinToString(prefix = "{", postfix = "}") { "${it.key}=${it.value}" }
}

internal fun <T : Any> AtomicReference<Tags>.computeIfAbsent(
  type: KClass<T>,
  compute: () -> T,

        this.setPluginArtifact(null); // TODO: v4
        this.setComponents(original.getMojos().stream()
                .map(m -> new MojoDescriptor(this, m))
                .collect(Collectors.toList()));
        this.setId(original.getId());
        this.setIsolatedRealm(original.isIsolatedRealm());
        this.setSource(null);
        this.setDependencies(Collections.emptyList()); // TODO: v4

                        return new BasicNameValuePair(name, value);
                    }).collect(Collectors.toList()));
            if (paramList != null) {
                parameters.addAll(
                        paramList.stream().map(p -> new BasicNameValuePair(p.getFirst(), p.getSecond())).collect(Collectors.toList()));
            }
            return new UrlEncodedFormEntity(parameters, encoding);