class DisallowBuildSrcAsNameIntegTest extends AbstractIntegrationSpec {

    def "fails when trying to include buildSrc as project"() {
        buildFile << """
            task t
        """
        settingsFile << """
            include 'buildSrc'
        """

        when:
        fails "t"

        then:

            """
        }

        when:
        configurationCacheRun 'tasks', '-I', initScript.absolutePath

        then:
        outputContains 'foo!'
        configurationCache.assertStateStored()
        problems.assertResultHasProblems(result) {
            withInput("Initialization script 'initscript.gradle': file 'input.txt'")
        }

        when:
        buildLogicInput.text = 'bar!'

        and:

    }

    def "executable is unavailable when not found in system path"() {
        def visitor = Mock(DiagnosticsVisitor)

        given:
        os.getExecutableName("cc") >> "cc.bin"
        os.path >> []

        when:
        def result = registry.locate(ToolType.C_COMPILER, "cc")

        then:
        !result.available

        when:
        result.explain(visitor)

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

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

        mainSourceFile.text = sourceFileWithGreeting("Hello World!")

        when:
        runWithWatchingEnabled("run")
        then:
        outputContains "Hello World!"
        executedAndNotSkipped ":compileJava", ":classes", ":run"

        when:
        mainSourceFile.text = sourceFileWithGreeting("Hello VFS!")
        waitForChangesToBePickedUp()

    def "applies Java plugin"() {
        when:
        project.pluginManager.apply(JavaLibraryPlugin)

        then:
        project.plugins.findPlugin(JavaPlugin)
    }

    def "adds configurations to the project"() {
        given:
        project.pluginManager.apply(JavaLibraryPlugin)

        when:
        def api = project.configurations.getByName(JvmConstants.API_CONFIGURATION_NAME)