*
     * @return a dependency factory
     * @implSpec Do not implement this method. Gradle generates the implementation automatically.
     *
     * @see DependencyFactory
     */
    @Inject
    DependencyFactory getDependencyFactory();

    /**
     * A dependency constraint factory is used to convert supported dependency notations into {@link DependencyConstraint} instances.
     *

 *
 * @param dependencyNotation dependency to add
 * @see DependencyFactory.create
 * @since 8.6
 */
operator fun DependencyCollector.invoke(dependencyNotation: CharSequence) = add(dependencyNotation)


/**
 * Add a dependency.
 *
 * @param dependencyNotation dependency to add
 * @param configuration an action to configure the dependency
 * @see DependencyFactory.create
 * @since 8.6
 */

public class DependencyConstraintNotationParser {

    public static DependencyConstraintNotationParser parser(Instantiator instantiator, DefaultProjectDependencyFactory dependencyFactory, Interner<String> stringInterner, ImmutableAttributesFactory attributesFactory) {

        classLoaderScopeRegistry: ClassLoaderScopeRegistry,
        dependencyFactory: DependencyFactoryInternal,
    ) =

        KotlinScriptClassPathProvider(
            moduleRegistry,
            classPathRegistry,
            classLoaderScopeRegistry.coreAndPluginsScope,
            gradleApiJarsProviderFor(dependencyFactory),
        )

    @Provides
    fun createPluginRequestsHandler(

import java.util.Map;

public class DependencyNotationParser {
    public static DependencyNotationParser create(Instantiator instantiator,
                                                  DefaultProjectDependencyFactory dependencyFactory,
                                                  ClassPathRegistry classPathRegistry,
                                                  FileCollectionFactory fileCollectionFactory,

    private
    val cachedClassLoaderClassPath = ClassLoaderClassPathCache()
}


internal
fun gradleApiJarsProviderFor(dependencyFactory: DependencyFactoryInternal): JarsProvider =
    { (dependencyFactory.gradleApi() as FileCollectionDependency).files.files }


private
val gradleApiNotation = DependencyFactoryInternal.ClassPathNotation.GRADLE_API


private

        delegate.findProperty(propertyName)

    override fun getDependencies(): DependencyHandler =
        delegate.dependencies

    override fun getDependencyFactory(): DependencyFactory =
        delegate.dependencyFactory

    override fun getResources(): ResourceHandler =
        delegate.resources

    override fun setDefaultTasks(defaultTasks: MutableList<String>) {

        @Override
        public ObjectFactory getObjectFactory() {
            return services.get(ObjectFactory.class);
        }

        @Override
        public DependencyFactory getDependencyFactory() {
            return services.get(DependencyFactory.class);
        }
    }

    private static class DefaultArtifactPublicationServices implements ArtifactPublicationServices {

                continue;
            }
            if (platformSupport.isTargetingPlatform(dependency)) {
                dependencyFactory.convertImportDependencyConstraint(dependency, platforms::add);
            } else {
                dependencyFactory.convertDependency(dependency, dependencies::add);
            }
        }

    RepositoryHandler repositoryHandlerMock = Stub(RepositoryHandler)
    DependencyHandler dependencyHandlerMock = Stub(DependencyHandler)
    DependencyFactory dependencyFactoryMock = Stub(DependencyFactory)
    ComponentMetadataHandler moduleHandlerMock = Stub(ComponentMetadataHandler)
    ScriptHandlerInternal scriptHandlerMock = Mock(ScriptHandlerInternal)