def "validate name"() {
        when:
        ModelPath.validateName("")

        then:
        def e = thrown(ModelPath.InvalidNameException)
        e.message =~ "empty string"

        when:
        ModelPath.validateName("ü")

        then:
        e = thrown(ModelPath.InvalidNameException)
        e.message =~ "first character"

        when:
        ModelPath.validateName(" ")

        def fileInWatchableHierarchies = file("first/inside/root/dir/file.txt")
        def fileOutsideOfWatchableHierarchies = file("forth").file("someFile.txt")

        when:
        registerWatchableHierarchies(watchableHierarchies)
        then:
        0 * _

        when:
        fileInWatchableHierarchies.createFile()
        addSnapshot(snapshotRegularFile(fileInWatchableHierarchies))
        then:

        server.start()

        when:
        def a = server.uri("a")
        def b = server.uri("b")

        then:
        a.scheme == "http"
        b.scheme == "http"
        a.toURL().text == "hi"
        b.toURL().text == "hi"

        when:
        server.stop()

        then:
        noExceptionThrown()
    }

    def "succeeds when expected serial requests are made"() {
        given:

        when:
        createInstance(extractedB)

        then:
        def e = thrown(Exception)
        e.cause.cause instanceof UnsupportedOperationException

        when:
        extractedA.STATIC_IN_A()

        then:
        thrown(UnsupportedOperationException)

        when:
        extractedB.STATIC_IN_B()

        then:

        then:
        1 * delegate.stop()
        0 * _._
    }

    def 'does nothing on end of processing when no tests received'() {
        expect:
        processor.stop()
    }

    def 'does nothing on end of processing when on nth test'() {
        when:
        processor.startProcessing(resultProcessor)
        processor.processTestClass(test1)
        processor.processTestClass(test2)

    }

    def "should have no content when downloaded file has no content"() {
        when:
        downloadedFile.text = ""
        underTest = new DownloadedUriTextResource("Test description", sourceUri, "", downloadedFile, resolver)

        then:
        underTest.getHasEmptyContent()
    }

    def "should have content when downloaded file has content"() {
        when:
        downloadedFile.text = "Some content"

        when:
        cacheConfigurations.createdResources.setRemoveUnusedEntriesAfterDays(0)

        then:
        thrown(IllegalArgumentException)

        when:
        cacheConfigurations.downloadedResources.setRemoveUnusedEntriesAfterDays(0)

        then:
        thrown(IllegalArgumentException)

        when:

            )
        }

        when:
        configurationCacheRun ":jar", "-Dcreator=creator1"

        then:
        assertCreatedBy 'creator1'
        assertStateStored()

        when:
        configurationCacheRun ":jar", "-Dcreator=creator2"

        then:
        assertCreatedBy 'creator2'
        assertStateLoaded()

        when:
        manifestFile.delete()

        def property = propertyWithDefaultValue(String)

        when:
        def p = property.map(transformer)

        then:
        !p.present
        0 * _

        when:
        property.set("123")
        p.present

        then:
        1 * transformer.transform("123") >> "present"
        0 * _

        when:
        def r = p.get()

        then:
        r == "321"

class ToolingParameterProxyTest extends Specification {

    def "returns parameter valid when well defined"() {
        when:
        ToolingParameterProxy.validateParameter(ValidParameter)

        then:
        noExceptionThrown()
    }

    def "returns parameter invalid when not a getter or setter"() {
        when:
        ToolingParameterProxy.validateParameter(InvalidParameter1)

        then: