def differentName = topLevel.child("other")
        def differentParent = differentName.child("child")

        Matchers.strictlyEquals(topLevel, sameTopLevel)
        Matchers.strictlyEquals(child, sameChild)
        topLevel != differentProject
        child != differentName
        child != differentParent
    }

import org.gradle.util.Path
import spock.lang.Specification

import static org.gradle.internal.component.local.model.TestComponentIdentifiers.newSelector
import static org.gradle.util.Matchers.strictlyEquals

class DefaultProjectComponentSelectorTest extends Specification {

    def "is instantiated with non-null constructor parameter values"() {
        when:

import org.gradle.api.internal.artifacts.DefaultModuleIdentifier
import org.gradle.internal.component.external.model.DefaultModuleComponentIdentifier
import spock.lang.Specification

import static org.gradle.util.Matchers.strictlyEquals

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

            }
        };
    }

    @Factory
    public static <T> Matcher<T> strictlyEqual(final T other) {
        return new BaseMatcher<T>() {
            @Override
            public boolean matches(Object o) {
                return strictlyEquals(o, other);
            }

            @Override
            public void describeTo(Description description) {

        action.inputTypes.empty
    }

    def "equality"() {
        def baseAction = {String val -> } as Action<String>
        def noInputsAction = ruleAction(baseAction)

        expect:
        Matchers.strictlyEquals(noInputsAction, ruleAction(baseAction))
        noInputsAction != ruleAction({String val -> } as Action<String>)
    }

    RuleAction<String> ruleAction(Action<String> action) {

        def sameId = new OpaqueComponentArtifactIdentifier(new File("one"))
        def differentId = new OpaqueComponentArtifactIdentifier(new File("two"))

        expect:
        Matchers.strictlyEquals(id, sameId)
        id != differentId
    }

        def differentComponent = new ComponentFileArtifactIdentifier(otherId, "one")
        def differentName = new ComponentFileArtifactIdentifier(componentId, "two")

        expect:
        Matchers.strictlyEquals(id, sameId)
        id != differentComponent
        id != differentName
    }

import org.gradle.util.Matchers
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:

        def id = new DefaultBuildIdentifier(Path.path(":one"))
        def same = new DefaultBuildIdentifier(Path.path(":one"))
        def different = new DefaultBuildIdentifier(Path.path(":two"))

        Matchers.strictlyEquals(id, same)
        id != different
    }

import org.gradle.api.internal.attributes.ImmutableAttributes
import spock.lang.Specification

import static org.gradle.internal.component.local.model.TestComponentIdentifiers.newProjectId
import static org.gradle.util.Matchers.strictlyEquals
import static org.gradle.util.AttributeTestUtil.attributes

class DefaultModuleComponentSelectorTest extends Specification {
    private static ImmutableVersionConstraint v(String version) {