def linkTarget3 = tmpDir.createFile("linkTarget3")

        rootDir.createLink(linkTarget1)
        linkTarget1.file("includedSymlink").createLink(linkTarget2)
        linkTarget1.file("excludedSymlink").createLink(linkTarget2)
        linkTarget2.file("symlinkedFile.txt").createLink(linkTarget3)
        linkTarget2.file("excludedSymlinkedFile.png").createLink(linkTarget3)

        // rootDir -> linkTarget1
        //   - included

        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 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 """

        } 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:

  public static CharSinkFactory asCharSinkFactory(final ByteSinkFactory factory) {
    checkNotNull(factory);
    return new CharSinkFactory() {
      @Override
      public CharSink createSink() throws IOException {
        return factory.createSink().asCharSink(Charsets.UTF_8);
      }

      @Override
      public String getSinkContents() throws IOException {
        return new String(factory.getSinkContents(), Charsets.UTF_8);

		}
	}
}

func wakefing() *g {
	if ok := fingStatus.CompareAndSwap(fingCreated|fingWait|fingWake, fingCreated); ok {
		return fing
	}
	return nil
}

func createfing() {
	// start the finalizer goroutine exactly once
	if fingStatus.Load() == fingUninitialized && fingStatus.CompareAndSwap(fingUninitialized, fingCreated) {
		go runfinq()
	}
}