blob: 51bc9679184e8c20d9ed29097015c10d9885a7df [file] [log] [blame]
// Copyright 2019 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package imports
import (
"archive/zip"
"context"
"fmt"
"io/ioutil"
"log"
"os"
"path/filepath"
"reflect"
"regexp"
"sort"
"strings"
"sync"
"testing"
"golang.org/x/mod/module"
"golang.org/x/tools/internal/gocommand"
"golang.org/x/tools/internal/gopathwalk"
"golang.org/x/tools/internal/proxydir"
"golang.org/x/tools/internal/testenv"
"golang.org/x/tools/txtar"
)
// Tests that we can find packages in the stdlib.
func TestScanStdlib(t *testing.T) {
mt := setup(t, `
-- go.mod --
module x
`, "")
defer mt.cleanup()
mt.assertScanFinds("fmt", "fmt")
}
// 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) {
mt := setup(t, `
-- go.mod --
module x
-- x.go --
package x
-- v2/go.mod --
module x
-- v2/x.go --
package x`, "")
defer mt.cleanup()
pkg := mt.assertScanFinds("x/v2", "x")
if pkg != nil && !strings.HasSuffix(filepath.ToSlash(pkg.dir), "main/v2") {
t.Errorf("x/v2 was found in %v, wanted .../main/v2", pkg.dir)
}
// We can't load the package name from the import path, but that should
// be okay -- if we end up adding this result, we'll add it with a name
// if necessary.
}
// 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) {
mt := setup(t, `
-- go.mod --
module x
require y v0.0.0
replace y => ./y
-- x.go --
package x
-- y/go.mod --
module y
-- y/y.go --
package y
-- y/z/go.mod --
module y/z
-- y/z/z.go --
package z
`, "")
defer mt.cleanup()
mt.assertFound("y", "y")
scan, err := scanToSlice(mt.resolver, nil)
if err != nil {
t.Fatal(err)
}
for _, pkg := range scan {
if strings.HasSuffix(filepath.ToSlash(pkg.dir), "main/y/z") {
t.Errorf("scan found a package %v in dir main/y/z, wanted none", pkg.importPathShort)
}
}
}
// Tests that path encoding is handled correctly. Adapted from mod_case.txt.
func TestModCase(t *testing.T) {
mt := setup(t, `
-- go.mod --
module x
require rsc.io/QUOTE v1.5.2
-- x.go --
package x
import _ "rsc.io/QUOTE/QUOTE"
`, "")
defer mt.cleanup()
mt.assertFound("rsc.io/QUOTE/QUOTE", "QUOTE")
}
// Not obviously relevant to goimports. Adapted from mod_domain_root.txt anyway.
func TestModDomainRoot(t *testing.T) {
mt := setup(t, `
-- go.mod --
module x
require example.com v1.0.0
-- x.go --
package x
import _ "example.com"
`, "")
defer mt.cleanup()
mt.assertFound("example.com", "x")
}
// Tests that scanning the module cache > 1 time is able to find the same module.
func TestModMultipleScans(t *testing.T) {
mt := setup(t, `
-- go.mod --
module x
require example.com v1.0.0
-- x.go --
package x
import _ "example.com"
`, "")
defer mt.cleanup()
mt.assertScanFinds("example.com", "x")
mt.assertScanFinds("example.com", "x")
}
// Tests that scanning the module cache > 1 time is able to find the same module
// in the module cache.
func TestModMultipleScansWithSubdirs(t *testing.T) {
mt := setup(t, `
-- go.mod --
module x
require rsc.io/quote v1.5.2
-- x.go --
package x
import _ "rsc.io/quote"
`, "")
defer mt.cleanup()
mt.assertScanFinds("rsc.io/quote", "quote")
mt.assertScanFinds("rsc.io/quote", "quote")
}
// 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) {
mt := setup(t, `
-- go.mod --
module x
require rsc.io/quote v1.5.2
-- x.go --
package x
import _ "rsc.io/quote"
`, "")
defer mt.cleanup()
found := mt.assertScanFinds("rsc.io/quote", "quote")
if found == nil {
t.Fatal("rsc.io/quote not found in initial scan.")
}
// Update the go.mod file of example.com so that it changes its module path (not allowed).
if err := os.Chmod(filepath.Join(found.dir, "go.mod"), 0644); err != nil {
t.Fatal(err)
}
if err := ioutil.WriteFile(filepath.Join(found.dir, "go.mod"), []byte("module bad.com\n"), 0644); err != nil {
t.Fatal(err)
}
// Test that with its cache of module packages it still finds the package.
mt.assertScanFinds("rsc.io/quote", "quote")
// Rewrite the main package so that rsc.io/quote is not in scope.
if err := ioutil.WriteFile(filepath.Join(mt.env.WorkingDir, "go.mod"), []byte("module x\n"), 0644); err != nil {
t.Fatal(err)
}
if err := ioutil.WriteFile(filepath.Join(mt.env.WorkingDir, "x.go"), []byte("package x\n"), 0644); err != nil {
t.Fatal(err)
}
// Uninitialize the go.mod dependent cached information and make sure it still finds the package.
mt.resolver.ClearForNewMod()
mt.assertScanFinds("rsc.io/quote", "quote")
}
// Tests that -mod=vendor works. Adapted from mod_vendor_build.txt.
func TestModVendorBuild(t *testing.T) {
mt := setup(t, `
-- go.mod --
module m
go 1.12
require rsc.io/sampler v1.3.1
-- x.go --
package x
import _ "rsc.io/sampler"
`, "")
defer mt.cleanup()
// Sanity-check the setup.
mt.assertModuleFoundInDir("rsc.io/sampler", "sampler", `pkg.*mod.*/sampler@.*$`)
// Populate vendor/ and clear out the mod cache so we can't cheat.
if _, err := mt.env.invokeGo(context.Background(), "mod", "vendor"); err != nil {
t.Fatal(err)
}
if _, err := mt.env.invokeGo(context.Background(), "clean", "-modcache"); err != nil {
t.Fatal(err)
}
// Clear out the resolver's cache, since we've changed the environment.
mt.resolver = newModuleResolver(mt.env)
mt.env.Env["GOFLAGS"] = "-mod=vendor"
mt.assertModuleFoundInDir("rsc.io/sampler", "sampler", `/vendor/`)
}
// 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) {
mt := setup(t, `
-- go.mod --
module m
go 1.14
require rsc.io/sampler v1.3.1
-- x.go --
package x
import _ "rsc.io/sampler"
`, "")
defer mt.cleanup()
// Populate vendor/.
if _, err := mt.env.invokeGo(context.Background(), "mod", "vendor"); err != nil {
t.Fatal(err)
}
wantDir := `pkg.*mod.*/sampler@.*$`
if testenv.Go1Point() >= 14 {
wantDir = `/vendor/`
}
mt.assertModuleFoundInDir("rsc.io/sampler", "sampler", wantDir)
}
// 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) {
mt := setup(t, `
-- go.mod --
module x
require rsc.io/quote v1.5.1
replace rsc.io/sampler v1.3.0 => rsc.io/sampler v1.3.1
-- x.go --
package x
import _ "rsc.io/quote"
`, "")
defer mt.cleanup()
mt.assertModuleFoundInDir("rsc.io/sampler", "sampler", `pkg.mod.*/sampler@v1.3.1$`)
}
// Tests that a local replace works. Adapted from mod_local_replace.txt.
func TestModLocalReplace(t *testing.T) {
mt := setup(t, `
-- x/y/go.mod --
module x/y
require zz v1.0.0
replace zz v1.0.0 => ../z
-- x/y/y.go --
package y
import _ "zz"
-- x/z/go.mod --
module x/z
-- x/z/z.go --
package z
`, "x/y")
defer mt.cleanup()
mt.assertFound("zz", "z")
}
// 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) {
mt := setup(t, `
-- go.mod --
module rsc.io/quote
-- x.go --
package quote
`, "")
defer mt.cleanup()
mt.assertModuleFoundInDir("rsc.io/quote", "quote", `/main`)
}
// 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) {
mt := setup(t, `
-- go.mod --
module rsc.io/quote
require rsc.io/quote/v2 v2.0.1
-- x.go --
package quote
import _ "rsc.io/quote/v2"
`, "")
defer mt.cleanup()
mt.assertModuleFoundInDir("rsc.io/quote", "quote", `/main`)
mt.assertModuleFoundInDir("rsc.io/quote/v2", "quote", `pkg.mod.*/v2@v2.0.1$`)
}
// 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) {
mt := setup(t, `
-- go.mod --
module rsc.io/quote
require rsc.io/quote/v2 v2.0.1
-- x.go --
package quote
import _ "rsc.io/quote/v2"
-- v2/go.mod --
package rsc.io/quote/v2
-- v2/x.go --
package quote
import _ "rsc.io/quote/v2"
`, "")
defer mt.cleanup()
mt.assertModuleFoundInDir("rsc.io/quote", "quote", `/main`)
mt.assertModuleFoundInDir("rsc.io/quote/v2", "quote", `pkg.mod.*/v2@v2.0.1$`)
}
// Tests a simple module dependency. Adapted from the first part of mod_replace.txt.
func TestModReplace1(t *testing.T) {
mt := setup(t, `
-- go.mod --
module quoter
require rsc.io/quote/v3 v3.0.0
-- main.go --
package main
`, "")
defer mt.cleanup()
mt.assertFound("rsc.io/quote/v3", "quote")
}
// Tests a local replace. Adapted from the second part of mod_replace.txt.
func TestModReplace2(t *testing.T) {
mt := setup(t, `
-- go.mod --
module quoter
require rsc.io/quote/v3 v3.0.0
replace rsc.io/quote/v3 => ./local/rsc.io/quote/v3
-- main.go --
package main
-- local/rsc.io/quote/v3/go.mod --
module rsc.io/quote/v3
require rsc.io/sampler v1.3.0
-- local/rsc.io/quote/v3/quote.go --
package quote
import "rsc.io/sampler"
`, "")
defer mt.cleanup()
mt.assertModuleFoundInDir("rsc.io/quote/v3", "quote", `/local/rsc.io/quote/v3`)
}
// 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) {
mt := setup(t, `
-- go.mod --
module quoter
require not-rsc.io/quote/v3 v3.1.0
replace not-rsc.io/quote/v3 v3.1.0 => ./local/rsc.io/quote/v3
-- usenewmodule/main.go --
package main
-- local/rsc.io/quote/v3/go.mod --
module rsc.io/quote/v3
require rsc.io/sampler v1.3.0
-- local/rsc.io/quote/v3/quote.go --
package quote
-- local/not-rsc.io/quote/v3/go.mod --
module not-rsc.io/quote/v3
-- local/not-rsc.io/quote/v3/quote.go --
package quote
`, "")
defer mt.cleanup()
mt.assertModuleFoundInDir("not-rsc.io/quote/v3", "quote", "local/rsc.io/quote/v3")
}
// 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) {
mt := setup(t, `
-- go.mod --
module example.com/m
replace (
example.com/a => ./a
example.com/a/b => ./b
)
replace (
example.com/x => ./x
example.com/x/v3 => ./v3
)
replace (
example.com/y/z/w => ./w
example.com/y => ./y
)
replace (
example.com/vv v1.11.0 => ./v11
example.com/vv v1.12.0 => ./v12
example.com/vv => ./vv
)
require (
example.com/a/b v0.0.0
example.com/x/v3 v3.0.0
example.com/y v0.0.0
example.com/y/z/w v0.0.0
example.com/vv v1.12.0
)
-- m.go --
package main
import (
_ "example.com/a/b"
_ "example.com/x/v3"
_ "example.com/y/z/w"
_ "example.com/vv"
)
func main() {}
-- a/go.mod --
module a.localhost
-- a/a.go --
package a
-- a/b/b.go--
package b
-- b/go.mod --
module a.localhost/b
-- b/b.go --
package b
-- x/go.mod --
module x.localhost
-- x/x.go --
package x
-- x/v3.go --
package v3
import _ "x.localhost/v3"
-- v3/go.mod --
module x.localhost/v3
-- v3/x.go --
package x
-- w/go.mod --
module w.localhost
-- w/skip/skip.go --
// Package skip is nested below nonexistent package w.
package skip
-- y/go.mod --
module y.localhost
-- y/z/w/w.go --
package w
-- v12/go.mod --
module v.localhost
-- v12/v.go --
package v
-- v11/go.mod --
module v.localhost
-- v11/v.go --
package v
-- vv/go.mod --
module v.localhost
-- vv/v.go --
package v
`, "")
defer mt.cleanup()
mt.assertModuleFoundInDir("example.com/a/b", "b", `main/b$`)
mt.assertModuleFoundInDir("example.com/x/v3", "x", `main/v3$`)
mt.assertModuleFoundInDir("example.com/y/z/w", "w", `main/y/z/w$`)
mt.assertModuleFoundInDir("example.com/vv", "v", `main/v12$`)
}
// Tests that we handle GO111MODULE=on with no go.mod file. See #30855.
func TestNoMainModule(t *testing.T) {
testenv.NeedsGo1Point(t, 12)
mt := setup(t, `
-- x.go --
package x
`, "")
defer mt.cleanup()
if _, err := mt.env.invokeGo(context.Background(), "mod", "download", "rsc.io/quote@v1.5.1"); err != nil {
t.Fatal(err)
}
mt.assertScanFinds("rsc.io/quote", "quote")
}
// 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) {
t.Helper()
names, err := t.resolver.loadPackageNames([]string{importPath}, t.env.WorkingDir)
if err != nil {
t.Errorf("loading package name for %v: %v", importPath, err)
}
if names[importPath] != pkgName {
t.Errorf("package name for %v = %v, want %v", importPath, names[importPath], pkgName)
}
pkg := t.assertScanFinds(importPath, pkgName)
_, foundDir := t.resolver.findPackage(importPath)
return foundDir, pkg
}
func (t *modTest) assertScanFinds(importPath, pkgName string) *pkg {
t.Helper()
scan, err := scanToSlice(t.resolver, nil)
if err != nil {
t.Errorf("scan failed: %v", err)
}
for _, pkg := range scan {
if pkg.importPathShort == importPath {
return pkg
}
}
t.Errorf("scanning for %v did not find %v", pkgName, importPath)
return nil
}
func scanToSlice(resolver Resolver, exclude []gopathwalk.RootType) ([]*pkg, error) {
var mu sync.Mutex
var result []*pkg
filter := &scanCallback{
rootFound: func(root gopathwalk.Root) bool {
for _, rt := range exclude {
if root.Type == rt {
return false
}
}
return true
},
dirFound: func(pkg *pkg) bool {
return true
},
packageNameLoaded: func(pkg *pkg) bool {
mu.Lock()
defer mu.Unlock()
result = append(result, pkg)
return false
},
}
err := resolver.scan(context.Background(), filter)
return result, err
}
// 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) {
t.Helper()
dir, pkg := t.assertFound(importPath, pkgName)
re, err := regexp.Compile(dirRE)
if err != nil {
t.Fatal(err)
}
if dir == "" {
t.Errorf("import path %v not found in active modules", importPath)
} else {
if !re.MatchString(filepath.ToSlash(dir)) {
t.Errorf("finding dir for %s: dir = %q did not match regex %q", importPath, dir, dirRE)
}
}
if pkg != nil {
if !re.MatchString(filepath.ToSlash(pkg.dir)) {
t.Errorf("scanning for %s: dir = %q did not match regex %q", pkgName, pkg.dir, dirRE)
}
}
}
var proxyOnce sync.Once
var proxyDir string
type modTest struct {
*testing.T
env *ProcessEnv
gopath string
resolver *ModuleResolver
cleanup func()
}
// setup builds a test environment from a txtar and supporting modules
// in testdata/mod, along the lines of TestScript in cmd/go.
func setup(t *testing.T, main, wd string) *modTest {
t.Helper()
testenv.NeedsGo1Point(t, 11)
testenv.NeedsTool(t, "go")
proxyOnce.Do(func() {
var err error
proxyDir, err = ioutil.TempDir("", "proxy-")
if err != nil {
t.Fatal(err)
}
if err := writeProxy(proxyDir, "testdata/mod"); err != nil {
t.Fatal(err)
}
})
dir, err := ioutil.TempDir("", t.Name())
if err != nil {
t.Fatal(err)
}
mainDir := filepath.Join(dir, "main")
if err := writeModule(mainDir, main); err != nil {
t.Fatal(err)
}
env := &ProcessEnv{
Env: map[string]string{
"GOPATH": filepath.Join(dir, "gopath"),
"GOMODCACHE": "",
"GO111MODULE": "on",
"GOSUMDB": "off",
"GOPROXY": proxydir.ToURL(proxyDir),
},
WorkingDir: filepath.Join(mainDir, wd),
GocmdRunner: &gocommand.Runner{},
}
if *testDebug {
env.Logf = log.Printf
}
// go mod download gets mad if we don't have a go.mod, so make sure we do.
_, err = os.Stat(filepath.Join(mainDir, "go.mod"))
if err != nil && !os.IsNotExist(err) {
t.Fatalf("checking if go.mod exists: %v", err)
}
if err == nil {
if _, err := env.invokeGo(context.Background(), "mod", "download", "all"); err != nil {
t.Fatal(err)
}
}
resolver, err := env.GetResolver()
if err != nil {
t.Fatal(err)
}
return &modTest{
T: t,
gopath: env.Env["GOPATH"],
env: env,
resolver: resolver.(*ModuleResolver),
cleanup: func() { removeDir(dir) },
}
}
// writeModule writes the module in the ar, a txtar, to dir.
func writeModule(dir, ar string) error {
a := txtar.Parse([]byte(ar))
for _, f := range a.Files {
fpath := filepath.Join(dir, f.Name)
if err := os.MkdirAll(filepath.Dir(fpath), 0755); err != nil {
return err
}
if err := ioutil.WriteFile(fpath, f.Data, 0644); err != nil {
return err
}
}
return nil
}
// writeProxy writes all the txtar-formatted modules in arDir to a proxy
// directory in dir.
func writeProxy(dir, arDir string) error {
files, err := ioutil.ReadDir(arDir)
if err != nil {
return err
}
for _, fi := range files {
if err := writeProxyModule(dir, filepath.Join(arDir, fi.Name())); err != nil {
return err
}
}
return nil
}
// writeProxyModule writes a txtar-formatted module at arPath to the module
// proxy in base.
func writeProxyModule(base, arPath string) error {
arName := filepath.Base(arPath)
i := strings.LastIndex(arName, "_v")
ver := strings.TrimSuffix(arName[i+1:], ".txt")
modDir := strings.Replace(arName[:i], "_", "/", -1)
modPath, err := module.UnescapePath(modDir)
if err != nil {
return err
}
dir := filepath.Join(base, modDir, "@v")
a, err := txtar.ParseFile(arPath)
if err != nil {
return err
}
if err := os.MkdirAll(dir, 0755); err != nil {
return err
}
f, err := os.OpenFile(filepath.Join(dir, ver+".zip"), os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
return err
}
z := zip.NewWriter(f)
for _, f := range a.Files {
if f.Name[0] == '.' {
if err := ioutil.WriteFile(filepath.Join(dir, ver+f.Name), f.Data, 0644); err != nil {
return err
}
} else {
zf, err := z.Create(modPath + "@" + ver + "/" + f.Name)
if err != nil {
return err
}
if _, err := zf.Write(f.Data); err != nil {
return err
}
}
}
if err := z.Close(); err != nil {
return err
}
if err := f.Close(); err != nil {
return err
}
list, err := os.OpenFile(filepath.Join(dir, "list"), os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
if err != nil {
return err
}
if _, err := fmt.Fprintf(list, "%s\n", ver); err != nil {
return err
}
if err := list.Close(); err != nil {
return err
}
return nil
}
func removeDir(dir string) {
_ = filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
if err != nil {
return nil
}
if info.IsDir() {
_ = os.Chmod(path, 0777)
}
return nil
})
_ = os.RemoveAll(dir) // ignore errors
}
// Tests that findModFile can find the mod files from a path in the module cache.
func TestFindModFileModCache(t *testing.T) {
mt := setup(t, `
-- go.mod --
module x
require rsc.io/quote v1.5.2
-- x.go --
package x
import _ "rsc.io/quote"
`, "")
defer mt.cleanup()
want := filepath.Join(mt.gopath, "pkg/mod", "rsc.io/quote@v1.5.2")
found := mt.assertScanFinds("rsc.io/quote", "quote")
modDir, _ := mt.resolver.modInfo(found.dir)
if modDir != want {
t.Errorf("expected: %s, got: %s", want, modDir)
}
}
// Tests that crud in the module cache is ignored.
func TestInvalidModCache(t *testing.T) {
testenv.NeedsGo1Point(t, 11)
dir, err := ioutil.TempDir("", t.Name())
if err != nil {
t.Fatal(err)
}
defer removeDir(dir)
// This doesn't have module@version like it should.
if err := os.MkdirAll(filepath.Join(dir, "gopath/pkg/mod/sabotage"), 0777); err != nil {
t.Fatal(err)
}
if err := ioutil.WriteFile(filepath.Join(dir, "gopath/pkg/mod/sabotage/x.go"), []byte("package foo\n"), 0777); err != nil {
t.Fatal(err)
}
env := &ProcessEnv{
Env: map[string]string{
"GOPATH": filepath.Join(dir, "gopath"),
"GO111MODULE": "on",
"GOSUMDB": "off",
},
GocmdRunner: &gocommand.Runner{},
WorkingDir: dir,
}
resolver, err := env.GetResolver()
if err != nil {
t.Fatal(err)
}
scanToSlice(resolver, nil)
}
func TestGetCandidatesRanking(t *testing.T) {
mt := setup(t, `
-- go.mod --
module example.com
require rsc.io/quote v1.5.1
require rsc.io/quote/v3 v3.0.0
-- rpackage/x.go --
package rpackage
import (
_ "rsc.io/quote"
_ "rsc.io/quote/v3"
)
`, "")
defer mt.cleanup()
if _, err := mt.env.invokeGo(context.Background(), "mod", "download", "rsc.io/quote/v2@v2.0.1"); err != nil {
t.Fatal(err)
}
type res struct {
relevance float64
name, path string
}
want := []res{
// Stdlib
{7, "bytes", "bytes"},
{7, "http", "net/http"},
// Main module
{6, "rpackage", "example.com/rpackage"},
// Direct module deps with v2+ major version
{5.003, "quote", "rsc.io/quote/v3"},
// Direct module deps
{5, "quote", "rsc.io/quote"},
// Indirect deps
{4, "language", "golang.org/x/text/language"},
// Out of scope modules
{3, "quote", "rsc.io/quote/v2"},
}
var mu sync.Mutex
var got []res
add := func(c ImportFix) {
mu.Lock()
defer mu.Unlock()
for _, w := range want {
if c.StmtInfo.ImportPath == w.path {
got = append(got, res{c.Relevance, c.IdentName, c.StmtInfo.ImportPath})
}
}
}
if err := GetAllCandidates(context.Background(), add, "", "foo.go", "foo", mt.env); err != nil {
t.Fatalf("getAllCandidates() = %v", err)
}
sort.Slice(got, func(i, j int) bool {
ri, rj := got[i], got[j]
if ri.relevance != rj.relevance {
return ri.relevance > rj.relevance // Highest first.
}
return ri.name < rj.name
})
if !reflect.DeepEqual(want, got) {
t.Errorf("wanted candidates in order %v, got %v", want, got)
}
}
func BenchmarkScanModCache(b *testing.B) {
testenv.NeedsGo1Point(b, 11)
env := &ProcessEnv{
GocmdRunner: &gocommand.Runner{},
Logf: log.Printf,
}
exclude := []gopathwalk.RootType{gopathwalk.RootGOROOT}
resolver, err := env.GetResolver()
if err != nil {
b.Fatal(err)
}
scanToSlice(resolver, exclude)
b.ResetTimer()
for i := 0; i < b.N; i++ {
scanToSlice(resolver, exclude)
resolver.(*ModuleResolver).ClearForNewScan()
}
}