- $jarPath (artifactType = jar)

Secondary Variants (*)

    --------------------------------------------------
    Secondary Variant classes
    --------------------------------------------------
    Directories containing compiled class files for main.

    Attributes
        - org.gradle.category            = library
        - org.gradle.dependency.bundling = external

}
----

[[sec:deleting_files_example]]
== Deleting files and directories

Deleting files and directories in Gradle involves removing them from the file system.

=== Using the `Delete` task

You can easily delete files and directories using the link:{groovyDslPath}/org.gradle.api.tasks.Delete.html[Delete] task.

| `@link:{javadocPath}/org/gradle/api/tasks/InputFiles.html[InputFiles]`
| `Iterable<File>`*
| An iterable of input files and directories

| `@link:{javadocPath}/org/gradle/api/tasks/Classpath.html[Classpath]`
| `Iterable<File>`*

	if err != nil {
		return err
	}
	wantDirs, err := xl.getDataDirs()
	if err != nil {
		return err
	}

	// Delete all directories we expect to be there.
	for _, dir := range wantDirs {
		delete(foundDirs, dir)
	}

	// Delete excessive directories.
	// Do not abort on context errors.
	for dir := range foundDirs {
		toRemove := pathJoin(volumeDir, path, dir+SlashSeparator)

 * <code>public</code> on the server <code>storage15</code>. In addition
 * to referencing files and directories, jCIFS can also address servers,
 * and workgroups.
 * <p>
 * <font color="#800000"><i>Important: all SMB URLs that represent
 * workgroups, servers, shares, or directories require a trailing slash '/'.
 * </i></font>
 * <p>
 * When using the <tt>java.net.URL</tt> class with

			// for c:\program files.
			continue
		}
		all = append(all, p)
	}
	return all
}

// SrcDirs returns a list of package source root directories.
// It draws from the current Go root and Go path but omits directories
// that do not exist.
func (ctxt *Context) SrcDirs() []string {
	var all []string
	if ctxt.GOROOT != "" && ctxt.Compiler != "gccgo" {
		dir := ctxt.joinPath(ctxt.GOROOT, "src")

- Converting files to a classpath where paths contain file separator.

==== Gradle does not ignore empty directories for file-trees with `@SkipWhenEmpty`

Previously Gradle used to detect if an input file collection annotated with `@SkipWhenEmpty` consisted only of file trees and then ignored directories automatically.
To ignore directories in Gradle 8.0 and later, the input property needs to be explicitly annotated with `@IgnoreEmptyDirectories`.

        outputContains('visiting a.txt')
        outputContains('visiting dir/b.txt')
        file('dest').assertHasDescendants(
            'sub/a.txt',
            'sub/dir/b.txt',
            'dir' // directories are not passed to eachFile
        )

        when:
        run 'copy'

        then:
        skipped(':copy')
        output.count('visiting ') == 0
        file('dest').assertHasDescendants(

	// limited module mode.
	AutoRoot Root = iota

	// NoRoot is used for commands that run in module mode and ignore any go.mod
	// file the current directory or in parent directories.
	NoRoot

	// NeedRoot is used for commands that must run in module mode and don't
	// make sense without a main module.
	NeedRoot
)

// ModFile returns the parsed go.mod file.
//

	t, _ := t1.(*testing.T)
	testBuckets := []string{
		// This bucket is used for testing ListObject operations.
		0: "test-bucket-list-object",
		// This bucket will be tested with empty directories
		1: "test-bucket-empty-dir",
		// Will not store any objects in this bucket,
		// Its to test ListObjects on an empty bucket.
		2: "empty-bucket",
		// Listing the case where the marker > last object.