import javax.annotation.Nullable;

/**
 * A partial {@link Provider} implementation. Subclasses must implement {@link ProviderInternal#getType()} and {@link AbstractMinimalProvider#calculateOwnValue(ValueConsumer)}.
 */
public abstract class AbstractMinimalProvider<T> implements ProviderInternal<T>, Managed {
    private static final DisplayName DEFAULT_DISPLAY_NAME = Describables.of("this provider");

    @Override

package org.gradle.architecture.test;

import com.tngtech.archunit.junit.AnalyzeClasses;
import com.tngtech.archunit.junit.ArchTest;
import com.tngtech.archunit.lang.ArchRule;
import org.gradle.api.internal.provider.AbstractMinimalProvider;
import org.gradle.api.provider.Provider;

import static com.tngtech.archunit.core.domain.JavaClass.Predicates.implement;
import static com.tngtech.archunit.lang.conditions.ArchConditions.beAssignableTo;

 * limitations under the License.
 */

package org.gradle.internal.flow.services

import org.gradle.api.flow.BuildWorkResult
import org.gradle.api.flow.FlowProviders
import org.gradle.api.internal.provider.AbstractMinimalProvider
import org.gradle.api.internal.provider.ValueSupplier
import org.gradle.api.provider.Provider
import org.gradle.internal.service.scopes.Scope
import org.gradle.internal.service.scopes.ServiceScope

 * limitations under the License.
 */

package org.gradle.api.internal.provider;

import javax.annotation.Nullable;

class OrElseProvider<T> extends AbstractMinimalProvider<T> {
    private final ProviderInternal<T> left;
    private final ProviderInternal<? extends T> right;

    public OrElseProvider(ProviderInternal<T> left, ProviderInternal<? extends T> right) {

 * see the {@link org.gradle.api.internal.provider.ProviderInternal} interface.</p>
 *
 * <p>Also, make sure to become familiar with {@link org.gradle.api.internal.provider.AbstractMinimalProvider},
 * the base class for all provider (and property) implementations.</p>
 *
 * <h3>Lazy properties</h3>
 *
 * <p>For the public API, see {@link org.gradle.api.provider.Property Property}.</p>
 *

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;

 *
 * <h3>Configuration Cache Behavior</h3>
 * <b>Eager</b>. The value is computed at store time and loaded from the cache.
 */
public class DefaultProvider<T> extends AbstractMinimalProvider<T> {
    private final Callable<? extends T> value;

    public DefaultProvider(Callable<? extends T> value) {
        this.value = value;
    }

    @Nullable
    @Override

import javax.annotation.Nonnull;
import javax.annotation.Nullable;

/**
 * A filtering provider that uses a spec to filter the value of another provider.
 **/
public class FilteringProvider<T> extends AbstractMinimalProvider<T> {

    protected final ProviderInternal<T> provider;
    protected final Spec<? super T> spec;

    public FilteringProvider(
        ProviderInternal<T> provider,
        Spec<? super T> spec
    ) {

 */
package org.gradle.api.internal.provider;

import org.gradle.api.provider.Provider;

import javax.annotation.Nullable;
import java.util.function.BiFunction;

public class BiProvider<R, A, B> extends AbstractMinimalProvider<R> {

    private final Class<R> type;
    private final BiFunction<? super A, ? super B, ? extends R> combiner;
    private final ProviderInternal<A> left;
    private final ProviderInternal<B> right;

        return new TestProviderWithChangingValue<>(valueType, Arrays.asList(values), producer);
    }

    private static class TestProvider<T> extends AbstractMinimalProvider<T> {
        final Class<T> type;
        final Iterator<T> values;
        final Task producer;

        TestProvider(Class<T> type, List<T> values, @Nullable  Task producer) {