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

                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'

 * 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:

        expect:
        withClassifier Matchers.strictlyEqual(same)
        withClassifier != differentName
        withClassifier != differentType
        withClassifier != differentExt
        withClassifier != differentAttributes
        withClassifier != emptyParts
        withClassifier != differentFile

        emptyParts Matchers.strictlyEqual(emptyPartsSame)
        emptyParts != withClassifier
    }