} else if os.IsNotExist(err) {
		return false, nil
	} else {
		return false, err
	}
}

// EnsureDir ensures that a directory exists at `path`, and if it must create the directory any
// necessary parent directories will also be created and the new directory will be empty.
func EnsureDir(fs utilfs.Filesystem, path string) error {
	// if dir exists, don't change it, but do report any unexpected errors

        dirVar.set(dir3)
        tree.files == [] as Set
    }

    def "Directory.files are relative to the directory"() {
        def baseDir = tmpDir.createDir("base")
        def directory = factory.dir(baseDir)

        expect:
        directory.files("file1", "file2").files ==~ [baseDir.file("file1"), baseDir.file("file2")]

    protected CopyAction createCopyAction() {
        File destinationDir = getDestinationDir();
        if (destinationDir == null) {
            throw new InvalidUserDataException("No copy destination directory has been specified, use 'into' to specify a target directory.");
        }
        return new FileCopyAction(getFileLookup().getFileResolver(destinationDir));
    }

    @Override
    protected CopySpecInternal createRootSpec() {

# mode if the modules.txt specifies ## workspace (and only in
# standard vendor if it doesn't).

# vendor directory produced for workspace, workspace mode
# runs in mod=vendor
go work vendor
cmp vendor/modules.txt want_workspace_modules_txt
go list -f {{.Dir}} example.com/b
stdout $GOPATH[\\/]src[\\/]vendor[\\/]example.com[\\/]b

# vendor directory produced for workspace, module mode
# runs in mod=readonly
env GOWORK=off

        layout.settingsFile == settingsFile
        !layout.buildDefinitionMissing

        where:
        settingsFilename << TEST_CASES
    }

    def "returns current directory when no ancestor directory contains a settings file or build file"() {
        given:
        def locator = buildLayoutFactoryFor()

        and: "temporary tree created out of the Gradle build tree"

                    + this.numberOfLinks + ",deletePending=" + this.deletePending + ",directory=" + this.directory + "]");
    }

@Deprecated
public abstract class EarPluginConvention {
    /**
     * The name of the application directory, relative to the project directory.
     * Default is "src/main/application".
     */
    public abstract String getAppDirName();

    public abstract void setAppDirName(String appDirName);

    /**
     * Allows changing the application directory.
     * Default is "src/main/application".
     */

    }

    def "throws exception if working directory is not provided when build is requested"() {
        when:
        createRunner().build()

        then:
        def t = thrown(InvalidRunnerConfigurationException)
        t.message == 'Please specify a project directory before executing the build'
    }

    def "throws exception if working directory is not provided when run is requested"() {
        when:

        // Directory is still empty
        testDirectory.assertIsEmptyDir()

        and:
        // Uses a directory under the user home for those things that happen to need a cache directory
        executer.gradleUserHomeDir.file(BuildScopeCacheDir.UNDEFINED_BUILD).assertIsDir()

        where:
        tasks << [["help"], [], [":help"]]
    }

    def "shows help message when run in a directory under the root directory of another build"() {

// UncachedCwd returns the current working directory.
// Most callers should use Cwd, which caches the result for future use.
// UncachedCwd is appropriate to call early in program startup before flag parsing,
// because the -C flag may change the current directory.
func UncachedCwd() string {
	wd, err := os.Getwd()
	if err != nil {
		Fatalf("cannot determine current directory: %v", err)
	}
	return wd
}