whenObjectAdded(ConfigureUtil.configureUsing(action));
    }

    @Override
    public Action<? super T> whenObjectRemoved(Action<? super T> action) {
        return delegate.whenObjectRemoved(action);
    }

    @Override
    public void whenObjectRemoved(Closure action) {
        whenObjectRemoved(ConfigureUtil.configureUsing(action));
    }

    @Override

    }

    def callsClosureWithRemovedObjectAsParameterWhenObjectRemoved() {
        def seen = []
        def closure = { seen << it }

        container.add("a");
        container.whenObjectRemoved(closure)

        when:
        container.remove("a")

        then:
        seen == ["a"]

        when:
        container.remove("a")
        container.remove("b")

        then:

    override fun getCollectionSchema(): NamedDomainObjectCollectionSchema =
        delegate.collectionSchema

    override fun whenObjectRemoved(action: Action<in T>): Action<in T> =
        delegate.whenObjectRemoved(action)

    override fun whenObjectRemoved(action: Closure<Any>) =
        delegate.whenObjectRemoved(action)

    override fun findAll(spec: Closure<Any>): MutableSet<T> =
        delegate.findAll(spec)

        return super.whenObjectAdded(Actions.filter(action, uniqueSpec));
    }

    @Override
    public Action<? super T> whenObjectRemoved(Action<? super T> action) {
        return super.whenObjectRemoved(Actions.filter(action, notInSpec));
    }

    public void addCollection(DomainObjectCollection<? extends T> collection) {
        if (!getStore().containsCollection(collection)) {

        return null
    }

    @Override
    void whenObjectAdded(Closure action) {

    }

    @Override
    Action<? super T> whenObjectRemoved(Action<? super T> action) {
        return null
    }

    @Override
    void whenObjectRemoved(Closure action) {

    }

    @Override
    void all(Action<? super T> action) {

    }

    @Override
    void all(Closure action) {

        delegate.collectionSchema

    override fun whenObjectRemoved(action: Action<in Task>): Action<in Task> =
        delegate.whenObjectRemoved(action)

    override fun whenObjectRemoved(action: Closure<Any>) =
        delegate.whenObjectRemoved(action)

    override fun findAll(spec: Closure<Any>): MutableSet<Task> =
        delegate.findAll(spec)

        Action<String> addAction = Mock()
        Action<String> removeAction = Mock()

        given:
        list.add('a')
        list.all(addAction)
        list.whenObjectRemoved(removeAction)

        when:
        list.set(0, 'b')

        then:
        1 * removeAction.execute('a')
        1 * addAction.execute('b')
        0 * removeAction._
        0 * addAction._

    }

    @Override
    public Action<? super T> whenObjectRemoved(Action<? super T> action) {
        eventRegister.registerRemoveAction(type, decorate(action));
        return action;
    }

    @Override
    public void whenObjectRemoved(Closure action) {
        whenObjectRemoved(toAction(action));
    }

    private Action<? super T> decorate(Action<? super T> action) {

        final List<Sign> result = new ArrayList<>();
        publications.all(publication -> result.add(createSignTaskFor((PublicationInternal<?>) publication)));
        publications.whenObjectRemoved(publication -> {
            final TaskContainer tasks = project.getTasks();
            final Task task = tasks.getByName(determineSignTaskNameForPublication(publication));
            task.setEnabled(false);

    def "can add action to execute only when object removed"() {
        containerAllowsElementRemoval()

        def action = Mock(Action)

        addToContainer(c)

        when:
        container.whenObjectRemoved(action)

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

        when:
        addToContainer(a)
        container.remove(c)
        container.remove(a)