cl.delegate = builder
        cl.call()
        def parent = sibling.parentNode
        def next = sibling.nextSibling
        builder.elements.each { element ->
            parent.insertBefore(element, next)
        }
        return builder.elements.size() == 1 ? builder.elements[0] : builder.elements
    }

        def collection = containing()
        def elements = collection.elements

        expect:
        elements.present
        elements.get().empty
    }

    def canViewElementsAsProviderRetainingOrder() {
        def file1 = new File("f1")
        def file2 = new File("f2")
        def collection = containing(file1, file2, file1, file2)
        def elements = collection.elements

        expect:
        elements.present

        !collection.explicit
    }

    def "elements provider tracks changes to content"() {
        given:
        def file1 = new File("1")
        def file2 = new File("2")
        def callable = Mock(Callable)

        collection.from(callable)
        def elements = collection.elements

        when:
        def f1 = elements.get()

        then:
        f1*.asFile == [file1, file2]

        output.contains "display-name: ModelSet<Person> 'people'"
        output.contains "to-string: ModelSet<Person> 'people'"
    }

    def "rule can create a managed collection of interface backed managed model elements"() {
        when:
        buildScript '''
            @Managed
            interface Person {
              String getName()
              void setName(String string)
            }

                    }
                }
            }
        '''

        when:
        run 'show'

        then:
        output.contains("p1 = default")
    }

    def "elements referenced by @RuleInput property are treated as implicit input of rules on RuleSource"() {
        buildFile << '''
            @Managed
            interface SomeThings {
                Thing getThingA()

                ${ finalize ? "countingService.finalizeValue()" : "" }
                doLast {
                    assert countingService.get().increment() == 2
                    assert requiredServices.elements.size() == 1
                    assert altServiceProvider.get().increment() == 3
                }
            }
        """
        def configurationCache = newConfigurationCacheFixture()

        when:

@UnsupportedWithConfigurationCache(because = "software model")
class ManagedModelMapIntegrationTest extends AbstractIntegrationSpec {

    def "rule can create a map of model elements"() {
        when:
        buildScript '''
            @Managed
            interface Thing extends Named {
              void setValue(String value)
              String getValue()
            }

                            return 1; 
                        } else {
                            return -1;
                        }
                    });
                    // Remove duplicates (equal adjacent elements) - a new, un@Incubating type will be here twice, as 2 errors are reported; use stringified JSON to compare
                    // Filtering an array is NOT in place

        "'contains=' + tree.contains(file1)"                                                            | "contains=false" | "contains=true"
    }

    def "elements of fixed file collection are not treated as build inputs"() {
        buildFile << """
            task report {
                def files = files("file1", "file2")
                def file1 = file("file1")

        0 * listener._
    }

    def "containsAll of existing elements is tracked"() {
        when:
        def result = set.containsAll(Arrays.asList('existing', 'other'))

        then:
        result
        1 * listener.onAccess('existing')
        1 * listener.onAccess('other')
        0 * listener._
    }

    def "containsAll of missing elements is tracked"() {
        when: