*/
    ProviderInternal<T> asSupplier(DisplayName owner, Class<? super T> targetType, ValueSanitizer<? super T> sanitizer);

    /**
     * Returns a copy of this provider with a final value. The returned value is used to replace this provider by a property when the property is finalized.
     */
    ProviderInternal<T> withFinalValue(ValueConsumer consumer);

    /**

    }

    public OrElseValueProducer(EvaluationContext.ScopeContext context, ProviderInternal<?> left, ProviderInternal<?> right) {
        this(context, left, right, right.getProducer());
    }

    private OrElseValueProducer(EvaluationContext.ScopeContext context, ProviderInternal<?> left, @Nullable ProviderInternal<?> right, ValueSupplier.ValueProducer rightProducer) {
        this.owner = Objects.requireNonNull(context.getOwner());

        }

        @Override
        List<Consumer<ProviderInternal<?>>> safeConsumers() {
            return [TO_STRING, GET_PRODUCER]
        }
    }

    static class BiProviderLeftCircularChainEvaluationTest extends CircularChainEvaluationSpec<String> implements UsesStringProperty {
        @Override
        ProviderInternal<String> wrapProviderWithProviderUnderTest(ProviderInternal<String> baseProvider) {

    }

    @Override
    protected ProviderInternal<? extends T> finalValue(EvaluationContext.ScopeContext context, ProviderInternal<? extends T> value, ValueConsumer consumer) {
        return value.withFinalValue(consumer);
    }

    @Override
    protected ProviderInternal<? extends T> getDefaultConvention() {
        return Cast.uncheckedCast(NOT_DEFINED);
    }

    @Override

    public static <T> ProviderInternal<T> of(ProviderInternal<T> provider, @Nullable SideEffect<? super T> sideEffect) {
        return sideEffect == null ? provider : new WithSideEffectProvider<>(provider, sideEffect);
    }

    private final ProviderInternal<T> provider;
    private final SideEffect<? super T> sideEffect;

    private WithSideEffectProvider(ProviderInternal<T> provider, SideEffect<? super T> sideEffect) {

        private final Consumer<ProviderInternal<?>> impl

        ProviderConsumer(String stringValue, Consumer<ProviderInternal<?>> impl) {
            this.impl = impl
            this.stringValue = stringValue
        }

        @Override
        String toString() {
            return stringValue
        }

        @Override
        void accept(ProviderInternal<?> providerInternal) {

class OrElseProviderTest {
    static class OrElseProviderLeftCircularChainEvaluationTest extends CircularChainEvaluationSpec<String> implements UsesStringProperty {
        @Override
        ProviderInternal<String> wrapProviderWithProviderUnderTest(ProviderInternal<String> baseProvider) {
            return new OrElseProvider<String>(baseProvider, Providers.of("B"))
        }
    }

    private boolean doRemove(Object o) {
        if (o instanceof ProviderInternal) {
            ProviderInternal<? extends T> providerInternal = Cast.uncheckedCast(o);
            if (getStore().removePending(providerInternal)) {
                // NOTE: When removing provider, we don't need to fireObjectRemoved as they were never added in the first place.
                didRemove(providerInternal);
                return true;

    }

    static class MappingProviderCircularFunctionEvaluationTest extends CircularFunctionEvaluationSpec<String> {
        @Override
        ProviderInternal<String> providerWithSelfReference() {
            def transform = new Transformer<String, String>() {
                ProviderInternal<String> provider

                @Override
                String transform(String s) {
                    return provider.get()
                }

public class ProviderTestUtil {
    public static <T> ProviderInternal<T> withNoValue() {
        return Providers.notDefined();
    }

    public static <T> ProviderInternal<T> withValues(T... values) {
        assert values.length > 0;
        return new TestProvider<>(Cast.uncheckedNonnullCast(values[0].getClass()), Arrays.asList(values), null);
    }

    public static <T> ProviderInternal<T> withChangingExecutionTimeValues(T... values) {