import java.util.zip.ZipEntry
import java.util.zip.ZipOutputStream
import javax.inject.Inject
import kotlin.collections.component1
import kotlin.collections.component2
import kotlin.collections.set
import kotlin.streams.toList


typealias LeftoverFiles = Map<File, List<String>>


abstract class TestFilesCleanupService @Inject constructor(
    private val fileSystemOperations: FileSystemOperations

                .collect(Collectors.toList());
        return new Dependency(result, artifact.getScope(), artifact.isOptional(), excl);
    }

    public static List<RemoteRepository> toRepos(List<ArtifactRepository> repos) {
        return Optional.ofNullable(repos).orElse(Collections.emptyList()).stream()
                .map(RepositoryUtils::toRepo)
                .collect(Collectors.toList());
    }

import org.gradle.kotlin.dsl.provider.KotlinScriptClassPathProvider;

import javax.inject.Inject;
import java.io.File;

import static com.google.common.collect.Iterables.getOnlyElement;
import static java.util.stream.Collectors.toList;

/**
 * Extracts Kotlin DSL runtime generated sources.
 *
 * Current implementation extracts these from the wrapper's API jars.
 * This is not correct as it should do this with the built distribution instead.
 *

                    newDoc.remove(indexFieldLang);
                }
                languageHelper.updateDocument(newDoc);
            }
            return newDoc;
        }).toList();
        if (fessConfig.isThumbnailCrawlerEnabled()) {
            final ThumbnailManager thumbnailManager = ComponentUtil.getThumbnailManager();
            final String thumbnailField = fessConfig.getIndexFieldThumbnail();

                })
                .map(Method::getName)
                .collect(Collectors.toList());

        List<String> overriddenMethods = Stream.of(FileToRawModelMerger.class.getDeclaredMethods())
                .map(Method::getName)
                .filter(m -> m.startsWith("merge"))
                .collect(Collectors.toList());

        assertThat(overriddenMethods, hasItems(methodNames.toArray(new String[0])));
    }

            ModelProblemCollector problems) {
        return getActiveProfiles(profiles.stream().map(Profile::new).collect(Collectors.toList()), context, problems)
                .stream()
                .map(Profile::getDelegate)
                .collect(Collectors.toList());
    }

                    appendJson("search-field", searchFieldMap, buf).append(',');
                    final Map<String, List<String>> requestHeaderMap = entity.getRequestHeaderList().stream()
                            .collect(Collectors.groupingBy(Pair::getFirst, Collectors.mapping(Pair::getSecond, Collectors.toList())));

    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.

                    prune((ModelBase.Builder) builder, p);
                    return builder.build(null).build();
                })
                .filter(p -> !isEmpty(p))
                .collect(Collectors.toList());
    }

    private static boolean isEmpty(Profile profile) {
        return profile.getActivation() == null
                && profile.getBuild() == null
                && profile.getDependencies().isEmpty()

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

  fun assertResponseCookies(vararg cookies: String?) {