"""
        }

        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 ->

    List<WbModule> getModules() {
        return component."wb-module"."dependent-module".collect { new WbModule(it) }
    }

    Map<String, String> getModuleProperties() {
        return component."wb-module".property.collectEntries { [(it.@name) : it.@value] }
    }

    WbModule lib(String jarName) {
        def module = modules.find {
            def handle = it.node.@handle

        }
        result
    }

    @CompileDynamic
    private OutputScrapingExecutionResult executeInContainer() {
        def invocation = buildInvocation()
        container.withEnv(invocation.environmentVars.collectEntries { k, v -> [k, v]})
        def containerResult = container.execute(["/gradle-under-test/bin/gradle", *invocation.args] as String[])
        def result
        if (containerResult.exitCode == 0) {

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]

                    }
                }
            """.stripIndent()
            resource
        }
    }

    Map<String, String> withFailingTests(int num) {
        (1..num).collectEntries() {
            final testName = "OtherTest_${it}" as String
            final resource = "test_${it}" as String
            root.file("src/test/java/OtherTest_${it}.java") << """
                $testFrameworkImports

    abstract protected Deleter createDeleter()

    def pack(OutputStream output, OriginWriter writeOrigin = this.writeOrigin, TreeDefinition... treeDefs) {
        Map<String, FileSystemSnapshot> snapshots = treeDefs.collectEntries { treeDef ->
            FileSystemSnapshot result = FileSystemSnapshot.EMPTY
            if (treeDef.root != null) {
                result = fileSystemAccess.read(treeDef.root.absolutePath)
            }

        return true
    }

    def assertReferencesProject(ProjectFile expectedProject, Collection<String> configurations) {
        assertReferencesProject(expectedProject, configurations.collectEntries {[(it):it]})
    }

    def assertReferencesProject(ProjectFile expectedProject, Map<String, String> configurations) {
        assertReferencesProject(expectedProject.name, expectedProject, configurations)
    }

        }
        excludeFile << JsonOutput.prettyPrint(content)
    }
}

private sortDeep(entry) {
    if (entry instanceof Map) {
        entry.collectEntries {
            [(it.key), sortDeep(it.value)]
        }.sort()
    } else if (entry instanceof Iterable) {
        entry.collect {
            sortDeep(it)
        }.sort()
    } else {
        entry
    }

        }

        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 ->