<?xml version="1.0"?><project>
  <parent>
    <artifactId>wagon</artifactId>
    <groupId>org.apache.maven.wagon</groupId>
    <version>1.0-beta-2</version>
  </parent>
  <modelVersion>4.0.0</modelVersion>
  <artifactId>wagon-provider-api</artifactId>
  <name>Maven Wagon API</name>
  <version>1.0-beta-2</version>
  <description>Maven Wagon API that defines the contract between different Wagon implementations</description>
  <dependencies>
    <dependency>

import java.lang.annotation.Target;

/**
 * Used to register service factory methods on a {@link ServiceRegistrationProvider}.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Keep
public @interface Provides {

     *
     * @param <T> the provider value type
     */
    static abstract class CircularChainEvaluationSpec<T> extends CircularEvaluationSpec<T> {
        /**
         * Returns a provider-under-test that uses baseProvider for its computation
         * @param baseProvider the provider to wrap
         * @return the provider-under-test
         */

        outputContains("test.foo=fooValue")
    }

    def "providers.exec returns a provider that throws if execution fails"() {
        given:
        def testScript = ShellScript.builder()
            .withExitValue(42)
            .writeTo(testDirectory, "script")

        buildFile """
            def execProvider = providers.exec {
                ${cmdToExecConfig(*testScript.commandLine)}
            }

            def transform = new Transformer<Provider<String>, String>() {
                ProviderInternal<String> provider

                @Override
                Provider<String> transform(String s) {
                    return Providers.of(provider.get())
                }

                @Override
                String toString() {
                    return "Transformer with $provider"
                }
            }

        task.getReports().all(action(report -> {
            report.getRequired().convention(providers.provider(() -> report.getName().equals(reportFormat.get())));
            report.getOutputLocation().convention(layout.getProjectDirectory().file(providers.provider(() -> {
                String fileSuffix = report.getName().equals("text") ? "txt" : report.getName();

     *
     * <p>The given provider will be queried when the value of this property is queried.
     * This property will have no value when the given provider has no value.
     *
     * @param provider the provider of the entries
     */
    void putAll(Provider<? extends Map<? extends K, ? extends V>> provider);

    /**

            runningOnCi = buildRunningOnCi
            runningInstallTask = provider { isRunningInstallTask() }
            runningDocsTestTask = provider { isRunningDocsTestTask() }
        }
    }


fun Project.buildTimestampFromBuildReceipt(): Provider<String> =
    providers.of(BuildTimestampFromBuildReceiptValueSource::class) {
        parameters {

import org.gradle.api.internal.provider.Providers;
import org.gradle.api.provider.Provider;
import org.gradle.internal.Try;

import java.util.function.Function;

public abstract class AbstractUserInputHandler implements UserInputHandler {
    @Override
    public <T> Provider<T> askUser(Function<? super UserQuestions, ? extends T> interaction) {
        return Providers.changing(new Providers.SerializableCallable<T>() {

/**
 * Tests covering the use of {@link org.gradle.api.provider.Provider} as an argument in the
 * {@link org.gradle.api.artifacts.dsl.DependencyHandler} block.
 */
class DependencyHandlerProviderIntegrationTest extends AbstractHttpDependencyResolutionTest {

    def resolve = new ResolveTestFixture(buildFile, "conf")

    def setup() {
        settingsFile << """
            rootProject.name = 'provider'
        """
        buildFile << """