return callable.provider
        }

        @Override
        List<Consumer<ProviderInternal<?>>> safeConsumers() {
            return [ProviderConsumer.TO_STRING, ProviderConsumer.GET_PRODUCER]
        }
    }

            return transform.provider
        }

        @Override
        List<Consumer<ProviderInternal<?>>> safeConsumers() {
            return [ProviderConsumer.TO_STRING, ProviderConsumer.GET_PRODUCER, ProviderConsumer.CALCULATE_PRESENCE]
        }
    }

    static class MappingProviderCircularChainEvaluationTest extends CircularChainEvaluationSpec<String> implements UsesStringProperty {
        @Override

        return Cast.uncheckedCast(List.class);
    }

    @Override
    public ValueProducer getProducer() {
        ImmutableList.Builder<ValueProducer> producers = ImmutableList.builderWithExpectedSize(items.size());
        for (Provider<R> item : items) {
            producers.add(Providers.internal(item).getProducer());
        }
        return new MergeValueProducer(producers.build());
    }

        this.valueFactory = valueFactory;
    }

    @Nullable
    @Override
    public Class<T> getType() {
        return valueType;
    }

    @Override
    public ValueProducer getProducer() {
        // not a lambda for readability purposes.
        //noinspection Convert2Lambda
        return new ValueProducer() {
            @Override

    @Override
    <U, R> Provider<R> zip(Provider<U> right, BiFunction<? super T, ? super U, ? extends R> combiner) {
        throw new UnsupportedOperationException()
    }

    @Override
    ValueProducer getProducer() {
        throw new UnsupportedOperationException()
    }

    @Override
    boolean calculatePresence(ValueConsumer consumer) {
        throw new UnsupportedOperationException()
    }

    @Override

        public InterceptingProvider(Callable<? extends T> value) {
            super(value);
        }

        @Override
        public ValueProducer getProducer() {
            calculatePresence(ValueConsumer.IgnoreUnsafeRead);
            return super.getProducer();
        }

        @Override
        public boolean calculatePresence(ValueConsumer consumer) {
            try {

        return String.format("or(%s, %s)", left, right);
    }

    @Nullable
    @Override
    public Class<T> getType() {
        return left.getType();
    }

    @Override
    public ValueProducer getProducer() {
        try (EvaluationContext.ScopeContext context = openScope()) {
            return new OrElseValueProducer(context, left, right);
        }
    }

    @Override

    @Override
    public void visitDependencies(TaskDependencyResolveContext context) {
        // When used as an input, add the producing tasks if known
        getProducer().visitProducerTasks(context);
    }

    @Override
    public ValueProducer getProducer() {
        return ValueProducer.unknown();
    }

    @Override
    public ExecutionTimeValue<? extends T> calculateExecutionTimeValue() {

    }

    @Nullable
    @Override
    public Class<T> getType() {
        return Cast.uncheckedCast(provider.getType());
    }

    @Override
    public ValueProducer getProducer() {
        try (EvaluationContext.ScopeContext context = openScope()) {
            return new OrElseValueProducer(context, provider);
        }
    }

    @Override

        return "file collection";
    }

    @Override
    public void visitDependencies(TaskDependencyResolveContext context) {
        ValueSupplier.ValueProducer producer = provider.getProducer();
        if (producer.isKnown()) {
            producer.visitProducerTasks(context);
        } else {
            // Producer is unknown, so unpack the value