then:
        Matchers.strictlyEquals(spec11.toKey(), spec11.toKey())
        Matchers.strictlyEquals(spec11.toKey(), spec11Impl1.toKey())
        Matchers.strictlyEquals(spec11Vendor1.toKey(), spec11Vendor1.toKey())
        !Matchers.strictlyEquals(spec11Vendor1.toKey(), spec11Vendor2.toKey())
        !Matchers.strictlyEquals(spec11.toKey(), spec12.toKey())
        Matchers.strictlyEquals(spec11Impl1.toKey(), spec11Impl1.toKey())

import org.gradle.api.artifacts.component.ComponentIdentifier
import org.gradle.api.internal.artifacts.dsl.dependencies.DependencyFactoryInternal
import spock.lang.Specification

import static org.gradle.util.Matchers.strictlyEquals

class OpaqueComponentIdentifierTest extends Specification {
    def "is instantiated with non-null constructor parameter value"() {
        when:

        def scopeAndType = ModelReference.of(String).inScope(ModelPath.path("scope"))

        Matchers.strictlyEquals(path, ModelReference.of("path"))
        Matchers.strictlyEquals(type, ModelReference.of(String))
        Matchers.strictlyEquals(pathAndType, ModelReference.of("path", String))
        Matchers.strictlyEquals(scopeAndType, type.inScope(ModelPath.path("scope")))

        path != type
        path != pathAndType

import static org.gradle.api.internal.initialization.ClassLoaderIds.testTaskClasspath
import static org.gradle.util.Matchers.strictlyEquals

class ClassLoaderIdsTest extends Specification {

    def "equality"() {
        expect:
        strictlyEquals(buildScript("x", "x"), buildScript("x", "x"))
        buildScript("x", "x") != buildScript("x", "y")
        buildScript("x", "x") != buildScript("y", "y")

        path(':a:b:').getPath() == ':a:b'
    }

    def "equals and hashCode"() {
        expect:
        strictlyEquals(Path.ROOT, Path.ROOT)
        strictlyEquals(path('path'), path('path'))
        strictlyEquals(path(':a:path'), path(':a:path'))
        !strictlyEquals(path(':a'), path(':b'))
        !strictlyEquals(path(':a'), path('a'))
    }

    def "can get parent"() {
        expect:

        def superType = new ModelType<List<? extends Number>>() {}.typeVariables[0]

        Matchers.strictlyEquals(type, same)
        Matchers.strictlyEquals(wildcard, extendsObject)
        Matchers.strictlyEquals(parameterized, sameParameterized)
        type != wildcard
        type != parameterized
        type != extendsObject
        type != notWildcard

        def n1 = factory.named(Named, "a")
        def n2 = factory.named(Named, "b")

        n1.is(n1)
        !n1.is(n2)

        n1.name == "a"
        n2.name == "b"

        Matchers.strictlyEquals(n1, n1)
        n2 != n1
        !n2.equals(n1)

        n1.hashCode() == n1.hashCode()
        n1.hashCode() != n2.hashCode()

        n1.toString() == "a"
        n2.toString() == "b"

 * limitations under the License.
 */

package org.gradle.internal.dispatch

import spock.lang.Specification

import static org.gradle.util.Matchers.strictlyEquals

class ProxyDispatchAdapterTest extends Specification {
    private final Dispatch<MethodInvocation> dispatch = Mock()

        expect:
        strictlyEquals(new PatternSet(), new PatternSet())
        strictlyEquals(new PatternSet(caseSensitive: false), new PatternSet(caseSensitive: false))
        strictlyEquals(new PatternSet(includes: ['i']), new PatternSet(includes: ['i']))
        strictlyEquals(new PatternSet(excludes: ['e']), new PatternSet(excludes: ['e']))

import org.gradle.api.artifacts.ModuleIdentifier
import org.gradle.api.internal.artifacts.DefaultModuleIdentifier
import spock.lang.Specification

import static org.gradle.util.Matchers.strictlyEquals

class MavenUniqueSnapshotComponentIdentifierTest extends Specification {
    private ModuleIdentifier moduleIdentifier = DefaultModuleIdentifier.newId("group", "module")

    def "delegates module version to owner"() {