where:
        taskName | packMethod | treeMethod
        "Zip"    | "zipTo"    | "zipTree"
        "Tar"    | "tarTo"    | "tarTree"
    }

    @Requires(UnitTestPreconditions.Symlinks)
    def "symlinked file permissions are preserved when using #taskName task"() {
        given:
        createDir('parent') {
            mode = 0777
            file('reference.txt').mode = 0746

                    if (relativePath.isRoot()) {
                        return false;
                    }
                    // Otherwise check for newly added broken symlinks and unreadable files
                    return hasNewContent(relativePath, missingSnapshot);
                }
            });
            if (newContent) {
                overlappingPath = snapshot.getAbsolutePath();

        }
        visitedDirectories.size() == 2
        visitedDirectories.every {
            it.isDirectory()
        }
    }

    @Requires(UnitTestPreconditions.Symlinks)
    def "missing symbolic link causes an exception - walker: #walkerInstance.class.simpleName"() {
        given:
        def rootDir = tmpDir.createDir("root")
        def dir = rootDir.createDir("a/b")

	// PathExists tests if the given path already exists
	// Error is returned on any other error than "file not found".
	PathExists(pathname string) (bool, error)
	// EvalHostSymlinks returns the path name after evaluating symlinks.
	EvalHostSymlinks(pathname string) (string, error)
	// GetOwner returns the integer ID for the user and group of the given path
	GetOwner(pathname string) (int64, int64, error)

func scanFile(file string, info fs.FileInfo, mustPrint bool) {
	if info.Mode()&fs.ModeSymlink != 0 {
		// Accept file symlinks only.
		i, err := os.Stat(file)
		if err != nil || !i.Mode().IsRegular() {
			if mustPrint {
				fmt.Fprintf(os.Stderr, "%s: symlink\n", file)
			}
			return
		}
		info = i
	}

	bi, err := buildinfo.ReadFile(file)
	if err != nil {
		if mustPrint {

		return &LinkError{"link", oldname, newname, err}
	}
	return nil
}

// Symlink creates newname as a symbolic link to oldname.
// On Windows, a symlink to a non-existent oldname creates a file symlink;
// if oldname is later created as a directory the symlink will not work.
// If there is an error, it will be of type *LinkError.
func Symlink(oldname, newname string) error {
	// '/' does not work in link's content

 *   <li>It assumes that <a href="https://github.com/google/guava/issues/3349">any class with a
 *       {@code $} in its name is a nested class</a>.
 * </ul>
 *
 * <h2>{@code ClassPath} and symlinks</h2>
 *
 * <p>In the case of directory classloaders, symlinks are supported but cycles are not traversed.
 * This guarantees discovery of each unique loadable resource. However, not all possible
 * aliases for resources on cyclic paths will be listed.

func (hu *HostUtil) PathExists(pathname string) (bool, error) {
	return utilpath.Exists(utilpath.CheckFollowSymlink, pathname)
}

// EvalHostSymlinks returns the path name after evaluating symlinks
func (hu *HostUtil) EvalHostSymlinks(pathname string) (string, error) {
	return filepath.EvalSymlinks(pathname)
}

// GetOwner returns the integer ID for the user and group of the given path

        this.collector = collector;
    }

    /**
     * Snapshots a directory, reusing existing previously known snapshots.
     *
     * Follows symlinks and includes them in the returned snapshot.
     * Snapshots of followed symlinks are marked with {@link AccessType#VIA_SYMLINK}.
     *
     * @param absolutePath The absolute path of the directory to snapshot.

        expect:
        !compatible
        unsatisfiedReason.contains "JVM is incompatible"
    }

    @Requires(UnitTestPreconditions.Symlinks)
    def "contexts with symlinked javaHome are compatible"() {
        def linkToJdk = tmp.testDirectory.file("link")
        linkToJdk.createLink(javaHome)

        assert javaHome != linkToJdk
        assert linkToJdk.exists()