def sourcePath = sourcePathFor(subProjectScriptFile).collect { path ->
            if (srcConventionalPathDirNames.contains(path.name)) {
                path.parentFile.parentFile.parentFile.name
            } else {
                path.name
            }
        }.unique()
        assertThat(sourcePath, matches)
    }

        "symlink owned by but not generated by build"        | true      | true         | false             | { it.createLink(it.parentFile.createFile("existing.txt")) }
        "broken symlink owned by but not generated by build" | true      | true         | false             | { it.createLink(it.parentFile.file("missing.txt")) }
        "file not owned by but generated by build"           | false     | false        | true              | { it.createFile() }

// That would be nice.

// IsPrint reports whether the rune is defined as printable by Go, with
// the same definition as [unicode.IsPrint]: letters, numbers, punctuation,
// symbols and ASCII space.
func IsPrint(r rune) bool {
	// Fast check for Latin-1
	if r <= 0xFF {
		if 0x20 <= r && r <= 0x7E {
			// All the ASCII is printable from space through DEL-1.
			return true
		}
		if 0xA1 <= r && r <= 0xFF {

            }
        }
        File androidAnalyticsSetting = new File(System.getProperty("user.home"), ".android/analytics.settings")
        if (!androidAnalyticsSetting.exists()) {
            androidAnalyticsSetting.parentFile.mkdirs()
            androidAnalyticsSetting.createNewFile()
        }
        workingDir.listFiles().findAll { it.name.contains("gradleUserHome") }.forEach { gradleUserHome ->

    protected static void file(File dir, String name, String content) {
        if (content == null) {
            return
        }
        def file = new File(dir, name)
        file.parentFile.mkdirs()
        file.setText(content.stripIndent().trim())
    }

        def dir = tmpDir.createDir("dir")

        expect:
        def set = from(dir)
        set.contains(dir)
        set.contains(dir.file("child"))
        !set.contains(dir.parentFile)
        !set.contains(tmpDir.file("dir2"))
        !set.contains(tmpDir.file("d"))
    }

    def "creates from empty collection"() {
        expect:
        def set = from()

            when (change.changeType) {
                ChangeType.ADDED, ChangeType.MODIFIED -> {

                    println("Processing file ${changedFile.name}")
                    outputLocation.parentFile.mkdirs()

                    outputLocation.writeText(changedFile.readLines().size.toString())
                }
                ChangeType.REMOVED -> {

        def rootDirSnapshot = snapshotDirectory(rootDir)

        when:
        registerWatchableHierarchies([rootDir.parentFile])
        addSnapshot(rootDirSnapshot)
        then:
        1 * watcher.startWatching({ equalIgnoringOrder(it, [rootDir.parentFile]) })
        0 * _

        when:
        invalidate(rootDirSnapshot.children[0])
        invalidate(rootDirSnapshot.children[1])

    @Test
    fun `recognizes relative paths pointing outside the root directory`() {
        val instance = createFromPaths(listOf("../../test1"))
        assertTrue(instance.isFileSystemCheckIgnoredFor(rootDir.parentFile.parentFile.resolve("test1")))
    }

    @Test
    fun `if created as case-sensitive, does not recognize paths in a different case`() {

        execute(task)

        then:
        def e = thrown(TaskExecutionException)
        assertHasMatchingCause(e, m -> m.startsWith("Toolchain installation '${invalidJavac.parentFile.parentFile.absolutePath}' could not be probed:"))
        assertHasMatchingCause(e, m -> m ==~ /Cannot run program .*java.*/)
    }

    def "fails if custom Java home does not exist"() {