// Using the Java API
println System.getProperty('system')

// Using the Gradle API, provides a lazy Provider<String>

// tag::gradle-properties[]
settingsEvaluated {
    // Using the API, provides a lazy Provider<String>
    println(providers.gradleProperty("gradlePropertiesProp").get())

    // Using Kotlin delegated properties on `settings`
    val gradlePropertiesProp: String by this
    println(gradlePropertiesProp)
}

        }
    }

    /**
     * A provider wrapping an existing provider with a cache
     * @param <T> the provided type
     */
    protected static class CachingProvider<T> implements Provider<T> {
        private final Provider<T> provider;
        private volatile T value;

        CachingProvider(Provider<T> provider) {
            this.provider = provider;
        }

        public T value() {

        protected final ProviderFactory providers;
        protected final DefaultVersionCatalog config;

        public PluginFactory(ProviderFactory providers, DefaultVersionCatalog config) {
            this.providers = providers;
            this.config = config;
        }

        protected Provider<PluginDependency> createPlugin(String name) {
            return providers.of(PluginDependencyValueSource.class,

            fs,
            providers.provider(() -> extension.isEnabled() && extension.getOutput() == JacocoTaskExtension.Output.FILE),
            providers.provider(extension::getDestinationFile)
        ));

        // Do not cache the task if we are not writing execution data to a file
        Provider<Boolean> doNotCachePredicate = providers.provider(() ->

        description | value
        'Provider'  | Providers.notDefined()
        'Provider in Callable'      | { -> Providers.notDefined() }
    }

    def "unpack of #description fails"() {
        when:
        DeferredUtil.unpack(value)
        then:
        thrown(MissingValueException)

        where:
        description            | value
        'Provider'             | Providers.notDefined()

 */

package org.gradle.api.internal.provider;

import org.gradle.api.Transformer;
import org.gradle.api.provider.Provider;

import javax.annotation.Nullable;

public class FlatMapProvider<S, T> extends AbstractMinimalProvider<S> {
    private final ProviderInternal<? extends T> provider;
    private final Transformer<? extends Provider<? extends S>, ? super T> transformer;

import org.gradle.api.configuration.BuildFeatures;
import org.gradle.api.internal.StartParameterInternal;
import org.gradle.api.internal.provider.ProviderInternal;
import org.gradle.api.internal.provider.Providers;
import org.gradle.api.provider.Provider;
import org.gradle.internal.buildoption.Option;
import org.gradle.internal.buildtree.BuildModelParameters;
import org.gradle.internal.lazy.Lazy;

        then:
        zipped instanceof Provider
        !zipped.isPresent()
        zipped.getOrNull() == null
    }

    def "can zip two providers and use null to remove the value, and it is live"() {
        def provider = withValues("accepted", "accepted", "rejected", "rejected")
        def second = providerFactory.provider { "value" }

        when:
        def zipped = providerFactory.zip(provider, second) { s1, s2 ->

                @Override
                String apply(String a, String b) {
                    return provider.get()
                }

                @Override
                String toString() {
                    return "BiFunction with $provider"
                }
            }
            transform.provider = new BiProvider(String, Providers.of("A"), Providers.of("B"), transform)