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:

        def installedJdk = Jvm.current().javaHome
        def symlinkedJdk = file("symlink-jdk")
        installedJdk.listFiles().each {
            symlinkedJdk.file(it.name).createLink(it)
        }
        file("gradle.properties").writeProperties("org.gradle.java.home": symlinkedJdk.canonicalPath)
        expect:
        succeeds("help")
    }

            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"

    }

    @Requires(UnitTestPreconditions.Symlinks)
    def "stats symlink"() {
        def file = tmpDir.file("file")
        file.text = "123"
        def link = tmpDir.file("link")
        link.createLink(file)

        expect:
        def stat = fs.stat(link)
        stat.type == FileType.RegularFile
        lastModified(stat) == lastModified(file)
        stat.length == 3
    }

    }

    @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()
        assert javaHome.canonicalFile == linkToJdk.canonicalFile

        clientWants(Jvm.forHome(javaHome))

        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }

    public TestFile createLink(String target) {
        return createLink(new File(target));
    }

    public TestFile createLink(File target) {
        if (Files.isSymbolicLink(this.toPath())) {
            try {
                Files.delete(toPath());
            } catch (IOException e) {

        def mode = 0746
        def testSourceFile = file(testFileName)
        testSourceFile << "test file content"
        testSourceFile.mode = mode

        def testSourceFileLink = file("${testFileName}_link").createLink(testSourceFile.getRelativePathFromBase())

        and:
        buildFile << """
        task copy(type: Copy) {
            from "${testSourceFile.absolutePath}"
            from "${testSourceFileLink.absolutePath}"

    def "can execute generated Unix start script using JAVA_HOME with spaces"() {
        given:
        def testJavaHome = file("javahome/java home with spaces")
        testJavaHome.createLink(Jvm.current().javaHome)

        when:
        succeeds('installDist')

        then:
        file('build/install/sample').exists()

        when:

        given:
        def taskOutput = file("outputDir").createDir()
        def symlink = file("symlink")
        symlink.createLink(taskOutput)

        and:
        Task a = task("a", type: AsyncWithOutputDirectory)
        _ * a.outputDirectory >> taskOutput
        Task b = task("b", type: AsyncWithOutputFile)