// something totally bogus (or the empty string), but then we would have no
		// idea what output the subprocess should actually produce: cwd itself may
		// contain symlinks preserved from the PWD value in the test's environment.
	}
	for _, tc := range cases {
		tc := tc
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()

			cmd := helperCommand(t, "pwd")

        }
        AccessType accessType = AccessType.viaSymlink(stat.getType() == FileInfo.Type.Symlink);
        if (accessType == AccessType.VIA_SYMLINK) {
            try {
                stat = files.stat(f, true);
            } catch (NativeException e) {
                // For a symlink cycle, file.exists() returns false when unable to stat the file.
                if (!f.exists()) {

On Windows, the mode bits reported by [Lstat] and [Stat] for
reparse points changed. Mount points no longer have [ModeSymlink] set,
and reparse points that are not symlinks, Unix sockets, or dedup files
now always have [ModeIrregular] set.
This behavior is controlled by the `winsymlink` setting.
For Go 1.23, it defaults to `winsymlink=1`.

# Check for any vendored package that imports main repo
# Staging repos are explicitly excluded even though go list does not currently consider symlinks
go run cmd/dependencycheck/dependencycheck.go -restrict "^k8s\.io/kubernetes/" -exclude "^k8s\.io/(${staging_repos_pattern})(/|$)" "${KUBE_TEMP}/deps_other.json"

     * @exception FileException if the operation fails
     */
    void createSymbolicLink(File link, File target) throws FileException;

    /**
     * Tells if the file is a symlink
     *
     * @param suspect the file to check
     * @return true if symlink, false otherwise
     */
    boolean isSymlink(File suspect);

        result.assertHasErrorOutput("package java.util.logging is not visible")
    }

    @Requires(UnitTestPreconditions.Symlinks)
    @Issue("https://github.com/gradle/gradle/issues/9202")
    def "source mapping file works with symlinks"() {
        // Daemon cleans up symlinks in VFS
        executer.requireDaemon()
        executer.requireIsolatedDaemons()

        given:
        buildFile << """

## resolve links - $0 may be a link to Maven's home
PRG="$0"

# need this for relative symlinks
while [ -h "$PRG" ] ; do
  ls=`ls -ld "$PRG"`
  link=`expr "$ls" : '.*-> \(.*\)$'`
  if expr "$link" : '/.*' > /dev/null; then
    PRG="$link"
  else
    PRG="`dirname "$PRG"`/$link"
  fi
done

saveddir=`pwd`

MAVEN_HOME=`dirname "$PRG"`/..

# make it fully qualified
MAVEN_HOME=`cd "$MAVEN_HOME" && pwd`

	err = os.WriteFile(realTestFile, []byte("foo: bar\n"), 0o640)
	g.Expect(err).NotTo(HaveOccurred())

	// Now, symlink the tmp `data1` dir to `data` in the baseDir
	os.Symlink(dataDir1, path.Join(watchDir, "data"))
	// And link the `<watchdir>/datadir/test.conf` to `<watchdir>/test.conf`
	watchFile := path.Join(watchDir, "test.conf")
	os.Symlink(path.Join(watchDir, "data", "test.conf"), watchFile)

                subDir.mkdirs()
                generateFilesAndSubDirectories(subDir, fileCount, dirCount, maxDepth, currentDepth + 1, fileIdGenerator)
            }
        }
    }

    @Requires(UnitTestPreconditions.Symlinks)
    def "symbolic links for directories are handled properly - walker: #walkerInstance.class.simpleName"() {
        given:
        def rootDir = tmpDir.createDir("root")
        def dir = rootDir.createDir("a/b")

	t.Parallel()

	tmpDir := t.TempDir()
	dir := tmpDir + "/dir"
	if err := Mkdir(dir, 0755); err != nil {
		t.Fatalf("Mkdir %s: %s", dir, err)
	}

	link := tmpDir + "/link"
	if err := Symlink("dir", link); err != nil {
		t.Fatalf("Symlink %s: %s", link, err)
	}

	path := link + "/foo"
	if err := MkdirAll(path, 0755); err != nil {
		t.Errorf("MkdirAll %q: %s", path, err)
	}
}

func TestMkdirAllAtSlash(t *testing.T) {