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

        outputDir.file("outputOfOther").createFile()
        def beforeExecution = snapshotOutput(outputDir)

        when:
        def filteredOutputs = filterOutputAfterExecution(EMPTY, beforeExecution, beforeExecution)
        then:
        collectFiles(filteredOutputs) == [outputDir]

        when:
        def outputOfCurrent = outputDir.file("outputOfCurrent").createFile()
        def afterExecution = snapshotOutput(outputDir)

    def "finds files for depth #depth"() {
        given:
        tmpDir.file("a/aa/aaa").createFile("1")
        tmpDir.file("a/aa/aaa").createFile("2")
        tmpDir.file("b/bb/bbb").createFile("3")
        tmpDir.file("b/bb/bbb").createFile("4")

        when:
        def result = new SingleDepthFilesFinder(depth).find(tmpDir.getTestDirectory(), { true })

        then:

    def deletedFiles = []

    def "deletes non-reserved matching files"() {
        def cacheEntries = [
            temporaryFolder.createFile("1"),
            temporaryFolder.createFile("2"),
            temporaryFolder.createFile("3"),
        ]

        when:
        cleanupAction(finder(cacheEntries), { it != cacheEntries[2] })
            .clean(cleanableStore, progressMonitor)

        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

			}
			return fs, nil
		}
	}

	// Use CreateFile to determine whether the file is a name surrogate and, if so,
	// save information about the link target.
	// Set FILE_FLAG_BACKUP_SEMANTICS so that CreateFile will create the handle
	// even if name refers to a directory.
	var flags uint32 = syscall.FILE_FLAG_BACKUP_SEMANTICS | syscall.FILE_FLAG_OPEN_REPARSE_POINT
	h, err := syscall.CreateFile(namep, 0, 0, nil, syscall.OPEN_EXISTING, flags, 0)

    def "with File returns this File"() {
        setup:
        def testFile = folder.createFile("test1")
        when:
        def object = parse(testFile)
        then:
        object instanceof File
        testFile == object
    }

    def "with Path returns the File it represents"() {
        setup:
        def testPath = folder.createFile("test1").toPath()
        when:
        def object = parse(testPath)
        then:

		name           string
		contents       string
		createFile     bool
		expectedResult *tracingapi.TracingConfiguration
		expectedError  *string
	}{
		{
			name:           "empty",
			createFile:     true,
			contents:       ``,
			expectedResult: &tracingapi.TracingConfiguration{},
			expectedError:  nil,
		},
		{
			name:           "absent",
			createFile:     false,
			contents:       ``,
			expectedResult: nil,

    def "cleans up resources"() {
        given:
        def file1 = resourcesDir.createDir("1/abc").createFile("test.txt")
        def file2 = resourcesDir.createDir("1/xyz").createFile("test.txt")
        def file3 = resourcesDir.createDir("2/uvw").createFile("test.txt")
        file2.parentFile.lastModified = 0
        file3.parentFile.lastModified = 0

        when:

        def initDir = gradleUserHomeDir.createDir('init.d')
        initDir.createFile('broken.gradle') << """
            throw new Exception('BOOM!')
        """

        file('foo').createDir().createFile('settings.gradle')
        file('bar').createDir().createFile('settings.gradle')
        settingsFile << """
            includeBuild('foo')
            includeBuild('bar')
        """