*/
    @SafeVarargs
    @SuppressWarnings("varargs")
    public static <T> List<T> toList(T... items) {
        ArrayList<T> coll = new ArrayList<T>();
        Collections.addAll(coll, items);
        return coll;
    }

    /**
     * Wraps the given items in a mutable list.
     */
    public static <T> List<T> toList(Iterable<? extends T> items) {
        ArrayList<T> coll = new ArrayList<T>();

import javax.annotation.Nullable;
import java.util.Collections;
import java.util.List;
import java.util.function.Supplier;

import static java.util.stream.Collectors.toList;

@NonNullApi
public class DefaultIntermediateToolingModelProvider implements IntermediateToolingModelProvider {

    private final IntermediateBuildActionRunner actionRunner;

    }

    @Override
    public List<DependencyArtifact> getArtifactSelectors() {
        return getIvyArtifacts().stream().map(this::asDependencyArtifact).collect(Collectors.toList());
    }

    private DependencyArtifact asDependencyArtifact(IvyArtifactName ivyArtifactName) {

        }
        this
    }

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

    def containsDescendants(String... relativePaths) {

        return toolchains.stream().filter(t -> !isValidToolchain(t)).collect(Collectors.toList());
    }

    private static List<JvmToolchainMetadata> validToolchains(Collection<JvmToolchainMetadata> toolchains) {
        return toolchains.stream().filter(ShowToolchainsTask::isValidToolchain).sorted(TOOLCHAIN_COMPARATOR).collect(Collectors.toList());
    }

    private static boolean isValidToolchain(JvmToolchainMetadata t) {

        return graph.getVertex(id).getParents().stream().map(Vertex::getLabel).collect(Collectors.toList());
    }

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

    public static String getId(MavenProject project) {

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

    }

    protected static List<Map<String, Object>> readJobLog(final String namePrefix) {
        final List<Map<String, Object>> logList = readLogItems("joblog");
        final List<Map<String, Object>> resList = new ArrayList<>();
        for (Map<String, Object> elem : logList) {
            if (elem.containsKey("job_name") && elem.get("job_name").equals(namePrefix + "Scheduler")) {
                resList.add(elem);

    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.