...
Run Format

Source file src/go/internal/gcimporter/gcimporter_test.go

Documentation: go/internal/gcimporter

  // Copyright 2011 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 gcimporter
  
  import (
  	"bytes"
  	"fmt"
  	"internal/testenv"
  	"io/ioutil"
  	"os"
  	"os/exec"
  	"path/filepath"
  	"runtime"
  	"strings"
  	"testing"
  	"time"
  
  	"go/types"
  )
  
  // skipSpecialPlatforms causes the test to be skipped for platforms where
  // builders (build.golang.org) don't have access to compiled packages for
  // import.
  func skipSpecialPlatforms(t *testing.T) {
  	switch platform := runtime.GOOS + "-" + runtime.GOARCH; platform {
  	case "nacl-amd64p32",
  		"nacl-386",
  		"nacl-arm",
  		"darwin-arm",
  		"darwin-arm64":
  		t.Skipf("no compiled packages available for import on %s", platform)
  	}
  }
  
  func compile(t *testing.T, dirname, filename string) string {
  	cmd := exec.Command(testenv.GoToolPath(t), "tool", "compile", filename)
  	cmd.Dir = dirname
  	out, err := cmd.CombinedOutput()
  	if err != nil {
  		t.Logf("%s", out)
  		t.Fatalf("go tool compile %s failed: %s", filename, err)
  	}
  	// filename should end with ".go"
  	return filepath.Join(dirname, filename[:len(filename)-2]+"o")
  }
  
  func testPath(t *testing.T, path, srcDir string) *types.Package {
  	t0 := time.Now()
  	pkg, err := Import(make(map[string]*types.Package), path, srcDir)
  	if err != nil {
  		t.Errorf("testPath(%s): %s", path, err)
  		return nil
  	}
  	t.Logf("testPath(%s): %v", path, time.Since(t0))
  	return pkg
  }
  
  const maxTime = 30 * time.Second
  
  func testDir(t *testing.T, dir string, endTime time.Time) (nimports int) {
  	dirname := filepath.Join(runtime.GOROOT(), "pkg", runtime.GOOS+"_"+runtime.GOARCH, dir)
  	list, err := ioutil.ReadDir(dirname)
  	if err != nil {
  		t.Fatalf("testDir(%s): %s", dirname, err)
  	}
  	for _, f := range list {
  		if time.Now().After(endTime) {
  			t.Log("testing time used up")
  			return
  		}
  		switch {
  		case !f.IsDir():
  			// try extensions
  			for _, ext := range pkgExts {
  				if strings.HasSuffix(f.Name(), ext) {
  					name := f.Name()[0 : len(f.Name())-len(ext)] // remove extension
  					if testPath(t, filepath.Join(dir, name), dir) != nil {
  						nimports++
  					}
  				}
  			}
  		case f.IsDir():
  			nimports += testDir(t, filepath.Join(dir, f.Name()), endTime)
  		}
  	}
  	return
  }
  
  func TestImportTestdata(t *testing.T) {
  	// This package only handles gc export data.
  	if runtime.Compiler != "gc" {
  		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
  	}
  
  	if outFn := compile(t, "testdata", "exports.go"); outFn != "" {
  		defer os.Remove(outFn)
  	}
  
  	if pkg := testPath(t, "./testdata/exports", "."); pkg != nil {
  		// The package's Imports list must include all packages
  		// explicitly imported by exports.go, plus all packages
  		// referenced indirectly via exported objects in exports.go.
  		// With the textual export format, the list may also include
  		// additional packages that are not strictly required for
  		// import processing alone (they are exported to err "on
  		// the safe side").
  		// TODO(gri) update the want list to be precise, now that
  		// the textual export data is gone.
  		got := fmt.Sprint(pkg.Imports())
  		for _, want := range []string{"go/ast", "go/token"} {
  			if !strings.Contains(got, want) {
  				t.Errorf(`Package("exports").Imports() = %s, does not contain %s`, got, want)
  			}
  		}
  	}
  }
  
  func TestVersionHandling(t *testing.T) {
  	skipSpecialPlatforms(t) // we really only need to exclude nacl platforms, but this is fine
  
  	// This package only handles gc export data.
  	if runtime.Compiler != "gc" {
  		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
  	}
  
  	const dir = "./testdata/versions"
  	list, err := ioutil.ReadDir(dir)
  	if err != nil {
  		t.Fatal(err)
  	}
  
  	for _, f := range list {
  		name := f.Name()
  		if !strings.HasSuffix(name, ".a") {
  			continue // not a package file
  		}
  		if strings.Contains(name, "corrupted") {
  			continue // don't process a leftover corrupted file
  		}
  		pkgpath := "./" + name[:len(name)-2]
  
  		// test that export data can be imported
  		_, err := Import(make(map[string]*types.Package), pkgpath, dir)
  		if err != nil {
  			t.Errorf("import %q failed: %v", pkgpath, err)
  			continue
  		}
  
  		// create file with corrupted export data
  		// 1) read file
  		data, err := ioutil.ReadFile(filepath.Join(dir, name))
  		if err != nil {
  			t.Fatal(err)
  		}
  		// 2) find export data
  		i := bytes.Index(data, []byte("\n$$B\n")) + 5
  		j := bytes.Index(data[i:], []byte("\n$$\n")) + i
  		if i < 0 || j < 0 || i > j {
  			t.Fatalf("export data section not found (i = %d, j = %d)", i, j)
  		}
  		// 3) corrupt the data (increment every 7th byte)
  		for k := j - 13; k >= i; k -= 7 {
  			data[k]++
  		}
  		// 4) write the file
  		pkgpath += "_corrupted"
  		filename := filepath.Join(dir, pkgpath) + ".a"
  		ioutil.WriteFile(filename, data, 0666)
  		defer os.Remove(filename)
  
  		// test that importing the corrupted file results in an error
  		_, err = Import(make(map[string]*types.Package), pkgpath, dir)
  		if err == nil {
  			t.Errorf("import corrupted %q succeeded", pkgpath)
  		} else if msg := err.Error(); !strings.Contains(msg, "version skew") {
  			t.Errorf("import %q error incorrect (%s)", pkgpath, msg)
  		}
  	}
  }
  
  func TestImportStdLib(t *testing.T) {
  	skipSpecialPlatforms(t)
  
  	// This package only handles gc export data.
  	if runtime.Compiler != "gc" {
  		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
  	}
  
  	dt := maxTime
  	if testing.Short() && testenv.Builder() == "" {
  		dt = 10 * time.Millisecond
  	}
  	nimports := testDir(t, "", time.Now().Add(dt)) // installed packages
  	t.Logf("tested %d imports", nimports)
  }
  
  var importedObjectTests = []struct {
  	name string
  	want string
  }{
  	{"math.Pi", "const Pi untyped float"},
  	{"io.Reader", "type Reader interface{Read(p []byte) (n int, err error)}"},
  	{"io.ReadWriter", "type ReadWriter interface{Reader; Writer}"},
  	{"math.Sin", "func Sin(x float64) float64"},
  	// TODO(gri) add more tests
  }
  
  func TestImportedTypes(t *testing.T) {
  	skipSpecialPlatforms(t)
  
  	// This package only handles gc export data.
  	if runtime.Compiler != "gc" {
  		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
  	}
  
  	for _, test := range importedObjectTests {
  		s := strings.Split(test.name, ".")
  		if len(s) != 2 {
  			t.Fatal("inconsistent test data")
  		}
  		importPath := s[0]
  		objName := s[1]
  
  		pkg, err := Import(make(map[string]*types.Package), importPath, ".")
  		if err != nil {
  			t.Error(err)
  			continue
  		}
  
  		obj := pkg.Scope().Lookup(objName)
  		if obj == nil {
  			t.Errorf("%s: object not found", test.name)
  			continue
  		}
  
  		got := types.ObjectString(obj, types.RelativeTo(pkg))
  		if got != test.want {
  			t.Errorf("%s: got %q; want %q", test.name, got, test.want)
  		}
  	}
  }
  
  func TestIssue5815(t *testing.T) {
  	skipSpecialPlatforms(t)
  
  	// This package only handles gc export data.
  	if runtime.Compiler != "gc" {
  		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
  	}
  
  	pkg := importPkg(t, "strings")
  
  	scope := pkg.Scope()
  	for _, name := range scope.Names() {
  		obj := scope.Lookup(name)
  		if obj.Pkg() == nil {
  			t.Errorf("no pkg for %s", obj)
  		}
  		if tname, _ := obj.(*types.TypeName); tname != nil {
  			named := tname.Type().(*types.Named)
  			for i := 0; i < named.NumMethods(); i++ {
  				m := named.Method(i)
  				if m.Pkg() == nil {
  					t.Errorf("no pkg for %s", m)
  				}
  			}
  		}
  	}
  }
  
  // Smoke test to ensure that imported methods get the correct package.
  func TestCorrectMethodPackage(t *testing.T) {
  	skipSpecialPlatforms(t)
  
  	// This package only handles gc export data.
  	if runtime.Compiler != "gc" {
  		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
  	}
  
  	imports := make(map[string]*types.Package)
  	_, err := Import(imports, "net/http", ".")
  	if err != nil {
  		t.Fatal(err)
  	}
  
  	mutex := imports["sync"].Scope().Lookup("Mutex").(*types.TypeName).Type()
  	mset := types.NewMethodSet(types.NewPointer(mutex)) // methods of *sync.Mutex
  	sel := mset.Lookup(nil, "Lock")
  	lock := sel.Obj().(*types.Func)
  	if got, want := lock.Pkg().Path(), "sync"; got != want {
  		t.Errorf("got package path %q; want %q", got, want)
  	}
  }
  
  func TestIssue13566(t *testing.T) {
  	skipSpecialPlatforms(t)
  
  	// This package only handles gc export data.
  	if runtime.Compiler != "gc" {
  		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
  	}
  
  	// On windows, we have to set the -D option for the compiler to avoid having a drive
  	// letter and an illegal ':' in the import path - just skip it (see also issue #3483).
  	if runtime.GOOS == "windows" {
  		t.Skip("avoid dealing with relative paths/drive letters on windows")
  	}
  
  	if f := compile(t, "testdata", "a.go"); f != "" {
  		defer os.Remove(f)
  	}
  	if f := compile(t, "testdata", "b.go"); f != "" {
  		defer os.Remove(f)
  	}
  
  	// import must succeed (test for issue at hand)
  	pkg := importPkg(t, "./testdata/b")
  
  	// make sure all indirectly imported packages have names
  	for _, imp := range pkg.Imports() {
  		if imp.Name() == "" {
  			t.Errorf("no name for %s package", imp.Path())
  		}
  	}
  }
  
  func TestIssue13898(t *testing.T) {
  	skipSpecialPlatforms(t)
  
  	// This package only handles gc export data.
  	if runtime.Compiler != "gc" {
  		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
  	}
  
  	// import go/internal/gcimporter which imports go/types partially
  	imports := make(map[string]*types.Package)
  	_, err := Import(imports, "go/internal/gcimporter", ".")
  	if err != nil {
  		t.Fatal(err)
  	}
  
  	// look for go/types package
  	var goTypesPkg *types.Package
  	for path, pkg := range imports {
  		if path == "go/types" {
  			goTypesPkg = pkg
  			break
  		}
  	}
  	if goTypesPkg == nil {
  		t.Fatal("go/types not found")
  	}
  
  	// look for go/types.Object type
  	obj := lookupObj(t, goTypesPkg.Scope(), "Object")
  	typ, ok := obj.Type().(*types.Named)
  	if !ok {
  		t.Fatalf("go/types.Object type is %v; wanted named type", typ)
  	}
  
  	// lookup go/types.Object.Pkg method
  	m, index, indirect := types.LookupFieldOrMethod(typ, false, nil, "Pkg")
  	if m == nil {
  		t.Fatalf("go/types.Object.Pkg not found (index = %v, indirect = %v)", index, indirect)
  	}
  
  	// the method must belong to go/types
  	if m.Pkg().Path() != "go/types" {
  		t.Fatalf("found %v; want go/types", m.Pkg())
  	}
  }
  
  func TestIssue15517(t *testing.T) {
  	skipSpecialPlatforms(t)
  
  	// This package only handles gc export data.
  	if runtime.Compiler != "gc" {
  		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
  	}
  
  	// On windows, we have to set the -D option for the compiler to avoid having a drive
  	// letter and an illegal ':' in the import path - just skip it (see also issue #3483).
  	if runtime.GOOS == "windows" {
  		t.Skip("avoid dealing with relative paths/drive letters on windows")
  	}
  
  	if f := compile(t, "testdata", "p.go"); f != "" {
  		defer os.Remove(f)
  	}
  
  	// Multiple imports of p must succeed without redeclaration errors.
  	// We use an import path that's not cleaned up so that the eventual
  	// file path for the package is different from the package path; this
  	// will expose the error if it is present.
  	//
  	// (Issue: Both the textual and the binary importer used the file path
  	// of the package to be imported as key into the shared packages map.
  	// However, the binary importer then used the package path to identify
  	// the imported package to mark it as complete; effectively marking the
  	// wrong package as complete. By using an "unclean" package path, the
  	// file and package path are different, exposing the problem if present.
  	// The same issue occurs with vendoring.)
  	imports := make(map[string]*types.Package)
  	for i := 0; i < 3; i++ {
  		if _, err := Import(imports, "./././testdata/p", "."); err != nil {
  			t.Fatal(err)
  		}
  	}
  }
  
  func TestIssue15920(t *testing.T) {
  	skipSpecialPlatforms(t)
  
  	// This package only handles gc export data.
  	if runtime.Compiler != "gc" {
  		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
  	}
  
  	// On windows, we have to set the -D option for the compiler to avoid having a drive
  	// letter and an illegal ':' in the import path - just skip it (see also issue #3483).
  	if runtime.GOOS == "windows" {
  		t.Skip("avoid dealing with relative paths/drive letters on windows")
  	}
  
  	if f := compile(t, "testdata", "issue15920.go"); f != "" {
  		defer os.Remove(f)
  	}
  
  	importPkg(t, "./testdata/issue15920")
  }
  
  func TestIssue20046(t *testing.T) {
  	skipSpecialPlatforms(t)
  
  	// This package only handles gc export data.
  	if runtime.Compiler != "gc" {
  		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
  	}
  
  	// On windows, we have to set the -D option for the compiler to avoid having a drive
  	// letter and an illegal ':' in the import path - just skip it (see also issue #3483).
  	if runtime.GOOS == "windows" {
  		t.Skip("avoid dealing with relative paths/drive letters on windows")
  	}
  
  	if f := compile(t, "testdata", "issue20046.go"); f != "" {
  		defer os.Remove(f)
  	}
  
  	// "./issue20046".V.M must exist
  	pkg := importPkg(t, "./testdata/issue20046")
  	obj := lookupObj(t, pkg.Scope(), "V")
  	if m, index, indirect := types.LookupFieldOrMethod(obj.Type(), false, nil, "M"); m == nil {
  		t.Fatalf("V.M not found (index = %v, indirect = %v)", index, indirect)
  	}
  }
  
  func importPkg(t *testing.T, path string) *types.Package {
  	pkg, err := Import(make(map[string]*types.Package), path, ".")
  	if err != nil {
  		t.Fatal(err)
  	}
  	return pkg
  }
  
  func lookupObj(t *testing.T, scope *types.Scope, name string) types.Object {
  	if obj := scope.Lookup(name); obj != nil {
  		return obj
  	}
  	t.Fatalf("%s not found", name)
  	return nil
  }
  

View as plain text