public IsolatedList(ImmutableList<Isolatable<?>> elements) {
        super(elements);
    }

    @Override
    public ValueSnapshot asSnapshot() {
        if (elements.isEmpty()) {
            return ListValueSnapshot.EMPTY;
        }
        ImmutableList.Builder<ValueSnapshot> builder = ImmutableList.builderWithExpectedSize(elements.size());
        for (Isolatable<?> element : elements) {
            builder.add(element.asSnapshot());

        when:
        container.get()

        then:
        def e = thrown(IllegalStateException)
        e.message == 'Cannot query the elements of this container as the elements have not been created yet.'
    }

    def "cannot get elements from when known action"() {
        given:
        container.add(Stub(SwiftBinary))
        container.whenElementKnown { container.get() }

        when:

    }

    def "fires events when elements are added"() {
        Action<String> action = Mock()

        given:
        list.all(action)

        when:
        list.addAll(0, ['a', 'b'])

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

    def "ignores duplicate elements when adding collection at given index"() {
        given:

import kotlin.math.min

/**
 * Split a list of elements into nearly even sublist. If an element is too large, largeElementSplitFunction will be used to split the large element into several smaller pieces;
 * if some elements are too small, they will be aggregated by smallElementAggregateFunction.
 *
 * @param list the list to split, must be ordered by size desc
 * @param toIntFunction the function used to map the element to its "size"

  // Query Operations

  /**
   * Returns the number of occurrences of {@code element} in this multiset.
   *
   * @param element the element to look for
   * @return the nonnegative number of occurrences of the element
   */
  @Override
  public int count(@CheckForNull Object element) {
    AtomicInteger existingCounter = Maps.safeGet(countMap, element);
    return (existingCounter == null) ? 0 : existingCounter.get();
  }

/**
 * A non-blocking queue which automatically evicts elements from the head of the queue when
 * attempting to add new elements onto the queue and it is full. This queue orders elements FIFO
 * (first-in-first-out). This data structure is logically equivalent to a circular buffer (i.e.,
 * cyclic buffer or ring buffer).
 *
 * <p>An evicting queue must be configured with a maximum size. Each time an element is added to a

/**
 * A non-blocking queue which automatically evicts elements from the head of the queue when
 * attempting to add new elements onto the queue and it is full. This queue orders elements FIFO
 * (first-in-first-out). This data structure is logically equivalent to a circular buffer (i.e.,
 * cyclic buffer or ring buffer).
 *
 * <p>An evicting queue must be configured with a maximum size. Each time an element is added to a

/**
 * Represents an element in a model. Elements are arranged in a hierarchy.
 */
@Incubating
public interface ModelElement extends Named {
    /**
     * Returns the name of this element. Each element has a name associated with it, that uniquely identifies the element amongst its siblings.
     * Some element have their name generated or automatically assigned, and for these elements the name may not be human consumable.
     */

    }

    @Override
    @SuppressWarnings("varargs")
    @SafeVarargs
    public final void appendAll(T... elements) {
        withActualValue(it -> it.addAll(elements));
    }

    @Override
    public void appendAll(Iterable<? extends T> elements) {
        withActualValue(it -> it.addAll(elements));
    }

    @Override
    public void appendAll(Provider<? extends Iterable<? extends T>> provider) {

        List<?> list = (List<?>) value;
        int pos = 0;
        int len = Math.min(elements.size(), list.size());
        ValueSnapshot newElement = null;
        for (; pos < len; pos++) {
            ValueSnapshot element = elements.get(pos);
            newElement = snapshotter.snapshot(list.get(pos), element);
            if (element != newElement) {
                break;
            }
            newElement = null;
        }