return decodeValue().toProvider()
    }

    suspend fun ReadContext.decodeValue(): ValueSupplier.ExecutionTimeValue<*> =
        when (readByte()) {
            1.toByte() -> ValueSupplier.ExecutionTimeValue.missing<Any>()
            2.toByte() -> ValueSupplier.ExecutionTimeValue.ofNullable(read()) // nullable because serialization may replace value with null, e.g. when using provider of Task

        if (value.isMissing()) {
            visitor.execute(ValueSupplier.ExecutionTimeValue.missing());
        } else if (value.hasFixedValue()) {
            // transform preserving side effects

import org.gradle.api.internal.provider.ValueSupplier

class SortedSetElementSourceTest extends ElementSourceSpec {

    def provider1 = Mock(ProviderInternal)
    def provider2 = Mock(ProviderInternal)
    def provider3 = Mock(ProviderInternal)

    ElementSource source = new SortedSetElementSource<CharSequence>()

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

import java.util.Collection;

/**
 * A {@link ValueSupplier value supplier} that supplies collection values. Instances of
 * this type are used as value suppliers for {@link AbstractCollectionProperty}.
 *
 * @param <T> the type of elements
 * @param <C> type of collection
 */
interface CollectionSupplier<T, C extends Collection<? extends T>> extends ValueSupplier {
    /**
     * Realizes and returns the (collection) value.

    @Override
    AbstractProperty<T, ? extends ValueSupplier> providerWithValue(T value) {
        return propertyWithNoValue().value(value)
    }

    @Override
    AbstractProperty<T, ? extends ValueSupplier> providerWithNoValue() {
        return propertyWithNoValue()
    }

    @Override
    abstract AbstractProperty<T, ? extends ValueSupplier> propertyWithNoValue()

import org.gradle.api.internal.file.FileCollectionInternal;
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.internal.tasks.TaskDependencyFactory;
import org.gradle.api.internal.tasks.TaskDependencyResolveContext;
import org.gradle.api.tasks.util.PatternSet;
import org.gradle.internal.Factory;

        then:
        1 * valueProvider.calculateValue(_) >> ValueSupplier.Value.of(['k1': 'v1'])
        1 * putProvider.calculateValue(_) >> ValueSupplier.Value.of('v2')
        1 * putAllProvider.calculateValue(_) >> ValueSupplier.Value.of(['k3': 'v3'])
        0 * _

        when:
        property.getOrNull()
        then:
        1 * valueProvider.calculateValue(_) >> ValueSupplier.Value.of(['k1': 'v1'])

        private final Supplier<T> valueSupplier;
        private final ImmutableSet.Builder<String> builder;

        public EvaluatableFilter(Function<ImmutableSet<String>, T> initializer, T emptyValue) {
            this.builder = ImmutableSet.builder();
            // if there are configured ignores, use the initializer to create the value, otherwise return emptyValue
            this.valueSupplier = () -> Optional.of(builder.build())

        then:
        1 * valueProvider.calculateValue(_) >> ValueSupplier.Value.of(["1"])
        1 * addProvider.calculateValue(_) >> ValueSupplier.Value.of("2")
        1 * addAllProvider.calculateValue(_) >> ValueSupplier.Value.of(["3"])
        0 * _

        when:
        property.getOrNull()

        then:
        1 * valueProvider.calculateValue(_) >> ValueSupplier.Value.of(["1"])

import javax.annotation.Nullable;
import java.io.Serializable;
import java.util.concurrent.Callable;

public class Providers {
    private static final NoValueProvider<Object> NULL_PROVIDER = new NoValueProvider<>(ValueSupplier.Value.MISSING);

    public static final Provider<Boolean> TRUE = of(true);
    public static final Provider<Boolean> FALSE = of(false);