}

    @Override
    ComponentIdResolveResult resolve(VersionSelector allRejects) {
        def result = new DefaultBuildableComponentIdResolveResult()
        result.resolved(projectId, DefaultModuleVersionIdentifier.newId("org", projectId.projectName, VERSION))
        return result
    }

    @Override
    ComponentIdResolveResult resolvePrefer(VersionSelector allRejects) {
        return null
    }

    @Override

import spock.lang.Specification

import static org.gradle.util.Matchers.strictlyEquals

class MavenUniqueSnapshotComponentIdentifierTest extends Specification {
    private ModuleIdentifier moduleIdentifier = DefaultModuleIdentifier.newId("group", "module")

    def "delegates module version to owner"() {
        def id = new MavenUniqueSnapshotComponentIdentifier(moduleIdentifier, version, "timestamp")

        expect:
        id.group == "group"

    val id = identities.getId(reference)
    if (id != null) {
        writeSmallInt(id)
    } else {
        val newId = identities.putInstance(reference)
        writeSmallInt(newId)
        circularReferences.enter(reference)
        try {
            encode(reference)
        } finally {
            circularReferences.leave(reference)
        }
    }

    def rules = []
    ComponentSelectionInternal componentSelection
    def metadataProvider = Mock(MetadataProvider)

    def setup() {
        def componentIdentifier = DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId("group", "module"), "version")
        componentSelection = new DefaultComponentSelection(componentIdentifier, metadataProvider)
    }

    def "all non-rejecting rules are evaluated"() {

    def 'converts a ModuleComponentIdentifier to a lock notation'() {
        given:
        def converter = new DependencyLockingNotationConverter()
        def module = new DefaultModuleComponentIdentifier(DefaultModuleIdentifier.newId('org', 'foo'), '1.1')

        when:
        def converted = converter.convertToLockNotation(module)

        then:
        converted == 'org:foo:1.1'
    }

        when:
        def componentIdentifier = componentIdentifierFactory.createComponentIdentifier(module)

        then:
        componentIdentifier == new DefaultModuleComponentIdentifier(DefaultModuleIdentifier.newId('some-group', 'some-name'), '1.0')
    }

            String libraryName = GUtil.elvis(libraryComponentSelector.getLibraryName(), "");
            return DefaultModuleVersionSelector.newSelector(DefaultModuleIdentifier.newId(libraryComponentSelector.getProjectPath(), libraryName), "undefined");
        }
        throw new GradleException("Unrecognized component selector: " + selector);
    }

    private AttributeContainer attributes = ImmutableAttributes.EMPTY;

    public AbstractDependencyImpl(String group, String name, String version) {
        this.moduleIdentifier = DefaultModuleIdentifier.newId(group, name);
        this.versionConstraint = new DefaultMutableVersionConstraint(version);
    }

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

    @Override

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

        return externalDependencies;
    }

//	    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