}
	}
}

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()
	}
}

        skipped ':producesLink'

        when:
        target.createFile()
        run 'producesLink'
        then:
        executedAndNotSkipped ':producesLink'
    }

    @Issue('https://github.com/gradle/gradle/issues/1365')
    def "broken symlink not produced by task is ignored"() {
        given:
        def input = file("input.txt").createFile()
        def outputDirectory = file("output")

    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

        } 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) {

				p.errs[i] = io.ErrShortWrite
				p.writers[i] = nil
			}
		} else {
			p.writers[i] = nil
		}
	}

	// If nilCount >= p.writeQuorum, we return nil. This is because HealFile() uses
	// CreateFile with p.writeQuorum=1 to accommodate healing of single disk.
	// i.e if we do no return here in such a case, reduceWriteQuorumErrs() would
	// return a quorum error to HealFile().
	nilCount := countErrs(p.errs, nil)

        createFile(new File(cachesDir, "transforms-1/first/transformed/file"))
        createFile(new File(cachesDir, "transforms-1/first/metadata.bin"))
        createFile(new File(cachesDir, "transforms-1/first/transformed/instrumented/file"))
        createFile(new File(cachesDir, "transforms-1/second/transformed/original/file"))

        @Provides
        Long createLong(Long value) {
            return value + 2
        }

        @Provides
        Long decorateLong(Long value) {
            return value + 2
        }
    }

    private static class TestDecoratingProviderWithCreate implements ServiceRegistrationProvider {
        @Provides
        Long createLong(Long value) {
            return value + 2

        given:
        def e = temp.file("a/b/c/d/e")
        def b = temp.createFile("a/b")
        def c = temp.file("a/b/c")

        expect:
        b.file

        when:
        mkdirs(e)

        then:
        def ex = thrown UncheckedIOException
        ex.message == "Cannot create parent directory '$c' when creating directory '$e' as '$b' is not a directory"
    }

        !isValidBuildSrcBuild(temp.createFile("buildSrc"))
    }

    def "ignores empty buildSrc directory"() {
        expect:
        !isValidBuildSrcBuild(temp.createDir("buildSrc"))
    }

    def "ignores buildSrc directory without valid Gradle build"() {
        when:
        def buildSrcDir = temp.createDir("buildSrc")
        buildSrcDir.createFile("build/libs/buildSrc.jar")

        given:
        def locator = buildLayoutFactoryFor()

        and:
        def currentDir = tmpDir.createDir("sub/current")
        def settingsFile = currentDir.createFile(settingsFilename)
        tmpDir.createFile("sub/$settingsFilename")
        tmpDir.createFile(settingsFilename)

        expect:
        def layout = locator.getLayoutFor(currentDir, true)
        layout.rootDirectory == currentDir