* <p>
     * For example, a linked resource to a file system folder /some/path/to/someFolder can have a name 'someFolder'
     *
     * @return name
     */
    String getName();

    /**
     * The resource type.
     * <p>
     * If 'location' property is used the values are: "1" for a file, or "2" for a folder.
     * <p>
     * If 'locationUri' property is used then the values are:

        then:
        def folders = project.eclipseClasspath.classpath.classFolders
        folders == [project.file('generated-folder'), project.file('ws-generated'), project.file('generated-test'), project.file('test-resources'), project.file('../some/external/dir')]
    }

    def "configures internal class folders for custom source sets"() {
        when:
        eclipsePlugin.apply(project)

        }

        FileReferenceFactory fileReferenceFactory = classpath.getFileReferenceFactory();
        return classpath.getClassFolders().stream()
            .map(folder -> {
                Library library = new Library(fileReferenceFactory.fromFile(folder));
                library.setExported(true);
                return library;
            }).collect(toImmutableList());
    }

				into.addChild(h)
				// We scanned a folder, optionally send update.
				f.updateCache.deleteRecursive(h)
				f.updateCache.copyWithChildren(&f.newCache, h, folder.parent)
				f.sendUpdate()
			}
		}

		// Transfer existing
		if !into.Compacted {
			for _, folder := range existingFolders {
				h := hashPath(folder.name)
				f.updateCache.copyWithChildren(&f.oldCache, h, folder.parent)
			}

 * whether it is an include/exclude filter that applies to files, folders,
 * or both.  The following example excludes the 'node_modules' folder.
 *
 * <pre class='autoTested'>
 * plugins {
 *     id 'java'
 *     id 'eclipse'
 * }
 *
 * eclipse {
 *   project {
 *     resourceFilter {
 *       appliesTo = 'FOLDERS'
 *       type = 'EXCLUDE_ALL'
 *       matcher {

* The latest https://gradle.org/install[Gradle distribution]
${toolChain.raw}

== Create a project folder

Gradle comes with a built-in task, called `init`, that initializes a new Gradle project in an empty folder.
The `init` task uses the (also built-in) `wrapper` task to create a Gradle wrapper script, `gradlew`.

The first step is to create a folder for the new project and change directory into it.

[listing.terminal.sample-command]
----

        SourceFolder folder = new SourceFolder(relativePath, null);
        folder.setDir(dir);
        folder.setName(dir.getName());
        folder.setIncludes(getIncludesForTree(sourceSet, tree));
        folder.setExcludes(getExcludesForTree(sourceSet, tree));
        folder.setOutput(sourceSetOutputPaths.get(sourceSet));
        addScopeAttributes(folder, sourceSet, sourceSetUsages);

        attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, Category.DOCUMENTATION))
        attribute(DocsType.DOCS_TYPE_ATTRIBUTE, objects.named(DocsType, 'source-folders'))
    }
    sourceSets.main.java.srcDirs.forEach { outgoing.artifact(it) }
}

// Share the coverage data to be aggregated for the whole product
configurations.create('coverageDataElements') {
    visible = false
    canBeResolved = false

 * <p>
 * Wherever a classpath (a list of files and folders) is configured in Gradle, it can be accompanied by a ModularClasspathHandling object
 * to describe how the entries of that list are to be passed to the --classpath and --module-path parameters.
 *
 * @since 6.4
 */
public interface ModularitySpec {

    /**
     * Should a --module-path be inferred by analysing JARs and class folders on the classpath?
     * <p>

	if err != nil {
		t.Fatal(err)
	}
	if got.root() == nil {
		t.Log("cached folders:")
		for folder := range got.Cache {
			t.Log("folder:", folder)
		}
		t.Fatal("got nil root.")
	}

	// Test dirs
	want := []struct {
		path       string
		isNil      bool
		size, objs int
		oSizes     sizeHistogram