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

        def changedLocationsWithAncestors = changedLocations.collectMany { locationWithAncestors(it) } as Set
        def versionsBefore = (changedLocationsWithAncestors + unchangedLocations + invalidateLocation).<String, Long, String> collectEntries {
            [(it): getVersion(it)]
        }
        def versionAtRootBefore = getVersion("/")
        when:
        updateVersions(invalidateLocation)
        then:

        def configs = itemGroup("ProjectConfigurations").collect {
            new Configuration(it.Configuration[0].text(), it.Platform[0].text())
        }
        return configs.collectEntries {
            [it.name, it]
        }
    }

    String getProjectGuid() {
        return globals.ProjectGUID[0].text()
    }

    Node getGlobals() {

            .collect { line -> new JsonSlurper().parse(new StringReader(line)) as Map<String, Map<String, String>> }
            .collectMany { it.entrySet() }
            .collectEntries { it }
        Map<String, ScopeIds> ids = [:]
        idsMap.each {
            ids[it.key] = new ScopeIds(
                UniqueId.from(it.value.buildInvocation),
                UniqueId.from(it.value.workspace),

        and:
        def compilerOperations = buildOperations.all(ExecuteWorkItemBuildOperationType)
        def taskOperations =
            compilerOperations.collectEntries {
                def op = buildOperations.parentsOf(it).reverse().find {
                    parent -> buildOperations.isType(parent, ExecuteTaskBuildOperationType)
                }
                [op.displayName, it]

    }

    Map<String, TestFile.Snapshot> snapshotObjects(TestFile projectDir) {
        def objDir = projectDir.file('build/obj')
        def objects = objDir.allDescendants()
        def snapshots = objects.collectEntries { path ->
            def obj = objDir.file(path)
            if (!obj.isFile()) {
                return null
            }
            [(path): obj.snapshot()]
        }
        return snapshots

            it.details.targetType == "project" &&
                it.details.targetPath == ":" &&
                it.details.buildPath == ":"
        }

        def pluginIdByClass = plugins.details.collectEntries ( { [it.pluginClass, it.pluginId ] })
        def expectedPlugins = [
            "org.gradle.api.plugins.HelpTasksPlugin": "org.gradle.help-tasks",
            // This tests runs in :core using a reduced distribution

                    mavenAttributes: artifact.attributes().findAll { it.key instanceof QName && it.key.namespaceURI == "http://ant.apache.org/ivy/maven" }.collectEntries { [it.key.localPart, it.value] }
            )

            artifacts.add(ivyArtifact)
        }


        ivy.dependencies.dependency.each { dep ->
            def ivyDependency = new IvyDescriptorDependency(