def notPresent = providerWithNoValue()
        def usesDefaultValue = notPresent.orElse(supplier1).orElse(supplier2).orElse(supplier3)
        usesDefaultValue.present
        usesDefaultValue.get() == someValue()
    }

    def "can unpack state and recreate instance when provider has no value"() {
        given:
        def provider = providerWithNoValue()

        expect:

package org.gradle.api.internal.provider


import org.gradle.api.provider.Provider
import org.gradle.internal.state.ManagedFactory

class ProvidersTest extends ProviderSpec<Integer> {
    @Override
    Provider providerWithNoValue() {
        return Providers.notDefined()
    }

    @Override
    Provider<Integer> providerWithValue(Integer value) {
        return Providers.of(value)
    }

    @Override

            assert false: "never called"
        }))

        expect:
        propertyWithBadValue.toString() == "property(java.lang.String, map(java.lang.String provider(?) check-type()))"
        providerWithNoValue().toString() == "property(java.lang.String, undefined)"
    }

    def "can set null value to discard value"() {
        given:
        def property = property()
        property.set(someValue())

    Provider<String> providerWithValue(String value) {
        return new MappingProvider(String, Providers.of(value.replace("{", "").replace("}", "")), { "{$it}" })
    }

    @Override
    Provider<String> providerWithNoValue() {
        return new MappingProvider(String, Providers.notDefined(), { "{$it}" })
    }

    @Override
    Class<String> type() {
        return String
    }

    @Override
    String someValue() {

import java.util.concurrent.Callable
import java.util.function.Consumer

class DefaultProviderTest extends ProviderSpec<String> {
    @Override
    DefaultProvider<String> providerWithNoValue() {
        return new DefaultProvider<String>({ null })
    }

    @Override
    DefaultProvider<String> providerWithValue(String value) {
        return new DefaultProvider<String>({ value })
    }

import javax.annotation.Nullable

class AbstractMinimalProviderTest extends ProviderSpec<String> {
    TestProvider provider = new TestProvider()

    @Override
    TestProvider providerWithNoValue() {
        return new TestProvider()
    }

    @Override
    TestProvider providerWithValue(String value) {
        def p = new TestProvider()
        p.value = value
        return p
    }

    @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.internal.state.ManagedFactory

import java.util.concurrent.atomic.AtomicInteger


class WithSideEffectProviderTest extends ProviderSpec<Integer> {

    @Override
    Provider providerWithNoValue() {
        return WithSideEffectProvider.of(Providers.notDefined(), Stub(ValueSupplier.SideEffect))
    }

    @Override
    Provider<Integer> providerWithValue(Integer value) {

abstract class PropertySpec<T> extends ProviderSpec<T> {
    @Override
    PropertyInternal<T> providerWithValue(T value) {
        return propertyWithNoValue().value(value)
    }

    @Override
    PropertyInternal<T> providerWithNoValue() {
        return propertyWithNoValue()
    }

    /**
     * Returns a property with _no_ value.
     */
    abstract PropertyInternal<T> propertyWithNoValue()

    @Override