when:
        def dirs = set.sourceDirectories
        set.srcDir 'dir1'

        then:
        dirs.files == [testDir.file('dir1')] as Set

        when:
        set.srcDir 'dir2'

        then:
        dirs.files == [testDir.file('dir1'), testDir.file('dir2')] as Set

        when:
        set.srcDirs = []

        then:
        dirs.files.empty
    }

func ReadDir(name string) ([]DirEntry, error) {
	f, err := openDir(name)
	if err != nil {
		return nil, err
	}
	defer f.Close()

	dirs, err := f.ReadDir(-1)
	slices.SortFunc(dirs, func(a, b DirEntry) int {
		return bytealg.CompareString(a.Name(), b.Name())
	})
	return dirs, err
}

// CopyFS copies the file system fsys into the directory dir,
// creating dir if necessary.
//

 *
 *     //and some extra test source dirs
 *     testSources.from(file('some-extra-test-dir'))
 *
 *     //and some extra resource dirs
 *     resourceDirs += file('some-extra-resource-dir')
 *
 *     //and some extra test resource dirs
 *     testResources.from(file('some-extra-test-resource-dir'))
 *
 *     //and hint to mark some of existing source dirs as generated sources

/**
 * IDEA compiler output settings.
 */
public interface IdeaCompilerOutput {

    /**
     * whether current module should inherit project's output directory.
     *
     * @return inherit output dirs flag
     * @see #getOutputDir()
     * @see #getTestOutputDir()
     */
    boolean getInheritOutputDirs();

    /**
     * directory to store module's production classes and resources.
     *

        def dirs = [emptyRootDir, resources.file(subDirA), resources.file(subDirB), resources]
        def files = [jarFile1, jarFile2, resources.file(fileInRoot), resources.file(fileInSubdirA), resources.file(fileInSubdirB)]

        return directorySensitivity == DirectorySensitivity.DEFAULT ? (dirs + files) : files
    }

    protected TestFile file(String... path) {

}

// MakeNestedMountpoints creates mount points in baseDir for volumes mounted beneath name
func MakeNestedMountpoints(name, baseDir string, pod v1.Pod) error {
	dirs, err := getNestedMountpoints(name, baseDir, pod)
	if err != nil {
		return err
	}
	for _, dir := range dirs {
		err := os.MkdirAll(filepath.Join(baseDir, dir), 0755)
		if err != nil {
			return fmt.Errorf("unable to create nested volume mountpoints: %v", err)
		}

        expect:
        convention.sourceCompatibility == JavaVersion.VERSION_14
        convention.targetCompatibility == JavaVersion.VERSION_14

    }

    def "default dirs"() {
        expect:
        checkDirs()
    }

    def "dynamic dirs"() {
        when:
        project.buildDir = project.file('mybuild')

        then:
        checkDirs()
    }

    private void checkDirs() {

 */
@Incubating
@HasInternalProtocol
public interface LanguageSourceSet extends BuildableComponentSpec {

    // TODO: do we want to keep using SourceDirectorySet in the new API?
    // would feel more natural if dirs could be added directly to LanguageSourceSet
    // could also think about extending SourceDirectorySet

    /**
     * The source files.
     */
    SourceDirectorySet getSource();

        file.withInputStream { InputStream instr ->
            def dirs = [] as Set
            def zipStr = new ZipInputStream(instr)
            def entry
            while (entry = zipStr.getNextEntry()) {
                if (entry.directory) {
                    assertTrue("Duplicate directory '$entry.name'", dirs.add(entry.name))
                }
                if (!entry.name.contains('/')) {

        """
        file("a/src/empty-dirs/ignore-me.txt").createFile()
        file("a/src/empty-dirs/a/dir").mkdirs()

        when:
        succeeds ":b:${language.compileTaskName}"

        then:
        executedAndNotSkipped ":a:${language.compileTaskName}"
        executedAndNotSkipped ":b:${language.compileTaskName}"

        when:
        file("a/src/empty-dirs/a/dir2").mkdirs()

        then: