open class ClassPathModeExceptionCollector : Stoppable {

    private
    val collection: MutableList<Exception> = synchronizedList(mutableListOf<Exception>())

    val exceptions: List<Exception>
        get() = collection.toList()

    fun collect(error: Exception) {
        collection.add(error)
    }

    override fun stop() {
        collection.clear()
    }
}

    public static class ApiSystemInfoResponse extends ApiResponse {
        protected List<Map<String, String>> envProps;
        protected List<Map<String, String>> systemProps;
        protected List<Map<String, String>> fessProps;
        protected List<Map<String, String>> bugReportProps;

        public ApiSystemInfoResponse envProps(final List<Map<String, String>> envProps) {
            this.envProps = envProps;

        }
    }

    override fun KaSession.collectSymbols(ktFile: KtFile, testServices: TestServices): SymbolsData =
        SymbolsData(getSymbolsFromScope(getScope(ktFile, testServices)).toList())

            val implementationClass = pluginProperties.getProperty("implementation-class")
            PluginEntry(id, implementationClass)
        }.toList()
    }
} catch (cause: IOException) {
    throw IllegalArgumentException(
        "Failed to extract plugin metadata from '" + jar.path + "'",
        cause
    )
}


private

        return checksumAlgorithmFactorySelector.getChecksumAlgorithmFactories().stream()
                .map(ChecksumAlgorithmFactory::getName)
                .collect(Collectors.toList());
    }

    @Override
    public ChecksumAlgorithm select(String algorithmName) {
        nonNull(algorithmName, "algorithmName");
        try {

        this.sessionId = sessionId;
        if (!cachedIncludeSet.isEmpty()) {
            try {
                getUrlFilterService().addIncludeUrlFilter(sessionId, cachedIncludeSet.stream().collect(Collectors.toList()));
            } catch (final Exception e) {
                logger.warn("Failed to add include_urls on " + sessionId, e);
            }
            cachedIncludeSet.clear();
        }

                })
                .collect(toList());
    }

    static class ScenarioBuilder {
        private String description;
        private List<String> activeRequiredProjects = emptyList();
        private List<String> activeOptionalProjects = emptyList();
        private List<String> inactiveRequiredProjects = emptyList();
        private List<String> inactiveOptionalProjects = emptyList();

        }
    }

    private static void rollbackStashedFiles(List<StashedFile> stashedFiles) {
        stashedFiles.forEach(StashedFile::unstash);
        if (LOG.isDebugEnabled()) {
            LOG.debug("Restoring stashed files: {}", stashedFiles.stream().map(f -> f.sourceFile.getAbsolutePath()).sorted().collect(Collectors.toList()));
        }
    }

    val projectLayout = layout
    doLast {
        val collection = projectLayout.files("src/file1.txt")

        // tag::usage[]
        // Iterate over the files in the collection
        collection.forEach { file: File ->
            println(file.name)
        }

        // Convert the collection to various types
        val set: Set<File> = collection.files
        val list: List<File> = collection.toList()

        return operations.records.values().find { it.displayName ==~ displayName }
    }

    @Override
    List<BuildOperationRecord> all() {
        return operations.records.values().toList()
    }

    @Override
    List<BuildOperationRecord> all(Pattern displayName) {
        return operations.records.values().findAll { it.displayName ==~ displayName }
    }

    @Override