! stderr 'matched no packages'
stderr '^go: example\.net/emptysubdir/subdir/\.\.\.: module example\.net/emptysubdir/subdir: reading http://.*: 404 Not Found\n\tserver response: 404 page not found\n\z'

# It doesn't make sense to 'go get' a path in the standard library,
# since the standard library necessarily can't have unresolved imports.
#
# TODO(#30241): Maybe that won't always be the case?
#

        def rootFile2 = root.createFile("rootFile2")
        def subdir = dir1.createDir("subdir")
        def subdirFile1 = subdir.createFile("subdirFile1")

        def unfiltered = fileSystemAccess.read(root.getAbsolutePath(), snapshottingFilter(new PatternSet())).get()

        expect:
        filteredPaths(unfiltered, include("**/*2")) == [root, dir1, dirFile2, subdir, rootFile2] as Set

        rootDir.file("subdir/file1.txt").write("content");
        rootDir.file("subdir2/file2.txt").write("content");
        archiveFileToRoot(getArchiveFile());

        assertVisits(getTree(), toList("subdir/file1.txt", "subdir2/file2.txt"), toList("subdir", "subdir2"));
        assertSetContainsForAllTypes(getTree(), toList("subdir/file1.txt", "subdir2/file2.txt"));
    }

    @Test

        ImmutableSortedSet.Builder<VersionSpecificCacheDirectory> builder = ImmutableSortedSet.naturalOrder();
        for (File subDir : listVersionSpecificCacheDirs()) {
            GradleVersion version = tryParseGradleVersion(subDir);
            if (version != null) {
                builder.add(new VersionSpecificCacheDirectory(subDir, version));
            }
        }
        return builder.build();
    }

chmod 0777 run.sh

! go list all
! stdout 'RAN SCRIPT'

cd subdir
! go list all
! stdout 'RAN SCRIPT'

-- go.mod --
module exploit

go 1.21
toolchain go1.999999-/run.sh
-- go1.999999-/run.sh --
#!/bin/sh
printf 'RAN SCRIPT\n'
exit 1
-- run.sh --
#!/bin/sh
printf 'RAN SCRIPT\n'
exit 1
-- subdir/go.mod --
module exploit

go 1.21
toolchain go1.999999-/../../run.sh

				continue
			}
			os.Stdout.Write(data)

		case "zip":
			if len(f) != 4 {
				fmt.Fprintf(os.Stderr, "?usage: zip rev subdir output\n")
				continue
			}
			subdir := f[2]
			if subdir == "-" {
				subdir = ""
			}
			rc, err := repo.ReadZip(f[1], subdir, 10<<20)
			if err != nil {
				fmt.Fprintf(os.Stderr, "?%s\n", err)
				continue
			}
			data, err := io.ReadAll(rc)
			rc.Close()

                }
            }
        """
        settingsFile << "include 'tmp'"

        when:
        def subdir = file("tmp")
        subdir.mkdirs()
        executer.inDirectory(subdir)
        succeeds ':checkDir'

        then:
        subdir.listFiles().length == 0
    }

	readZip       func(rev, subdir, remote, target string) []string                                   // cmd to read rev's subdir as zip file
	doReadZip     func(ctx context.Context, dst io.Writer, workDir, rev, subdir, remote string) error // arbitrary function to read rev's subdir as zip file
}

var re = lazyregexp.New

var vcsCmds = map[string]*vcsCmd{
	"hg": {

			},
		},

		{
			repo:   gitrepo1,
			rev:    "aaaaaaaaab",
			subdir: "",
			err:    "unknown revision",
		},
		{
			repo:   hgrepo1,
			rev:    "aaaaaaaaab",
			subdir: "",
			err:    "unknown revision",
		},

		{
			repo:   vgotest1,
			rev:    "submod/v1.0.4",
			subdir: "submod",
			files: map[string]uint64{
				"prefix/":                0,

        given:
        def firstCleanupAction = Mock(CleanupAction)
        def secondCleanupAction = Mock(CleanupAction)
        def subDir = temporaryFolder.file("subDir")

        when:
        CompositeCleanupAction.builder()
            .add(firstCleanupAction)
            .add(subDir, secondCleanupAction)
            .build()
            .clean(cleanableStore, progressMonitor)

        then: