"bin",
                kotlinFilesIn(srcDir),
                loggerFor<ProjectAccessorsClassPathTest>(),
                classPath.asFiles
            )
        )
    }

    private
    fun kotlinFilesIn(srcDir: File) =
        srcDir.walkTopDown().filter { it.isFile && it.extension == "kt" }.toList()

    private

        destDir = project.file("destDir")
        depCacheDir = project.file("depCache")
        srcDir = project.file("src")
        srcDir.mkdirs()

        scalaCompile = createTask(ScalaCompile)
        scalaCompile.setCompiler(scalaCompiler)

        FileUtils.touch(new File(srcDir, "incl/file.scala"))
        FileUtils.touch(new File(srcDir, "incl/file.java"))
    }

    def "default values"() {
        given:

		// Don't require the source files to be present.
		if abs, err := filepath.Abs(srcDir); err == nil { // see issue 14282
			srcDir = abs
		}
		var bp *build.Package
		bp, err = build.Import(path, srcDir, build.FindOnly|build.AllowBinary)
		if bp.PkgObj == "" {
			if bp.Goroot && bp.Dir != "" {
				filename, err = lookupGorootExport(bp.Dir)
				if err == nil {
					_, err = os.Stat(filename)
				}

                    source.srcDir "src/main/comp-a"
                }
                compB(LibrarySourceSet) {
                    source.srcDir "src/main/comp-b"
                }
            }
            binaries {
                bin(SampleBinary) {
                    sources {
                        binaryA(LibrarySourceSet) {
                            source.srcDir "src/main/binary-a"
                        }

// tag::c-sources[]
            sources {
                c {
                    source {
                        srcDir "src/source"
                        include "**/*.c"
                    }
                    exportedHeaders {
                        srcDir "src/include"
                    }
                }
            }
// end::c-sources[]
        }
        main(NativeExecutableSpec) {

        when:
        set.srcDir 'dir1'
        set.srcDir 'dir2'

        then:
        assertSetContainsForAllTypes(set, 'subdir/file1.txt')
    }

    void failsWhenSourceDirectoryIsNotADirectory() {
        File srcDir = new File(testDir, 'dir1')
        touch(srcDir)

        when:
        set.srcDir 'dir1'
        set.addToAntBuilder("node", "fileset")

    /**
     * Compiles generated Java source files.
     *
     * @param srcDir where the compiler will output the sources
     * @param dstDir where the compiler will output the class files
     * @param classes the classes to compile
     * @param classPath the classpath to use for compilation
     */

tasks.whenTaskAdded { task ->
    task.ext.srcDir = 'src/main/java'
}

tasks.register('a')

tasks.whenTaskAdded {
    extra["srcDir"] = "src/main/java"
}

val a by tasks.registering

    # This sets up the environment, like GOCACHE, which keeps the worktree cleaner.
    kube::golang::setup_env

    _tmpdir="$(kube::realpath "$(mktemp -d -t "verify-generated-$(basename "$1").XXXXXX")")"
    git worktree add -f -q "${_tmpdir}" HEAD
    kube::util::trap_add "git worktree remove -f ${_tmpdir}" EXIT
    cd "${_tmpdir}"

    # Update generated files.
    "$@"

    # Test for diffs
    diffs=$(git status --porcelain | wc -l)