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

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