return true;
    }

    @Override
    public void symlink(File link, File target) {
        link.getParentFile().mkdirs();
        posixFiles.symlink(link, target.getPath());
    }

    @Override
    public boolean isSymlink(File suspect) {
        return posixFiles.stat(suspect).getType() == FileInfo.Type.Symlink;
    }

# Checks that an identical binary is built with -trimpath from the same
# source files, with GOROOT in two different locations.
# Verifies golang.org/issue/38989

[short] skip
[!symlink] skip

# Symlink the compiler to a local path
env GOROOT=$WORK/goroot1
symlink $GOROOT -> $TESTGO_GOROOT

# Set up fresh GOCACHE
env GOCACHE=$WORK/gocache1
mkdir $GOCACHE

# Build a simple binary
go build -o binary1 -trimpath -x main.go

[!symlink] skip
env GO111MODULE=off

mkdir $WORK/tmp/gopath/src/x/y/_vendor/src/x
symlink $WORK/tmp/gopath/src/x/y/_vendor/src/x/y -> ../../..
mkdir $WORK/tmp/gopath/src/x/y/_vendor/src/x/y/w
cp w.go $WORK/tmp/gopath/src/x/y/w/w.go
symlink $WORK/tmp/gopath/src/x/y/w/vendor -> ../_vendor/src
mkdir $WORK/tmp/gopath/src/x/y/_vendor/src/x/y/z
cp z.go $WORK/tmp/gopath/src/x/y/z/z.go

env GOPATH=$WORK/tmp/gopath/src/x/y/_vendor${:}$WORK/tmp/gopath

			continue
		}
		if fi.Mode().IsRegular() {
			return true, nil
		}

		// fi is the result of an Lstat, so it doesn't follow symlinks.
		// But it's okay if the file is a symlink pointing to a regular
		// file, so use os.Stat to follow symlinks and check that.
		actualFilePath, _ := OverlayPath(filepath.Join(dir, fi.Name()))
		fi, err := os.Stat(actualFilePath)
		if err == nil && fi.Mode().IsRegular() {

        delete.getTargetFiles().getFiles() == getProject().files(delete.getDelete()).getFiles()
    }

    @Requires(UnitTestPreconditions.Symlinks)
    def "can follow symlinks"() {
        given:
        def keepTxt = temporaryFolder.createFile("originalDir", "keep.txt")
        def originalDir = keepTxt.getParentFile()

	if fi.Mode()&fs.ModeSymlink != 0 {
		t.Errorf("%q should not be a symlink", path)
	}
}

// testIsSymlink verifies that fi refers to symlink.
func testIsSymlink(t *testing.T, path string, fi fs.FileInfo) {
	t.Helper()
	if fi.IsDir() {
		t.Errorf("%q should not be a directory", path)
	}
	if fi.Mode()&fs.ModeSymlink == 0 {
		t.Errorf("%q should be a symlink", path)
	}
}

# even when it's been moved to a different directory.
# Simulate that by creating a symlink to the tree.

# We use net instead of std because stale std has
# the behavior of checking that all std targets
# are stale rather than any of them.

[!symlink] skip
[short] skip

go build net
! stale net

symlink new -> $GOROOT
env OLDGOROOT=$GOROOT
env GOROOT=$WORK${/}gopath${/}src${/}new
go env GOROOT

        localCache.listCacheFailedFiles().size() == 1
    }

    @Requires(UnitTestPreconditions.Symlinks)
    @Issue("https://github.com/gradle/gradle/issues/9906")
    def "don't cache if task produces broken symlink"() {
        def link = file('root/link')
        buildFile << """
            import java.nio.file.*
            class ProducesLink extends DefaultTask {

[!symlink] skip
env GO111MODULE=off

mkdir $WORK/tmp/gopath/src/dir1/vendor/v
cp p.go $WORK/tmp/gopath/src/dir1/p.go
cp v.go $WORK/tmp/gopath/src/dir1/vendor/v/v.go
symlink $WORK/tmp/symdir1 -> $WORK/tmp/gopath/src/dir1
env GOPATH=$WORK/tmp/gopath
cd $WORK/tmp/symdir1

go list -f '{{.Root}}' .
stdout '^'$WORK/tmp/gopath'$'

# All of these should succeed, not die in vendor-handling code.
go run p.go &
go build &
go install &

# testone $T/linkdir/dir
# testone $T/linkdir/linkfile
# testone $T/linkdir/linkdir
function kube::readlinkdashf {
  # run in a subshell for simpler 'cd'
  (
    if [[ -d "${1}" ]]; then # This also catch symlinks to dirs.
      cd "${1}"
      pwd -P
    else
      cd "$(dirname "${1}")"
      local f
      f=$(basename "${1}")
      if [[ -L "${f}" ]]; then
        readlink "${f}"
      else