- devicePath: /dev/disk/by-id/some-random-clusterb9772-pvc-c2435a06-14d7-11e7-9baf-42010a800049
    name: kubernetes.io/pd/some-random-clusterb9772-pvc-c2435a06-14d7-11e7-9baf-42010a800049
  - devicePath: /dev/disk/by-id/some-random-clusterb9772-pvc-8bf50554-fd42-11e6-94d4-42010a800049
    name: kubernetes.io/pd/some-random-clusterb9772-pvc-8bf50554-fd42-11e6-94d4-42010a800049

			meshConfig: &meshconfig.MeshConfig{
				TrustDomain:        "cluster.local",
				TrustDomainAliases: []string{"alias-1.domain", "some-other-alias-1.domain", "alias-2.domain"},
			},
			want: []string{"cluster.local", "alias-1.domain", "some-other-alias-1.domain", "alias-2.domain"},
		},
		{
			name:       "Empty mesh config",
			meshConfig: &meshconfig.MeshConfig{},
			want:       []string{},
		},

        def failure = new UnknownModelException("not found")

        given:
        _ * workerThreadRegistry.workerThread >> true
        1 * modelController.locateBuilderForDefaultTarget('some.model', false) >> modelScope
        1 * modelScope.getModel("some.model", null) >> { throw failure }

        when:
        controller.getModel(null, modelId)

        then:
        InternalUnsupportedModelException e = thrown()

        reference.untyped
        reference.state == ModelNode.State.GraphClosed
    }

    def "path only"() {
        expect:
        def reference = ModelReference.of("some.path")
        reference.scope == null
        reference.path == ModelPath.path("some.path")
        reference.type == ModelType.of(Object)
        reference.untyped
        reference.state == ModelNode.State.GraphClosed
    }

    def "type only"() {

            assert event.descriptor.displayName == 'some build'
            assert event.descriptor.parent == null
        }
    }

    def "convert to BuildStartEvent"() {
        given:
        def listener = Mock(ProgressListener)
        def adapter = createAdapter(listener)

        when:
        def buildDesc = buildDescriptor(666, 'some build')

            val casted = closureExtension as groovy.lang.Closure<*>
            println(casted.call("some"))
            """
        )

        build("help").apply {
            assertOutputContains("closureExtension: java.lang.Object")
            assertOutputContains("SOME")
        }
    }

    @Test
    fun `accessors to __untyped__ kotlin lambda extensions are typed Any`() {

        where:
        commonPrefix | firstPostFix | secondPostFix
        "some"      | "path"            | "other/some"
        "some"      | "pather/one"      | "path/two/three"
        "some/path" | "one"             | "two/three"
        ""          | "one"             | "two/three"
        ""          | "oner"            | "one"
        "some/path" | "with/one/ending" | "without/two/different"
    }

        cacheLayout.name == 'modules'
        cacheLayout.key == 'modules-2'
        cacheLayout.version == CacheVersion.of(2)
        cacheLayout.version.toString() == '2'
        cacheLayout.getPath(new File('some/dir')) == new File('some/dir/modules-2')
        !cacheLayout.versionMapping.getVersionUsedBy(GradleVersion.version("1.8")).present
        cacheLayout.versionMapping.getVersionUsedBy(GradleVersion.version("1.9-rc-1")).get() == CacheVersion.of(1)

        withExtension("/some/path/to/foo", ".bar") == "/some/path/to/foo.bar"
        withExtension("foo.baz", ".bar") == "foo.bar"
        withExtension("/some/path/to/foo.baz", ".bar") == "/some/path/to/foo.bar"
        withExtension("\\some\\path\\to\\foo.baz", ".bar") == "\\some\\path\\to\\foo.bar"
        withExtension("/some/path/to/foo.boo.baz", ".bar") == "/some/path/to/foo.boo.bar"

    with pytest.raises(WebSocketDisconnect):
        with client.websocket_connect("/items/bar/ws?token=some-token") as websocket:
            message = "Message one"
            websocket.send_text(message)
            data = websocket.receive_text()
            assert data == "Session cookie or query token value is: some-token"
            data = websocket.receive_text()