/**
     * @return the paths to be deleted.
     */
    Object[] getPaths();

    /**
     * Returns whether or not deletion will follow symlinks.
     *
     * @return whether or not deletion follows symlinks.
     */
    boolean isFollowSymlinks();

	// symlinks. Note that the function makes sure that it creates the directory
	// somewhere under the base, nothing else. E.g. if the directory already
	// exists, it may exist outside of the base due to symlinks.
	// This method should be used if the directory to create is inside volume
	// that's under user control. User must not be able to use symlinks to

    }

    @Requires(UnitTestPreconditions.Symlinks)
    def "normalizes path which points to a link to something that does not exist"() {
        def file = new File(tmpDir.testDirectory, 'a/other.txt')
        createLink(file, 'unknown.txt')
        assert !file.exists() && !file.file

        expect:
        normalize(file) == file
    }

    @Requires(UnitTestPreconditions.Symlinks)

     * hierarchy containing a symlink, as we can't be sure if the snapshot would still be valid of
     * the relocated link.
     *
     * If performance around symlinks becomes more important, we can improve this in multiple ways:
     * - keep symlinks that don't point outside the relocated snapshot hierarchy,
     * - re-snapshot relocated locations pointed to by snapshots,

class SupportedBuildJvmIntegrationTest extends AbstractIntegrationSpec {

    @Requires(UnitTestPreconditions.Symlinks)
    def "can start Gradle with a JDK that contains symlinks"() {
        // Zulu sets their Java distribution up like this
        def installedJdk = Jvm.current().javaHome
        def symlinkedJdk = file("symlink-jdk")
        installedJdk.listFiles().each {
            symlinkedJdk.file(it.name).createLink(it)
        }

				if err != nil {
					// It got deleted in the meantime, not found
					// or returns too many symlinks ignore this
					// file/directory.
					if osIsNotExist(err) || isSysErrPathNotFound(err) ||
						isSysErrTooManySymlinks(err) {
						continue
					}
					return err
				}

				// Ignore symlinked directories.
				if fi.IsDir() {
					continue
				}
			}

        then:
        3 * statisticsCollector.recordVisitDirectory()
        2 * statisticsCollector.recordVisitFile()
        0 * _
    }

    @Requires(UnitTestPreconditions.Symlinks)
    def "can visit broken symlink"() {
        given:
        def rootDir = tmpDir.createDir("root")
        rootDir.file('brokenSymlink').createLink("linkTarget")
        assert rootDir.listFiles()*.exists() == [false]

		klog.ErrorS(err, "Lchown failed", "path", filename)
	}

	// chmod passes through to the underlying file for symlinks.
	// Symlinks have a mode of 777 but this really doesn't mean anything.
	// The permissions of the underlying file are what matter.
	// However, if one reads the mode of a symlink then chmods the symlink
	// with that mode, it changes the mode of the underlying file, overridden

env GO111MODULE=on
[!symlink] skip

# 'go get' should resolve modules of imported packages.
go get
go list -deps -f '{{.Module}}' .
stdout golang.org/x/text

go get ./subpkg
go list -deps -f '{{.Module}}' ./subpkg
stdout golang.org/x/text

# Create a copy of the module using symlinks in src/links.
mkdir links
symlink links/go.mod -> $GOPATH/src/go.mod
symlink links/go.sum -> $GOPATH/src/go.sum

UnitTestPreconditions$SmartTerminalAvailable
UnitTestPreconditions$StableGroovy
UnitTestPreconditions$StableGroovy,UnitTestPreconditions$Jdk11OrLater,UnitTestPreconditions$Jdk21OrEarlier
UnitTestPreconditions$Symlinks
UnitTestPreconditions$Unix
UnitTestPreconditions$UnixDerivative
UnitTestPreconditions$UnixDerivative,PluginTestPreconditions$BashAvailable
UnitTestPreconditions$UnixDerivative,PluginTestPreconditions$DashAvailable