*/
    Property<String> getBaseName();

    /**
     * Defines the source files or directories of this component. You can add files or directories to this collection. When a directory is added, all source files are included for compilation.
     *
     * <p>When this collection is empty, the directory {@code src/main/cpp} is used by default.</p>

            require(sourceDirs.isNotEmpty()) {
                "Expected source directories but got none"
            }

            val subprojectSourcePath = "org/gradle/StartParameter.java"
            val subprojectFound = sourceDirs.find { it.resolve(subprojectSourcePath).isFile }
            require(subprojectFound != null) {
                "Source directories do not contain subproject file '${'$'}subprojectSourcePath'. Searched in:\n  " +

            .with { line ->
                def matcher = line =~ /Watched directory hierarchies: \[(.*)]/
                String directories = matcher[0][1]
                return (directories.empty
                    ? []
                    : directories.split(', ').collect { new File(it) }
                ) as Set
            }

        assert watchedHierarchies == (expected as Set)
    }

/**
 * <p>Marks a property as specifying one or more output directories for a task.</p>
 *
 * <p>This annotation should be attached to the getter method in Java or the property in Groovy.
 * Annotations on setters or just the field in Java are ignored.</p>
 *
 * <p>This will cause the task to be considered out-of-date when the directory paths or task
 * output to those directories have been modified since the task was last run.</p>
 *

    }
}
// end::set-input-files[]

// tag::add-input-files[]
compile {
    // Add some source directories use String paths
    source 'src/main/java', 'src/main/groovy'

    // Add a source directory using a File object
    source file('../shared/java')

    // Add some source directories using a closure
    source { file('src/test/').listFiles() }
}

# Build something so that the cache gets populates
go build main.go

# Check that cache contains directories before running
exists $GOCACHE/00

# Run go clean -cache -n and ensure that directories weren't deleted
go clean -cache -n
exists $GOCACHE/00

# Re-run go clean cache without the -n flag go ensure that directories were properly removed
go clean -cache
! exists $GOCACHE/00

! go clean -cache .

manage.bat(sh) => 23 (generate):
A execution command of Generate task
which generates classes corresponding your tables,
for example, entities, condition-beans to specified
directories by DBFlute properties on "dfprop" directory.

Generated structures (directories and classes) are like this:
/- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
allcommon : classes bridging to DBFlute Runtime
bsbhv     : base behaviors

        given:
        def supplier = new CurrentInstallationSupplier()

        when:
        def directories = supplier.get()

        then:
        directories.size() == 1
        directories[0].location == Jvm.current().javaHome
        directories[0].source == "Current JVM"
    }

	}
	return true, nil
}

func TestRemoveAllOneFilesystem(t *testing.T) {
	tests := []struct {
		name string
		// Items of the test directory. Directories end with "/".
		// Directories starting with "mount" are considered to be mount points.
		// Directories starting with "err" will cause an error in
		// IsLikelyNotMountPoint.
		items       []string
		expectError bool
	}{
		{
			"empty dir",
			[]string{},

internal
fun File.walkReproducibly(): Sequence<File> = sequence {

    require(isDirectory)

    yield(this@walkReproducibly)

    var directories: List<File> = listOf(this@walkReproducibly)
    while (directories.isNotEmpty()) {
        val subDirectories = mutableListOf<File>()
        directories.forEach { dir ->
            dir.listFilesOrdered().partition { it.isDirectory }.let { (childDirectories, childFiles) ->