file 'java'
            }
        }

        expect:
        def jvm = new Jvm(os, installDir, "1.8.0", 8)
        def jvm2 = new Jvm(os, installDir, "1.8.0", 8)
        Matchers.strictlyEquals(jvm, jvm2)
    }

    def "Returns current JVM when located using Java home dir"() {
        expect:
        def current = Jvm.current()
        def jvm = Jvm.forHome(current.javaHome)

        def equal = adapter.adapt(TestModel.class, protocolModel1)
        def different = adapter.adapt(TestModel.class, protocolModel2)

        expect:
        Matchers.strictlyEquals(model, equal)
        model != different
    }

    def methodInvocationOnModelDelegatesToTheProtocolModelObject() {
        TestProtocolModel protocolModel = Mock()
        _ * protocolModel.getName() >> 'name'

    }

    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:

    }

    @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:
        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)