IdeExtendedRepoFileDependency ideRepoFileDependency = new IdeExtendedRepoFileDependency();
            ideRepoFileDependency.setId(DefaultModuleVersionIdentifier.newId(moduleId.getModuleIdentifier(), moduleId.getVersion()));
            externalDependencies.add(ideRepoFileDependency);
        }

        return externalDependencies;
    }

class RenderableDependencyResultTest extends Specification {

    def "renders name"() {
        given:
        def requested = newSelector(DefaultModuleIdentifier.newId('org.mockito', 'mockito-core'), new DefaultMutableVersionConstraint('1.0'))
        def same = newModule('org.mockito', 'mockito-core', '1.0')
        def differentVersion = newModule('org.mockito', 'mockito-core', '2.0')

//	    defer task.End()
//	    trace.WithRegion(ctx, "remainingWork", remainingWork)
//	}()
func NewTask(pctx context.Context, taskType string) (ctx context.Context, task *Task) {
	pid := fromContext(pctx).id
	id := newID()
	userTaskCreate(id, pid, taskType)
	s := &Task{id: id}
	return context.WithValue(pctx, traceContextKey{}, s), s

	// We allocate a new task even when
	// the tracing is disabled because the context and task

        boolean transitive = externalModuleDependency.isTransitive();

        ModuleComponentSelector selector = DefaultModuleComponentSelector.newSelector(
            DefaultModuleIdentifier.newId(nullToEmpty(dependency.getGroup()), nullToEmpty(dependency.getName())),
            ((VersionConstraintInternal) externalModuleDependency.getVersionConstraint()).asImmutable(),
            dependency.getAttributes(),

        IvyResolver publisher = ((DefaultIvyArtifactRepository) repository).createPublisher();
        ModuleComponentIdentifier moduleVersionIdentifier = DefaultModuleComponentIdentifier.newId(publication.getCoordinates());

        for (IvyArtifact artifact : publication.getAllArtifacts()) {

        return this;
    }

    @Override
    public void notFound(ModuleComponentIdentifier versionIdentifier) {
        failed(new ModuleVersionNotFoundException(DefaultModuleVersionIdentifier.newId(versionIdentifier), getAttempted()));
    }

    @Override
    public void resolved(ComponentGraphResolveState state, ComponentGraphSpecificResolveState graphState) {
        this.state = state;

import static org.gradle.util.AttributeTestUtil.attributesFactory

class ModuleComponentSelectorSerializerTest extends SerializerSpec {
    private final static ModuleIdentifier UTIL = DefaultModuleIdentifier.newId("org", "util")

    private serializer = new ModuleComponentSelectorSerializer(new DesugaredAttributeContainerSerializer(attributesFactory(), TestUtil.objectInstantiator()))

    def "serializes"() {
        when:

    // It's only there for backwards compatibility with the Nebula plugin
    public DefaultModuleVersionSelector(String group, String name, String version) {
        this(DefaultModuleIdentifier.newId(group, name), version);
    }

    @Override
    public String getGroup() {
        return module.getGroup();
    }

    @Override
    public String getName() {
        return module.getName();
    }

class ModuleForcingResolveRuleSpec extends Specification {

    private static ModuleIdentifier mid(String group, String name) {
        DefaultModuleIdentifier.newId(group, name)
    }

    def "forces modules"() {
        given:
        def details = Mock(DependencySubstitutionInternal)

        when:
        new ModuleForcingResolveRule([

    }

    @Override
    public ModuleIdentifier getModule() {
        String group = projectDependency.getGroup();
        return DefaultModuleIdentifier.newId(group != null ? group : "", projectDependency.getName());
    }

    @Override
    public void setForce(boolean force) {
        validateMutation();
        this.force = force;
    }

    @Override