}

    def "equality"() {
        expect:
        new DefaultPluginId("foo") Matchers.strictlyEqual(new DefaultPluginId("foo"))
        new DefaultPluginId("foo.bar") Matchers.strictlyEqual(new DefaultPluginId("foo.bar"))
        def qualified = new DefaultPluginId("foo").withNamespace("some.org")
        qualified Matchers.strictlyEqual(new DefaultPluginId("some.org.foo"))
        new DefaultPluginId("foo") != new DefaultPluginId("foo.bar")

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

import spock.lang.Specification

import static org.gradle.util.Matchers.strictlyEqual

class DefaultModuleIdentifierSpec extends Specification {

    def "has useful toString()"() {
        def module = DefaultModuleIdentifier.newId("org.foo", "bar")

        expect:

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

import spock.lang.Specification

import static org.gradle.util.Matchers.strictlyEqual

class DefaultModuleVersionIdentifierSpec extends Specification {
    def "has useful toString()"() {
        def module = new DefaultModuleVersionIdentifier("group", "module", "version")

        expect:

 * limitations under the License.
 */
package org.gradle.internal.dispatch

import spock.lang.Specification

import static org.gradle.util.Matchers.strictlyEqual
import static org.hamcrest.MatcherAssert.assertThat

class MethodInvocationTest extends Specification {

    def "equality"() {

    }

    @Test
    public void hasWellBehavedEqualsAndHashCode() {
        assertThat(new RelativePath(true), strictlyEqual(new RelativePath(true)));
        assertThat(new RelativePath(true, "one"), strictlyEqual(new RelativePath(true, "one")));
        assertThat(new RelativePath(false, "one", "two"), strictlyEqual(new RelativePath(false, "one", "two")));

        expect:
        artifact Matchers.strictlyEqual(equalArtifact)
        artifact Matchers.strictlyEqual(differentModule)
        artifact != differentId
    }

    def dep(String group, String moduleName, String version) {
        new DefaultModuleVersionIdentifier(group, moduleName, version)

        expect:
        withClassifier Matchers.strictlyEqual(same)
        withClassifier != differentName
        withClassifier != differentType
        withClassifier != differentExt
        withClassifier != differentAttributes
        withClassifier != emptyParts
        withClassifier != differentFile

        emptyParts Matchers.strictlyEqual(emptyPartsSame)
        emptyParts != withClassifier
    }

        def differentCandidates = new MultiChoiceAddress(id, 1234, [address2])
        def differentCanonical = new MultiChoiceAddress(otherId, 1234, [address1])

        expect:
        address Matchers.strictlyEqual(same)
        address != differentCandidates
        address != differentPort
        address != differentCanonical
    }

import spock.lang.Subject

import static org.gradle.util.Matchers.strictlyEqual

class VersionParserTest extends Specification {

    @Subject
    VersionParser versionParser = new VersionParser()

    def "parsed version is equal when source string is equal"() {
        def v = parse("1.2.b")
        def equal = parse("1.2.b")

        expect:
        v strictlyEqual(equal)
        v != parse("1.2.c")
        v != parse("1.2")

    void "knows if is equal"() {
        expect:
        assertThat(new DefaultProjectDependency(project, true),
            strictlyEqual(new DefaultProjectDependency(project, true)))

        assertThat(new DefaultProjectDependency(project, "conf1", false, TestFiles.taskDependencyFactory()),
            strictlyEqual(new DefaultProjectDependency(project, "conf1", false, TestFiles.taskDependencyFactory())))

        when: