context.add(dependency);
            } else if (dependency instanceof ProviderInternal) {
                // When a Provider is used as a task dependency (rather than as a task input), need to unpack the value
                ProviderInternal<?> provider = (ProviderInternal<?>) dependency;
                ValueSupplier.ValueProducer producer = provider.getProducer();

        return ImmutableList.copyOf(subscriptions.keySet());
    }

    @Override
    public void subscribe(Provider<?> provider) {
        ProviderInternal<?> providerInternal = Providers.internal(provider);
        if (OperationCompletionListener.class.isAssignableFrom(providerInternal.getType())) {
            onTaskCompletion(Cast.uncheckedCast(provider));
        } else {
            onOperationCompletion(Cast.uncheckedCast(provider));

        expect:
        assertValueIs(["abc", "1"])
    }

    def "providers only called once per query"() {
        def valueProvider = Mock(ProviderInternal)
        def addProvider = Mock(ProviderInternal)
        def addAllProvider = Mock(ProviderInternal)

        given:
        property.set(valueProvider)
        property.add(addProvider)
        property.addAll(addAllProvider)

        when:

 * limitations under the License.
 */

package org.gradle.api.internal.provider;

public interface CollectionProviderInternal<T, C extends Iterable<T>> extends ProviderInternal<C> {
    Class<? extends T> getElementType();

    int size();

 */
class ProviderCodec(
    private val providerCodec: FixedValueReplacingProviderCodec
) : Codec<ProviderInternal<*>> {

    override suspend fun WriteContext.encode(value: ProviderInternal<*>) {
        // TODO - should write the provider value type
        providerCodec.run { encodeProvider(value) }
    }

    override suspend fun ReadContext.decode() =

                    }),
                    Iterables.transform(index.getPendingAsMap().entrySet(), new Function<Map.Entry<String, ProviderInternal<? extends T>>, NamedDomainObjectSchema>() {
                        @Override
                        public NamedDomainObjectSchema apply(final Map.Entry<String, ProviderInternal<? extends T>> e) {
                            return new NamedDomainObjectSchema() {
                                @Override

 * limitations under the License.
 */

package org.gradle.api.internal.provider;

import java.util.Map;

public interface MapProviderInternal<K, V> extends ProviderInternal<Map<K, V>> {

    Class<? extends K> getKeyType();

    Class<? extends V> getValueType();

import org.gradle.api.provider.SupportsConvention;
import org.gradle.internal.state.ModelObject;
import org.gradle.internal.state.OwnerAware;

public interface PropertyInternal<T> extends ProviderInternal<T>, HasConfigurableValueInternal, OwnerAware, LazyGroovySupport, SupportsConvention {
    /**
     * Associates this property with the task that produces its value.
     */
    void attachProducer(ModelObject owner);

import org.gradle.api.file.DirectoryTree
import org.gradle.api.file.FileCollection
import org.gradle.api.internal.file.FileCollectionInternal
import org.gradle.api.internal.file.TestFiles
import org.gradle.api.internal.provider.ProviderInternal
import org.gradle.api.tasks.TaskDependency
import org.gradle.api.tasks.TaskOutputs
import org.gradle.internal.file.PathToFileResolver
import org.gradle.internal.Factory
import org.gradle.api.Buildable

 */

package org.gradle.api.internal.file

import org.gradle.api.Action
import org.gradle.api.Task
import org.gradle.api.internal.provider.PropertyHost
import org.gradle.api.internal.provider.ProviderInternal
import org.gradle.internal.state.ModelObject
import org.gradle.test.fixtures.file.TestFile
import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider
import org.junit.Rule
import spock.lang.Specification