':!:vendor/*'        `# catches vendor/...` \
        ':!:*/vendor/*'      `# catches any subdir/vendor/...` \
        ':!:third_party/*'   `# catches third_party/...` \
        ':!:*/third_party/*' `# catches any subdir/third_party/...` \
        ':!:*/testdata/*'    `# catches any subdir/testdata/...` \
        ':(glob)**/*.go' \
        "$@"
}

# replace net.ParseIP() and netParseIPCDR

! go get example.net/missing/subdir@v0.1.0
stderr '^go: module example.net/missing@v0.1.0 found \(replaced by ./missing\), but does not contain package example.net/missing/subdir$'

go get example.net/missing@v0.1.0


# Getting the subdirectory should continue to fail even if the corresponding
# module is already present in the build list.

! go get example.net/missing/subdir@v0.1.0

        }
        if (currentDepth < maxDepth) {
            for (int i = 0; i < dirCount; i++) {
                File subDir = new File(parentDir, "dir" + fileIdGenerator.incrementAndGet())
                subDir.mkdirs()
                generateFilesAndSubDirectories(subDir, fileCount, dirCount, maxDepth, currentDepth + 1, fileIdGenerator)
            }
        }
    }

    @Requires(UnitTestPreconditions.Symlinks)

        (1..1000).each {
            def subdir = dir.file(it)
            subdir.file("in-dir.txt").createFile()
        }

        allowFileSystemAccess(true)
        read(dir)
        def executorService = Executors.newFixedThreadPool(100)

        when:
        (1..1000).each { num ->
            executorService.submit({
                def locationToUpdate = dir.file(num).file("in-dir.txt")

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

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

        dir1.file("subdir/f2").createFile()
        TestFile missing = testDir.file("f3")
        testDir.file("f2").createFile()
        testDir.file("ignored1").createFile()
        def collection = containing(file1, dir1, missing)
        def tree = collection.asFileTree

        expect:
        assertSetContainsForFileSet(tree, toSet("f1", "f2", "subdir/f2"))

    git ls-files -cmo --exclude-standard \
        ':!:vendor/*'        `# catches vendor/...` \
        ':!:*/vendor/*'      `# catches any subdir/vendor/...` \
        ':!:third_party/*'   `# catches third_party/...` \
        ':!:*/third_party/*' `# catches third_party/...` \
        ':!:*/testdata/*'    `# catches any subdir/testdata/...` \
        ':(glob)**/*.go' \
        "$@"
}

val makeFile = tasks.register("makeFile") {
    val sharedFile = layout.buildDirectory.file("some-subdir/shared-file.txt")
    outputs.file(sharedFile)
    doFirst {
        sharedFile.get().asFile.writeText("This file is shared across Gradle subprojects.")
    }
}

val sharedConfiguration by configurations.creating {
    isCanBeResolved = false
}

artifacts {
    add(sharedConfiguration.name, makeFile)

}

// FormatDirEntry returns a formatted version of dir for human readability.
// Implementations of [DirEntry] can call this from a String method.
// The outputs for a directory named subdir and a file named hello.go are:
//
//	d subdir/
//	- hello.go
func FormatDirEntry(dir DirEntry) string {
	name := dir.Name()
	b := make([]byte, 0, 5+len(name))

	// The Type method does not return any permission bits,

		// Done!
		volumeutil.SetReady(b.getMetaDir())
		return nil
	}

	var subdir string

	switch {
	case len(b.target) != 0 && filepath.Clean(b.target) == ".":
		// if target dir is '.', use the current dir
		subdir = filepath.Join(dir)
	case len(files) == 1:
		// if target is not '.', use the generated folder
		subdir = filepath.Join(dir, files[0].Name())
	default: