*/
package org.gradle.api.internal.tasks

import org.gradle.api.Buildable
import org.gradle.api.Task
import org.gradle.api.internal.provider.ProviderInternal
import org.gradle.api.internal.provider.ValueSupplier
import org.gradle.api.tasks.TaskDependency
import org.gradle.api.tasks.TaskProvider
import org.gradle.internal.typeconversion.UnsupportedNotationException
import org.gradle.util.internal.TextUtil

                    @Override
                    public void visitInputFileProperty(String propertyName, InputBehavior behavior, InputFileValueSupplier valueSupplier) {
                        if (behavior.shouldTrackChanges()) {
                            Object value = valueSupplier.getValue();
                            if (value == null) {

        if (isPresent(unnested)) {
            // only resolve deferred values if actually required by some action
            Supplier<Object> valueSupplier = Suppliers.memoize(() -> DeferredUtil.unpack(unnested));
            validationAction.validate(propertyName, valueSupplier, context);
        } else {
            if (!optional) {
                reportValueNotSet(propertyName, context, hasConfigurableValue(unnested));
            }

import org.gradle.internal.execution.UnitOfWork.InputFileValueSupplier;
import org.gradle.internal.execution.UnitOfWork.InputVisitor;
import org.gradle.internal.execution.UnitOfWork.ValueSupplier;
import org.gradle.internal.fingerprint.CurrentFileCollectionFingerprint;
import org.gradle.internal.fingerprint.FileCollectionFingerprint;
import org.gradle.internal.properties.InputBehavior;

/**
 * A collector is a value supplier of zero or more values of type {@link T}.
 * <p>
 *     A <code>Collector</code> represents an increment to a collection property.
 * </p>
 */
public interface Collector<T> extends ValueSupplier {
    Value<Void> collectEntries(ValueConsumer consumer, ValueCollector<T> collector, ImmutableCollection.Builder<T> dest);

    int size();

 * </p>
 */
public interface MapCollector<K, V> extends ValueSupplier {

    Value<Void> collectEntries(ValueConsumer consumer, MapEntryCollector<K, V> collector, Map<K, V> dest);

 *
 * @param <K> the type of map entry key
 * @param <V> the type of map entry value
 */
interface MapSupplier<K, V> extends ValueSupplier {
    Value<? extends Map<K, V>> calculateValue(ValueConsumer consumer);

    Value<? extends Set<K>> calculateKeys(ValueConsumer consumer);

    MapSupplier<K, V> plus(MapCollector<K, V> collector);

    /**

        default void visitInputProperty(
            String propertyName,
            ValueSupplier value
        ) {}

        default void visitInputFileProperty(
            String propertyName,
            InputBehavior behavior,
            InputFileValueSupplier value
        ) {}
    }

    interface ValueSupplier {
        @Nullable
        Object getValue();
    }

    private void declareInput(File file) {
        def valueSupplier = Stub(UnitOfWork.InputFileValueSupplier) {
            getFiles() >> TestFiles.fixed(file)
        }
        inputListeners.broadcastFileSystemInputsOf(Stub(UnitOfWork) {
            visitRegularInputs(_ as InputVisitor) >> { InputVisitor visitor ->
                visitor.visitInputFileProperty("test", PRIMARY, valueSupplier)
            }
        }, EnumSet.allOf(InputBehavior))

 *     input providers that have a fixed value with that value, as above.
 *     </p>
 *     </li>
 * </ul>
 *
 * <p>See {@link org.gradle.api.internal.provider.ValueSupplier.ExecutionTimeValue}, which represents these states.</p>
 *
 * <p>The value itself might be "missing", which means there is no value available, or "broken", which means the calculation failed with some exception, or some object.