! 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

    def "parallel invalidation yields correct results"() {
        def dir = temporaryFolder.createDir("some/deep/hierarchy")
        (1..1000).each {
            def subdir = dir.file(it)
            subdir.file("in-dir.txt").createFile()
        }

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

        when:

        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

        this.optimizationOptions = optimizationOptions;
    }

    public File getStubDir() {
        return stubDir;
    }

    public void setStubDir(File stubDir) {
        this.stubDir = stubDir;
    }

    @Nullable
    public File getConfigurationScript() {
        return configurationScript;
    }

        def excludedFile = rootDir.file("subdir1/a/b/c.html").createFile()
        def notUnderRoot = temporaryFolder.createDir("root2").file("a.txt").createFile()
        def doesNotExist = rootDir.file("b.txt")

        when:
        def patterns = new PatternSet()
        patterns.include("**/*.txt")
        patterns.exclude("subdir1/**")

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

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,

# Tests Issue #3562
# go get foo.io (not foo.io/subdir) was not working consistently.

env GO111MODULE=off
env GOPATH=$WORK/gopath1${:}$WORK/gopath2

mkdir $WORK/gopath1/src/test
mkdir $WORK/gopath2/src/test
cp main.go $WORK/gopath2/src/test/main.go
cd $WORK/gopath2/src/test

! go install
stderr 'no install location for.*gopath2.src.test: hidden by .*gopath1.src.test'

-- main.go --
package main

        def subdir = repo.file("subdir")
        repo.workTree.listFiles().each {
            if (it.name == '.git') {
                return
            }
            it.copyTo(subdir.file(it.name))
            it.delete()
        }
        commit = repo.commit('updated')
        mappingFor(repo, "org.test:dep", 'rootDir = "subdir"')

        expect:
        succeeds('assemble')