* <p>
 * <b>Note:</b> This interface is not intended for implementation by build script or plugin authors.
 * </p>
 *
 * @since 7.6
 */
@HasInternalProtocol
@NonExtensible
@Incubating
public interface DependencyFactory {
    /**
     * Create an {@link ExternalModuleDependency} from the <code>"<i>group</i>:<i>name</i>:<i>version</i>:<i>classifier</i>@<i>extension</i>"</code> notation.
     *
     * <p>

    def currentProject = Mock(Project)

    DependencyFactoryInternal dependencyFactory
    JvmComponentDependencies dependencies

    def setup() {
        dependencyFactory = Mock(DependencyFactoryInternal) {
            createDependency(_) >> { it[0] }
        }

        def of = TestUtil.createTestServices {
            it.add(DependencyFactoryInternal, dependencyFactory)
            it.add(Project, currentProject)

         */
        public ExternalPluginResolution(DependencyFactory dependencyFactory, PluginRequestInternal pluginRequest, boolean useWeakVersion) {
            this.dependencyFactory = dependencyFactory;
            this.pluginRequest = pluginRequest;
            this.useWeakVersion = useWeakVersion;
        }

        @Override
        public PluginId getPluginId() {

    private final org.gradle.api.artifacts.ClientModule clientModule;
    private final DependencyFactoryInternal dependencyFactory;

    public ModuleFactoryDelegate(org.gradle.api.artifacts.ClientModule clientModule, DependencyFactoryInternal dependencyFactory) {
        this.clientModule = clientModule;
        this.dependencyFactory = dependencyFactory;
    }

    @SuppressWarnings("rawtypes")

import java.util.List;

public abstract class DefaultDependencyCollector implements DependencyCollector {
    private final DependencyFactoryInternal dependencyFactory;

    @Inject
    public DefaultDependencyCollector(DependencyFactoryInternal dependencyFactory) {
        this.dependencyFactory = dependencyFactory;
        this.getDependencies().finalizeValueOnRead();
        this.getDependencyConstraints().finalizeValueOnRead();
    }

    @Nested

            protected DependencyHandler getDependencyHandler() {
                return dependencyFactory
            }
        }
    }

    def "can add implementation dependency"() {
        def dep = Stub(Dependency)

        when:
        dependencies.implementation("a:b:c")

        then:
        1 * dependencyFactory.create("a:b:c") >> dep
        1 * deps.add(dep)
    }

            @Override
            protected DependencyHandler getDependencyHandler() {
                return dependencyFactory
            }
        }
    }

    def "can add api dependency"() {
        def dep = Stub(Dependency)

        when:
        dependencies.api("a:b:c")

        then:
        1 * dependencyFactory.create("a:b:c") >> dep
        1 * deps.add(dep)
    }

 */

package org.gradle.api.testing.toolchains.internal;

import com.google.common.collect.ImmutableSet;
import org.gradle.api.artifacts.Dependency;
import org.gradle.api.artifacts.dsl.DependencyFactory;
import org.gradle.api.internal.tasks.testing.TestFramework;
import org.gradle.api.internal.tasks.testing.filter.DefaultTestFilter;
import org.gradle.api.internal.tasks.testing.junit.JUnitTestFramework;

public class VersionCatalogView implements VersionCatalog {

    private final DefaultVersionCatalog config;
    private final ProviderFactory providerFactory;

    private final ExternalModuleDependencyFactory dependencyFactory;
    private final BundleFactory bundleFactory;

    public VersionCatalogView(
        DefaultVersionCatalog config,
        ProviderFactory providerFactory,
        ObjectFactory objects,

 * limitations under the License.
 */
package org.gradle.api.internal.artifacts;

import org.gradle.api.artifacts.ConfigurationContainer;
import org.gradle.api.artifacts.dsl.DependencyFactory;
import org.gradle.api.artifacts.dsl.DependencyHandler;
import org.gradle.api.artifacts.dsl.DependencyLockingHandler;
import org.gradle.api.artifacts.dsl.RepositoryHandler;
import org.gradle.api.attributes.AttributesSchema;