// Tests that we can find packages in the stdlib. func TestScanStdlib(t *testing.T) { … } // Tests that we handle a nested module. This is different from other tests // where the module is in scope -- here we have to figure out the import path // without any help from go list. func TestScanOutOfScopeNestedModule(t *testing.T) { … } // Tests that we don't find a nested module contained in a local replace target. // The code for this case is too annoying to write, so it's just ignored. func TestScanNestedModuleInLocalReplace(t *testing.T) { … } // Tests that path encoding is handled correctly. Adapted from mod_case.txt. func TestModCase(t *testing.T) { … } // Not obviously relevant to goimports. Adapted from mod_domain_root.txt anyway. func TestModDomainRoot(t *testing.T) { … } // Tests that scanning the module cache > 1 time is able to find the same module. func TestModMultipleScans(t *testing.T) { … } // Tests that scanning the module cache > 1 time is able to find the same module // in the module cache. func TestModMultipleScansWithSubdirs(t *testing.T) { … } // Tests that scanning the module cache > 1 after changing a package in module cache to make it unimportable // is able to find the same module. func TestModCacheEditModFile(t *testing.T) { … } // Tests that -mod=vendor works. Adapted from mod_vendor_build.txt. func TestModVendorBuild(t *testing.T) { … } // Tests that -mod=vendor is auto-enabled only for go1.14 and higher. // Vaguely inspired by mod_vendor_auto.txt. func TestModVendorAuto(t *testing.T) { … } // Tests that a module replace works. Adapted from mod_list.txt. We start with // go.mod2; the first part of the test is irrelevant. func TestModList(t *testing.T) { … } // Tests that a local replace works. Adapted from mod_local_replace.txt. func TestModLocalReplace(t *testing.T) { … } // Tests that the package at the root of the main module can be found. // Adapted from the first part of mod_multirepo.txt. func TestModMultirepo1(t *testing.T) { … } // Tests that a simple module dependency is found. Adapted from the third part // of mod_multirepo.txt (We skip the case where it doesn't have a go.mod // entry -- we just don't work in that case.) func TestModMultirepo3(t *testing.T) { … } // Tests that a nested module is found in the module cache, even though // it's checked out. Adapted from the fourth part of mod_multirepo.txt. func TestModMultirepo4(t *testing.T) { … } // Tests a simple module dependency. Adapted from the first part of mod_replace.txt. func TestModReplace1(t *testing.T) { … } // Tests a local replace. Adapted from the second part of mod_replace.txt. func TestModReplace2(t *testing.T) { … } // Tests that a module can be replaced by a different module path. Adapted // from the third part of mod_replace.txt. func TestModReplace3(t *testing.T) { … } // Tests more local replaces, notably the case where an outer module provides // a package that could also be provided by an inner module. Adapted from // mod_replace_import.txt, with example.com/v changed to /vv because Go 1.11 // thinks /v is an invalid major version. func TestModReplaceImport(t *testing.T) { … } // Tests that go.work files are respected. func TestModWorkspace(t *testing.T) { … } // Tests replaces in workspaces. Uses the directory layout in the cmd/go // work_replace test. It tests both that replaces in go.work files are // respected and that a wildcard replace in go.work overrides a versioned replace // in go.mod. func TestModWorkspaceReplace(t *testing.T) { … } // Tests a case where conflicting replaces are overridden by a replace // in the go.work file. func TestModWorkspaceReplaceOverride(t *testing.T) { … } // Tests that the correct versions of modules are found in // workspaces with module pruning. This is based on the // cmd/go mod_prune_all script test. func TestModWorkspacePrune(t *testing.T) { … } // Tests that we handle GO111MODULE=on with no go.mod file. See #30855. func TestNoMainModule(t *testing.T) { … } // assertFound asserts that the package at importPath is found to have pkgName, // and that scanning for pkgName finds it at importPath. func (t *modTest) assertFound(importPath, pkgName string) (string, *pkg) { … } func (t *modTest) assertScanFinds(importPath, pkgName string) *pkg { … } func scanToSlice(resolver Resolver, exclude []gopathwalk.RootType) ([]*pkg, error) { … } // assertModuleFoundInDir is the same as assertFound, but also checks that the // package was found in an active module whose Dir matches dirRE. func (t *modTest) assertModuleFoundInDir(importPath, pkgName, dirRE string) { … } var proxyOnce … var proxyDir … type modTest … // setup builds a test environment from a txtar and supporting modules // in testdata/mod, along the lines of TestScript in cmd/go. // // extraEnv is applied on top of the default test env. func setup(t *testing.T, extraEnv map[string]string, main, wd string) *modTest { … } // writeModule writes the module in the ar, a txtar, to dir. func writeModule(dir, ar string) error { … } // writeProxy writes all the txtar-formatted modules in arDir to a proxy // directory in dir. func writeProxy(dir, arDir string) error { … } // writeProxyModule writes a txtar-formatted module at arPath to the module // proxy in base. func writeProxyModule(base, arPath string) error { … } func removeDir(dir string) { … } // Tests that findModFile can find the mod files from a path in the module cache. func TestFindModFileModCache(t *testing.T) { … } // Tests that crud in the module cache is ignored. func TestInvalidModCache(t *testing.T) { … } func TestGetCandidatesRanking(t *testing.T) { … } func BenchmarkModuleResolver_RescanModCache(b *testing.B) { … } func BenchmarkModuleResolver_InitialScan(b *testing.B) { … } // Tests that go.work files and vendor directory are respected. func TestModWorkspaceVendoring(t *testing.T) { … }
Codebase Browser
gotools