def "stats a symlink cycle"() {
        def first = tmpDir.file("first")
        def second = tmpDir.file("second")
        def third = tmpDir.file("third")
        first.createLink(second)
        second.createLink(third)
        third.createLink(first)

        expect:
        def stat = accessor.stat(first)
        stat.type == FileType.Missing
        stat.lastModified == 0
        stat.length == 0

    def "supplies installations with symlinked candidate"() {
        given:
        def real = candidates.createDir("java/11.0.6.hs-adpt")
        def symlink = candidates.file("java/symlink").createLink(real)

        when:
        def directories = supplier.get()

        then:
        directories.size() == 2
        directories*.location.containsAll(real, symlink)

        def baseDir = file('build')
        baseDir.file('file').text = 'some contents'
        def symlinked = baseDir.file('symlinked')
        symlinked.text = 'target of symlink'
        baseDir.file('symlink').createLink(symlinked)

        buildScript << """
            def baseDir = new File("${escapeString(baseDir)}")
            def file = new File(baseDir, "file")
            def symlink = new File(baseDir, "symlink")

    def "gracefully handle when declaring the same path as an input via symlinks"() {
        def actualDir = file("actualDir").createDir()
        file("symlink1").createLink(actualDir)
        file("symlink2").createLink(actualDir)

        buildFile << """
            task myTask {
                def outputFile = file("build/output.txt")
                inputs.dir("symlink1")

    def "supplies installations with symlinked candidate"() {
        given:
        def real = candidates.createDir("installs/java/11.0.6.hs-adpt")
        def symlink = candidates.file("installs/java/symlink").createLink(real)

        when:
        def directories = supplier.get()

        then:
        directories.size() == 2
        directories*.location.containsAll(real, symlink)

        dir(name).create(cl)
    }

    TestFile file(String name) {
        baseDir.file(name).createFile()
    }

    TestFile link(String name, String target) {
        baseDir.file(name).createLink(target)
    }

    def setMode(int mode) {
        baseDir.mode = mode
    }

    def methodMissing(String name, Object args) {
        if (args.length == 1 && args[0] instanceof Closure) {

        def binary = new File("/usr/bin/$command")
        if (!binary.exists()) {
            binary = new File("/bin/$command")
        }
        assert binary.exists()
        binDir.file(command).createLink(binary)
    }

    def "can define gradle user home via environment variable"() {
        // the actual testing is done in the build script.
        when:
        buildFile """

    def "supplies installations with symlinked candidate"() {
        given:
        def otherLocation = temporaryFolder.createDir("other")
        candidates.createDir("14-real")
        candidates.file("symlinked").createLink(otherLocation.canonicalFile)

        def supplier = new LinuxInstallationSupplier(OperatingSystem.LINUX, candidates)

        when:
        def directories = supplier.get()

        then:

            void beforeBuild(BuildContext context) {
                TestFile target = new TestFile(invocationSettings.projectDir, "archive-contents")
                if (!target.exists()) {
                    target.createLink(source)
                }
            }
        }
    }

    private static sampleFileContent = RandomStringUtils.random(1500)

    private static generateArchiveContents(File target) {

    }

    def "parse symlinked Jar"(String symlinkName, String fileName, String version, String dependencyNotation) {
        def actualFile = tmpDir.file(fileName).touch()
        def symlinkFile = tmpDir.file(symlinkName).createLink(actualFile)

        def jar = GroovyJarFile.parse(symlinkFile)

        expect:
        jar != null
        jar.file == actualFile
        jar.baseName == "groovy"