def provider2 = Mock(ProviderInternal)
        def provider3 = Mock(ProviderInternal)

        given:
        _ * provider1.type >> type
        _ * provider1.calculateValue(_) >> ValueSupplier.Value.of(a)
        _ * provider1.present >> true
        _ * provider2.type >> type
        _ * provider2.calculateValue(_) >> ValueSupplier.Value.of(b)
        _ * provider2.present >> true

        given:
        def provider1 = registerService("one", ServiceImpl)
        def provider2 = registerService("two", StoppableServiceImpl)
        def provider3 = registerService("three", StoppableServiceImpl)

        when:
        def notStoppable = provider1.get()
        def stoppable1 = provider2.get()
        def stoppable2 = provider3.get()

        then:

     *
     * @param provider The provider whose value should be used when this provider has no value.
     * @since 5.6
     */
    Provider<T> orElse(Provider<? extends T> provider);

    /**
     * Deprecated. There is no need to use this method.
     *
     * @since 6.5
     * @deprecated Since version 7.4 this method does nothing. All providers can be used at configuration time without explicit opt-in.

// are cloud provider dependent. It uses the API to listen to new events on resources.

package main

// NOTE: Importing all in-tree cloud-providers is not required when
// implementing an out-of-tree cloud-provider. Leaving this empty file
// here as a reference.

// Here is how you would inject a cloud provider, first

var (
	ErrNotImplemented     = errors.New("function not implemented")
	ErrAccessTokenExpired = errors.New("access_token expired or unauthorized")
)

// Provider implements identity provider specific admin operations, such as
// looking up users, fetching additional attributes etc.
type Provider interface {
	LoginWithUser(username, password string) error
	LoginWithClientID(clientID, clientSecret string) error
	LookupUser(userid string) (User, error)

import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

/**
 * Can be used on a static method to provide a bean.
 */
@Target(METHOD)
@Retention(RUNTIME)
@Documented

}

/**
 * While the main declaration provider created via [createDeclarationProvider] is scope-based, there are other declaration providers which
 * are not, such as file-based declaration providers. Not all declarations provided by such declaration providers can be provided by the
 * main declaration provider, even if the correct scope is provided (such as a file-based scope). For example, the main declaration provider

Method <org.gradle.api.tasks.Sync.getPreserve()> does not have raw return type assignable to org.gradle.api.provider.Provider in (Sync.java:0)
Method <org.gradle.api.tasks.Sync.getRootSpec()> does not have raw return type assignable to org.gradle.api.provider.Provider in (Sync.java:0)
Method <org.gradle.api.tasks.Sync.getRootSpec()> does not have raw return type assignable to org.gradle.api.provider.Provider in (Sync.java:0)

class DefaultClassPathRegistryTest extends Specification {
    final ClassPathProvider provider1 = Mock()
    final ClassPathProvider provider2 = Mock()
    final DefaultClassPathRegistry registry = new DefaultClassPathRegistry(provider1, provider2)

    def "fails for unknown classpath"() {
        given:
        provider1.findClassPath(_) >> null
        provider2.findClassPath(_) >> null

        when:
        registry.getClassPath("name")

** If it's a new property, expose it as a link:{javadocPath}/org/gradle/api/provider/Property.html[Property] or link:{javadocPath}/org/gradle/api/provider/Provider.html[Provider] using a single getter.
** If it's incubating, change it to use a link:{javadocPath}/org/gradle/api/provider/Property.html[Property] or link:{javadocPath}/org/gradle/api/provider/Provider.html[Provider] using a single getter.