def srcDir = new File(testDir, "srcdir")
    def configurationMock = TestFiles.fixed(new File("classpath"))
    def tool = Mock(JavadocToolAdapter)

    Javadoc task

    def setup() {
        task = TestUtil.createTask(Javadoc, project, "javadoc")
        task.setClasspath(configurationMock)
        task.setDestinationDir(destDir)
        task.source(srcDir)

        FileUtils.touch(new File(srcDir, "file.java"))

import org.gradle.api.tasks.bundling.AbstractArchiveTaskTest
import org.gradle.test.fixtures.archive.JarTestFixture

class JarTest extends AbstractArchiveTaskTest {
    Jar jar

    def setup() {
        jar = createTask(Jar)
        configure(jar)
    }

    @Override
    AbstractArchiveTask getArchiveTask() {
        jar
    }

    def "test Jar"() {
        expect:

    def platform = Mock(NativePlatformInternal)
    def platformToolChain = Mock(PlatformToolProvider)
    Compiler<CppPCHCompileSpec> cppPCHCompiler = Mock(Compiler)

    def setup() {
        cppPCHCompile = TestUtil.createTask(CppPreCompiledHeaderCompile, project)
    }

    def "executes using the Cpp PCH Compiler"() {
        def sourceFile = temporaryFolder.createFile("sourceFile")
        def result = Mock(WorkResult)
        when:

    private ProjectInternal project = TestUtil.create(tmpDir).rootProject()
    private ProjectDetails projectDetails = ProjectDetails.of(project)

    def setup() throws Exception {
        task = TestUtil.createTask(TestReportTask.class, project)
        task.setGenerator(generator)
        task.setRenderer(renderer)
        task.setProjects(WrapUtil.<Project>toSet(project))
    }

    def completesRendererAtEndOfGeneration() {

    def platformToolChain = Mock(PlatformToolProvider)
    Compiler<CppCompileSpec> cppCompiler = Mock(Compiler)
    def pch = Mock(PreCompiledHeader)

    def setup() {
        cppCompile = TestUtil.createTask(CppCompile, project)
    }

    def "executes using the CppCompiler"() {
        def sourceFile = temporaryFolder.createFile("sourceFile")
        def result = Mock(WorkResult)
        when:

import org.gradle.util.TestUtil

class DependencyInsightReportTaskSpec extends AbstractProjectBuilderSpec {
    DependencyInsightReportTask task

    def setup() {
        task = TestUtil.createTask(DependencyInsightReportTask, project)
    }

    def "fails if configuration missing"() {
        when:
        task.report()

        then:
        thrown(InvalidUserDataException)
    }

class ProjectReportTaskTest extends AbstractProjectBuilderSpec {
    ProjectReportTask task
    final TestStyledTextOutput output = new TestStyledTextOutput().ignoreStyle()

    def setup() {
        task = TestUtil.createTask(ProjectReportTask, project)
        task.renderer.output = output
    }

    def rendersReportForRootProjectWithChildren() {
        project.description = 'this is the root project'

import static org.gradle.api.internal.file.TestFiles.fileSystem

class DeleteTest extends AbstractConventionTaskTest {
    private Delete delete

    def setup() {
        delete = createTask(Delete)
    }

    ConventionTask getTask() {
        return delete
    }

    def "deletes nothing by default"() {
        expect:
        delete.getDelete().isEmpty()
    }

    private DependencyReportRenderer renderer = Mock(DependencyReportRenderer)
    private Configuration conf1
    private Configuration conf2

    def setup() {
        task = TestUtil.createTask(DependencyReportTask.class, project)
        conf1 = project.configurations.create("conf1")
        conf2 = project.configurations.create("conf2")
        task.renderer = renderer
    }

    def platformToolChain = Mock(PlatformToolProvider)
    Compiler<CCompileSpec> cCompiler = Mock(Compiler)
    def pch = Mock(PreCompiledHeader)

    def setup() {
        cCompile = TestUtil.createTask(CCompile, project)
    }

    def "executes using the C Compiler"() {
        def sourceFile = temporaryFolder.createFile("sourceFile")
        def result = Mock(WorkResult)

        when: