def task = Mock(Task)
        def provider = supplierWithProducer(task)
        def property = propertyWithNoValue()
        property.set(provider)

        expect:
        assertHasProducer(property.shallowCopy(), task)
    }

    def "shallow copy does not follow changes to dependencies of the original"() {
        given:
        def task = Mock(Task)
        def provider = supplierWithProducer(task)

simpleMessageProperty.set("Hello, World from a Property!")
// Accessing a property
println(simpleMessageProperty.get())
// end::set-prop[]

// tag::set-prov[]
// Setting a provider
val simpleMessageProvider: Provider<String> = project.providers.provider { "Hello, World from a Provider!" }
// Accessing a provider
println(simpleMessageProvider.get())
// end::set-prov[]

// tag::introduction[]
abstract class MyIntroTask : DefaultTask() {
    @get:Input

    }

    def "is present when value is not null"() {
        expect:
        !provider.present
        provider.value("s1")
        provider.present
    }

    def "can query with default when value is null"() {
        expect:
        provider.getOrNull() == null
        provider.getOrElse("s2") == "s2"
    }

    def "mapped provider is live"() {
        def transformer = Stub(Transformer)

import org.gradle.api.internal.file.collections.MinimalFileSet;
import org.gradle.api.internal.provider.MappingProvider;
import org.gradle.api.internal.provider.PropertyHost;
import org.gradle.api.internal.provider.Providers;
import org.gradle.api.internal.tasks.TaskDependencyFactory;
import org.gradle.api.provider.Provider;
import org.gradle.api.tasks.util.PatternSet;
import org.gradle.internal.Factory;

import java.io.File;

    private final List<ClassPathProvider> providers = new ArrayList<ClassPathProvider>();

    public DefaultClassPathRegistry(ClassPathProvider... providers) {
        this.providers.addAll(Arrays.asList(providers));
    }

    @Override
    public ClassPath getClassPath(String name) {
        for (ClassPathProvider provider : providers) {
            ClassPath classpath = provider.findClassPath(name);

 */

package org.gradle.api.internal.provider


import org.gradle.api.provider.Provider
import org.gradle.internal.state.ManagedFactory

class ProvidersTest extends ProviderSpec<Integer> {
    @Override
    Provider providerWithNoValue() {
        return Providers.notDefined()
    }

    @Override
    Provider<Integer> providerWithValue(Integer value) {
        return Providers.of(value)
    }

    @Override

    }

    public ServiceRegistryBuilder parent(ServiceRegistry parent) {
        this.parents.add(parent);
        return this;
    }

    public ServiceRegistryBuilder provider(ServiceRegistrationProvider provider) {
        this.providers.add(provider);
        return this;
    }

    /**
     * Providing a scope makes the resulting {@link ServiceRegistry}

apiVersion: telemetry.istio.io/v1alpha1
kind: Telemetry
metadata:
  name: otel-tracing
spec:
  tracing:
  - providers:
    - name: test-otel-res-detectors
    randomSamplingPercentage: 100.0
    customTags:
      "provider":
        literal:

 * limitations under the License.
 */

package org.gradle.api.internal.file

import org.gradle.api.Task
import org.gradle.api.file.FileSystemLocation
import org.gradle.api.internal.provider.PropertySpec
import org.gradle.api.internal.provider.Providers
import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider
import org.junit.Rule

abstract class FileSystemPropertySpec<T extends FileSystemLocation> extends PropertySpec<T> {

import org.gradle.api.Incubating;
import org.gradle.api.file.ConfigurableFileCollection;
import org.gradle.api.file.FileCollection;
import org.gradle.api.internal.provider.Providers;
import org.gradle.api.model.ObjectFactory;
import org.gradle.api.provider.ListProperty;
import org.gradle.api.provider.Property;
import org.gradle.api.tasks.IgnoreEmptyDirectories;
import org.gradle.api.tasks.Input;
import org.gradle.api.tasks.InputFiles;