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

            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"

    }

    def "can get by name and namespace" () {
        given:
        def extraInfo = new DefaultIvyExtraInfo([
                (new NamespaceId('http://my.extra.info', 'foo')): 'fooValue',
                (new NamespaceId('http://some.extra.info', 'foo')): 'anotherValue'
        ])

        expect:

            System.out.println("Some test output from ${testClassName}.testOne - " + i);
            System.err.println("Some test error  from ${testClassName}.testOne - " + i);
        }
        assertEquals(production.getProperty(), "value");
    }

    @Test
    public void testTwo() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("Some test output from ${testClassName}.testTwo - " + i);

            it.put("a.class", "bytes".bytes)
            it.put("dir/b.class", "bytes".bytes)
            it.put("some/dir/c.class", "bytes".bytes)
        }

        then:
        def zip = new ZipTestFixture(file)
        zip.hasDescendants("a.class", "dir/b.class", "some/dir/c.class")
        zip.hasDirs("dir", "some", "some/dir")
    }

    def "overrides previously constructed jar"() {
        def file = tmpDir.file("thing.zip")

        where:
        endpoint << ['http://some', 'httP://some', 'httpS://some', 'HTTpS://some']
    }

    def "should default invalid disableAuthentication parameter"() {
        expect:
        new GcsConnectionProperties("http://some", null, value).requiresAuthentication()
        then:
        where:
        value << ['foo', 'true-ish', 'false-y', '1']