when:
        def result = toList(container)

        then:
        result == iterationOrder(b, a, d, c)

        and:
        1 * provider1.calculateValue(_) >> ValueSupplier.Value.of(a)
        1 * provider2.calculateValue(_) >> ValueSupplier.Value.of(d)
        0 * _
    }

    def "provider for iterable of elements is queried when elements iterated and insertion order is retained"() {

        }

        @Override
        Integer calculateValue(NodeExecutionContext context) {
            spec.thread.blockUntil.start1
            spec.thread.blockUntil.start2
            spec.thread.blockUntil.start3
            spec.thread.block()
            spec.instant.finishCalculation
            return super.calculateValue(context)
        }
    }

        def counter = new AtomicInteger(23)
        def parent = Providers.changing { counter.getAndIncrement() }
        def provider = parent.withSideEffect(sideEffect)

        when:
        provider.calculateValue(ValueSupplier.ValueConsumer.IgnoreUnsafeRead)
        provider.calculateExecutionTimeValue()

        then:
        0 * _ // no side effects when values are not unpacked

        when:
        counter.set(23)

        try (EvaluationContext.ScopeContext ignored = openScope()) {
            Value<? extends T> leftValue = left.calculateValue(consumer);
            if (!leftValue.isMissing()) {
                return leftValue;
            }
            Value<? extends T> rightValue = right.calculateValue(consumer);
            if (!rightValue.isMissing()) {
                return rightValue;
            }

        try (EvaluationContext.ScopeContext context = openScope()) {
            Value<? extends T> value = provider.calculateValue(consumer);
            if (value.isMissing()) {
                return value.asType();
            }
            return doMapValue(context, value).calculateValue(consumer);
        }
    }

    ElementSource source = new SortedSetElementSource<CharSequence>()

    def setup() {
        _ * provider1.calculateValue(_) >> ValueSupplier.Value.of("provider1")
        _ * provider2.calculateValue(_) >> ValueSupplier.Value.of("provider2")
        _ * provider3.calculateValue(_) >> ValueSupplier.Value.of("provider3")
    }

    def "can remove elements using iteratorNoFlush"() {
        source.add("foo")

            return provider.getType()
        }
    }

    enum ProviderConsumer implements Consumer<ProviderInternal<?>> {
        GET("get", { it.get() }),
        CALCULATE_VALUE("calculateValue", { it.calculateValue(IgnoreUnsafeRead) }),
        CALCULATE_PRESENCE("calculatePresence", { it.calculatePresence(IgnoreUnsafeRead) }),

        try (EvaluationContext.ScopeContext ignored = openScope()) {
            Value<? extends A> leftValue = left.calculateValue(consumer);
            if (leftValue.isMissing()) {
                return leftValue.asType();
            }
            Value<? extends B> rightValue = right.calculateValue(consumer);
            if (rightValue.isMissing()) {
                return rightValue.asType();
            }

 *
 * @param <K> the type of map entry key
 * @param <V> the type of map entry value
 */
interface MapSupplier<K, V> extends ValueSupplier {
    Value<? extends Map<K, V>> calculateValue(ValueConsumer consumer);

    Value<? extends Set<K>> calculateKeys(ValueConsumer consumer);

    MapSupplier<K, V> plus(MapCollector<K, V> collector);

    /**

        }

        @Override
        public Value<Void> collectEntries(ValueConsumer consumer, MapEntryCollector<K, V> collector, Map<K, V> dest) {
            Value<? extends V> value = providerOfValue.calculateValue(consumer);
            if (value.isMissing()) {
                return value.asType();
            }
            collector.add(key, value.getWithoutSideEffect(), dest);