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

                    }
                }
            """.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

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

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

        }

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

    def "adapter can subscribe to progress events of types #operationTypes"() {
        given:
        Map<OperationType, List<ProgressListener>> listeners = operationTypes.collectEntries {
            [(it): [Stub(ProgressListener)]]
        }

        when:
        def adapter = new BuildProgressListenerAdapter(listeners)

        then:

    }

    def inputProperties() {
        def visitor = new GetInputPropertiesVisitor()
        TaskPropertyUtils.visitProperties(walker, task, visitor)
        return visitor.properties.collectEntries { [it.propertyName, InputParameterUtils.prepareInputParameterValue(it.value)] }
    }

    def inputFileProperties() {
        def inputFiles = [:]

        }
        return '_' + dimensions.values()*.name.join('_').replaceAll('-', '_')
    }

    static VariantContext of(Map<String, String> dimensions = [:]) {
        return new VariantContext(dimensions.collectEntries([:]) { key, value ->
            [(key): VariantDimension.of(key, value)]
        })
    }

    static List<VariantContext> from(Object[] listOfDimensionArrays) {
        def result = new ArrayList<VariantContext>()