DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId(group, name), version)
    }

    protected static ModuleComponentSelector moduleId(String group, String name, String version) {
        DefaultModuleComponentSelector.newSelector(DefaultModuleIdentifier.newId(group, name), new DefaultMutableVersionConstraint(version))
    }

    }

    private static ModuleComponentIdentifier id(String notation) {
        String[] parts = notation.split(':')
        DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId(parts[0], parts[1]), parts[2])
    }

    def "fails for invalid filter #filters"() {
        when:
        LockEntryFilterFactory.forParameter(filters, "Update lock", true)

        then:

    }

    def "cannot get id when resolve failed"() {
        org.gradle.internal.Factory<String> broken = { "too bad" }
        def failure = new ModuleVersionResolveException(newSelector(DefaultModuleIdentifier.newId("a", "b"), "c"), broken)

        when:
        result.failed(failure)
        result.moduleVersionId

        then:
        ModuleVersionResolveException e = thrown()
        e == failure
    }

        when:
        substitutions.ruleAction.execute(moduleDetails)

        then:
        _ * moduleDetails.requested >> DefaultModuleComponentSelector.newSelector(DefaultModuleIdentifier.newId("org.utils", "api"), new DefaultMutableVersionConstraint("1.5"))
        1 * action.execute(moduleDetails)
        0 * _

        def projectDetails = Mock(DependencySubstitutionInternal)

        when:

    }

    private DefaultMutableIvyModuleResolveMetadata ivyMetadata() {
        def module = DefaultModuleIdentifier.newId("group", "module")
        def metadata = ivyMetadataFactory.create(DefaultModuleComponentIdentifier.newId(module, "version"), [])
        metadata.status = "integration"
        metadata.statusScheme = ["integration", "release"]
        return metadata
    }

    }

    def "is equal when all attributes and module version are the same"() {
        def moduleVersion = DefaultModuleVersionIdentifier.newId("group", "module", "version")
        def componentId = DefaultModuleComponentIdentifier.newId(moduleVersion)

        def withClassifier = localArtifactIdentifier(componentId, "name", "type", "ext", 'classifier')

        MavenArtifact pomArtifact,
        MavenArtifact mainArtifact,
        Set<MavenArtifact> allArtifacts
    ) {
        this.name = name;
        this.coordinates = DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId(projectIdentity.getGroupId().get(), projectIdentity.getArtifactId().get()), projectIdentity.getVersion().get());
        this.packaging = packaging;
        this.pomArtifact = pomArtifact;

			t.Error(err)
			continue
		}
		err = Rewrite(tf, m, newID)
		err2 := tf.Close()
		if err != nil {
			t.Errorf("Rewrite(%s): %v", f, err)
			continue
		}
		if err2 != nil {
			t.Fatal(err2)
		}

		id, err = ReadFile(tmp)
		if id != newID || err != nil {
			t.Errorf("ReadFile(%s after Rewrite) = %q, %v, want %q, nil", f, id, err, newID)
		}

		// Test an ELF PT_NOTE segment with an Align field of 0.

                        newTestResult.addTestClassResult(classResult);
                    } else {
                        long newId = newIdCounter.incrementAndGet();
                        newTestResult = new OverlaidIdProxyingTestClassResult(newId, classResult);
                        aggregatedTestResults.put(classResult.getClassName(), newTestResult);
                    }

    }

    public MutableIvyModuleResolveMetadata build() {
        ModuleRevisionId moduleRevisionId = ivyDescriptor.getModuleRevisionId();
        ModuleComponentIdentifier cid = DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId(moduleRevisionId.getOrganisation(), moduleRevisionId.getName()), moduleRevisionId.getRevision());
        List<Configuration> configurations = converter.extractConfigurations(ivyDescriptor);