* <p>
 * All providers implement this interface, but this interface may be implemented whenever
 * lazy evaluation is required.
 * </p>
 */
public interface ValueSupplier {
    /**
     * Visits the producer of the value for this supplier. This might be one or more tasks, some external location, nothing (for a fixed value) or might unknown.
     */
    ValueProducer getProducer();

        0 * _
    }

    def "runs side effects for zipped providers when #description value"() {
        given:
        def leftSideEffect = Mock(ValueSupplier.SideEffect)
        def rightSideEffect = Mock(ValueSupplier.SideEffect)
        def zippedSideEffect = Mock(ValueSupplier.SideEffect)
        def leftWithSideEffect = Providers.ofNullable(leftValue).withSideEffect(leftSideEffect)

import java.util.Objects;

class OrElseValueProducer implements ValueSupplier.ValueProducer {
    private final EvaluationContext.EvaluationOwner owner;
    private final ProviderInternal<?> left;
    @Nullable
    private final ProviderInternal<?> right;
    private final ValueSupplier.ValueProducer leftProducer;
    private final ValueSupplier.ValueProducer rightProducer;

    override fun calculateOwnValue(consumer: ValueSupplier.ValueConsumer): ValueSupplier.Value<out BuildWorkResult> {
        require(result != null) {
            "Cannot access the value of '${BuildWorkResult::class.simpleName}' before it becomes available!"
        }
        return ValueSupplier.Value.ofNullable(result)
    }

    override fun calculateExecutionTimeValue(): ValueSupplier.ExecutionTimeValue<out BuildWorkResult> =

        !provider1.isPresent()
        !provider2.isPresent()
    }

    def "runs side effects"() {
        given:
        def leftSideEffect = Mock(ValueSupplier.SideEffect)
        def rightSideEffect = Mock(ValueSupplier.SideEffect)
        def mergedSideEffect = Mock(ValueSupplier.SideEffect)

        def left = Providers.of("left").withSideEffect(leftSideEffect)
        def right = Providers.of("right").withSideEffect(rightSideEffect)

                }
            }
            return finalizeOnNextGet || consumer == ValueSupplier.ValueConsumer.DisallowUnsafeRead;
        }

        @Override
        public ValueSupplier.ValueConsumer forUpstream(ValueSupplier.ValueConsumer consumer) {
            if (disallowUnsafeRead) {
                return ValueSupplier.ValueConsumer.DisallowUnsafeRead;
            } else {
                return consumer;

        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"() {

        def sideEffect3 = Mock(ValueSupplier.SideEffect)
        def sideEffect4 = Mock(ValueSupplier.SideEffect)
        def sideEffect5 = Mock(ValueSupplier.SideEffect)
        def propertyFactory = new DefaultPropertyFactory(Stub(PropertyHost))
        def source = getSource()

        when:
        def provider1 = Providers.of("v1").withSideEffect(sideEffect1)
        source.addPending(provider1)

        given:
        def sideEffect1 = Mock(ValueSupplier.SideEffect)
        def sideEffect2 = Mock(ValueSupplier.SideEffect)
        def parent = providerWithValue(someValue())
        def provider = parent.withSideEffect(sideEffect1).withSideEffect(sideEffect2)

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

import org.gradle.api.internal.file.TestFiles
import org.gradle.api.internal.provider.ProviderInternal
import org.gradle.api.internal.provider.ProviderResolutionStrategy
import org.gradle.api.internal.provider.ValueSupplier
import org.gradle.api.tasks.TaskDependency
import org.gradle.internal.Factory
import org.gradle.internal.file.PathToFileResolver
import spock.lang.Specification