* It is also available via {@link org.gradle.api.Project#getProviders()} and {@link Settings#getProviders()}.
 *
 * @since 4.0
 */
@NonExtensible
@ServiceScope(Scope.Build.class)
public interface ProviderFactory {

    /**
     * Creates a {@link Provider} whose value is calculated using the given {@link Callable}.
     *

        given:
        def cacheDir = newCacheDirProvider([jdk] as Set)
        def providerFactory = Mock(ProviderFactory)
        providerFactory.gradleProperty("org.gradle.java.installations.auto-detect") >> Providers.ofNullable("false")
        providerFactory.gradleProperty("org.gradle.java.installations.auto-download") >> Providers.ofNullable("true")

        when:
        provisioningService.tryInstall(spec)

        then:
        1 * downloader.download(DOWNLOAD.getUri(), new File(temporaryFolder, ARCHIVE_NAME), _)
    }

    ProviderFactory createProviderFactory(String propertyValue) {
        return Mock(ProviderFactory) {

    @Inject
    public ProviderBackedToolchainConfiguration(ProviderFactory providerFactory) {
        this(providerFactory, SystemProperties.getInstance());
    }

    ProviderBackedToolchainConfiguration(ProviderFactory providerFactory, SystemProperties systemProperties) {
        this.providerFactory = providerFactory;
        this.systemProperties = systemProperties;
    }

    @Override

    private final ObjectFactory objectFactory;
    private final ProviderFactory providerFactory;
    private final InstanceGenerator instanceGenerator;
    private final ProjectInternal project;

    @Inject
    public DefaultJvmPluginServices(ObjectFactory objectFactory,
                                    ProviderFactory providerFactory,
                                    InstanceGenerator instanceGenerator,

    private final AuthenticationSupporter authenticationSupporter;

    private final ProviderFactory providerFactory;

    @Inject
    public DefaultJavaToolchainRepository(
            String name,
            AuthenticationContainer authenticationContainer,
            AuthenticationSupporter authenticationSupporter,
            ProviderFactory providerFactory
    ) {
        this.name = name;

    private final ProviderFactory providerFactory;
    private final ProjectInternal project;
    private final InstanceGenerator instanceGenerator;
    private final Map<ConfigurationInternal, Set<TaskProvider<?>>> configurationToCompileTasks; // ? is really AbstractCompile & HasCompileOptions

    @Inject
    public DefaultJvmLanguageUtilities(
            ProviderFactory providerFactory,

        this.providerFactory = providerFactory
    }

    @TaskAction
    void doTaskAction() {
        var outputDirectory = providerFactory.provider { "build/my-file.txt" }
        println(outputDirectory.get())
    }
}

tasks.register("myInjectedProviderFactoryTask",MyProviderFactoryTask) {}
// end::provider-factory-inject[]

// tag::worker-executor[]

tasks.register("printMessage") {
    doLast {
        val providerFactory = project.providers
        val messageProvider = providerFactory.provider { "Hello, Gradle!" }
        println(messageProvider.get())
    }
}
// end::provider-factory[]

// tag::provider-factory-inject[]
abstract class MyProviderFactoryTask
@Inject constructor(private var providerFactory: ProviderFactory) : DefaultTask() {

    @TaskAction

    private final ProviderFactory providerFactory;
    private final Provider<String> toolchainLocation;
    private final XPathFactory xPathFactory;
    private final DocumentBuilderFactory documentBuilderFactory;
    private final FileResolver fileResolver;

    @Inject
    public MavenToolchainsInstallationSupplier(ProviderFactory factory, FileResolver fileResolver) {