import org.gradle.api.Task

trait ProviderAssertions {
    void assertHasNoProducer(ProviderInternal<?> provider) {
        def producer = provider.producer
        assert !producer.known
        producer.visitProducerTasks { assert false }
        producer.visitContentProducerTasks { assert false }
    }

    void assertHasKnownProducer(ProviderInternal<?> provider) {
        def producer = provider.producer
        assert producer.known

    }

    public static <T> ProviderInternal<T> nullableValue(ValueSupplier.Value<? extends T> value) {
        if (value.isMissing()) {
            if (value.getPathToOrigin().isEmpty()) {
                return notDefined();
            } else {
                return new NoValueProvider<>(value);
            }
        } else {
            ProviderInternal<T> provider = of(value.getWithoutSideEffect());

        @Nullable
        ProviderInternal<? extends T> getPending(String name);

        void putPending(String name, ProviderInternal<? extends T> provider);

        void removePending(String name);

        void removePending(ProviderInternal<? extends T> provider);

        Map<String, ProviderInternal<? extends T>> getPendingAsMap();
    }

import org.gradle.api.internal.provider.ProviderInternal
import org.gradle.api.internal.provider.ValueSanitizer
import org.gradle.api.internal.tasks.TaskDependencyResolveContext
import org.gradle.api.provider.Provider
import org.gradle.api.specs.Spec
import org.gradle.internal.DisplayName

import java.util.function.BiFunction

class TestNamedProvider<T> implements ProviderInternal<T>, Named {

    private final String name

import java.util.function.Consumer;

public class ProviderBackedFileCollection extends CompositeFileCollection {
    private final ProviderInternal<?> provider;
    private final PathToFileResolver resolver;
    private final ProviderResolutionStrategy providerResolutionStrategy;

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) {
        this.left = left;
        this.right = right;
    }

    @Override
    protected String toStringNoReentrance() {

    }

    def "can remove realized external providers without realizing more providers"() {
        containerAllowsExternalProviders()
        def provider1 = Mock(ProviderInternal)
        def provider2 = Mock(ProviderInternal)
        def provider3 = Mock(ProviderInternal)

        given:
        _ * provider1.type >> type
        _ * provider1.calculateValue(_) >> ValueSupplier.Value.of(a)

        private final ProviderInternal<? extends Map<? extends K, ? extends V>> providerOfEntries;
        private final boolean ignoreAbsent;

        public EntriesFromMapProvider(ProviderInternal<? extends Map<? extends K, ? extends V>> providerOfEntries) {
            this(providerOfEntries, false);
        }

        @Override
        ProviderInternal<String> wrapProviderWithProviderUnderTest(ProviderInternal<String> baseProvider) {
            return new OrElseFixedValueProvider<String>(baseProvider, "B")
        }

        @Override
        List<Consumer<ProviderInternal<?>>> safeConsumers() {

 */
public abstract class AbstractMinimalProvider<T> implements ProviderInternal<T>, Managed {
    private static final DisplayName DEFAULT_DISPLAY_NAME = Describables.of("this provider");

    @Override