+++ /dev/null
-// Copyright 2013 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 (
- "context"
- "flag"
- "fmt"
- "go/build"
- "io/ioutil"
- "log"
- "path/filepath"
- "reflect"
- "runtime"
- "sort"
- "strings"
- "sync"
- "testing"
-
- "golang.org/x/tools/go/packages/packagestest"
- "golang.org/x/tools/internal/gocommand"
-)
-
-var testDebug = flag.Bool("debug", false, "enable debug output")
-
-var tests = []struct {
- name string
- formatOnly bool
- in, out string
-}{
- // Adding an import to an existing parenthesized import
- {
- name: "factored_imports_add",
- in: `package foo
-import (
- "fmt"
-)
-func bar() {
-var b bytes.Buffer
-fmt.Println(b.String())
-}
-`,
- out: `package foo
-
-import (
- "bytes"
- "fmt"
-)
-
-func bar() {
- var b bytes.Buffer
- fmt.Println(b.String())
-}
-`,
- },
-
- // Adding an import to an existing parenthesized import,
- // verifying it goes into the first section.
- {
- name: "factored_imports_add_first_sec",
- in: `package foo
-import (
- "fmt"
-
- "github.com/golang/snappy"
-)
-func bar() {
-var b bytes.Buffer
-_ = snappy.ErrCorrupt
-fmt.Println(b.String())
-}
-`,
- out: `package foo
-
-import (
- "bytes"
- "fmt"
-
- "github.com/golang/snappy"
-)
-
-func bar() {
- var b bytes.Buffer
- _ = snappy.ErrCorrupt
- fmt.Println(b.String())
-}
-`,
- },
-
- // Adding an import to an existing parenthesized import,
- // verifying it goes into the first section. (test 2)
- {
- name: "factored_imports_add_first_sec_2",
- in: `package foo
-import (
- "fmt"
-
- "github.com/golang/snappy"
-)
-func bar() {
-_ = math.NaN
-_ = fmt.Sprintf
-_ = snappy.ErrCorrupt
-}
-`,
- out: `package foo
-
-import (
- "fmt"
- "math"
-
- "github.com/golang/snappy"
-)
-
-func bar() {
- _ = math.NaN
- _ = fmt.Sprintf
- _ = snappy.ErrCorrupt
-}
-`,
- },
-
- // Adding a new import line, without parens
- {
- name: "add_import_section",
- in: `package foo
-func bar() {
-var b bytes.Buffer
-}
-`,
- out: `package foo
-
-import "bytes"
-
-func bar() {
- var b bytes.Buffer
-}
-`,
- },
-
- // Adding two new imports, which should make a parenthesized import decl.
- {
- name: "add_import_paren_section",
- in: `package foo
-func bar() {
-_, _ := bytes.Buffer, zip.NewReader
-}
-`,
- out: `package foo
-
-import (
- "archive/zip"
- "bytes"
-)
-
-func bar() {
- _, _ := bytes.Buffer, zip.NewReader
-}
-`,
- },
-
- // Make sure we don't add things twice
- {
- name: "no_double_add",
- in: `package foo
-func bar() {
-_, _ := bytes.Buffer, bytes.NewReader
-}
-`,
- out: `package foo
-
-import "bytes"
-
-func bar() {
- _, _ := bytes.Buffer, bytes.NewReader
-}
-`,
- },
-
- // Make sure we don't add packages that don't have the right exports
- {
- name: "no_mismatched_add",
- in: `package foo
-
-func bar() {
- _ := bytes.NonexistentSymbol
-}
-`,
- out: `package foo
-
-func bar() {
- _ := bytes.NonexistentSymbol
-}
-`,
- },
-
- // Remove unused imports, 1 of a factored block
- {
- name: "remove_unused_1_of_2",
- in: `package foo
-import (
-"bytes"
-"fmt"
-)
-
-func bar() {
-_, _ := bytes.Buffer, bytes.NewReader
-}
-`,
- out: `package foo
-
-import (
- "bytes"
-)
-
-func bar() {
- _, _ := bytes.Buffer, bytes.NewReader
-}
-`,
- },
-
- // Remove unused imports, 2 of 2
- {
- name: "remove_unused_2_of_2",
- in: `package foo
-import (
-"bytes"
-"fmt"
-)
-
-func bar() {
-}
-`,
- out: `package foo
-
-func bar() {
-}
-`,
- },
-
- // Remove unused imports, 1 of 1
- {
- name: "remove_unused_1_of_1",
- in: `package foo
-
-import "fmt"
-
-func bar() {
-}
-`,
- out: `package foo
-
-func bar() {
-}
-`,
- },
-
- // Don't remove empty imports.
- {
- name: "dont_remove_empty_imports",
- in: `package foo
-import (
-_ "image/png"
-_ "image/jpeg"
-)
-`,
- out: `package foo
-
-import (
- _ "image/jpeg"
- _ "image/png"
-)
-`,
- },
-
- // Don't remove dot imports.
- {
- name: "dont_remove_dot_imports",
- in: `package foo
-import (
-. "foo"
-. "bar"
-)
-`,
- out: `package foo
-
-import (
- . "bar"
- . "foo"
-)
-`,
- },
-
- // Skip refs the parser can resolve.
- {
- name: "skip_resolved_refs",
- in: `package foo
-
-func f() {
- type t struct{ Println func(string) }
- fmt := t{Println: func(string) {}}
- fmt.Println("foo")
-}
-`,
- out: `package foo
-
-func f() {
- type t struct{ Println func(string) }
- fmt := t{Println: func(string) {}}
- fmt.Println("foo")
-}
-`,
- },
-
- // Do not add a package we already have a resolution for.
- {
- name: "skip_template",
- in: `package foo
-
-import "html/template"
-
-func f() { t = template.New("sometemplate") }
-`,
- out: `package foo
-
-import "html/template"
-
-func f() { t = template.New("sometemplate") }
-`,
- },
-
- // Don't touch cgo
- {
- name: "cgo",
- in: `package foo
-
-/*
-#include <foo.h>
-*/
-import "C"
-`,
- out: `package foo
-
-/*
-#include <foo.h>
-*/
-import "C"
-`,
- },
-
- // Put some things in their own section
- {
- name: "make_sections",
- in: `package foo
-
-import (
-"os"
-)
-
-func foo () {
-_, _ = os.Args, fmt.Println
-_, _ = snappy.ErrCorrupt, p.P
-}
-`,
- out: `package foo
-
-import (
- "fmt"
- "os"
-
- "github.com/golang/snappy"
- "rsc.io/p"
-)
-
-func foo() {
- _, _ = os.Args, fmt.Println
- _, _ = snappy.ErrCorrupt, p.P
-}
-`,
- },
- // Merge import blocks, even when no additions are required.
- {
- name: "merge_import_blocks_no_fix",
- in: `package foo
-
-import (
- "fmt"
-)
-import "os"
-
-import (
- "rsc.io/p"
-)
-
-var _, _ = os.Args, fmt.Println
-var _, _ = snappy.ErrCorrupt, p.P
-`,
- out: `package foo
-
-import (
- "fmt"
- "os"
-
- "github.com/golang/snappy"
- "rsc.io/p"
-)
-
-var _, _ = os.Args, fmt.Println
-var _, _ = snappy.ErrCorrupt, p.P
-`,
- },
- // Delete existing empty import block
- {
- name: "delete_empty_import_block",
- in: `package foo
-
-import ()
-`,
- out: `package foo
-`,
- },
-
- // Use existing empty import block
- {
- name: "use_empty_import_block",
- in: `package foo
-
-import ()
-
-func f() {
- _ = fmt.Println
-}
-`,
- out: `package foo
-
-import "fmt"
-
-func f() {
- _ = fmt.Println
-}
-`,
- },
-
- // Blank line before adding new section.
- {
- name: "blank_line_before_new_group",
- in: `package foo
-
-import (
- "fmt"
- "net"
-)
-
-func f() {
- _ = net.Dial
- _ = fmt.Printf
- _ = snappy.ErrCorrupt
-}
-`,
- out: `package foo
-
-import (
- "fmt"
- "net"
-
- "github.com/golang/snappy"
-)
-
-func f() {
- _ = net.Dial
- _ = fmt.Printf
- _ = snappy.ErrCorrupt
-}
-`,
- },
-
- // Blank line between standard library and third-party stuff.
- {
- name: "blank_line_separating_std_and_third_party",
- in: `package foo
-
-import (
- "github.com/golang/snappy"
- "fmt"
- "net"
-)
-
-func f() {
- _ = net.Dial
- _ = fmt.Printf
- _ = snappy.Foo
-}
-`,
- out: `package foo
-
-import (
- "fmt"
- "net"
-
- "github.com/golang/snappy"
-)
-
-func f() {
- _ = net.Dial
- _ = fmt.Printf
- _ = snappy.Foo
-}
-`,
- },
-
- // golang.org/issue/6884
- {
- name: "new_imports_before_comment",
- in: `package main
-
-// A comment
-func main() {
- fmt.Println("Hello, world")
-}
-`,
- out: `package main
-
-import "fmt"
-
-// A comment
-func main() {
- fmt.Println("Hello, world")
-}
-`,
- },
-
- // golang.org/issue/7132
- {
- name: "new_section_for_dotless_import",
- in: `package main
-
-import (
-"fmt"
-
-"gu"
-"manypackages.com/packagea"
-)
-
-var (
-a = packagea.A
-b = gu.A
-c = fmt.Printf
-)
-`,
- out: `package main
-
-import (
- "fmt"
-
- "gu"
-
- "manypackages.com/packagea"
-)
-
-var (
- a = packagea.A
- b = gu.A
- c = fmt.Printf
-)
-`,
- },
-
- {
- name: "fragment_with_main",
- in: `func main(){fmt.Println("Hello, world")}`,
- out: `package main
-
-import "fmt"
-
-func main() { fmt.Println("Hello, world") }
-`,
- },
-
- {
- name: "fragment_without_main",
- in: `func notmain(){fmt.Println("Hello, world")}`,
- out: `import "fmt"
-
-func notmain() { fmt.Println("Hello, world") }`,
- },
-
- // Remove first import within in a 2nd/3rd/4th/etc. section.
- // golang.org/issue/7679
- {
- name: "remove_first_import_in_section",
- in: `package main
-
-import (
- "fmt"
-
- "manypackages.com/packagea"
- "manypackages.com/packageb"
-)
-
-func main() {
- var _ = fmt.Println
- //var _ = packagea.A
- var _ = packageb.B
-}
-`,
- out: `package main
-
-import (
- "fmt"
-
- "manypackages.com/packageb"
-)
-
-func main() {
- var _ = fmt.Println
- //var _ = packagea.A
- var _ = packageb.B
-}
-`,
- },
-
- // Blank line can be added before all types of import declarations.
- // golang.org/issue/7866
- {
- name: "new_section_for_all_kinds_of_imports",
- in: `package main
-
-import (
- "fmt"
- renamed_packagea "manypackages.com/packagea"
-
- . "manypackages.com/packageb"
- "io"
-
- _ "manypackages.com/packagec"
- "strings"
-)
-
-var _, _, _, _, _ = fmt.Errorf, io.Copy, strings.Contains, renamed_packagea.A, B
-`,
- out: `package main
-
-import (
- "fmt"
-
- renamed_packagea "manypackages.com/packagea"
-
- "io"
-
- . "manypackages.com/packageb"
-
- "strings"
-
- _ "manypackages.com/packagec"
-)
-
-var _, _, _, _, _ = fmt.Errorf, io.Copy, strings.Contains, renamed_packagea.A, B
-`,
- },
-
- // Non-idempotent comment formatting
- // golang.org/issue/8035
- {
- name: "comments_formatted",
- in: `package main
-
-import (
- "fmt" // A
- "go/ast" // B
- _ "manypackages.com/packagec" // C
-)
-
-func main() { _, _ = fmt.Print, ast.Walk }
-`,
- out: `package main
-
-import (
- "fmt" // A
- "go/ast" // B
-
- _ "manypackages.com/packagec" // C
-)
-
-func main() { _, _ = fmt.Print, ast.Walk }
-`,
- },
-
- // Failure to delete all duplicate imports
- // golang.org/issue/8459
- {
- name: "remove_duplicates",
- in: `package main
-
-import (
- "fmt"
- "log"
- "log"
- "math"
-)
-
-func main() { fmt.Println("pi:", math.Pi) }
-`,
- out: `package main
-
-import (
- "fmt"
- "math"
-)
-
-func main() { fmt.Println("pi:", math.Pi) }
-`,
- },
-
- // Too aggressive prefix matching
- // golang.org/issue/9961
- {
- name: "no_extra_groups",
- in: `package p
-
-import (
- "zip"
-
- "rsc.io/p"
-)
-
-var (
- _ = fmt.Print
- _ = zip.Store
- _ p.P
- _ = regexp.Compile
-)
-`,
- out: `package p
-
-import (
- "fmt"
- "regexp"
- "zip"
-
- "rsc.io/p"
-)
-
-var (
- _ = fmt.Print
- _ = zip.Store
- _ p.P
- _ = regexp.Compile
-)
-`,
- },
-
- // Unused named import is mistaken for unnamed import
- // golang.org/issue/8149
- {
- name: "named_import_doesnt_provide_package_name",
- in: `package main
-
-import foo "fmt"
-
-func main() { fmt.Println() }
-`,
- out: `package main
-
-import "fmt"
-
-func main() { fmt.Println() }
-`,
- },
-
- // Unused named import is mistaken for unnamed import
- // golang.org/issue/8149
- {
- name: "unused_named_import_removed",
- in: `package main
-
-import (
- "fmt"
- x "fmt"
-)
-
-func main() { fmt.Println() }
-`,
- out: `package main
-
-import (
- "fmt"
-)
-
-func main() { fmt.Println() }
-`,
- },
-
- {
- name: "ignore_unexported_identifier",
- in: `package main
-var _ = fmt.unexported`,
- out: `package main
-
-var _ = fmt.unexported
-`,
- },
-
- // FormatOnly
- {
- name: "formatonly_works",
- formatOnly: true,
- in: `package main
-
-import (
-"fmt"
-"manypackages.com/packagea"
-)
-
-func main() {}
-`,
- out: `package main
-
-import (
- "fmt"
-
- "manypackages.com/packagea"
-)
-
-func main() {}
-`,
- },
-
- {
- name: "preserve_import_group",
- in: `package p
-
-import (
- "bytes"
- "fmt"
-)
-
-var _ = fmt.Sprintf
-`,
- out: `package p
-
-import (
- "fmt"
-)
-
-var _ = fmt.Sprintf
-`,
- },
- {
- name: "import_grouping_not_path_dependent_no_groups",
- in: `package main
-
-import (
- "time"
-)
-
-func main() {
- _ = snappy.ErrCorrupt
- _ = p.P
- _ = time.Parse
-}
-`,
- out: `package main
-
-import (
- "time"
-
- "github.com/golang/snappy"
- "rsc.io/p"
-)
-
-func main() {
- _ = snappy.ErrCorrupt
- _ = p.P
- _ = time.Parse
-}
-`,
- },
-
- {
- name: "import_grouping_not_path_dependent_existing_group",
- in: `package main
-
-import (
- "time"
-
- "github.com/golang/snappy"
-)
-
-func main() {
- _ = snappy.ErrCorrupt
- _ = p.P
- _ = time.Parse
-}
-`,
- out: `package main
-
-import (
- "time"
-
- "github.com/golang/snappy"
- "rsc.io/p"
-)
-
-func main() {
- _ = snappy.ErrCorrupt
- _ = p.P
- _ = time.Parse
-}
-`,
- },
-
- // golang.org/issue/12097
- {
- name: "package_statement_insertion_preserves_comments",
- in: `// a
-// b
-// c
-
-func main() {
- _ = fmt.Println
-}`,
- out: `package main
-
-import "fmt"
-
-// a
-// b
-// c
-
-func main() {
- _ = fmt.Println
-}
-`,
- },
-
- {
- name: "import_comment_stays_on_import",
- in: `package main
-
-import (
- "math" // fun
-)
-
-func main() {
- x := math.MaxInt64
- fmt.Println(strings.Join(",", []string{"hi"}), x)
-}`,
- out: `package main
-
-import (
- "fmt"
- "math" // fun
- "strings"
-)
-
-func main() {
- x := math.MaxInt64
- fmt.Println(strings.Join(",", []string{"hi"}), x)
-}
-`,
- },
-
- {
- name: "no_blank_after_comment",
- in: `package main
-
-import (
- _ "io"
- _ "net/http"
- _ "net/http/pprof" // install the pprof http handlers
- _ "strings"
-)
-
-func main() {
-}
-`,
- out: `package main
-
-import (
- _ "io"
- _ "net/http"
- _ "net/http/pprof" // install the pprof http handlers
- _ "strings"
-)
-
-func main() {
-}
-`,
- },
-
- {
- name: "no_blank_after_comment_reordered",
- in: `package main
-
-import (
- _ "io"
- _ "net/http/pprof" // install the pprof http handlers
- _ "net/http"
- _ "strings"
-)
-
-func main() {
-}
-`,
- out: `package main
-
-import (
- _ "io"
- _ "net/http"
- _ "net/http/pprof" // install the pprof http handlers
- _ "strings"
-)
-
-func main() {
-}
-`,
- },
-
- {
- name: "no_blank_after_comment_unnamed",
- in: `package main
-
-import (
- "encoding/json"
- "io"
- "net/http"
- _ "net/http/pprof" // install the pprof http handlers
- "strings"
-
- "manypackages.com/packagea"
-)
-
-func main() {
- _ = strings.ToUpper("hello")
- _ = io.EOF
- var (
- _ json.Number
- _ *http.Request
- _ packagea.A
- )
-}
-`,
- out: `package main
-
-import (
- "encoding/json"
- "io"
- "net/http"
- _ "net/http/pprof" // install the pprof http handlers
- "strings"
-
- "manypackages.com/packagea"
-)
-
-func main() {
- _ = strings.ToUpper("hello")
- _ = io.EOF
- var (
- _ json.Number
- _ *http.Request
- _ packagea.A
- )
-}
-`,
- },
-
- {
- name: "blank_after_package_statement_with_comment",
- in: `package p // comment
-
-import "math"
-
-var _ = fmt.Printf
-`,
- out: `package p // comment
-
-import "fmt"
-
-var _ = fmt.Printf
-`,
- },
-
- {
- name: "blank_after_package_statement_no_comment",
- in: `package p
-
-import "math"
-
-var _ = fmt.Printf
-`,
- out: `package p
-
-import "fmt"
-
-var _ = fmt.Printf
-`,
- },
-
- {
- name: "cryptorand_preferred_easy_possible",
- in: `package p
-
-var _ = rand.Read
-`,
- out: `package p
-
-import "crypto/rand"
-
-var _ = rand.Read
-`,
- },
-
- {
- name: "cryptorand_preferred_easy_impossible",
- in: `package p
-
-var _ = rand.NewZipf
-`,
- out: `package p
-
-import "math/rand"
-
-var _ = rand.NewZipf
-`,
- },
-
- {
- name: "cryptorand_preferred_complex_possible",
- in: `package p
-
-var _, _ = rand.Read, rand.Prime
-`,
- out: `package p
-
-import "crypto/rand"
-
-var _, _ = rand.Read, rand.Prime
-`,
- },
-
- {
- name: "cryptorand_preferred_complex_impossible",
- in: `package p
-
-var _, _ = rand.Read, rand.NewZipf
-`,
- out: `package p
-
-import "math/rand"
-
-var _, _ = rand.Read, rand.NewZipf
-`,
- },
-}
-
-func TestSimpleCases(t *testing.T) {
- const localPrefix = "local.com,github.com/local"
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- testConfig{
- modules: []packagestest.Module{
- {
- Name: "golang.org/fake",
- Files: fm{"x.go": tt.in},
- },
- // Skeleton non-stdlib packages for use during testing.
- // Each includes one arbitrary symbol, e.g. the first declaration in the first file.
- // Try not to add more without a good reason.
- // DO NOT USE PACKAGES NOT LISTED HERE -- they will be downloaded!
- {
- Name: "rsc.io",
- Files: fm{"p/x.go": "package p\nfunc P(){}\n"},
- },
- {
- Name: "github.com/golang/snappy",
- Files: fm{"x.go": "package snappy\nvar ErrCorrupt error\n"},
- },
- {
- Name: "manypackages.com",
- Files: fm{
- "packagea/x.go": "package packagea\nfunc A(){}\n",
- "packageb/x.go": "package packageb\nfunc B(){}\n",
- "packagec/x.go": "package packagec\nfunc C(){}\n",
- "packaged/x.go": "package packaged\nfunc D(){}\n",
- },
- },
- {
- Name: "local.com",
- Files: fm{"foo/x.go": "package foo\nfunc Foo(){}\n"},
- },
- {
- Name: "github.com/local",
- Files: fm{"bar/x.go": "package bar\nfunc Bar(){}\n"},
- },
- },
- }.test(t, func(t *goimportTest) {
- options := &Options{
- LocalPrefix: localPrefix,
- TabWidth: 8,
- TabIndent: true,
- Comments: true,
- Fragment: true,
- FormatOnly: tt.formatOnly,
- }
- t.assertProcessEquals("golang.org/fake", "x.go", nil, options, tt.out)
- })
-
- })
- }
-}
-
-func TestAppengine(t *testing.T) {
- const input = `package p
-
-var _, _, _ = fmt.Printf, appengine.Main, datastore.ErrInvalidEntityType
-`
-
- const want = `package p
-
-import (
- "fmt"
-
- "appengine"
- "appengine/datastore"
-)
-
-var _, _, _ = fmt.Printf, appengine.Main, datastore.ErrInvalidEntityType
-`
-
- testConfig{
- gopathOnly: true, // can't create a module named appengine, so no module tests.
- modules: []packagestest.Module{
- {
- Name: "golang.org/fake",
- Files: fm{"x.go": input},
- },
- {
- Name: "appengine",
- Files: fm{
- "x.go": "package appengine\nfunc Main(){}\n",
- "datastore/x.go": "package datastore\nvar ErrInvalidEntityType error\n",
- },
- },
- },
- }.processTest(t, "golang.org/fake", "x.go", nil, nil, want)
-}
-
-func TestReadFromFilesystem(t *testing.T) {
- tests := []struct {
- name string
- in, out string
- }{
- {
- name: "works",
- in: `package foo
-func bar() {
-fmt.Println("hi")
-}
-`,
- out: `package foo
-
-import "fmt"
-
-func bar() {
- fmt.Println("hi")
-}
-`,
- },
- {
- name: "missing_package",
- in: `
-func bar() {
-fmt.Println("hi")
-}
-`,
- out: `
-import "fmt"
-
-func bar() {
- fmt.Println("hi")
-}
-`,
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- options := &Options{
- TabWidth: 8,
- TabIndent: true,
- Comments: true,
- Fragment: true,
- }
- testConfig{
- module: packagestest.Module{
- Name: "golang.org/fake",
- Files: fm{"x.go": tt.in},
- },
- }.processTest(t, "golang.org/fake", "x.go", nil, options, tt.out)
- })
- }
-
-}
-
-// Test support for packages in GOPATH that are actually symlinks.
-// Also test that a symlink loop does not block the process.
-func TestImportSymlinks(t *testing.T) {
- switch runtime.GOOS {
- case "windows", "plan9":
- t.Skipf("skipping test on %q as there are no symlinks", runtime.GOOS)
- }
-
- const input = `package p
-
-var (
- _ = fmt.Print
- _ = mypkg.Foo
-)
-`
- const want = `package p
-
-import (
- "fmt"
-
- "golang.org/fake/x/y/mypkg"
-)
-
-var (
- _ = fmt.Print
- _ = mypkg.Foo
-)
-`
-
- testConfig{
- module: packagestest.Module{
- Name: "golang.org/fake",
- Files: fm{
- "target/f.go": "package mypkg\nvar Foo = 123\n",
- "x/y/mypkg": packagestest.Symlink("../../target"), // valid symlink
- "x/y/apkg": packagestest.Symlink(".."), // symlink loop
- "myotherpackage/toformat.go": input,
- },
- },
- }.processTest(t, "golang.org/fake", "myotherpackage/toformat.go", nil, nil, want)
-}
-
-func TestImportSymlinksWithIgnore(t *testing.T) {
- switch runtime.GOOS {
- case "windows", "plan9":
- t.Skipf("skipping test on %q as there are no symlinks", runtime.GOOS)
- }
-
- const input = `package p
-
-var (
- _ = fmt.Print
- _ = mypkg.Foo
-)
-`
- const want = `package p
-
-import "fmt"
-
-var (
- _ = fmt.Print
- _ = mypkg.Foo
-)
-`
-
- testConfig{
- gopathOnly: true,
- module: packagestest.Module{
- Name: "golang.org/fake",
- Files: fm{
- "target/f.go": "package mypkg\nvar Foo = 123\n",
- "x/y/mypkg": packagestest.Symlink("../../target"), // valid symlink
- "x/y/apkg": packagestest.Symlink(".."), // symlink loop
- "myotherpkg/toformat.go": input,
- "../../.goimportsignore": "golang.org/fake/x/y/mypkg\n",
- },
- },
- }.processTest(t, "golang.org/fake", "myotherpkg/toformat.go", nil, nil, want)
-}
-
-// Test for x/y/v2 convention for package y.
-func TestModuleVersion(t *testing.T) {
- const input = `package p
-
-import (
- "fmt"
-
- "github.com/foo/v2"
-)
-
-var (
- _ = fmt.Print
- _ = foo.Foo
-)
-`
-
- testConfig{
- modules: []packagestest.Module{
- {
- Name: "mypkg.com/outpkg",
- Files: fm{"toformat.go": input},
- },
- {
- Name: "github.com/foo/v2",
- Files: fm{"x.go": "package foo\n func Foo(){}\n"},
- },
- },
- }.processTest(t, "mypkg.com/outpkg", "toformat.go", nil, nil, input)
-}
-
-// Test for correctly identifying the name of a vendored package when it
-// differs from its directory name. In this test, the import line
-// "mypkg.com/mypkg_v1" would be removed if goimports wasn't able to detect
-// that the package name is "mypkg".
-func TestVendorPackage(t *testing.T) {
- const input = `package p
-import (
- "fmt"
- "mypkg.com/mypkg_v1"
-)
-var _, _ = fmt.Print, mypkg.Foo
-`
-
- const want = `package p
-
-import (
- "fmt"
-
- mypkg "mypkg.com/mypkg_v1"
-)
-
-var _, _ = fmt.Print, mypkg.Foo
-`
-
- testConfig{
- gopathOnly: true,
- module: packagestest.Module{
- Name: "mypkg.com/outpkg",
- Files: fm{
- "vendor/mypkg.com/mypkg_v1/f.go": "package mypkg\nvar Foo = 123\n",
- "toformat.go": input,
- },
- },
- }.processTest(t, "mypkg.com/outpkg", "toformat.go", nil, nil, want)
-}
-
-func TestInternal(t *testing.T) {
- const input = `package bar
-
-var _ = race.Acquire
-`
- const importAdded = `package bar
-
-import "foo.com/internal/race"
-
-var _ = race.Acquire
-`
-
- // Packages under the same directory should be able to use internal packages.
- testConfig{
- module: packagestest.Module{
- Name: "foo.com",
- Files: fm{
- "internal/race/x.go": "package race\n func Acquire(){}\n",
- "bar/x.go": input,
- },
- },
- }.processTest(t, "foo.com", "bar/x.go", nil, nil, importAdded)
-
- // Packages outside the same directory should not.
- testConfig{
- modules: []packagestest.Module{
- {
- Name: "foo.com",
- Files: fm{"internal/race/x.go": "package race\n func Acquire(){}\n"},
- },
- {
- Name: "bar.com",
- Files: fm{"x.go": input},
- },
- },
- }.processTest(t, "bar.com", "x.go", nil, nil, input)
-}
-
-func TestProcessVendor(t *testing.T) {
- const input = `package p
-
-var _ = hpack.HuffmanDecode
-`
- const want = `package p
-
-import "golang.org/x/net/http2/hpack"
-
-var _ = hpack.HuffmanDecode
-`
- testConfig{
- gopathOnly: true,
- module: packagestest.Module{
- Name: "foo.com",
- Files: fm{
- "vendor/golang.org/x/net/http2/hpack/huffman.go": "package hpack\nfunc HuffmanDecode() { }\n",
- "bar/x.go": input,
- },
- },
- }.processTest(t, "foo.com", "bar/x.go", nil, nil, want)
-}
-
-func TestFindStdlib(t *testing.T) {
- tests := []struct {
- pkg string
- symbols []string
- want string
- }{
- {"http", []string{"Get"}, "net/http"},
- {"http", []string{"Get", "Post"}, "net/http"},
- {"http", []string{"Get", "Foo"}, ""},
- {"bytes", []string{"Buffer"}, "bytes"},
- {"ioutil", []string{"Discard"}, "io/ioutil"},
- }
- for _, tt := range tests {
- input := "package p\n"
- for _, sym := range tt.symbols {
- input += fmt.Sprintf("var _ = %s.%s\n", tt.pkg, sym)
- }
- testConfig{
- module: packagestest.Module{
- Name: "foo.com",
- Files: fm{"x.go": input},
- },
- }.test(t, func(t *goimportTest) {
- buf, err := t.process("foo.com", "x.go", nil, nil)
- if err != nil {
- t.Fatal(err)
- }
- if got := string(buf); !strings.Contains(got, tt.want) {
- t.Errorf("Process(%q) = %q, wanted it to contain %q", input, buf, tt.want)
- }
- })
- }
-}
-
-// https://golang.org/issue/31814
-func TestStdlibNotPrefixed(t *testing.T) {
- const input = `package p
-var _ = bytes.Buffer
-`
- const want = `package p
-
-import "bytes"
-
-var _ = bytes.Buffer
-`
- // Force a scan of the stdlib.
- savedStdlib := stdlib
- defer func() { stdlib = savedStdlib }()
- stdlib = map[string][]string{}
-
- testConfig{
- module: packagestest.Module{
- Name: "ignored.com",
- Files: fm{"x.go": "package x"},
- },
- }.test(t, func(t *goimportTest) {
- // Run in GOROOT/src so that the std module shows up in go list -m all.
- t.env.WorkingDir = filepath.Join(t.goroot, "src")
- got, err := t.processNonModule(filepath.Join(t.goroot, "src/x.go"), []byte(input), nil)
- if err != nil {
- t.Fatalf("Process() = %v", err)
- }
- if string(got) != want {
- t.Errorf("Got:\n%s\nWant:\n%s", got, want)
- }
- })
-}
-
-func TestStdlibSelfImports(t *testing.T) {
- const input = `package ecdsa
-
-var _ = ecdsa.GenerateKey
-`
-
- testConfig{
- module: packagestest.Module{
- Name: "ignored.com",
- Files: fm{"x.go": "package x"},
- },
- }.test(t, func(t *goimportTest) {
- got, err := t.processNonModule(filepath.Join(t.goroot, "src/crypto/ecdsa/foo.go"), []byte(input), nil)
- if err != nil {
- t.Fatalf("Process() = %v", err)
- }
- if string(got) != input {
- t.Errorf("Got:\n%s\nWant:\n%s", got, input)
- }
- })
-}
-
-type testConfig struct {
- gopathOnly bool
- module packagestest.Module
- modules []packagestest.Module
-}
-
-// fm is the type for a packagestest.Module's Files, abbreviated for shorter lines.
-type fm map[string]interface{}
-
-func (c testConfig) test(t *testing.T, fn func(*goimportTest)) {
- t.Helper()
-
- if c.module.Name != "" {
- c.modules = []packagestest.Module{c.module}
- }
-
- for _, exporter := range packagestest.All {
- t.Run(exporter.Name(), func(t *testing.T) {
- t.Helper()
- if c.gopathOnly && exporter.Name() == "Modules" {
- t.Skip("test marked GOPATH-only")
- }
- exported := packagestest.Export(t, exporter, c.modules)
- defer exported.Cleanup()
-
- env := map[string]string{}
- for _, kv := range exported.Config.Env {
- split := strings.SplitN(kv, "=", 2)
- env[split[0]] = split[1]
- }
- it := &goimportTest{
- T: t,
- env: &ProcessEnv{
- Env: env,
- WorkingDir: exported.Config.Dir,
- GocmdRunner: &gocommand.Runner{},
- },
- exported: exported,
- }
- if *testDebug {
- it.env.Logf = log.Printf
- }
- // packagestest clears out GOROOT to work around golang/go#32849,
- // which isn't relevant here. Fill it back in so we can find the standard library.
- it.env.Env["GOROOT"] = build.Default.GOROOT
- it.goroot = build.Default.GOROOT
-
- fn(it)
- })
- }
-}
-
-func (c testConfig) processTest(t *testing.T, module, file string, contents []byte, opts *Options, want string) {
- t.Helper()
- c.test(t, func(t *goimportTest) {
- t.Helper()
- t.assertProcessEquals(module, file, contents, opts, want)
- })
-}
-
-type goimportTest struct {
- *testing.T
- goroot string
- env *ProcessEnv
- exported *packagestest.Exported
-}
-
-func (t *goimportTest) process(module, file string, contents []byte, opts *Options) ([]byte, error) {
- t.Helper()
- f := t.exported.File(module, file)
- if f == "" {
- t.Fatalf("%v not found in exported files (typo in filename?)", file)
- }
- return t.processNonModule(f, contents, opts)
-}
-
-func (t *goimportTest) processNonModule(file string, contents []byte, opts *Options) ([]byte, error) {
- if contents == nil {
- var err error
- contents, err = ioutil.ReadFile(file)
- if err != nil {
- return nil, err
- }
- }
- if opts == nil {
- opts = &Options{Comments: true, TabIndent: true, TabWidth: 8}
- }
- // ProcessEnv is not safe for concurrent use. Make a copy.
- opts.Env = t.env.CopyConfig()
- return Process(file, contents, opts)
-}
-
-func (t *goimportTest) assertProcessEquals(module, file string, contents []byte, opts *Options, want string) {
- buf, err := t.process(module, file, contents, opts)
- if err != nil {
- t.Fatalf("Process() = %v", err)
- }
- if string(buf) != want {
- t.Errorf("Got:\n%s\nWant:\n%s", buf, want)
- }
-}
-
-// Tests that added imports are renamed when the import path's base doesn't
-// match its package name.
-func TestRenameWhenPackageNameMismatch(t *testing.T) {
- const input = `package main
- const Y = bar.X`
-
- const want = `package main
-
-import bar "foo.com/foo/bar/baz"
-
-const Y = bar.X
-`
- testConfig{
- module: packagestest.Module{
- Name: "foo.com",
- Files: fm{
- "foo/bar/baz/x.go": "package bar \n const X = 1",
- "test/t.go": input,
- },
- },
- }.processTest(t, "foo.com", "test/t.go", nil, nil, want)
-}
-
-// Tests that an existing import with badly mismatched path/name has its name
-// correctly added. See #28645 and #29041.
-func TestAddNameToMismatchedImport(t *testing.T) {
- const input = `package main
-
-import (
-"foo.com/a.thing"
-"foo.com/surprise"
-"foo.com/v1"
-"foo.com/other/v2"
-"foo.com/other/v3"
-"foo.com/go-thing"
-"foo.com/go-wrong"
-)
-
-var _ = []interface{}{bar.X, v1.Y, a.A, v2.V2, other.V3, thing.Thing, gow.Wrong}`
-
- const want = `package main
-
-import (
- "foo.com/a.thing"
- "foo.com/go-thing"
- gow "foo.com/go-wrong"
- v2 "foo.com/other/v2"
- "foo.com/other/v3"
- bar "foo.com/surprise"
- v1 "foo.com/v1"
-)
-
-var _ = []interface{}{bar.X, v1.Y, a.A, v2.V2, other.V3, thing.Thing, gow.Wrong}
-`
-
- testConfig{
- module: packagestest.Module{
- Name: "foo.com",
- Files: fm{
- "a.thing/a.go": "package a \n const A = 1",
- "surprise/x.go": "package bar \n const X = 1",
- "v1/x.go": "package v1 \n const Y = 1",
- "other/v2/y.go": "package v2 \n const V2 = 1",
- "other/v3/z.go": "package other \n const V3 = 1",
- "go-thing/b.go": "package thing \n const Thing = 1",
- "go-wrong/b.go": "package gow \n const Wrong = 1",
- "test/t.go": input,
- },
- },
- }.processTest(t, "foo.com", "test/t.go", nil, nil, want)
-}
-
-// Tests that the LocalPrefix option causes imports
-// to be added into a later group (num=3).
-func TestLocalPrefix(t *testing.T) {
- tests := []struct {
- name string
- modules []packagestest.Module
- localPrefix string
- src string
- want string
- }{
- {
- name: "one_local",
- modules: []packagestest.Module{
- {
- Name: "foo.com",
- Files: fm{
- "bar/bar.go": "package bar \n const X = 1",
- },
- },
- },
- localPrefix: "foo.com/",
- src: "package main \n const Y = bar.X \n const _ = runtime.GOOS",
- want: `package main
-
-import (
- "runtime"
-
- "foo.com/bar"
-)
-
-const Y = bar.X
-const _ = runtime.GOOS
-`,
- },
- {
- name: "two_local",
- modules: []packagestest.Module{
- {
- Name: "foo.com",
- Files: fm{
- "foo/foo.go": "package foo \n const X = 1",
- "foo/bar/bar.go": "package bar \n const X = 1",
- },
- },
- },
- localPrefix: "foo.com/foo",
- src: "package main \n const Y = bar.X \n const Z = foo.X \n const _ = runtime.GOOS",
- want: `package main
-
-import (
- "runtime"
-
- "foo.com/foo"
- "foo.com/foo/bar"
-)
-
-const Y = bar.X
-const Z = foo.X
-const _ = runtime.GOOS
-`,
- },
- {
- name: "three_prefixes",
- modules: []packagestest.Module{
- {
- Name: "example.org/pkg",
- Files: fm{"pkg.go": "package pkg \n const A = 1"},
- },
- {
- Name: "foo.com",
- Files: fm{"bar/bar.go": "package bar \n const B = 1"},
- },
- {
- Name: "code.org/r/p",
- Files: fm{"expproj/expproj.go": "package expproj \n const C = 1"},
- },
- },
- localPrefix: "example.org/pkg,foo.com/,code.org",
- src: "package main \n const X = pkg.A \n const Y = bar.B \n const Z = expproj.C \n const _ = runtime.GOOS",
- want: `package main
-
-import (
- "runtime"
-
- "code.org/r/p/expproj"
- "example.org/pkg"
- "foo.com/bar"
-)
-
-const X = pkg.A
-const Y = bar.B
-const Z = expproj.C
-const _ = runtime.GOOS
-`,
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- testConfig{
- // The module being processed has to be first so it's the primary module.
- modules: append([]packagestest.Module{{
- Name: "test.com",
- Files: fm{"t.go": tt.src},
- }}, tt.modules...),
- }.test(t, func(t *goimportTest) {
- options := &Options{
- LocalPrefix: tt.localPrefix,
- TabWidth: 8,
- TabIndent: true,
- Comments: true,
- Fragment: true,
- }
- t.assertProcessEquals("test.com", "t.go", nil, options, tt.want)
- })
- })
- }
-}
-
-// Tests that "package documentation" files are ignored.
-func TestIgnoreDocumentationPackage(t *testing.T) {
- const input = `package x
-
-const Y = foo.X
-`
- const want = `package x
-
-import "foo.com/foo"
-
-const Y = foo.X
-`
-
- testConfig{
- module: packagestest.Module{
- Name: "foo.com",
- Files: fm{
- "foo/foo.go": "package foo\nconst X = 1\n",
- "foo/doc.go": "package documentation \n // just to confuse things\n",
- "x/x.go": input,
- },
- },
- }.processTest(t, "foo.com", "x/x.go", nil, nil, want)
-}
-
-// Tests importPathToNameGoPathParse and in particular that it stops
-// after finding the first non-documentation package name, not
-// reporting an error on inconsistent package names (since it should
-// never make it that far).
-func TestImportPathToNameGoPathParse(t *testing.T) {
- testConfig{
- module: packagestest.Module{
- Name: "example.net/pkg",
- Files: fm{
- "doc.go": "package documentation\n", // ignored
- "gen.go": "package main\n", // also ignored
- "pkg.go": "package the_pkg_name_to_find\n and this syntax error is ignored because of parser.PackageClauseOnly",
- "z.go": "package inconsistent\n", // inconsistent but ignored
- },
- },
- }.test(t, func(t *goimportTest) {
- if strings.Contains(t.Name(), "GoPackages") {
- t.Skip("go/packages does not ignore package main")
- }
- r, err := t.env.GetResolver()
- if err != nil {
- t.Fatal(err)
- }
- srcDir := filepath.Dir(t.exported.File("example.net/pkg", "z.go"))
- names, err := r.loadPackageNames([]string{"example.net/pkg"}, srcDir)
- if err != nil {
- t.Fatal(err)
- }
- const want = "the_pkg_name_to_find"
- if got := names["example.net/pkg"]; got != want {
- t.Errorf("loadPackageNames(..) = %q; want %q", got, want)
- }
- })
-}
-
-func TestIgnoreConfiguration(t *testing.T) {
- const input = `package x
-
-const _ = pkg.X
-`
- const want = `package x
-
-import "foo.com/otherwise-longer-so-worse-example/foo/pkg"
-
-const _ = pkg.X
-`
-
- testConfig{
- gopathOnly: true,
- module: packagestest.Module{
- Name: "foo.com",
- Files: fm{
- "../.goimportsignore": "# comment line\n\n foo.com/example", // tests comment, blank line, whitespace trimming
- "example/pkg/pkg.go": "package pkg\nconst X = 1",
- "otherwise-longer-so-worse-example/foo/pkg/pkg.go": "package pkg\nconst X = 1",
- "x/x.go": input,
- },
- },
- }.processTest(t, "foo.com", "x/x.go", nil, nil, want)
-}
-
-// Skip "node_modules" directory.
-func TestSkipNodeModules(t *testing.T) {
- const input = `package x
-
-const _ = pkg.X
-`
- const want = `package x
-
-import "foo.com/otherwise-longer/not_modules/pkg"
-
-const _ = pkg.X
-`
-
- testConfig{
- gopathOnly: true,
- module: packagestest.Module{
- Name: "foo.com",
- Files: fm{
- "example/node_modules/pkg/a.go": "package pkg\nconst X = 1",
- "otherwise-longer/not_modules/pkg/a.go": "package pkg\nconst X = 1",
- "x/x.go": input,
- },
- },
- }.processTest(t, "foo.com", "x/x.go", nil, nil, want)
-}
-
-// Tests that package global variables with the same name and function name as
-// a function in a separate package do not result in an import which masks
-// the global variable
-func TestGlobalImports(t *testing.T) {
- const usesGlobal = `package pkg
-
-func doSomething() {
- t := time.Now()
-}
-`
-
- const declaresGlobal = `package pkg
-
-type Time struct{}
-
-func (t Time) Now() Time {
- return Time{}
-}
-
-var time Time
-`
-
- testConfig{
- module: packagestest.Module{
- Name: "foo.com",
- Files: fm{
- "pkg/uses.go": usesGlobal,
- "pkg/global.go": declaresGlobal,
- },
- },
- }.processTest(t, "foo.com", "pkg/uses.go", nil, nil, usesGlobal)
-}
-
-// Some people put multiple packages' files in the same directory. Globals
-// declared in other packages should be ignored.
-func TestGlobalImports_DifferentPackage(t *testing.T) {
- const declaresGlobal = `package main
-var fmt int
-`
- const input = `package pkg
-var _ = fmt.Printf
-`
- const want = `package pkg
-
-import "fmt"
-
-var _ = fmt.Printf
-`
-
- testConfig{
- module: packagestest.Module{
- Name: "foo.com",
- Files: fm{
- "pkg/main.go": declaresGlobal,
- "pkg/uses.go": input,
- },
- },
- }.processTest(t, "foo.com", "pkg/uses.go", nil, nil, want)
-}
-
-func TestGlobalImports_MultipleMains(t *testing.T) {
- const declaresGlobal = `package main
-var fmt int
-`
- const input = `package main
-import "fmt"
-var _, _ = fmt.Printf, bytes.Equal
-`
- const want = `package main
-
-import (
- "bytes"
- "fmt"
-)
-
-var _, _ = fmt.Printf, bytes.Equal
-`
-
- testConfig{
- module: packagestest.Module{
- Name: "foo.com",
- Files: fm{
- "pkg/main.go": declaresGlobal,
- "pkg/uses.go": input,
- },
- },
- }.processTest(t, "foo.com", "pkg/uses.go", nil, nil, want)
-}
-
-// Tests that sibling files - other files in the same package - can provide an
-// import that may not be the default one otherwise.
-func TestSiblingImports(t *testing.T) {
-
- // provide is the sibling file that provides the desired import.
- const provide = `package siblingimporttest
-
-import "local/log"
-import "my/bytes"
-import renamed "fmt"
-
-func LogSomething() {
- log.Print("Something")
- bytes.SomeFunc()
- renamed.Println("Something")
-}
-`
-
- // need is the file being tested that needs the import.
- const need = `package siblingimporttest
-
-var _ = bytes.Buffer{}
-
-func LogSomethingElse() {
- log.Print("Something else")
- renamed.Println("Yet another")
-}
-`
-
- // want is the expected result file
- const want = `package siblingimporttest
-
-import (
- "bytes"
- renamed "fmt"
- "local/log"
-)
-
-var _ = bytes.Buffer{}
-
-func LogSomethingElse() {
- log.Print("Something else")
- renamed.Println("Yet another")
-}
-`
-
- testConfig{
- module: packagestest.Module{
- Name: "foo.com",
- Files: fm{
- "p/needs_import.go": need,
- "p/provides_import.go": provide,
- },
- },
- }.processTest(t, "foo.com", "p/needs_import.go", nil, nil, want)
-}
-
-// Tests #29180: a sibling import of the right package with the wrong name is used.
-func TestSiblingImport_Misnamed(t *testing.T) {
- const sibling = `package main
-import renamed "fmt"
-var _ = renamed.Printf
-`
- const input = `package pkg
-var _ = fmt.Printf
-`
- const want = `package pkg
-
-import "fmt"
-
-var _ = fmt.Printf
-`
-
- testConfig{
- module: packagestest.Module{
- Name: "foo.com",
- Files: fm{
- "pkg/main.go": sibling,
- "pkg/uses.go": input,
- },
- },
- }.processTest(t, "foo.com", "pkg/uses.go", nil, nil, want)
-
-}
-
-// Tests that an input file's own package is ignored.
-func TestIgnoreOwnPackage(t *testing.T) {
- const input = `package pkg
-
-const _ = pkg.X
-`
- const want = `package pkg
-
-const _ = pkg.X
-`
-
- testConfig{
- module: packagestest.Module{
- Name: "foo.com",
- Files: fm{
- "pkg/a.go": "package pkg\nconst X = 1",
- "pkg/b.go": input,
- },
- },
- }.processTest(t, "foo.com", "pkg/b.go", nil, nil, want)
-}
-
-func TestExternalTestImportsPackageUnderTest(t *testing.T) {
- const provide = `package pkg
-func DoIt(){}
-`
- const input = `package pkg_test
-
-var _ = pkg.DoIt`
-
- const want = `package pkg_test
-
-import "foo.com/pkg"
-
-var _ = pkg.DoIt
-`
-
- testConfig{
- module: packagestest.Module{
- Name: "foo.com",
- Files: fm{
- "pkg/provide.go": provide,
- "pkg/x_test.go": input,
- },
- },
- }.processTest(t, "foo.com", "pkg/x_test.go", nil, nil, want)
-}
-
-func TestPkgIsCandidate(t *testing.T) {
- tests := []struct {
- name string
- filename string
- pkgIdent string
- pkg *pkg
- want bool
- }{
- {
- name: "normal_match",
- filename: "/gopath/src/my/pkg/pkg.go",
- pkgIdent: "client",
- pkg: &pkg{
- dir: "/gopath/src/client",
- importPathShort: "client",
- },
- want: true,
- },
- {
- name: "no_match",
- filename: "/gopath/src/my/pkg/pkg.go",
- pkgIdent: "zzz",
- pkg: &pkg{
- dir: "/gopath/src/client",
- importPathShort: "client",
- },
- want: false,
- },
- {
- name: "match_too_early",
- filename: "/gopath/src/my/pkg/pkg.go",
- pkgIdent: "client",
- pkg: &pkg{
- dir: "/gopath/src/client/foo/foo/foo",
- importPathShort: "client/foo/foo",
- },
- want: false,
- },
- {
- name: "substring_match",
- filename: "/gopath/src/my/pkg/pkg.go",
- pkgIdent: "client",
- pkg: &pkg{
- dir: "/gopath/src/foo/go-client",
- importPathShort: "foo/go-client",
- },
- want: true,
- },
- {
- name: "hidden_internal",
- filename: "/gopath/src/my/pkg/pkg.go",
- pkgIdent: "client",
- pkg: &pkg{
- dir: "/gopath/src/foo/internal/client",
- importPathShort: "foo/internal/client",
- },
- want: false,
- },
- {
- name: "visible_internal",
- filename: "/gopath/src/foo/bar.go",
- pkgIdent: "client",
- pkg: &pkg{
- dir: "/gopath/src/foo/internal/client",
- importPathShort: "foo/internal/client",
- },
- want: true,
- },
- {
- name: "invisible_vendor",
- filename: "/gopath/src/foo/bar.go",
- pkgIdent: "client",
- pkg: &pkg{
- dir: "/gopath/src/other/vendor/client",
- importPathShort: "client",
- },
- want: false,
- },
- {
- name: "visible_vendor",
- filename: "/gopath/src/foo/bar.go",
- pkgIdent: "client",
- pkg: &pkg{
- dir: "/gopath/src/foo/vendor/client",
- importPathShort: "client",
- },
- want: true,
- },
- {
- name: "match_with_hyphens",
- filename: "/gopath/src/foo/bar.go",
- pkgIdent: "socketio",
- pkg: &pkg{
- dir: "/gopath/src/foo/socket-io",
- importPathShort: "foo/socket-io",
- },
- want: true,
- },
- {
- name: "match_with_mixed_case",
- filename: "/gopath/src/foo/bar.go",
- pkgIdent: "fooprod",
- pkg: &pkg{
- dir: "/gopath/src/foo/FooPROD",
- importPathShort: "foo/FooPROD",
- },
- want: true,
- },
- {
- name: "matches_with_hyphen_and_caps",
- filename: "/gopath/src/foo/bar.go",
- pkgIdent: "fooprod",
- pkg: &pkg{
- dir: "/gopath/src/foo/Foo-PROD",
- importPathShort: "foo/Foo-PROD",
- },
- want: true,
- },
- }
- for i, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- refs := references{tt.pkgIdent: nil}
- got := pkgIsCandidate(tt.filename, refs, tt.pkg)
- if got != tt.want {
- t.Errorf("test %d. pkgIsCandidate(%q, %q, %+v) = %v; want %v",
- i, tt.filename, tt.pkgIdent, *tt.pkg, got, tt.want)
- }
- })
- }
-}
-
-// Issue 20941: this used to panic on Windows.
-func TestProcessStdin(t *testing.T) {
- testConfig{
- module: packagestest.Module{
- Name: "foo.com",
- },
- }.test(t, func(t *goimportTest) {
- got, err := t.processNonModule("<standard input>", []byte("package main\nfunc main() {\n\tfmt.Println(123)\n}\n"), nil)
- if err != nil {
- t.Fatal(err)
- }
- if !strings.Contains(string(got), `"fmt"`) {
- t.Errorf("expected fmt import; got: %s", got)
- }
- })
-}
-
-// Tests LocalPackagePromotion when there is a local package that matches, it
-// should be the closest match.
-// https://golang.org/issues/17557
-func TestLocalPackagePromotion(t *testing.T) {
- const input = `package main
-var c = &config.SystemConfig{}
-`
- const want = `package main
-
-import "mycompany.net/tool/config"
-
-var c = &config.SystemConfig{}
-`
-
- testConfig{
- modules: []packagestest.Module{
- {
- Name: "config.net/config",
- Files: fm{"config.go": "package config\n type SystemConfig struct {}"}, // Will match but should not be first choice
- },
- {
- Name: "mycompany.net/config",
- Files: fm{"config.go": "package config\n type SystemConfig struct {}"}, // Will match but should not be first choice
- },
- {
- Name: "mycompany.net/tool",
- Files: fm{
- "config/config.go": "package config\n type SystemConfig struct {}", // Local package should be promoted over shorter package
- "main.go": input,
- },
- },
- },
- }.processTest(t, "mycompany.net/tool", "main.go", nil, nil, want)
-}
-
-// Tests FindImportInLocalGoFiles looks at the import lines for other Go files in the
-// local directory, since the user is likely to import the same packages in the current
-// Go file. If an import is found that satisfies the need, it should be used over the
-// standard library.
-// https://golang.org/issues/17557
-func TestFindImportInLocalGoFiles(t *testing.T) {
- const input = `package main
- var _ = &bytes.Buffer{}`
-
- const want = `package main
-
-import "bytes.net/bytes"
-
-var _ = &bytes.Buffer{}
-`
- testConfig{
- modules: []packagestest.Module{
- {
- Name: "mycompany.net/tool",
- Files: fm{
- "io.go": "package main\n import \"bytes.net/bytes\"\n var _ = &bytes.Buffer{}", // Contains package import that will cause stdlib to be ignored
- "main.go": input,
- },
- },
- {
- Name: "bytes.net/bytes",
- Files: fm{"bytes.go": "package bytes\n type Buffer struct {}"}, // Should be selected over standard library
- },
- },
- }.processTest(t, "mycompany.net/tool", "main.go", nil, nil, want)
-}
-
-func TestInMemoryFile(t *testing.T) {
- const input = `package main
- var _ = &bytes.Buffer{}`
-
- const want = `package main
-
-import "bytes"
-
-var _ = &bytes.Buffer{}
-`
- testConfig{
- module: packagestest.Module{
- Name: "foo.com",
- Files: fm{"x.go": "package x\n"},
- },
- }.processTest(t, "foo.com", "x.go", []byte(input), nil, want)
-}
-
-func TestImportNoGoFiles(t *testing.T) {
- const input = `package main
- var _ = &bytes.Buffer{}`
-
- const want = `package main
-
-import "bytes"
-
-var _ = &bytes.Buffer{}
-`
- testConfig{
- module: packagestest.Module{
- Name: "mycompany.net",
- },
- }.test(t, func(t *goimportTest) {
- buf, err := t.processNonModule("mycompany.net/tool/main.go", []byte(input), nil)
- if err != nil {
- t.Fatalf("Process() = %v", err)
- }
- if string(buf) != want {
- t.Errorf("Got:\n%s\nWant:\n%s", buf, want)
- }
- })
-
-}
-
-// Ensures a token as large as 500000 bytes can be handled
-// https://golang.org/issues/18201
-func TestProcessLargeToken(t *testing.T) {
- largeString := strings.Repeat("x", 500000)
-
- input := `package testimports
-
-import (
- "bytes"
-)
-
-const s = fmt.Sprintf("%s", "` + largeString + `")
-var _ = bytes.Buffer{}
-
-// end
-`
-
- want := `package testimports
-
-import (
- "bytes"
- "fmt"
-)
-
-const s = fmt.Sprintf("%s", "` + largeString + `")
-
-var _ = bytes.Buffer{}
-
-// end
-`
-
- testConfig{
- module: packagestest.Module{
- Name: "foo.com",
- Files: fm{"foo.go": input},
- },
- }.processTest(t, "foo.com", "foo.go", nil, nil, want)
-}
-
-// Tests that an external test package will import the package under test if it
-// also uses symbols exported only in test files.
-// https://golang.org/issues/29979
-func TestExternalTest(t *testing.T) {
- const input = `package a_test
-func TestX() {
- a.X()
- a.Y()
-}
-`
- const want = `package a_test
-
-import "foo.com/a"
-
-func TestX() {
- a.X()
- a.Y()
-}
-`
-
- testConfig{
- modules: []packagestest.Module{
- {
- Name: "foo.com/a",
- Files: fm{
- "a.go": "package a\n func X() {}",
- "export_test.go": "package a\n func Y() {}",
- "a_test.go": input,
- },
- },
- },
- }.processTest(t, "foo.com/a", "a_test.go", nil, nil, want)
-}
-
-// TestGetCandidates tests that get packages finds packages
-// with correct priorities.
-func TestGetCandidates(t *testing.T) {
- type res struct {
- relevance float64
- name, path string
- }
- want := []res{
- {0, "bytes", "bytes"},
- {0, "http", "net/http"},
- {0, "rand", "crypto/rand"},
- {0, "bar", "bar.com/bar"},
- {0, "foo", "foo.com/foo"},
- }
-
- testConfig{
- modules: []packagestest.Module{
- {
- Name: "bar.com",
- Files: fm{"bar/bar.go": "package bar\n"},
- },
- {
- Name: "foo.com",
- Files: fm{"foo/foo.go": "package foo\n"},
- },
- },
- }.test(t, func(t *goimportTest) {
- 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, "", "x.go", "x", t.env); err != nil {
- t.Fatalf("GetAllCandidates() = %v", err)
- }
- // Sort, then clear out relevance so it doesn't mess up the DeepEqual.
- 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
- })
- for i := range got {
- got[i].relevance = 0
- }
- if !reflect.DeepEqual(want, got) {
- t.Errorf("wanted results in order %v, got %v", want, got)
- }
- })
-}
-
-func TestGetImportPaths(t *testing.T) {
- type res struct {
- relevance float64
- name, path string
- }
- want := []res{
- {0, "http", "net/http"},
- {0, "net", "net"},
- {0, "neta", "neta.com/neta"},
- }
-
- testConfig{
- modules: []packagestest.Module{
- {
- Name: "neta.com",
- Files: fm{"neta/neta.go": "package neta\n"},
- },
- },
- }.test(t, func(t *goimportTest) {
- 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 := GetImportPaths(context.Background(), add, "ne", "x.go", "x", t.env); err != nil {
- t.Fatalf("GetImportPaths() = %v", err)
- }
- // Sort, then clear out relevance so it doesn't mess up the DeepEqual.
- 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
- })
- for i := range got {
- got[i].relevance = 0
- }
- if !reflect.DeepEqual(want, got) {
- t.Errorf("wanted results in order %v, got %v", want, got)
- }
- })
-}
-
-func TestGetPackageCompletions(t *testing.T) {
- type res struct {
- relevance float64
- name, path, symbol string
- }
- want := []res{
- {0, "rand", "math/rand", "Seed"},
- {0, "rand", "bar.com/rand", "Bar"},
- }
-
- testConfig{
- modules: []packagestest.Module{
- {
- Name: "bar.com",
- Files: fm{"rand/bar.go": "package rand\nvar Bar int\n"},
- },
- },
- }.test(t, func(t *goimportTest) {
- var mu sync.Mutex
- var got []res
- add := func(c PackageExport) {
- mu.Lock()
- defer mu.Unlock()
- for _, csym := range c.Exports {
- for _, w := range want {
- if c.Fix.StmtInfo.ImportPath == w.path && csym == w.symbol {
- got = append(got, res{c.Fix.Relevance, c.Fix.IdentName, c.Fix.StmtInfo.ImportPath, csym})
- }
- }
- }
- }
- if err := GetPackageExports(context.Background(), add, "rand", "x.go", "x", t.env); err != nil {
- t.Fatalf("getPackageCompletions() = %v", err)
- }
- // Sort, then clear out relevance so it doesn't mess up the DeepEqual.
- 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
- })
- for i := range got {
- got[i].relevance = 0
- }
- if !reflect.DeepEqual(want, got) {
- t.Errorf("wanted results in order %v, got %v", want, got)
- }
- })
-}
-
-// Tests #34895: process should not panic on concurrent calls.
-func TestConcurrentProcess(t *testing.T) {
- testConfig{
- module: packagestest.Module{
- Name: "foo.com",
- Files: fm{
- "p/first.go": `package foo
-
-func _() {
- fmt.Println()
-}
-`,
- "p/second.go": `package foo
-
-import "fmt"
-
-func _() {
- fmt.Println()
- imports.Bar() // not imported.
-}
-`,
- },
- },
- }.test(t, func(t *goimportTest) {
- var (
- n = 10
- wg sync.WaitGroup
- )
- wg.Add(n)
- for i := 0; i < n; i++ {
- go func() {
- defer wg.Done()
- _, err := t.process("foo.com", "p/first.go", nil, nil)
- if err != nil {
- t.Error(err)
- }
- }()
- }
- wg.Wait()
- })
-}
-
-func TestNonlocalDot(t *testing.T) {
- const input = `package main
-import (
- "fmt"
-)
-var _, _ = fmt.Sprintf, dot.Dot
-`
- const want = `package main
-
-import (
- "fmt"
- "noninternet/dot.v1/dot"
-)
-
-var _, _ = fmt.Sprintf, dot.Dot
-`
- testConfig{
- modules: []packagestest.Module{
- {
- Name: "golang.org/fake",
- Files: fm{"x.go": input},
- },
- {
- Name: "noninternet/dot.v1",
- Files: fm{
- "dot/dot.go": "package dot\nfunc Dot(){}\n",
- },
- },
- },
- gopathOnly: true, // our modules testing setup doesn't allow modules without dots.
- }.processTest(t, "golang.org/fake", "x.go", nil, nil, want)
-}
projects / dotfiles / .git / blobdiff