--- /dev/null
+// 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 tests exports functionality to be used across a variety of gopls tests.
+package tests
+
+import (
+ "bytes"
+ "context"
+ "flag"
+ "fmt"
+ "go/ast"
+ "go/token"
+ "io/ioutil"
+ "os"
+ "path/filepath"
+ "regexp"
+ "sort"
+ "strconv"
+ "strings"
+ "sync"
+ "testing"
+ "time"
+
+ "golang.org/x/tools/go/expect"
+ "golang.org/x/tools/go/packages"
+ "golang.org/x/tools/go/packages/packagestest"
+ "golang.org/x/tools/internal/lsp/protocol"
+ "golang.org/x/tools/internal/lsp/source"
+ "golang.org/x/tools/internal/lsp/source/completion"
+ "golang.org/x/tools/internal/span"
+ "golang.org/x/tools/internal/testenv"
+ "golang.org/x/tools/txtar"
+)
+
+const (
+ overlayFileSuffix = ".overlay"
+ goldenFileSuffix = ".golden"
+ inFileSuffix = ".in"
+ summaryFile = "summary.txt"
+ testModule = "golang.org/x/tools/internal/lsp"
+)
+
+var UpdateGolden = flag.Bool("golden", false, "Update golden files")
+
+type CallHierarchy map[span.Span]*CallHierarchyResult
+type CodeLens map[span.URI][]protocol.CodeLens
+type Diagnostics map[span.URI][]*source.Diagnostic
+type CompletionItems map[token.Pos]*completion.CompletionItem
+type Completions map[span.Span][]Completion
+type CompletionSnippets map[span.Span][]CompletionSnippet
+type UnimportedCompletions map[span.Span][]Completion
+type DeepCompletions map[span.Span][]Completion
+type FuzzyCompletions map[span.Span][]Completion
+type CaseSensitiveCompletions map[span.Span][]Completion
+type RankCompletions map[span.Span][]Completion
+type FoldingRanges []span.Span
+type Formats []span.Span
+type Imports []span.Span
+type SemanticTokens []span.Span
+type SuggestedFixes map[span.Span][]string
+type FunctionExtractions map[span.Span]span.Span
+type Definitions map[span.Span]Definition
+type Implementations map[span.Span][]span.Span
+type Highlights map[span.Span][]span.Span
+type References map[span.Span][]span.Span
+type Renames map[span.Span]string
+type PrepareRenames map[span.Span]*source.PrepareItem
+type Symbols map[span.URI][]protocol.DocumentSymbol
+type SymbolsChildren map[string][]protocol.DocumentSymbol
+type SymbolInformation map[span.Span]protocol.SymbolInformation
+type WorkspaceSymbols map[string][]protocol.SymbolInformation
+type Signatures map[span.Span]*protocol.SignatureHelp
+type Links map[span.URI][]Link
+
+type Data struct {
+ Config packages.Config
+ Exported *packagestest.Exported
+ CallHierarchy CallHierarchy
+ CodeLens CodeLens
+ Diagnostics Diagnostics
+ CompletionItems CompletionItems
+ Completions Completions
+ CompletionSnippets CompletionSnippets
+ UnimportedCompletions UnimportedCompletions
+ DeepCompletions DeepCompletions
+ FuzzyCompletions FuzzyCompletions
+ CaseSensitiveCompletions CaseSensitiveCompletions
+ RankCompletions RankCompletions
+ FoldingRanges FoldingRanges
+ Formats Formats
+ Imports Imports
+ SemanticTokens SemanticTokens
+ SuggestedFixes SuggestedFixes
+ FunctionExtractions FunctionExtractions
+ Definitions Definitions
+ Implementations Implementations
+ Highlights Highlights
+ References References
+ Renames Renames
+ PrepareRenames PrepareRenames
+ Symbols Symbols
+ symbolsChildren SymbolsChildren
+ symbolInformation SymbolInformation
+ WorkspaceSymbols WorkspaceSymbols
+ FuzzyWorkspaceSymbols WorkspaceSymbols
+ CaseSensitiveWorkspaceSymbols WorkspaceSymbols
+ Signatures Signatures
+ Links Links
+
+ t testing.TB
+ fragments map[string]string
+ dir string
+ golden map[string]*Golden
+ mode string
+
+ ModfileFlagAvailable bool
+
+ mappersMu sync.Mutex
+ mappers map[span.URI]*protocol.ColumnMapper
+}
+
+type Tests interface {
+ CallHierarchy(*testing.T, span.Span, *CallHierarchyResult)
+ CodeLens(*testing.T, span.URI, []protocol.CodeLens)
+ Diagnostics(*testing.T, span.URI, []*source.Diagnostic)
+ Completion(*testing.T, span.Span, Completion, CompletionItems)
+ CompletionSnippet(*testing.T, span.Span, CompletionSnippet, bool, CompletionItems)
+ UnimportedCompletion(*testing.T, span.Span, Completion, CompletionItems)
+ DeepCompletion(*testing.T, span.Span, Completion, CompletionItems)
+ FuzzyCompletion(*testing.T, span.Span, Completion, CompletionItems)
+ CaseSensitiveCompletion(*testing.T, span.Span, Completion, CompletionItems)
+ RankCompletion(*testing.T, span.Span, Completion, CompletionItems)
+ FoldingRanges(*testing.T, span.Span)
+ Format(*testing.T, span.Span)
+ Import(*testing.T, span.Span)
+ SemanticTokens(*testing.T, span.Span)
+ SuggestedFix(*testing.T, span.Span, []string)
+ FunctionExtraction(*testing.T, span.Span, span.Span)
+ Definition(*testing.T, span.Span, Definition)
+ Implementation(*testing.T, span.Span, []span.Span)
+ Highlight(*testing.T, span.Span, []span.Span)
+ References(*testing.T, span.Span, []span.Span)
+ Rename(*testing.T, span.Span, string)
+ PrepareRename(*testing.T, span.Span, *source.PrepareItem)
+ Symbols(*testing.T, span.URI, []protocol.DocumentSymbol)
+ WorkspaceSymbols(*testing.T, string, []protocol.SymbolInformation, map[string]struct{})
+ FuzzyWorkspaceSymbols(*testing.T, string, []protocol.SymbolInformation, map[string]struct{})
+ CaseSensitiveWorkspaceSymbols(*testing.T, string, []protocol.SymbolInformation, map[string]struct{})
+ SignatureHelp(*testing.T, span.Span, *protocol.SignatureHelp)
+ Link(*testing.T, span.URI, []Link)
+}
+
+type Definition struct {
+ Name string
+ IsType bool
+ OnlyHover bool
+ Src, Def span.Span
+}
+
+type CompletionTestType int
+
+const (
+ // Default runs the standard completion tests.
+ CompletionDefault = CompletionTestType(iota)
+
+ // Unimported tests the autocompletion of unimported packages.
+ CompletionUnimported
+
+ // Deep tests deep completion.
+ CompletionDeep
+
+ // Fuzzy tests deep completion and fuzzy matching.
+ CompletionFuzzy
+
+ // CaseSensitive tests case sensitive completion.
+ CompletionCaseSensitive
+
+ // CompletionRank candidates in test must be valid and in the right relative order.
+ CompletionRank
+)
+
+type WorkspaceSymbolsTestType int
+
+const (
+ // Default runs the standard workspace symbols tests.
+ WorkspaceSymbolsDefault = WorkspaceSymbolsTestType(iota)
+
+ // Fuzzy tests workspace symbols with fuzzy matching.
+ WorkspaceSymbolsFuzzy
+
+ // CaseSensitive tests workspace symbols with case sensitive.
+ WorkspaceSymbolsCaseSensitive
+)
+
+type Completion struct {
+ CompletionItems []token.Pos
+}
+
+type CompletionSnippet struct {
+ CompletionItem token.Pos
+ PlainSnippet string
+ PlaceholderSnippet string
+}
+
+type CallHierarchyResult struct {
+ IncomingCalls, OutgoingCalls []protocol.CallHierarchyItem
+}
+
+type Link struct {
+ Src span.Span
+ Target string
+ NotePosition token.Position
+}
+
+type Golden struct {
+ Filename string
+ Archive *txtar.Archive
+ Modified bool
+}
+
+func Context(t testing.TB) context.Context {
+ return context.Background()
+}
+
+func DefaultOptions(o *source.Options) {
+ o.SupportedCodeActions = map[source.FileKind]map[protocol.CodeActionKind]bool{
+ source.Go: {
+ protocol.SourceOrganizeImports: true,
+ protocol.QuickFix: true,
+ protocol.RefactorRewrite: true,
+ protocol.RefactorExtract: true,
+ protocol.SourceFixAll: true,
+ },
+ source.Mod: {
+ protocol.SourceOrganizeImports: true,
+ },
+ source.Sum: {},
+ }
+ o.ExperimentalOptions.Codelens[source.CommandTest.Name] = true
+ o.HoverKind = source.SynopsisDocumentation
+ o.InsertTextFormat = protocol.SnippetTextFormat
+ o.CompletionBudget = time.Minute
+ o.HierarchicalDocumentSymbolSupport = true
+ o.ExperimentalWorkspaceModule = true
+ o.SemanticTokens = true
+}
+
+func RunTests(t *testing.T, dataDir string, includeMultiModule bool, f func(*testing.T, *Data)) {
+ t.Helper()
+ modes := []string{"Modules", "GOPATH"}
+ if includeMultiModule {
+ modes = append(modes, "MultiModule")
+ }
+ for _, mode := range modes {
+ t.Run(mode, func(t *testing.T) {
+ t.Helper()
+ if mode == "MultiModule" {
+ // Some bug in 1.12 breaks reading markers, and it's not worth figuring out.
+ testenv.NeedsGo1Point(t, 13)
+ }
+ datum := load(t, mode, dataDir)
+ f(t, datum)
+ })
+ }
+}
+
+func load(t testing.TB, mode string, dir string) *Data {
+ t.Helper()
+
+ datum := &Data{
+ CallHierarchy: make(CallHierarchy),
+ CodeLens: make(CodeLens),
+ Diagnostics: make(Diagnostics),
+ CompletionItems: make(CompletionItems),
+ Completions: make(Completions),
+ CompletionSnippets: make(CompletionSnippets),
+ UnimportedCompletions: make(UnimportedCompletions),
+ DeepCompletions: make(DeepCompletions),
+ FuzzyCompletions: make(FuzzyCompletions),
+ RankCompletions: make(RankCompletions),
+ CaseSensitiveCompletions: make(CaseSensitiveCompletions),
+ Definitions: make(Definitions),
+ Implementations: make(Implementations),
+ Highlights: make(Highlights),
+ References: make(References),
+ Renames: make(Renames),
+ PrepareRenames: make(PrepareRenames),
+ SuggestedFixes: make(SuggestedFixes),
+ FunctionExtractions: make(FunctionExtractions),
+ Symbols: make(Symbols),
+ symbolsChildren: make(SymbolsChildren),
+ symbolInformation: make(SymbolInformation),
+ WorkspaceSymbols: make(WorkspaceSymbols),
+ FuzzyWorkspaceSymbols: make(WorkspaceSymbols),
+ CaseSensitiveWorkspaceSymbols: make(WorkspaceSymbols),
+ Signatures: make(Signatures),
+ Links: make(Links),
+
+ t: t,
+ dir: dir,
+ fragments: map[string]string{},
+ golden: map[string]*Golden{},
+ mode: mode,
+ mappers: map[span.URI]*protocol.ColumnMapper{},
+ }
+
+ if !*UpdateGolden {
+ summary := filepath.Join(filepath.FromSlash(dir), summaryFile+goldenFileSuffix)
+ if _, err := os.Stat(summary); os.IsNotExist(err) {
+ t.Fatalf("could not find golden file summary.txt in %#v", dir)
+ }
+ archive, err := txtar.ParseFile(summary)
+ if err != nil {
+ t.Fatalf("could not read golden file %v/%v: %v", dir, summary, err)
+ }
+ datum.golden[summaryFile] = &Golden{
+ Filename: summary,
+ Archive: archive,
+ }
+ }
+
+ files := packagestest.MustCopyFileTree(dir)
+ overlays := map[string][]byte{}
+ for fragment, operation := range files {
+ if trimmed := strings.TrimSuffix(fragment, goldenFileSuffix); trimmed != fragment {
+ delete(files, fragment)
+ goldFile := filepath.Join(dir, fragment)
+ archive, err := txtar.ParseFile(goldFile)
+ if err != nil {
+ t.Fatalf("could not read golden file %v: %v", fragment, err)
+ }
+ datum.golden[trimmed] = &Golden{
+ Filename: goldFile,
+ Archive: archive,
+ }
+ } else if trimmed := strings.TrimSuffix(fragment, inFileSuffix); trimmed != fragment {
+ delete(files, fragment)
+ files[trimmed] = operation
+ } else if index := strings.Index(fragment, overlayFileSuffix); index >= 0 {
+ delete(files, fragment)
+ partial := fragment[:index] + fragment[index+len(overlayFileSuffix):]
+ contents, err := ioutil.ReadFile(filepath.Join(dir, fragment))
+ if err != nil {
+ t.Fatal(err)
+ }
+ overlays[partial] = contents
+ }
+ }
+
+ modules := []packagestest.Module{
+ {
+ Name: testModule,
+ Files: files,
+ Overlay: overlays,
+ },
+ }
+ switch mode {
+ case "Modules":
+ datum.Exported = packagestest.Export(t, packagestest.Modules, modules)
+ case "GOPATH":
+ datum.Exported = packagestest.Export(t, packagestest.GOPATH, modules)
+ case "MultiModule":
+ files := map[string]interface{}{}
+ for k, v := range modules[0].Files {
+ files[filepath.Join("testmodule", k)] = v
+ }
+ modules[0].Files = files
+
+ overlays := map[string][]byte{}
+ for k, v := range modules[0].Overlay {
+ overlays[filepath.Join("testmodule", k)] = v
+ }
+ modules[0].Overlay = overlays
+
+ golden := map[string]*Golden{}
+ for k, v := range datum.golden {
+ if k == summaryFile {
+ golden[k] = v
+ } else {
+ golden[filepath.Join("testmodule", k)] = v
+ }
+ }
+ datum.golden = golden
+
+ datum.Exported = packagestest.Export(t, packagestest.Modules, modules)
+ default:
+ panic("unknown mode " + mode)
+ }
+
+ for _, m := range modules {
+ for fragment := range m.Files {
+ filename := datum.Exported.File(m.Name, fragment)
+ datum.fragments[filename] = fragment
+ }
+ }
+
+ // Turn off go/packages debug logging.
+ datum.Exported.Config.Logf = nil
+ datum.Config.Logf = nil
+
+ // Merge the exported.Config with the view.Config.
+ datum.Config = *datum.Exported.Config
+ datum.Config.Fset = token.NewFileSet()
+ datum.Config.Context = Context(nil)
+ datum.Config.ParseFile = func(fset *token.FileSet, filename string, src []byte) (*ast.File, error) {
+ panic("ParseFile should not be called")
+ }
+
+ // Do a first pass to collect special markers for completion and workspace symbols.
+ if err := datum.Exported.Expect(map[string]interface{}{
+ "item": func(name string, r packagestest.Range, _ []string) {
+ datum.Exported.Mark(name, r)
+ },
+ "symbol": func(name string, r packagestest.Range, _ []string) {
+ datum.Exported.Mark(name, r)
+ },
+ }); err != nil {
+ t.Fatal(err)
+ }
+
+ // Collect any data that needs to be used by subsequent tests.
+ if err := datum.Exported.Expect(map[string]interface{}{
+ "codelens": datum.collectCodeLens,
+ "diag": datum.collectDiagnostics,
+ "item": datum.collectCompletionItems,
+ "complete": datum.collectCompletions(CompletionDefault),
+ "unimported": datum.collectCompletions(CompletionUnimported),
+ "deep": datum.collectCompletions(CompletionDeep),
+ "fuzzy": datum.collectCompletions(CompletionFuzzy),
+ "casesensitive": datum.collectCompletions(CompletionCaseSensitive),
+ "rank": datum.collectCompletions(CompletionRank),
+ "snippet": datum.collectCompletionSnippets,
+ "fold": datum.collectFoldingRanges,
+ "format": datum.collectFormats,
+ "import": datum.collectImports,
+ "semantic": datum.collectSemanticTokens,
+ "godef": datum.collectDefinitions,
+ "implementations": datum.collectImplementations,
+ "typdef": datum.collectTypeDefinitions,
+ "hover": datum.collectHoverDefinitions,
+ "highlight": datum.collectHighlights,
+ "refs": datum.collectReferences,
+ "rename": datum.collectRenames,
+ "prepare": datum.collectPrepareRenames,
+ "symbol": datum.collectSymbols,
+ "signature": datum.collectSignatures,
+ "link": datum.collectLinks,
+ "suggestedfix": datum.collectSuggestedFixes,
+ "extractfunc": datum.collectFunctionExtractions,
+ "incomingcalls": datum.collectIncomingCalls,
+ "outgoingcalls": datum.collectOutgoingCalls,
+ }); err != nil {
+ t.Fatal(err)
+ }
+ for _, symbols := range datum.Symbols {
+ for i := range symbols {
+ children := datum.symbolsChildren[symbols[i].Name]
+ symbols[i].Children = children
+ }
+ }
+ // Collect names for the entries that require golden files.
+ if err := datum.Exported.Expect(map[string]interface{}{
+ "godef": datum.collectDefinitionNames,
+ "hover": datum.collectDefinitionNames,
+ "workspacesymbol": datum.collectWorkspaceSymbols(WorkspaceSymbolsDefault),
+ "workspacesymbolfuzzy": datum.collectWorkspaceSymbols(WorkspaceSymbolsFuzzy),
+ "workspacesymbolcasesensitive": datum.collectWorkspaceSymbols(WorkspaceSymbolsCaseSensitive),
+ }); err != nil {
+ t.Fatal(err)
+ }
+ if mode == "MultiModule" {
+ if err := os.Rename(filepath.Join(datum.Config.Dir, "go.mod"), filepath.Join(datum.Config.Dir, "testmodule/go.mod")); err != nil {
+ t.Fatal(err)
+ }
+ }
+
+ return datum
+}
+
+func Run(t *testing.T, tests Tests, data *Data) {
+ t.Helper()
+ checkData(t, data)
+
+ eachCompletion := func(t *testing.T, cases map[span.Span][]Completion, test func(*testing.T, span.Span, Completion, CompletionItems)) {
+ t.Helper()
+
+ for src, exp := range cases {
+ for i, e := range exp {
+ t.Run(SpanName(src)+"_"+strconv.Itoa(i), func(t *testing.T) {
+ t.Helper()
+ if strings.Contains(t.Name(), "complit") || strings.Contains(t.Name(), "UnimportedCompletion") {
+ if data.mode == "MultiModule" {
+ t.Skip("Unimported completions are broken in multi-module mode")
+ }
+ }
+ if strings.Contains(t.Name(), "cgo") {
+ testenv.NeedsTool(t, "cgo")
+ }
+ if strings.Contains(t.Name(), "declarecgo") {
+ testenv.NeedsGo1Point(t, 15)
+ }
+ test(t, src, e, data.CompletionItems)
+ })
+ }
+
+ }
+ }
+
+ eachWorkspaceSymbols := func(t *testing.T, cases map[string][]protocol.SymbolInformation, test func(*testing.T, string, []protocol.SymbolInformation, map[string]struct{})) {
+ t.Helper()
+
+ for query, expectedSymbols := range cases {
+ name := query
+ if name == "" {
+ name = "EmptyQuery"
+ }
+ t.Run(name, func(t *testing.T) {
+ t.Helper()
+ dirs := make(map[string]struct{})
+ for _, si := range expectedSymbols {
+ d := filepath.Dir(si.Location.URI.SpanURI().Filename())
+ if _, ok := dirs[d]; !ok {
+ dirs[d] = struct{}{}
+ }
+ }
+ test(t, query, expectedSymbols, dirs)
+ })
+ }
+ }
+
+ t.Run("CallHierarchy", func(t *testing.T) {
+ t.Helper()
+ for spn, callHierarchyResult := range data.CallHierarchy {
+ t.Run(SpanName(spn), func(t *testing.T) {
+ t.Helper()
+ tests.CallHierarchy(t, spn, callHierarchyResult)
+ })
+ }
+ })
+
+ t.Run("Completion", func(t *testing.T) {
+ t.Helper()
+ eachCompletion(t, data.Completions, tests.Completion)
+ })
+
+ t.Run("CompletionSnippets", func(t *testing.T) {
+ t.Helper()
+ for _, placeholders := range []bool{true, false} {
+ for src, expecteds := range data.CompletionSnippets {
+ for i, expected := range expecteds {
+ name := SpanName(src) + "_" + strconv.Itoa(i+1)
+ if placeholders {
+ name += "_placeholders"
+ }
+
+ t.Run(name, func(t *testing.T) {
+ t.Helper()
+ tests.CompletionSnippet(t, src, expected, placeholders, data.CompletionItems)
+ })
+ }
+ }
+ }
+ })
+
+ t.Run("UnimportedCompletion", func(t *testing.T) {
+ t.Helper()
+ eachCompletion(t, data.UnimportedCompletions, tests.UnimportedCompletion)
+ })
+
+ t.Run("DeepCompletion", func(t *testing.T) {
+ t.Helper()
+ eachCompletion(t, data.DeepCompletions, tests.DeepCompletion)
+ })
+
+ t.Run("FuzzyCompletion", func(t *testing.T) {
+ t.Helper()
+ eachCompletion(t, data.FuzzyCompletions, tests.FuzzyCompletion)
+ })
+
+ t.Run("CaseSensitiveCompletion", func(t *testing.T) {
+ t.Helper()
+ eachCompletion(t, data.CaseSensitiveCompletions, tests.CaseSensitiveCompletion)
+ })
+
+ t.Run("RankCompletions", func(t *testing.T) {
+ t.Helper()
+ eachCompletion(t, data.RankCompletions, tests.RankCompletion)
+ })
+
+ t.Run("CodeLens", func(t *testing.T) {
+ t.Helper()
+ for uri, want := range data.CodeLens {
+ // Check if we should skip this URI if the -modfile flag is not available.
+ if shouldSkip(data, uri) {
+ continue
+ }
+ t.Run(uriName(uri), func(t *testing.T) {
+ t.Helper()
+ tests.CodeLens(t, uri, want)
+ })
+ }
+ })
+
+ t.Run("Diagnostics", func(t *testing.T) {
+ t.Helper()
+ for uri, want := range data.Diagnostics {
+ // Check if we should skip this URI if the -modfile flag is not available.
+ if shouldSkip(data, uri) {
+ continue
+ }
+ t.Run(uriName(uri), func(t *testing.T) {
+ t.Helper()
+ tests.Diagnostics(t, uri, want)
+ })
+ }
+ })
+
+ t.Run("FoldingRange", func(t *testing.T) {
+ t.Helper()
+ for _, spn := range data.FoldingRanges {
+ t.Run(uriName(spn.URI()), func(t *testing.T) {
+ t.Helper()
+ tests.FoldingRanges(t, spn)
+ })
+ }
+ })
+
+ t.Run("Format", func(t *testing.T) {
+ t.Helper()
+ for _, spn := range data.Formats {
+ t.Run(uriName(spn.URI()), func(t *testing.T) {
+ t.Helper()
+ tests.Format(t, spn)
+ })
+ }
+ })
+
+ t.Run("Import", func(t *testing.T) {
+ t.Helper()
+ for _, spn := range data.Imports {
+ t.Run(uriName(spn.URI()), func(t *testing.T) {
+ t.Helper()
+ tests.Import(t, spn)
+ })
+ }
+ })
+
+ t.Run("SemanticTokens", func(t *testing.T) {
+ t.Helper()
+ for _, spn := range data.SemanticTokens {
+ t.Run(uriName(spn.URI()), func(t *testing.T) {
+ t.Helper()
+ tests.SemanticTokens(t, spn)
+ })
+ }
+ })
+
+ t.Run("SuggestedFix", func(t *testing.T) {
+ t.Helper()
+ for spn, actionKinds := range data.SuggestedFixes {
+ // Check if we should skip this spn if the -modfile flag is not available.
+ if shouldSkip(data, spn.URI()) {
+ continue
+ }
+ t.Run(SpanName(spn), func(t *testing.T) {
+ t.Helper()
+ tests.SuggestedFix(t, spn, actionKinds)
+ })
+ }
+ })
+
+ t.Run("FunctionExtraction", func(t *testing.T) {
+ t.Helper()
+ for start, end := range data.FunctionExtractions {
+ // Check if we should skip this spn if the -modfile flag is not available.
+ if shouldSkip(data, start.URI()) {
+ continue
+ }
+ t.Run(SpanName(start), func(t *testing.T) {
+ t.Helper()
+ tests.FunctionExtraction(t, start, end)
+ })
+ }
+ })
+
+ t.Run("Definition", func(t *testing.T) {
+ t.Helper()
+ for spn, d := range data.Definitions {
+ t.Run(SpanName(spn), func(t *testing.T) {
+ t.Helper()
+ if strings.Contains(t.Name(), "cgo") {
+ testenv.NeedsTool(t, "cgo")
+ }
+ if strings.Contains(t.Name(), "declarecgo") {
+ testenv.NeedsGo1Point(t, 15)
+ }
+ tests.Definition(t, spn, d)
+ })
+ }
+ })
+
+ t.Run("Implementation", func(t *testing.T) {
+ t.Helper()
+ for spn, m := range data.Implementations {
+ t.Run(SpanName(spn), func(t *testing.T) {
+ t.Helper()
+ tests.Implementation(t, spn, m)
+ })
+ }
+ })
+
+ t.Run("Highlight", func(t *testing.T) {
+ t.Helper()
+ for pos, locations := range data.Highlights {
+ t.Run(SpanName(pos), func(t *testing.T) {
+ t.Helper()
+ tests.Highlight(t, pos, locations)
+ })
+ }
+ })
+
+ t.Run("References", func(t *testing.T) {
+ t.Helper()
+ for src, itemList := range data.References {
+ t.Run(SpanName(src), func(t *testing.T) {
+ t.Helper()
+ tests.References(t, src, itemList)
+ })
+ }
+ })
+
+ t.Run("Renames", func(t *testing.T) {
+ t.Helper()
+ for spn, newText := range data.Renames {
+ t.Run(uriName(spn.URI())+"_"+newText, func(t *testing.T) {
+ t.Helper()
+ tests.Rename(t, spn, newText)
+ })
+ }
+ })
+
+ t.Run("PrepareRenames", func(t *testing.T) {
+ t.Helper()
+ for src, want := range data.PrepareRenames {
+ t.Run(SpanName(src), func(t *testing.T) {
+ t.Helper()
+ tests.PrepareRename(t, src, want)
+ })
+ }
+ })
+
+ t.Run("Symbols", func(t *testing.T) {
+ t.Helper()
+ for uri, expectedSymbols := range data.Symbols {
+ t.Run(uriName(uri), func(t *testing.T) {
+ t.Helper()
+ tests.Symbols(t, uri, expectedSymbols)
+ })
+ }
+ })
+
+ t.Run("WorkspaceSymbols", func(t *testing.T) {
+ t.Helper()
+ eachWorkspaceSymbols(t, data.WorkspaceSymbols, tests.WorkspaceSymbols)
+ })
+
+ t.Run("FuzzyWorkspaceSymbols", func(t *testing.T) {
+ t.Helper()
+ eachWorkspaceSymbols(t, data.FuzzyWorkspaceSymbols, tests.FuzzyWorkspaceSymbols)
+ })
+
+ t.Run("CaseSensitiveWorkspaceSymbols", func(t *testing.T) {
+ t.Helper()
+ eachWorkspaceSymbols(t, data.CaseSensitiveWorkspaceSymbols, tests.CaseSensitiveWorkspaceSymbols)
+ })
+
+ t.Run("SignatureHelp", func(t *testing.T) {
+ t.Helper()
+ for spn, expectedSignature := range data.Signatures {
+ t.Run(SpanName(spn), func(t *testing.T) {
+ t.Helper()
+ tests.SignatureHelp(t, spn, expectedSignature)
+ })
+ }
+ })
+
+ t.Run("Link", func(t *testing.T) {
+ t.Helper()
+ for uri, wantLinks := range data.Links {
+ // If we are testing GOPATH, then we do not want links with
+ // the versions attached (pkg.go.dev/repoa/moda@v1.1.0/pkg),
+ // unless the file is a go.mod, then we can skip it alltogether.
+ if data.Exported.Exporter == packagestest.GOPATH {
+ if strings.HasSuffix(uri.Filename(), ".mod") {
+ continue
+ }
+ re := regexp.MustCompile(`@v\d+\.\d+\.[\w-]+`)
+ for i, link := range wantLinks {
+ wantLinks[i].Target = re.ReplaceAllString(link.Target, "")
+ }
+ }
+ t.Run(uriName(uri), func(t *testing.T) {
+ t.Helper()
+ tests.Link(t, uri, wantLinks)
+ })
+ }
+ })
+
+ if *UpdateGolden {
+ for _, golden := range data.golden {
+ if !golden.Modified {
+ continue
+ }
+ sort.Slice(golden.Archive.Files, func(i, j int) bool {
+ return golden.Archive.Files[i].Name < golden.Archive.Files[j].Name
+ })
+ if err := ioutil.WriteFile(golden.Filename, txtar.Format(golden.Archive), 0666); err != nil {
+ t.Fatal(err)
+ }
+ }
+ }
+}
+
+func checkData(t *testing.T, data *Data) {
+ buf := &bytes.Buffer{}
+ diagnosticsCount := 0
+ for _, want := range data.Diagnostics {
+ diagnosticsCount += len(want)
+ }
+ linksCount := 0
+ for _, want := range data.Links {
+ linksCount += len(want)
+ }
+ definitionCount := 0
+ typeDefinitionCount := 0
+ for _, d := range data.Definitions {
+ if d.IsType {
+ typeDefinitionCount++
+ } else {
+ definitionCount++
+ }
+ }
+
+ snippetCount := 0
+ for _, want := range data.CompletionSnippets {
+ snippetCount += len(want)
+ }
+
+ countCompletions := func(c map[span.Span][]Completion) (count int) {
+ for _, want := range c {
+ count += len(want)
+ }
+ return count
+ }
+
+ countCodeLens := func(c map[span.URI][]protocol.CodeLens) (count int) {
+ for _, want := range c {
+ count += len(want)
+ }
+ return count
+ }
+
+ fmt.Fprintf(buf, "CallHierarchyCount = %v\n", len(data.CallHierarchy))
+ fmt.Fprintf(buf, "CodeLensCount = %v\n", countCodeLens(data.CodeLens))
+ fmt.Fprintf(buf, "CompletionsCount = %v\n", countCompletions(data.Completions))
+ fmt.Fprintf(buf, "CompletionSnippetCount = %v\n", snippetCount)
+ fmt.Fprintf(buf, "UnimportedCompletionsCount = %v\n", countCompletions(data.UnimportedCompletions))
+ fmt.Fprintf(buf, "DeepCompletionsCount = %v\n", countCompletions(data.DeepCompletions))
+ fmt.Fprintf(buf, "FuzzyCompletionsCount = %v\n", countCompletions(data.FuzzyCompletions))
+ fmt.Fprintf(buf, "RankedCompletionsCount = %v\n", countCompletions(data.RankCompletions))
+ fmt.Fprintf(buf, "CaseSensitiveCompletionsCount = %v\n", countCompletions(data.CaseSensitiveCompletions))
+ fmt.Fprintf(buf, "DiagnosticsCount = %v\n", diagnosticsCount)
+ fmt.Fprintf(buf, "FoldingRangesCount = %v\n", len(data.FoldingRanges))
+ fmt.Fprintf(buf, "FormatCount = %v\n", len(data.Formats))
+ fmt.Fprintf(buf, "ImportCount = %v\n", len(data.Imports))
+ fmt.Fprintf(buf, "SemanticTokenCount = %v\n", len(data.SemanticTokens))
+ fmt.Fprintf(buf, "SuggestedFixCount = %v\n", len(data.SuggestedFixes))
+ fmt.Fprintf(buf, "FunctionExtractionCount = %v\n", len(data.FunctionExtractions))
+ fmt.Fprintf(buf, "DefinitionsCount = %v\n", definitionCount)
+ fmt.Fprintf(buf, "TypeDefinitionsCount = %v\n", typeDefinitionCount)
+ fmt.Fprintf(buf, "HighlightsCount = %v\n", len(data.Highlights))
+ fmt.Fprintf(buf, "ReferencesCount = %v\n", len(data.References))
+ fmt.Fprintf(buf, "RenamesCount = %v\n", len(data.Renames))
+ fmt.Fprintf(buf, "PrepareRenamesCount = %v\n", len(data.PrepareRenames))
+ fmt.Fprintf(buf, "SymbolsCount = %v\n", len(data.Symbols))
+ fmt.Fprintf(buf, "WorkspaceSymbolsCount = %v\n", len(data.WorkspaceSymbols))
+ fmt.Fprintf(buf, "FuzzyWorkspaceSymbolsCount = %v\n", len(data.FuzzyWorkspaceSymbols))
+ fmt.Fprintf(buf, "CaseSensitiveWorkspaceSymbolsCount = %v\n", len(data.CaseSensitiveWorkspaceSymbols))
+ fmt.Fprintf(buf, "SignaturesCount = %v\n", len(data.Signatures))
+ fmt.Fprintf(buf, "LinksCount = %v\n", linksCount)
+ fmt.Fprintf(buf, "ImplementationsCount = %v\n", len(data.Implementations))
+
+ want := string(data.Golden("summary", summaryFile, func() ([]byte, error) {
+ return buf.Bytes(), nil
+ }))
+ got := buf.String()
+ if want != got {
+ t.Errorf("test summary does not match:\n%s", Diff(want, got))
+ }
+}
+
+func (data *Data) Mapper(uri span.URI) (*protocol.ColumnMapper, error) {
+ data.mappersMu.Lock()
+ defer data.mappersMu.Unlock()
+
+ if _, ok := data.mappers[uri]; !ok {
+ content, err := data.Exported.FileContents(uri.Filename())
+ if err != nil {
+ return nil, err
+ }
+ converter := span.NewContentConverter(uri.Filename(), content)
+ data.mappers[uri] = &protocol.ColumnMapper{
+ URI: uri,
+ Converter: converter,
+ Content: content,
+ }
+ }
+ return data.mappers[uri], nil
+}
+
+func (data *Data) Golden(tag string, target string, update func() ([]byte, error)) []byte {
+ data.t.Helper()
+ fragment, found := data.fragments[target]
+ if !found {
+ if filepath.IsAbs(target) {
+ data.t.Fatalf("invalid golden file fragment %v", target)
+ }
+ fragment = target
+ }
+ golden := data.golden[fragment]
+ if golden == nil {
+ if !*UpdateGolden {
+ data.t.Fatalf("could not find golden file %v: %v", fragment, tag)
+ }
+ var subdir string
+ if fragment != summaryFile {
+ subdir = "primarymod"
+ }
+ golden = &Golden{
+ Filename: filepath.Join(data.dir, subdir, fragment+goldenFileSuffix),
+ Archive: &txtar.Archive{},
+ Modified: true,
+ }
+ data.golden[fragment] = golden
+ }
+ var file *txtar.File
+ for i := range golden.Archive.Files {
+ f := &golden.Archive.Files[i]
+ if f.Name == tag {
+ file = f
+ break
+ }
+ }
+ if *UpdateGolden {
+ if file == nil {
+ golden.Archive.Files = append(golden.Archive.Files, txtar.File{
+ Name: tag,
+ })
+ file = &golden.Archive.Files[len(golden.Archive.Files)-1]
+ }
+ contents, err := update()
+ if err != nil {
+ data.t.Fatalf("could not update golden file %v: %v", fragment, err)
+ }
+ file.Data = append(contents, '\n') // add trailing \n for txtar
+ golden.Modified = true
+
+ }
+ if file == nil {
+ data.t.Fatalf("could not find golden contents %v: %v", fragment, tag)
+ }
+ if len(file.Data) == 0 {
+ return file.Data
+ }
+ return file.Data[:len(file.Data)-1] // drop the trailing \n
+}
+
+func (data *Data) collectCodeLens(spn span.Span, title, cmd string) {
+ if _, ok := data.CodeLens[spn.URI()]; !ok {
+ data.CodeLens[spn.URI()] = []protocol.CodeLens{}
+ }
+ m, err := data.Mapper(spn.URI())
+ if err != nil {
+ return
+ }
+ rng, err := m.Range(spn)
+ if err != nil {
+ return
+ }
+ data.CodeLens[spn.URI()] = append(data.CodeLens[spn.URI()], protocol.CodeLens{
+ Range: rng,
+ Command: protocol.Command{
+ Title: title,
+ Command: cmd,
+ },
+ })
+}
+
+func (data *Data) collectDiagnostics(spn span.Span, msgSource, msg, msgSeverity string) {
+ if _, ok := data.Diagnostics[spn.URI()]; !ok {
+ data.Diagnostics[spn.URI()] = []*source.Diagnostic{}
+ }
+ m, err := data.Mapper(spn.URI())
+ if err != nil {
+ return
+ }
+ rng, err := m.Range(spn)
+ if err != nil {
+ return
+ }
+ severity := protocol.SeverityError
+ switch msgSeverity {
+ case "error":
+ severity = protocol.SeverityError
+ case "warning":
+ severity = protocol.SeverityWarning
+ case "hint":
+ severity = protocol.SeverityHint
+ case "information":
+ severity = protocol.SeverityInformation
+ }
+ // This is not the correct way to do this, but it seems excessive to do the full conversion here.
+ want := &source.Diagnostic{
+ Range: rng,
+ Severity: severity,
+ Source: msgSource,
+ Message: msg,
+ }
+ data.Diagnostics[spn.URI()] = append(data.Diagnostics[spn.URI()], want)
+}
+
+func (data *Data) collectCompletions(typ CompletionTestType) func(span.Span, []token.Pos) {
+ result := func(m map[span.Span][]Completion, src span.Span, expected []token.Pos) {
+ m[src] = append(m[src], Completion{
+ CompletionItems: expected,
+ })
+ }
+ switch typ {
+ case CompletionDeep:
+ return func(src span.Span, expected []token.Pos) {
+ result(data.DeepCompletions, src, expected)
+ }
+ case CompletionUnimported:
+ return func(src span.Span, expected []token.Pos) {
+ result(data.UnimportedCompletions, src, expected)
+ }
+ case CompletionFuzzy:
+ return func(src span.Span, expected []token.Pos) {
+ result(data.FuzzyCompletions, src, expected)
+ }
+ case CompletionRank:
+ return func(src span.Span, expected []token.Pos) {
+ result(data.RankCompletions, src, expected)
+ }
+ case CompletionCaseSensitive:
+ return func(src span.Span, expected []token.Pos) {
+ result(data.CaseSensitiveCompletions, src, expected)
+ }
+ default:
+ return func(src span.Span, expected []token.Pos) {
+ result(data.Completions, src, expected)
+ }
+ }
+}
+
+func (data *Data) collectCompletionItems(pos token.Pos, args []string) {
+ if len(args) < 3 {
+ loc := data.Exported.ExpectFileSet.Position(pos)
+ data.t.Fatalf("%s:%d: @item expects at least 3 args, got %d",
+ loc.Filename, loc.Line, len(args))
+ }
+ label, detail, kind := args[0], args[1], args[2]
+ var documentation string
+ if len(args) == 4 {
+ documentation = args[3]
+ }
+ data.CompletionItems[pos] = &completion.CompletionItem{
+ Label: label,
+ Detail: detail,
+ Kind: protocol.ParseCompletionItemKind(kind),
+ Documentation: documentation,
+ }
+}
+
+func (data *Data) collectFoldingRanges(spn span.Span) {
+ data.FoldingRanges = append(data.FoldingRanges, spn)
+}
+
+func (data *Data) collectFormats(spn span.Span) {
+ data.Formats = append(data.Formats, spn)
+}
+
+func (data *Data) collectImports(spn span.Span) {
+ data.Imports = append(data.Imports, spn)
+}
+
+func (data *Data) collectSemanticTokens(spn span.Span) {
+ data.SemanticTokens = append(data.SemanticTokens, spn)
+}
+
+func (data *Data) collectSuggestedFixes(spn span.Span, actionKind string) {
+ if _, ok := data.SuggestedFixes[spn]; !ok {
+ data.SuggestedFixes[spn] = []string{}
+ }
+ data.SuggestedFixes[spn] = append(data.SuggestedFixes[spn], actionKind)
+}
+
+func (data *Data) collectFunctionExtractions(start span.Span, end span.Span) {
+ if _, ok := data.FunctionExtractions[start]; !ok {
+ data.FunctionExtractions[start] = end
+ }
+}
+
+func (data *Data) collectDefinitions(src, target span.Span) {
+ data.Definitions[src] = Definition{
+ Src: src,
+ Def: target,
+ }
+}
+
+func (data *Data) collectImplementations(src span.Span, targets []span.Span) {
+ data.Implementations[src] = targets
+}
+
+func (data *Data) collectIncomingCalls(src span.Span, calls []span.Span) {
+ for _, call := range calls {
+ m, err := data.Mapper(call.URI())
+ if err != nil {
+ data.t.Fatal(err)
+ }
+ rng, err := m.Range(call)
+ if err != nil {
+ data.t.Fatal(err)
+ }
+ // we're only comparing protocol.range
+ if data.CallHierarchy[src] != nil {
+ data.CallHierarchy[src].IncomingCalls = append(data.CallHierarchy[src].IncomingCalls,
+ protocol.CallHierarchyItem{
+ URI: protocol.DocumentURI(call.URI()),
+ Range: rng,
+ })
+ } else {
+ data.CallHierarchy[src] = &CallHierarchyResult{
+ IncomingCalls: []protocol.CallHierarchyItem{
+ {URI: protocol.DocumentURI(call.URI()), Range: rng},
+ },
+ }
+ }
+ }
+}
+
+func (data *Data) collectOutgoingCalls(src span.Span, calls []span.Span) {
+ for _, call := range calls {
+ m, err := data.Mapper(call.URI())
+ if err != nil {
+ data.t.Fatal(err)
+ }
+ rng, err := m.Range(call)
+ if err != nil {
+ data.t.Fatal(err)
+ }
+ // we're only comparing protocol.range
+ if data.CallHierarchy[src] != nil {
+ data.CallHierarchy[src].OutgoingCalls = append(data.CallHierarchy[src].OutgoingCalls,
+ protocol.CallHierarchyItem{
+ URI: protocol.DocumentURI(call.URI()),
+ Range: rng,
+ })
+ } else {
+ data.CallHierarchy[src] = &CallHierarchyResult{
+ OutgoingCalls: []protocol.CallHierarchyItem{
+ {URI: protocol.DocumentURI(call.URI()), Range: rng},
+ },
+ }
+ }
+ }
+}
+
+func (data *Data) collectHoverDefinitions(src, target span.Span) {
+ data.Definitions[src] = Definition{
+ Src: src,
+ Def: target,
+ OnlyHover: true,
+ }
+}
+
+func (data *Data) collectTypeDefinitions(src, target span.Span) {
+ data.Definitions[src] = Definition{
+ Src: src,
+ Def: target,
+ IsType: true,
+ }
+}
+
+func (data *Data) collectDefinitionNames(src span.Span, name string) {
+ d := data.Definitions[src]
+ d.Name = name
+ data.Definitions[src] = d
+}
+
+func (data *Data) collectHighlights(src span.Span, expected []span.Span) {
+ // Declaring a highlight in a test file: @highlight(src, expected1, expected2)
+ data.Highlights[src] = append(data.Highlights[src], expected...)
+}
+
+func (data *Data) collectReferences(src span.Span, expected []span.Span) {
+ data.References[src] = expected
+}
+
+func (data *Data) collectRenames(src span.Span, newText string) {
+ data.Renames[src] = newText
+}
+
+func (data *Data) collectPrepareRenames(src span.Span, rng span.Range, placeholder string) {
+ m, err := data.Mapper(src.URI())
+ if err != nil {
+ data.t.Fatal(err)
+ }
+ // Convert range to span and then to protocol.Range.
+ spn, err := rng.Span()
+ if err != nil {
+ data.t.Fatal(err)
+ }
+ prng, err := m.Range(spn)
+ if err != nil {
+ data.t.Fatal(err)
+ }
+ data.PrepareRenames[src] = &source.PrepareItem{
+ Range: prng,
+ Text: placeholder,
+ }
+}
+
+// collectSymbols is responsible for collecting @symbol annotations.
+func (data *Data) collectSymbols(name string, spn span.Span, kind string, parentName string, siName string) {
+ m, err := data.Mapper(spn.URI())
+ if err != nil {
+ data.t.Fatal(err)
+ }
+ rng, err := m.Range(spn)
+ if err != nil {
+ data.t.Fatal(err)
+ }
+ sym := protocol.DocumentSymbol{
+ Name: name,
+ Kind: protocol.ParseSymbolKind(kind),
+ SelectionRange: rng,
+ }
+ if parentName == "" {
+ data.Symbols[spn.URI()] = append(data.Symbols[spn.URI()], sym)
+ } else {
+ data.symbolsChildren[parentName] = append(data.symbolsChildren[parentName], sym)
+ }
+
+ // Reuse @symbol in the workspace symbols tests.
+ si := protocol.SymbolInformation{
+ Name: siName,
+ Kind: sym.Kind,
+ Location: protocol.Location{
+ URI: protocol.URIFromSpanURI(spn.URI()),
+ Range: sym.SelectionRange,
+ },
+ }
+ data.symbolInformation[spn] = si
+}
+
+func (data *Data) collectWorkspaceSymbols(typ WorkspaceSymbolsTestType) func(string, []span.Span) {
+ switch typ {
+ case WorkspaceSymbolsFuzzy:
+ return func(query string, targets []span.Span) {
+ data.FuzzyWorkspaceSymbols[query] = make([]protocol.SymbolInformation, 0, len(targets))
+ for _, target := range targets {
+ data.FuzzyWorkspaceSymbols[query] = append(data.FuzzyWorkspaceSymbols[query], data.symbolInformation[target])
+ }
+ }
+ case WorkspaceSymbolsCaseSensitive:
+ return func(query string, targets []span.Span) {
+ data.CaseSensitiveWorkspaceSymbols[query] = make([]protocol.SymbolInformation, 0, len(targets))
+ for _, target := range targets {
+ data.CaseSensitiveWorkspaceSymbols[query] = append(data.CaseSensitiveWorkspaceSymbols[query], data.symbolInformation[target])
+ }
+ }
+ default:
+ return func(query string, targets []span.Span) {
+ data.WorkspaceSymbols[query] = make([]protocol.SymbolInformation, 0, len(targets))
+ for _, target := range targets {
+ data.WorkspaceSymbols[query] = append(data.WorkspaceSymbols[query], data.symbolInformation[target])
+ }
+ }
+ }
+}
+
+func (data *Data) collectSignatures(spn span.Span, signature string, activeParam int64) {
+ data.Signatures[spn] = &protocol.SignatureHelp{
+ Signatures: []protocol.SignatureInformation{
+ {
+ Label: signature,
+ },
+ },
+ ActiveParameter: float64(activeParam),
+ }
+ // Hardcode special case to test the lack of a signature.
+ if signature == "" && activeParam == 0 {
+ data.Signatures[spn] = nil
+ }
+}
+
+func (data *Data) collectCompletionSnippets(spn span.Span, item token.Pos, plain, placeholder string) {
+ data.CompletionSnippets[spn] = append(data.CompletionSnippets[spn], CompletionSnippet{
+ CompletionItem: item,
+ PlainSnippet: plain,
+ PlaceholderSnippet: placeholder,
+ })
+}
+
+func (data *Data) collectLinks(spn span.Span, link string, note *expect.Note, fset *token.FileSet) {
+ position := fset.Position(note.Pos)
+ uri := spn.URI()
+ data.Links[uri] = append(data.Links[uri], Link{
+ Src: spn,
+ Target: link,
+ NotePosition: position,
+ })
+}
+
+func uriName(uri span.URI) string {
+ return filepath.Base(strings.TrimSuffix(uri.Filename(), ".go"))
+}
+
+func SpanName(spn span.Span) string {
+ return fmt.Sprintf("%v_%v_%v", uriName(spn.URI()), spn.Start().Line(), spn.Start().Column())
+}
+
+func CopyFolderToTempDir(folder string) (string, error) {
+ if _, err := os.Stat(folder); err != nil {
+ return "", err
+ }
+ dst, err := ioutil.TempDir("", "modfile_test")
+ if err != nil {
+ return "", err
+ }
+ fds, err := ioutil.ReadDir(folder)
+ if err != nil {
+ return "", err
+ }
+ for _, fd := range fds {
+ srcfp := filepath.Join(folder, fd.Name())
+ stat, err := os.Stat(srcfp)
+ if err != nil {
+ return "", err
+ }
+ if !stat.Mode().IsRegular() {
+ return "", fmt.Errorf("cannot copy non regular file %s", srcfp)
+ }
+ contents, err := ioutil.ReadFile(srcfp)
+ if err != nil {
+ return "", err
+ }
+ if err := ioutil.WriteFile(filepath.Join(dst, fd.Name()), contents, stat.Mode()); err != nil {
+ return "", err
+ }
+ }
+ return dst, nil
+}
+
+func shouldSkip(data *Data, uri span.URI) bool {
+ if data.ModfileFlagAvailable {
+ return false
+ }
+ // If the -modfile flag is not available, then we do not want to run
+ // any tests on the go.mod file.
+ if strings.HasSuffix(uri.Filename(), ".mod") {
+ return true
+ }
+ // If the -modfile flag is not available, then we do not want to test any
+ // uri that contains "go mod tidy".
+ m, err := data.Mapper(uri)
+ return err == nil && strings.Contains(string(m.Content), ", \"go mod tidy\",")
+}
projects / dotfiles / .git / blobdiff