when:
        succeeds "scaladoc" // intentionally non-qualified

        then:
        executedAndNotSkipped scaladoc
        file(docsPath).assertContainsDescendants("House.html", "Other.html", "Person.html")
        file("utils/$docsPath").assertContainsDescendants("City.html")
    }

    def "can exclude classes from Scaladoc generation"() {
        classes.baseline()
        buildScript(classes.buildScript())

                into 'libs'
                from configurations.conf
            }
        """.stripIndent()

        when:
        succeeds('resolve')

        then:
        file('libs').assertContainsDescendants('nifi-smb-nar-1.12.0.nar')
    }

    def 'resolve maven module with valid custom packaging artifact - applies java plugin'() {
        given:
        buildFile.text = '''plugins {
            id 'java'

        withScalaSources()

        expect:
        succeeds("assertZincVersion", "compileScala")
        output.contains("Compiling with Zinc Scala compiler")
        scalaClassFile("compile/test").assertContainsDescendants(
            "Person.class",
            "Person2.class"
        )
    }

    def withScalaSources() {
        file("src/main/scala/compile/test/Person.scala") <<
            """
package compile.test

    def versionIsCopiedAndExists(lib, version, root="") {
        assert TextUtil.normaliseFileSeparators(output).contains("ivy-repo/org.gradle.test/${lib}/${version}/${lib}-${version}.jar")
        testDirectory.assertContainsDescendants("${root}build/copies/${lib}-${version}.jar")
        true
    }

    def resolveTask = "resolveAndCopy"

    def taskWhichPublishes(lib, version) {
        return """
            publishing {

        then:
        generated.name == "test.${extension}"
        generated.parentFile == pchSourceDir
        generated.text == "#include \"test.h\""
        pchSourceDir.assertContainsDescendants("test.h", "test.${extension}")

        where:
        type              | extension
        CPCHCompileSpec   | "c"
        CppPCHCompileSpec | "cpp"
    }

            outputs.recompiledClasses('renamed-sum')
        } else {
            outputs.recompiledClasses('greeter', 'renamed-sum', 'main')
        }

        outputDirectory.assertContainsDescendants(expectedIntermediateDescendants(app.alternate))
        installation("build/install/main/debug").exec().out == app.expectedAlternateOutput
    }

    def "removes stale object files for library"() {

     * Asserts that this is a directory and contains the given set of descendant files (and possibly other files). Ignores directories that are not empty.
     */
    public TestFile assertContainsDescendants(String... descendants) {
        return assertContainsDescendants(Arrays.asList(descendants));
    }

    public TestFile assertIsEmptyDir() {
        assertHasDescendants();
        return this;
    }

            def outputDirectories = file(pchHeaderDirName).listFiles().findAll { it.isDirectory() }
            assert outputDirectories.size() == 1
            outputDirectories[0].assertContainsDescendants("prefix-headers.${getSuffix()}")
        }
        true
    }

    def pchNotCompiled(String lib="hello", String linkage="shared", String sourceSet=app.sourceType) {

        !downloadedLibsDir.isDirectory()

        when:
        moduleA.pom.expectGet()
        moduleA.artifact.expectGet()
        succeeds('resolve')

        then:
        downloadedLibsDir.assertContainsDescendants('a-1.0.jar')
    }

    def "skips subsequent dependency resolution if HTTP connection exceeds timeout, and only prints original cause once"() {
        given:

                from tarTree('v7.tar')
                into 'dest'
            }
        """

        when:
        succeeds("copy")

        then:
        file("dest").assertContainsDescendants("file.txt", "sub/subfile.txt")
    }

    def cannotCreateAnEmptyZip() {
        given:
        buildFile << '''
            task zip(type: Zip) {
                from 'test'