import spock.lang.Specification

import static org.gradle.api.internal.provider.ProviderTestUtil.withNoValue
import static org.gradle.api.internal.provider.ProviderTestUtil.withValues
import static org.gradle.util.Matchers.strictlyEquals

class DefaultProjectLayoutTest extends Specification {
    @Rule
    TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())
    TestFile projectDir
    DefaultProjectLayout layout

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

        def impl2 = proxyClass.newInstance(state2, typeConverter)

        then:
        Matchers.strictlyEquals(impl1, sameState)
        Matchers.strictlyEquals(impl1, sameStateDifferentType)
        !impl1.equals(impl2)
    }

    def "Two views are equal when their state objects are equal"() {
        def state1 = Mock(GeneratedViewState)

    }

    def "equality"() {
        given:
        def c = {String foo -> }
        def a1 = action(c)

        expect:
        Matchers.strictlyEquals(a1, action(c))
        a1 == action(c)
        a1 != action({String bar -> })
        a1 != new ClosureBackedRuleAction(Integer.class, { Integer val -> })
    }

    RuleAction<String> action(Closure<?> c) {

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

import static com.google.common.collect.Iterables.concat
import static com.google.common.collect.Sets.newHashSet
import static org.gradle.util.Matchers.strictlyEquals
import static org.gradle.util.internal.WrapUtil.toSet

class DefaultResolvedDependencySpec extends Specification {private BuildOperationExecutor buildOperationProcessor = new TestBuildOperationExecutor()

    def init() {

        // Note: buildTime is null when running a local build
        version.buildTimestamp == null || version.buildTimestamp.endsWith("UTC")
    }

    def equalsAndHashCode() {
        expect:
        Matchers.strictlyEquals(GradleVersion.version('0.9'), GradleVersion.version('0.9'))
        GradleVersion.version('0.9') != GradleVersion.version('1.0')
    }

    def canConstructVersionFromString(String version) {
        expect:

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