expect:
        id.getOriginalFileName() == "original"
        id.getFileName() == "current"
        id.getDisplayName() == "original -> current (foo)"
    }

    def "equals and hash code differentiate between same and different instances"() {
        def componentId = newComponentId("foo")

        when:
        def id = new TransformedComponentFileArtifactIdentifier(componentId, "a", "b")

        given:
        def sha1 = "abcd"*10
        def md = new DefaultExternalResourceMetaData(new URI("scheme:thing"), -1, -1, null, null, HashCode.fromString(sha1))

        expect:
        md.sha1.equals(HashCode.fromString(sha1))
    }

        def metadata = new PublishArtifactLocalArtifactMetadata(componentId, publishArtifact)

        expect:
        metadata.getDisplayName() == "name-1234.jar (foo:foo:foo)"
    }

    def "equals and hash code differentiate between same and different instances"() {
        when:

class DefaultToolchainSpecTest extends Specification {
    JavaToolchainSpec createSpec() {
        TestUtil.objectFactory().newInstance(DefaultToolchainSpec)
    }

    def "spec key implements equals"() {
        given:
        def spec11 = createSpec()
        def spec12 = createSpec()
        def spec11Vendor1 = createSpec()
        def spec11Vendor2 = createSpec()
        def spec11Impl1 = createSpec()

        key(hex).asLong == decimal
        key(decimal).asHex == hex

        where:
        hex        | decimal
        "AAAAAAAA" | 2863311530
        "DA124B92" | 3658632082
    }

    def "equals impl"() {
        expect:
        key("AAAAAAAA") == key(2863311530)
    }

    def "comparison"() {
        expect:
        key("00000000") < key("00000001")
        key("00000001") > key("00000000")
    }

        classLoader.visit(visitor)

        then:
        1 * visitor.visitSpec({it instanceof CachingClassLoader.Spec})
        1 * visitor.visitParent(parent)
        0 * visitor._
    }

    def "equals and hashcode"() {
        def c1 = new URLClassLoader()
        def c2 = new URLClassLoader()

        expect:
        new CachingClassLoader(c1) == new CachingClassLoader(c1)

                @Test
                public void testFoo() {
                    Class1 c = new Class1();
                    assertTrue(c.isFoo("foo"));
                }

                public boolean equals(Object arg) { return java.lang.Boolean.valueOf(true); }
            }
            """
    }

                (new NamespaceId('http://my.extra.info', 'bar')): 'barValue'
        ])

        when:
        extraInfo.get('foo')

        then:
        def e = thrown(InvalidUserDataException)
        e.message.equals('Cannot get extra info element named \'foo\' by name since elements with this name were found from multiple namespaces (http://my.extra.info, http://some.extra.info).  Use get(String namespace, String name) instead.')
    }

import org.gradle.plugins.ide.eclipse.model.internal.DefaultResourceFilterMatcher
import spock.lang.Specification

public class ResourceFilterMatcherTest extends Specification {
    def "ResourceFilterMatcher equals and hashCode satisfies contract"() {
        when:
        EqualsVerifier.forClass(DefaultResourceFilterMatcher.class)
                .suppress(Warning.NONFINAL_FIELDS)

import spock.lang.Specification

class PathTest extends Specification {
    def "paths are equal when they have the same canonical url"() {
        expect:
        Matchers.strictlyEquals(new Path('file://$ROOT_DIR$/file'), new Path('file://$ROOT_DIR$/file'))
        new Path('file://$ROOT_DIR$/file') != new Path('file://$ROOT_DIR$/other')
    }

    def "equals honors subclasses"() {
        expect: