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

        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']))

        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)

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

                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'

        def relative = new ExternalResourceName("a/b/c")
        def sameRelative = new ExternalResourceName("a/b/c")

        expect:
        name Matchers.strictlyEqual(same)
        name Matchers.strictlyEqual(samePath)
        relative Matchers.strictlyEqual(sameRelative)
        name != differentPath
        name != differentRoot
        name != relative
    }

    def "can resolve an absolute path"() {