import org.gradle.api.model.ObjectFactory;
import org.gradle.api.provider.ProviderFactory;

public class DefaultExternalDependencyFactory extends AbstractExternalDependencyFactory {

    public DefaultExternalDependencyFactory(
        DefaultVersionCatalog config,
        ProviderFactory providers,
        ObjectFactory objects,
        ImmutableAttributesFactory attributesFactory,

                                          ChecksumService checksumService,
                                          ProviderFactory providerFactory,
                                          VersionParser versionParser
    ) {
        super(instantiatorFactory.decorateLenient(), authenticationContainer, objectFactory, providerFactory, versionParser);
        this.describer = describer;
        this.fileResolver = fileResolver;

        MavenPublicationCoordinates coordinates = pom.getCoordinates();
        coordinates.getGroupId().convention(providerFactory.provider(module::getGroup));
        coordinates.getArtifactId().convention(providerFactory.provider(module::getName));
        coordinates.getVersion().convention(providerFactory.provider(module::getVersion));
    }

    @Override
    public abstract Property<SoftwareComponentInternal> getComponent();

import org.gradle.api.file.ProjectLayout
import org.gradle.api.internal.artifacts.configurations.RoleBasedConfigurationContainerInternal
import org.gradle.api.model.ObjectFactory
import org.gradle.api.provider.ProviderFactory
import org.gradle.integtests.fixtures.AbstractIntegrationSpec
import org.gradle.internal.execution.ExecutionEngine
import org.gradle.process.ExecOperations

import javax.inject.Inject

        Deleter deleter = services.get(Deleter.class);
        DocumentationRegistry documentationRegistry = services.get(DocumentationRegistry.class);
        ProviderFactory providers = services.get(ProviderFactory.class);
        TaskDependencyFactory taskDependencyFactory = services.get(TaskDependencyFactory.class);
        DecompressionCoordinator decompressionCoordinator = services.get(DecompressionCoordinator.class);

import org.gradle.api.internal.catalog.DefaultVersionCatalog;
import org.gradle.api.model.ObjectFactory;
import org.gradle.api.provider.Provider;
import org.gradle.api.provider.ProviderFactory;

import javax.inject.Inject;
import java.util.function.Supplier;

public class DefaultVersionCatalogPluginExtension implements CatalogExtensionInternal {

                return TestUtil.providerFactory().provider { TestUtil.providerFactory().provider { null } } as Provider<Provider<Provider<NestedType>>>
            }
            @TestNested
            Provider<Provider<?>> getNestedGenericProvider() {
                return TestUtil.providerFactory().provider { null } as Provider<Provider<?>>
            }
        }
        def visitor = new TestInstanceMetadataVisitor()

        when:

    }

    static DomainObjectCollectionFactory domainObjectCollectionFactory() {
        return services().get(DomainObjectCollectionFactory)
    }

    static ProviderFactory providerFactory() {
        return services().get(ProviderFactory)
    }

    static TaskDependencyFactory taskDependencyFactory() {
        return services().get(TaskDependencyFactory)
    }

 * limitations under the License.
 */

package gradlebuild.integrationtests.ide

import org.gradle.api.file.DirectoryProperty
import org.gradle.api.provider.Provider
import org.gradle.api.provider.ProviderFactory
import org.gradle.api.tasks.InputFiles
import org.gradle.api.tasks.Internal
import org.gradle.api.tasks.Nested
import org.gradle.api.tasks.Optional
import org.gradle.api.tasks.PathSensitive

        CollectionCallbackActionDecorator collectionCallbackActionDecorator,
        VersionMappingStrategyInternal versionMappingStrategy,
        TaskDependencyFactory taskDependencyFactory,
        ProviderFactory providerFactory
    ) {
        this.name = name;
        this.publicationCoordinates = publicationCoordinates;
        this.immutableAttributesFactory = immutableAttributesFactory;