}

    def "analyze good code"() {
        goodCode()

        expect:
        succeeds('check')
        file("build/reports/checkstyle/main.sarif").assertDoesNotExist()
        file("build/reports/checkstyle/test.sarif").assertDoesNotExist()
        file("build/reports/checkstyle/main.xml").assertContents(containsClass("org.gradle.Class1"))

        contentsDir.file('src/wrapper-main/org/gradle/wrapper/GradleWrapperMain.java').assertIsFile()

        // Samples
        contentsDir.file('samples').assertDoesNotExist()

        assertDocsExist(contentsDir, version)
    }

        and:
        run 'retrieve'

        then:
        file('libs').assertDoesNotExist()

        when:
        server.resetExpectations()
        run 'retrieve'

        then: // Uses cached artifacts
        file('libs').assertDoesNotExist()
    }

            .withScheme('Hello')
            .succeeds(XcodebuildExecutor.XcodeAction.CLEAN)

        then:
        exe("app/build/exe/main/debug/App").assertDoesNotExist()
        sharedLib("hello/build/lib/main/debug/Hello").assertDoesNotExist()
        sharedLib("log/build/lib/main/debug/Log").assertExists()
    }

    @ToBeFixedForConfigurationCache

        executer.usingProjectDirectory(file("buildSrc"))
        then:
        succeeds("jar")
        file("buildSrc/.gradle").assertIsDir()
        executer.gradleUserHomeDir.file(BuildScopeCacheDir.UNDEFINED_BUILD).assertDoesNotExist()
    }

    def "treats empty buildSrc as undefined build"() {
        given:
        file("buildSrc").createDir()

        expect:
        executer.usingProjectDirectory(file("buildSrc"))

    def jarsNotBuilt(String... projects) {
        projects.each {
            file("${it}/build/libs/${it}.jar").assertDoesNotExist()
        }
    }

    def depsCopied(String project, Collection<String> deps) {
        def depsDir = file("${project}/deps")
        if (deps.isEmpty()) {
            depsDir.assertDoesNotExist()
        } else {
            String[] depJars = deps.collect {
                "${it}.jar"

        libDir.assertIsDir()
        libDir.file(os.getExecutableName(script.name)).assertIsFile()
        this
    }

    NativeInstallationFixture assertNotInstalled() {
        installDir.assertDoesNotExist()
        this
    }

    NativeInstallationFixture assertIncludesLibraries(String... names) {
        def expected = names.collect { os.getSharedLibraryName(it) } as Set

model {
    components {
        main(NativeExecutableSpec)
    }
}
"""

        when:
        succeeds "mainExecutable"

        then:
        executable("build/binaries/mainExecutable/main").assertDoesNotExist()
    }

    @ToBeFixedForConfigurationCache
    def "assemble task constructs all buildable binaries"() {
        given:
        new CHelloWorldApp().writeSources(file("src/main"))

        and:

        when:
        succeeds("javadoc")
        then:
        file("test/build/docs/javadoc/test/test/Test.html").assertExists()
        file("test/build/docs/javadoc/test/test/internal/TestInternal.html").assertDoesNotExist()
    }

    @Issue("https://github.com/gradle/gradle/issues/21399")
    def "can build javadoc from modularized java with -module-source-path specified"() {

        testBuildFile << """

        expect:
        succeeds "compileDebug"
        result.assertTasksExecuted(":compileDebugSwift", ":compileDebug")
        objectFiles(lib)*.assertExists()
        staticLibrary("build/lib/main/debug/Foo").assertDoesNotExist()
    }