}

    @Override
    protected Value<? extends T> calculateOwnValue(ValueConsumer consumer) {
        return provider.calculateValue(consumer).withSideEffect(sideEffect);
    }

    @Override
    public ExecutionTimeValue<? extends T> calculateExecutionTimeValue() {
        return provider.calculateExecutionTimeValue().withSideEffect(sideEffect);
    }

    @Override

    }

    @Override
    public ValueProducer getProducer() {
        return ValueProducer.unknown();
    }

    @Override
    public ExecutionTimeValue<? extends T> calculateExecutionTimeValue() {
        return ExecutionTimeValue.value(calculateOwnValue(ValueConsumer.IgnoreUnsafeRead));
    }

    @Override

     * same elements as this supplier, plus the elements obtained via the given <code>added</code> collector
     */
    CollectionSupplier<T, C> plus(Collector<T> added);

    ExecutionTimeValue<? extends C> calculateExecutionTimeValue();

    /**
     * Returns a view of this supplier that will calculate its value as empty if it would be missing.

    }

    @Override
    ProviderInternal<T> withFinalValue(ValueConsumer consumer) {
        throw new UnsupportedOperationException()
    }

    @Override
    ExecutionTimeValue<? extends T> calculateExecutionTimeValue() {
        throw new UnsupportedOperationException()
    }

    @Override
    Provider<T> filter(Spec<? super T> spec) {

        try (EvaluationContext.ScopeContext context = openScope()) {
            return backingProvider(context, ValueConsumer.IgnoreUnsafeRead).getProducer();
        }
    }

    @Override
    public ExecutionTimeValue<? extends S> calculateExecutionTimeValue() {
        try (EvaluationContext.ScopeContext context = openScope()) {
            return backingProvider(context, ValueConsumer.IgnoreUnsafeRead).calculateExecutionTimeValue();

        return this;
    }

    @Override
    public Property<T> unsetConvention() {
        discardConvention();
        return this;
    }

    @Override
    protected ExecutionTimeValue<? extends T> calculateOwnExecutionTimeValue(EvaluationContext.ScopeContext context, ProviderInternal<? extends T> value) {
        // Discard this property from a provider chain, as it does not contribute anything to the calculation.

        }

        @Override
        protected Value<? extends T> calculateOwnValue(ValueConsumer consumer) {
            return provider.calculateValue(consumer)
        }

        @Override
        ExecutionTimeValue<? extends T> calculateExecutionTimeValue() {
            return provider.calculateExecutionTimeValue()
        }

        @Nullable
        @Override
        Class<T> getType() {

 *     input providers that have a fixed value with that value, as above.
 *     </p>
 *     </li>
 * </ul>
 *
 * <p>See {@link org.gradle.api.internal.provider.ValueSupplier.ExecutionTimeValue}, which represents these states.</p>
 *
 * <p>The value itself might be "missing", which means there is no value available, or "broken", which means the calculation failed with some exception, or some object.

        when:
        def provider = parent.withSideEffect(sideEffect)
        def value = provider.calculateValue(ValueSupplier.ValueConsumer.IgnoreUnsafeRead)
        def executionTimeValue = provider.calculateExecutionTimeValue()
        then:
        0 * _ // no side effects when values are not unpacked

        when:
        def unpackedValue = value.get()
        then:

        property.add(Providers.of("other value").withSideEffect(sideEffect2))

        def value = property.calculateValue(ValueSupplier.ValueConsumer.IgnoreUnsafeRead)
        def executionTimeValue = property.calculateExecutionTimeValue()
        then:
        0 * _ // no side effects until values are unpacked

        when:
        def unpackedValue = value.get()
        then: