}
		var wantType fs.FileMode
		if test.isMountPoint && winsymlink.Value() != "0" {
			// Mount points are reparse points, and we no longer treat them as symlinks.
			wantType = fs.ModeIrregular
		} else {
			// This is either a real symlink, or a mount point treated as a symlink.
			wantType = fs.ModeSymlink
		}
		if tp := fi2.Mode().Type(); tp != wantType {
			t.Errorf("Lstat(%q) is type %v; want %v", link, tp, wantType)
		}

set, and reparse points that are not symlinks, Unix sockets, or dedup files now
always have [`os.ModeIrregular`](/pkg/os#ModeIrregular) set. As a result of these changes,
[`filepath.EvalSymlinks`](/pkg/path/filepath#EvalSymlinks) no longer evaluates
mount points, which was a source of many inconsistencies and bugs.
At previous versions (`winsymlink=0`), mount points are treated as symlinks,

        SnapshotHierarchy newRoot = root;
        // We are not being notified about changes to content accessed via symlinks
        newRoot = removeIndirectlySymlinkedRoots(newRoot, invalidator);
        newRoot = removeDirectSymlinks(newRoot, invalidator);
        return newRoot;
    }

    @CheckReturnValue

			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() {

#
##############################################################################

# Attempt to set APP_HOME

# Resolve links: \$0 may be a link
app_path=\$0

# Need this for daisy-chained symlinks.
while
    APP_HOME=\${app_path%"\${app_path##*/}"}  # leaves a trailing /; empty if no leading path
    [ -h "\$app_path" ]
do
    ls=\$( ls -ld "\$app_path" )
    link=\${ls#*' -> '}

						// Hence the symlink may be deemed unhealthy during that period.
						// See https://github.com/kubernetes/kubernetes/issues/52172
						//
						// We only remove unhealthy symlink for dead containers
						klog.V(5).InfoS("Container is still running, not removing symlink", "containerID", containerID, "path", logSymlink)
						continue
					}
				}

        when:
        run "copy"
        then:
        file("build/tmp/testchild").mode == mode
        where:
        mode << [0755, 0776]
    }

    @Requires(UnitTestPreconditions.Symlinks)
    def "symlinked file permissions are preserved in copy action"() {
        given:
        def mode = 0746
        def testSourceFile = file(testFileName)
        testSourceFile << "test file content"

// by [filepath.Separator], which isn't necessarily '/'.
//
// Note that Dir could expose sensitive files and directories. Dir will follow
// symlinks pointing out of the directory tree, which can be especially dangerous
// if serving from a directory in which users are able to create arbitrary symlinks.
// Dir will also allow access to files and directories starting with a period,
// which could expose sensitive directories like .git or sensitive files like

// HasSymlink reports whether the current system can use os.Symlink.
func HasSymlink() bool {
	ok, _ := hasSymlink()
	return ok
}

// MustHaveSymlink reports whether the current system can use os.Symlink.
// If not, MustHaveSymlink calls t.Skip with an explanation.
func MustHaveSymlink(t testing.TB) {
	ok, reason := hasSymlink()
	if !ok {
		t.Skipf("skipping test: cannot make symlinks on %s/%s: %s", runtime.GOOS, runtime.GOARCH, reason)

		f, _ = fsys.OverlayPath(f)
		args = append(args, f)
	}

	output, err = sh.runOut(p.Dir, nil, args)
	return ofile, output, err
}

// buildImportcfgSymlinks builds in root a tree of symlinks
// implementing the directives from importcfg.
// This serves as a temporary transition mechanism until
// we can depend on gccgo reading an importcfg directly.
// (The Go 1.9 and later gc compilers already do.)