property.set(upstream)

        when:
        property.replace { it.map { m -> m.collectEntries { k, v -> [v, k] } } }
        upstream.set(someOtherValue())

        then:
        property.get() == someOtherValue().collectEntries { k, v -> [v, k] }
    }

    def "returning null from replace unsets the property"() {
        given:
        property.set(someValue())

        if (branch) {
            infoAttrs.branch = branch
        }
        infoAttrs += extraAttributes.collectEntries { key, value -> ["e:$key", value] }
        if (writeGradleMetadataRedirection) {
            ivyFileWriter << "<!-- ${MetaDataParser.GRADLE_6_METADATA_MARKER} -->"
        }
        builder.info(infoAttrs) {

            tasks.register("defaultTask") {
                assert false : "This should not be realized"
            }

            def schema = tasks.collectionSchema.elements.collectEntries { e ->
                [ e.name, e.publicType.simpleName ]
            }

            // check some built-in tasks
            assert schema["help"] == "Help"

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

         'java.vendor',
         'java.runtime.name',
         'java.runtime.version',
         'java.vm.name',
         'java.vm.version',
         'java.vm.vendor',
         'os.arch',
        ].collectEntries { [it, System.getProperty(it)] }
    }

    private static Map<String, String> openJdkJvm(String version) {
        ['java.home': "java-home",
         'java.version': "1.${version}.0",

        Map<String, FileSystemLocationSnapshot> knownSnapshots = [knownFileSnapshot, knownDirSnapshot].collectEntries { [it.absolutePath, it] }

        when:
        def snapshot = directorySnapshotter.snapshot(rootDir.absolutePath, null, knownSnapshots, unfilteredSubSnapshotsCollector)

        then:
        0 * _

     */
    def createJarWithProperties(String path, Map<String, ?> properties = [source: 1]) {
        def props = new Properties()
        def sw = new StringWriter()
        props.putAll(properties.collectEntries { k, v -> [k, String.valueOf(v)] })
        props.setProperty(path, testDirectory.path)
        props.store(sw, null)
        file(path).delete()
        createZip(path) {

        return buildOperations.progress(IdentifyTransformExecutionProgressDetails)
            .groupBy { it.details["artifactName"] as String }
            .collectEntries { [(it.key): it.value.collect { it.details["transformActionClass"] }] }
    }

    private void setupProjectTransformInBuildScriptBlock(boolean inExternalScript) {
        setupBuildWithChainedColorTransform()

    }

    Transformation transformStep2(Map<String, List<String>> artifactWithDependencies) {
        return Transformation.fromMap("Transform step 2", artifactWithDependencies.collectEntries { artifact, dependencies -> [(artifact + ".txt"): dependencies.collect { it + ".txt" }] })
    }

    void assertTransformationsExecuted(Transformation... expectedTransforms) {