when:
        collection.from = ["a", "b"]
        then:
        collection.from as List == [["a", "b"]]
    }

    def "can mutate the from collection"() {
        collection.from("src1", "src2")
        def from = collection.from

        when:
        from.clear()

        then:
        from.empty
        collection.from.empty

        when:
        def add1 = from.add('a')

        when:
        container.whenObjectAdded(action)

        then:
        // Does not fire for existing elements
        0 * action._

        when:
        addToContainer(a)

        then:
        1 * action.execute(a)
        0 * action._

        when:
        addToContainer(a)

        then:
        0 * action._

        when:

    // Documents existing behaviour. The absolute path of the input artifact is baked into the workspace identity
    // for incremental transforms, and so when the path changes the outputs are invalidated
    def "can attach #description to input artifact property with incrementally transformed artifact but it has no effect when not caching"() {
        createDirs("a", "b", "c")
        settingsFile << "include 'a', 'b', 'c'"
        setupBuildWithColorTransform()

        property.set(someValue())

        when:
        property.finalizeValueOnRead()

        then:
        0 * _

        when:
        def value = property.orNull

        then:
        value == someValue()

        and:
        1 * host.beforeRead(null) >> null
    }

    def "can disallow changes when host is not ready when unsafe read disallowed"() {
        given:

    def "can change value to empty map"() {
        when:
        property.set([a: 'b'])
        property.empty()
        then:
        assertValueIs([:])
    }

    def "can set value using empty map"() {
        when:
        property.set([:])
        then:
        assertValueIs([:])
    }

    def "returns immutable copy of value"() {
        when:
        property.set(['k': 'v'])
        then:

    }

    def "throws NullPointerException when provider returns list with null to property"() {
        given:
        property.addAll(Providers.of([null]))

        when:
        property.get()

        then:
        def ex = thrown(NullPointerException)
    }

    def "throws NullPointerException when adding a null value to the property"() {
        when:
        property.add(null)

        then:

               into 'dest'
            }
        '''

        when:
        run 'copy'
        then:
        executedAndNotSkipped(":copy")

        when:
        file("files/sub/empty").createDir()
        run 'copy'
        then:
        executedAndNotSkipped(":copy")

        when:
        run 'copy'
        then:
        skipped(":copy")
    }

            }
        }
    }
}
"""
    }

    def "transform can access artifact dependencies as a set of files when using ArtifactView"() {
        given:
        setupBuildWithSingleStep()

        when:
        executer.withArgument("--parallel")
        run ":app:resolveGreen"

        then:
        output.count('Transforming') == 5

        when:
        configuration.extendsFrom(conf("other"))
        then:
        thrown(InvalidUserDataException)

        when:
        configuration.dependencies.add(Mock(Dependency))
        then:
        thrown(InvalidUserDataException)

        when:
        configuration.dependencies.remove(Mock(Dependency))
        then:
        thrown(InvalidUserDataException)

        when:

class DefaultModelRegistryTest extends Specification {

    def registry = new ModelRegistryHelper()

    def "can maybe get non existing"() {
        when:
        registry.realize("foo")

        then:
        thrown IllegalStateException

        when:
        def modelElement = registry.find("foo", ModelType.untyped())

        then:
        noExceptionThrown()

        and:
        modelElement == null