}

    def "returning null from replace clears collection"() {
        given:
        collection.from(containing(new File("a.txt")))

        when:
        collection.replace { null }

        then:
        collection.isEmpty()
    }

    def "replace transformation runs eagerly"() {
        given:
        Transformer<FileCollection, FileCollection> transform = Mock()

    }

    def "adds a single entry using put"() {
        given:
        property.set(['k1': 'v1'])
        property.put('k2', 'v2')
        property.put('k3', 'v3')

        expect:
        assertValueIs(['k1': 'v1', 'k2': 'v2', 'k3': 'v3'])
    }

    def "put overrides entries added earlier"() {
        given:
        property.set(['k': 'v1'])
        property.put('k', 'v2')

    }

    def "appends a single value using add"() {
        given:
        property.set(toMutable(["abc"]))
        property.add("123")
        property.add("456")

        expect:
        assertValueIs(["abc", "123", "456"])
    }

    def "appends a single value to string property using GString"() {
        given:
        property.set(toMutable(["abc"]))

    def "can set value using chaining method"() {
        given:
        def property = propertyWithNoValue()
        property.value(someValue())

        expect:
        property.get() == someValue()
    }

    def "can set value using provider"() {
        def provider = supplierWithValues(someValue(), someOtherValue(), someValue())

        given:
        def property = propertyWithNoValue()

        def action = Mock(Transformer)

        given:
        registry.register("bar") { it.unmanaged String, Integer, action }
        registry.registerInstance("foo", 12.toInteger())
        action.transform(12) >> "[12]"

        expect:
        registry.realize("bar") == "[12]"
    }

    def "parent of input is implicitly closed when input is not known"() {
        given:

               testImplementation "junit:junit:4.13"
           }
"""
    }

    void "can publish jar and descriptor to ivy repository"() {
        requiresExternalDependencies = true
        given:
        createBuildScripts("""
            publishing {
                publications {
                    ivy(IvyPublication) {
                        from components.java
                    }
                }

     * property.</li>
     *
     * <li>If this project has an extra property with the given name, return the value of the property.</li>
     *
     * <li>If this project has a task with the given name, return the task.</li>
     *
     * <li>Search up through this project's ancestor projects for a convention property or extra property with the
     * given name.</li>
     *

    def "can check for membership"() {
        given:
        addToContainer(b)
        addToContainer(a)

        expect:
        !container.contains(c)
        container.contains(a)
    }

    def "provider for element is queried when membership checked"() {
        containerAllowsExternalProviders()
        def provider = Mock(ProviderInternal)

        given:
        addToContainer(b)

import static org.gradle.api.internal.component.ArtifactType.MAVEN_POM

class GradlePomModuleDescriptorParserTest extends AbstractGradlePomModuleDescriptorParserTest {
    def "parses simple pom"() {
        given:
        pomFile << """
<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>group-one</groupId>
    <artifactId>artifact-one</artifactId>
    <version>version-one</version>
    <name>Test Artifact One</name>

        } else if (value instanceof Node) {
            return [value]
        } else {
            return value
        }
    }

    def "runs finalizer and its dependencies after finalized task"() {
        given:
        Task dep = task("dep", type: Async)
        Task finalizerDep1 = task("finalizerDep1", type: Async)
        Task finalizerDep2 = task("finalizerDep2", type: Async)