return this
    }

    MutableUnitOfWorkBuilder withOutputFiles(File... outputFiles) {
        return withOutputFiles((outputFiles as List)
            .withIndex()
            .collectEntries { outputFile, index -> [('defaultFiles' + index): outputFile] }
        )
    }

    MutableUnitOfWorkBuilder withOutputFiles(Map<String, ? extends File> files) {
        this.outputFiles = files

    def "all samples are different"() {
        given:
        def metadata = sampleFiles().collectEntries { [it.name, parse(it)] }

        when:
        def serializedMetadata = metadata.collectEntries { [it.key, Hashing.sha1().hashBytes(serialize(it.value))] }

        then:
        println "Checking that all ${metadata.size()} samples are different"

 * </p>
 */
public interface MapCollector<K, V> extends ValueSupplier {

    Value<Void> collectEntries(ValueConsumer consumer, MapEntryCollector<K, V> collector, Map<K, V> dest);

    Value<Void> collectKeys(ValueConsumer consumer, ValueCollector<K> collector, ImmutableCollection.Builder<K> dest);

    @Override
    void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
        Map<String, String> entries = request.getHeaderNames().toList().collectEntries { headerName -> [headerName, request.getHeader(headerName as String)] }
        allHeaders.add(entries)
        String authorization = getAuthorizationHeader(request)
        if (authorization != null) {

    }

    void withPluginAlias(String alias) {
        withPlugins([:], [(alias): null])
    }

    void withPluginAliases(List<String> aliases = []) {
        withPlugins([:], aliases.collectEntries { [it, null] })
    }

    void withPluginsBlockContents(String block) {
        def text = buildFile.text
        int idx = text.indexOf('allprojects')
        text = """${text.substring(0, idx)}

        GetInputPropertiesVisitor visitor = new GetInputPropertiesVisitor()
        TaskPropertyUtils.visitProperties(propertyWalker, task, visitor)
        return visitor.getProperties().collectEntries { [it.propertyName, it.value.call()] }
    }

    static FileCollection getInputFiles(DefaultTask task) {
        def fileCollectionFactory = task.getServices().get(FileCollectionFactory)

        }
        Map<File, KotlinDslScriptModel> singleRequestModels = model.scriptModels

        and:
        Map<File, KotlinBuildScriptModel> multiRequestsModels = spec.scripts.values().collectEntries {
            [(it): kotlinBuildScriptModelFor(projectDir, it)]
        }

        then:
        spec.scripts.values().each { script ->

class NamedDomainObjectCollectionSchemaIntegrationTest extends AbstractIntegrationSpec {
    def setup() {
        buildFile """
            def extractSchema(container) {
                return container.collectionSchema.elements.collectEntries { e ->
                    [ e.name, e.publicType.simpleName ]
                }.sort()
            }
            def assertSchemaIs(Map expected, NamedDomainObjectCollection container) {

        fails "validatePlugins"
        def report = new TaskValidationReportFixture(file("build/reports/plugin-development/validation-report.json"))
        report.verify(messages.collectEntries {
            def fullMessage = it.message
            if (!it.defaultDocLink) {
                fullMessage = "${fullMessage}\n${learnAt(it.id, it.section)}"
            }
            [(fullMessage): it.severity]

            """
        }

        when:
        run(*apps.keySet().collect { "install${it.capitalize()}MainExecutable" })

        then:
        Map<NativeInstallationFixture, HelloWorldApp> installations = apps.collectEntries { name, app ->
            def installation = installation("build/install/${name}Main")
            [installation, app]
        }
        installations.every { installation, app ->