</thead>
            <tr>
                <td>toolChain</td>
            </tr>
            <tr>
                <td>targetPlatform</td>
            </tr>
            <tr>
                <td>outputDir</td>
            </tr>
            <tr>
                <td>source</td>
            </tr>
            <tr>
                <td>includes</td>
            </tr>
            <tr>
                <td>macros</td>

        given:
        Task a = task("a", type: AsyncWithOutputDirectory)
        _ * a.outputDirectory >> file("outputDir")
        Task b = task("b", type: AsyncWithOutputDirectory)
        _ * b.outputDirectory >> file("outputDir").file("outputSubdir").file("output")

        expect:
        tasksAreNotExecutedInParallel(a, b)
    }

            while (true) {
                val (timestamp, event) = poll() ?: break
                write(timestamp, event)
            }
        }
    }

    private
    val outputFile by lazy {
        outputDir().let { logDir ->
            cleanupLogDirectory(logDir)
            logDir.resolve("resolver-${timestampForFileName()}.log")
        }
    }

    private
    fun bufferedAppendWriter() =

                    }
                }
            }
        """

        when:
        succeeds 'resolveDependencyArtifacts'

        then:
        def outputDir = temporaryFolder.testDirectory.file(outputDirPath)
        def jarFiles = outputDir.listFiles()
        jarFiles.size() == 2
        def gradleApiJar = jarFiles.find { it.name.startsWith('gradle-api-') }

        module.testResourceFolders == customTestResourceFolders
        module.generatedSourceFolders == customGeneratedSourceFolders
        module.excludeFolders == customExcludeFolders
        module.outputDir == path('file://$MODULE_DIR$/out')
        module.testOutputDir == path('file://$MODULE_DIR$/outTest')
        (module.dependencies as List) == customDependencies
    }

    @Override
    public void visitOutputs(File workspace, OutputVisitor visitor) {
        File outputDir = getOutputDir(workspace);
        File resultsFile = getResultsFile(workspace);
        visitor.visitOutputProperty(OUTPUT_DIRECTORY_PROPERTY_NAME, DIRECTORY,
            OutputFileValueSupplier.fromStatic(outputDir, fileCollectionFactory.fixed(outputDir)));
        visitor.visitOutputProperty(RESULTS_FILE_PROPERTY_NAME, FILE,

    }

    def "generates -s option"() {
        def outputDir = new File("build/generated-sources")
        spec.compileOptions.annotationProcessorGeneratedSourcesDirectory = outputDir

        expect:
        builder.build() == ["-g", "-sourcepath", "", "-proc:none", "-s", outputDir.path, USE_UNSHARED_COMPILER_TABLE_OPTION, "-classpath", ""]
    }

            def outputDir = layout.buildDirectory.dir(providers.provider { childDirName })
            println "src dir 1: " + srcDir.get()
            println "output dir 1: " + outputDir.get()
            buildDir = "output/some-dir"
            childDirName = "other-child"
            println "src dir 2: " + srcDir.get()
            println "output dir 2: " + outputDir.get()
"""

        when:

        when:
        builder.create(target).generate()

        then:
        assertOutputFile("""$COMMON_START
 */

// Add some thing
foo.bar {
    e1 {
    }
}

foo.bar {
    e2 {
    }
}

prop = foo.bar.e1
prop2 = foo.bar.e2.outputDir
""")
    }

        buildFile << """
            @CacheableTask
            class CustomTask extends DefaultTask {
                @OutputDirectory File outputDir = new File(temporaryDir, 'output')
                @TaskAction
                void generate() {
                    new File(outputDir, "output").text = "OK"
                }
            }

            task cacheable(type: CustomTask)
        """