route/vendor/golang.org/x/tools/godoc/index_test.go

324 lines
7.4 KiB
Go

// 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 godoc
import (
"bytes"
"reflect"
"sort"
"strings"
"testing"
"golang.org/x/tools/godoc/vfs/mapfs"
)
func newCorpus(t *testing.T) *Corpus {
c := NewCorpus(mapfs.New(map[string]string{
"src/foo/foo.go": `// Package foo is an example.
package foo
import "bar"
const Pi = 3.1415
var Foos []Foo
// Foo is stuff.
type Foo struct{}
func New() *Foo {
return new(Foo)
}
`,
"src/bar/bar.go": `// Package bar is another example to test races.
package bar
`,
"src/other/bar/bar.go": `// Package bar is another bar package.
package bar
func X() {}
`,
"src/skip/skip.go": `// Package skip should be skipped.
package skip
func Skip() {}
`,
"src/bar/readme.txt": `Whitelisted text file.
`,
"src/bar/baz.zzz": `Text file not whitelisted.
`,
}))
c.IndexEnabled = true
c.IndexDirectory = func(dir string) bool {
return !strings.Contains(dir, "skip")
}
if err := c.Init(); err != nil {
t.Fatal(err)
}
return c
}
func TestIndex(t *testing.T) {
for _, docs := range []bool{true, false} {
for _, goCode := range []bool{true, false} {
for _, fullText := range []bool{true, false} {
c := newCorpus(t)
c.IndexDocs = docs
c.IndexGoCode = goCode
c.IndexFullText = fullText
c.UpdateIndex()
ix, _ := c.CurrentIndex()
if ix == nil {
t.Fatal("no index")
}
t.Logf("docs, goCode, fullText = %v,%v,%v", docs, goCode, fullText)
testIndex(t, c, ix)
}
}
}
}
func TestIndexWriteRead(t *testing.T) {
type key struct {
docs, goCode, fullText bool
}
type val struct {
buf *bytes.Buffer
c *Corpus
}
m := map[key]val{}
for _, docs := range []bool{true, false} {
for _, goCode := range []bool{true, false} {
for _, fullText := range []bool{true, false} {
k := key{docs, goCode, fullText}
c := newCorpus(t)
c.IndexDocs = docs
c.IndexGoCode = goCode
c.IndexFullText = fullText
c.UpdateIndex()
ix, _ := c.CurrentIndex()
if ix == nil {
t.Fatal("no index")
}
var buf bytes.Buffer
nw, err := ix.WriteTo(&buf)
if err != nil {
t.Fatalf("Index.WriteTo: %v", err)
}
m[k] = val{bytes.NewBuffer(buf.Bytes()), c}
ix2 := new(Index)
nr, err := ix2.ReadFrom(&buf)
if err != nil {
t.Fatalf("Index.ReadFrom: %v", err)
}
if nr != nw {
t.Errorf("Wrote %d bytes to index but read %d", nw, nr)
}
testIndex(t, c, ix)
}
}
}
// Test CompatibleWith
for k1, v1 := range m {
ix := new(Index)
if _, err := ix.ReadFrom(v1.buf); err != nil {
t.Fatalf("Index.ReadFrom: %v", err)
}
for k2, v2 := range m {
if got, want := ix.CompatibleWith(v2.c), k1 == k2; got != want {
t.Errorf("CompatibleWith = %v; want %v for %v, %v", got, want, k1, k2)
}
}
}
}
func testIndex(t *testing.T, c *Corpus, ix *Index) {
if _, ok := ix.words["Skip"]; ok {
t.Errorf("the word Skip was found; expected it to be skipped")
}
checkStats(t, c, ix)
checkImportCount(t, c, ix)
checkPackagePath(t, c, ix)
checkExports(t, c, ix)
checkIdents(t, c, ix)
}
// checkStats checks the Index's statistics.
// Some statistics are only set when we're indexing Go code.
func checkStats(t *testing.T, c *Corpus, ix *Index) {
want := Statistics{}
if c.IndexFullText {
want.Bytes = 314
want.Files = 4
want.Lines = 21
} else if c.IndexDocs || c.IndexGoCode {
want.Bytes = 291
want.Files = 3
want.Lines = 20
}
if c.IndexGoCode {
want.Words = 8
want.Spots = 12
}
if got := ix.Stats(); !reflect.DeepEqual(got, want) {
t.Errorf("Stats = %#v; want %#v", got, want)
}
}
// checkImportCount checks the Index's import count map.
// It is only set when we're indexing Go code.
func checkImportCount(t *testing.T, c *Corpus, ix *Index) {
want := map[string]int{}
if c.IndexGoCode {
want = map[string]int{
"bar": 1,
}
}
if got := ix.ImportCount(); !reflect.DeepEqual(got, want) {
t.Errorf("ImportCount = %v; want %v", got, want)
}
}
// checkPackagePath checks the Index's package path map.
// It is set if at least one of the indexing options is enabled.
func checkPackagePath(t *testing.T, c *Corpus, ix *Index) {
want := map[string]map[string]bool{}
if c.IndexDocs || c.IndexGoCode || c.IndexFullText {
want = map[string]map[string]bool{
"foo": {
"foo": true,
},
"bar": {
"bar": true,
"other/bar": true,
},
}
}
if got := ix.PackagePath(); !reflect.DeepEqual(got, want) {
t.Errorf("PackagePath = %v; want %v", got, want)
}
}
// checkExports checks the Index's exports map.
// It is only set when we're indexing Go code.
func checkExports(t *testing.T, c *Corpus, ix *Index) {
want := map[string]map[string]SpotKind{}
if c.IndexGoCode {
want = map[string]map[string]SpotKind{
"foo": {
"Pi": ConstDecl,
"Foos": VarDecl,
"Foo": TypeDecl,
"New": FuncDecl,
},
"other/bar": {
"X": FuncDecl,
},
}
}
if got := ix.Exports(); !reflect.DeepEqual(got, want) {
t.Errorf("Exports = %v; want %v", got, want)
}
}
// checkIdents checks the Index's indents map.
// It is only set when we're indexing documentation.
func checkIdents(t *testing.T, c *Corpus, ix *Index) {
want := map[SpotKind]map[string][]Ident{}
if c.IndexDocs {
want = map[SpotKind]map[string][]Ident{
PackageClause: {
"bar": {
{"bar", "bar", "bar", "Package bar is another example to test races."},
{"other/bar", "bar", "bar", "Package bar is another bar package."},
},
"foo": {{"foo", "foo", "foo", "Package foo is an example."}},
"other": {{"other/bar", "bar", "bar", "Package bar is another bar package."}},
},
ConstDecl: {
"Pi": {{"foo", "foo", "Pi", ""}},
},
VarDecl: {
"Foos": {{"foo", "foo", "Foos", ""}},
},
TypeDecl: {
"Foo": {{"foo", "foo", "Foo", "Foo is stuff."}},
},
FuncDecl: {
"New": {{"foo", "foo", "New", ""}},
"X": {{"other/bar", "bar", "X", ""}},
},
}
}
if got := ix.Idents(); !reflect.DeepEqual(got, want) {
t.Errorf("Idents = %v; want %v", got, want)
}
}
func TestIdentResultSort(t *testing.T) {
ic := map[string]int{
"/a/b/pkg1": 10,
"/a/b/pkg2": 2,
"/b/d/pkg3": 20,
}
for _, tc := range []struct {
ir []Ident
exp []Ident
}{
{
ir: []Ident{
{"/a/b/pkg2", "pkg2", "MyFunc2", ""},
{"/b/d/pkg3", "pkg3", "MyFunc3", ""},
{"/a/b/pkg1", "pkg1", "MyFunc1", ""},
},
exp: []Ident{
{"/b/d/pkg3", "pkg3", "MyFunc3", ""},
{"/a/b/pkg1", "pkg1", "MyFunc1", ""},
{"/a/b/pkg2", "pkg2", "MyFunc2", ""},
},
},
{
ir: []Ident{
{"/a/a/pkg1", "pkg1", "MyFunc1", ""},
{"/a/b/pkg1", "pkg1", "MyFunc1", ""},
},
exp: []Ident{
{"/a/b/pkg1", "pkg1", "MyFunc1", ""},
{"/a/a/pkg1", "pkg1", "MyFunc1", ""},
},
},
} {
if sort.Sort(byImportCount{tc.ir, ic}); !reflect.DeepEqual(tc.ir, tc.exp) {
t.Errorf("got: %v, want %v", tc.ir, tc.exp)
}
}
}
func TestIdentFilter(t *testing.T) {
ic := map[string]int{}
for _, tc := range []struct {
ir []Ident
pak string
exp []Ident
}{
{
ir: []Ident{
{"/a/b/pkg2", "pkg2", "MyFunc2", ""},
{"/b/d/pkg3", "pkg3", "MyFunc3", ""},
{"/a/b/pkg1", "pkg1", "MyFunc1", ""},
},
pak: "pkg2",
exp: []Ident{
{"/a/b/pkg2", "pkg2", "MyFunc2", ""},
},
},
} {
res := byImportCount{tc.ir, ic}.filter(tc.pak)
if !reflect.DeepEqual(res, tc.exp) {
t.Errorf("got: %v, want %v", res, tc.exp)
}
}
}