path == ModelPath.ROOT.child("a").child("b").child("c")
    }

    def "equals and hashcode"() {
        def p1 = ModelPath.path("a")

        expect:
        Matchers.strictlyEquals(p1, ModelPath.path("a"))
        p1 != ModelPath.path(("b"))
        p1 != ModelPath.path(("abc"))
        p1 != ModelPath.path(("a.b"))
        p1 != p1.parent
        p1 != p1.child("b")
    }

 * 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:

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

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

 * 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"() {

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")

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

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

    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:

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

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

        def extra = DefaultClassPath.of(file1, file2, file3)
        def different = DefaultClassPath.of(file3)

        expect:
        cp Matchers.strictlyEqual(same)
        cp Matchers.strictlyEqual(sameWithDuplicates)
        cp != differentOrder
        cp != missing
        cp != extra
        cp != different
    }