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(

        def opsPerCache = configCache ? 2 : 1
        finalizeOps.size() == expectedCacheDirs.size() * opsPerCache
        def pathToCacheDirMap = finalizeOps.collectEntries {
            [
                it.details.buildPath,
                new File(it.result.local.config.location as String)
            ]
        } as Map<String, File>

        return "-Dfile.encoding=$encoding"
    }

    private static List<String> localeProperties(Locale locale = Locale.default) {
        ["country", "language", "variant"].sort().collectEntries {
            ["user.$it", locale."$it"]
        }.collect {
            it.value ? "-D$it.key=$it.value" : "-D$it.key"
        }
    }

            // Breaking changes were made to JavaCompile prior to 2.0
            taskClasses.remove(JavaCompile)
        }

        Map<String, String> subclasses = taskClasses.collectEntries { ["custom" + it.name.replace(".", "_"), it.name] }
        def apiDepConf = "implementation"
        if (targetVersion < GradleVersion.version("7.0-rc-1")) {
            apiDepConf = "compile"
        }