internal/modindex/lookup_test.go

// Copyright 2024 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 modindex_test

import (
	"fmt"
	"log"
	"os"
	"path/filepath"
	"strings"
	"testing"

	. "golang.org/x/tools/internal/modindex"
)

type tdata struct {
	fname string
	pkg   string
	items []titem
}

type titem struct {
	code   string
	result result
}

var thedata = tdata{
	fname: "cloud.google.com/go/!longrunning@v0.4.1/foo.go",
	pkg:   "foo",
	items: []titem{
		// these need to be in alphabetical order
		{"func Foo() {}", result{"Foo", Func, false, 0, nil}},
		{"const FooC = 23", result{"FooC", Const, false, 0, nil}},
		{"func FooF(int, float) error {return nil}", result{"FooF", Func, false, 1,
			[]Field{{"_", "int"}, {"_", "float"}}}},
		{"type FooT struct{}", result{"FooT", Type, false, 0, nil}},
		{"var FooV int", result{"FooV", Var, false, 0, nil}},
		{"func Goo() {}", result{"Goo", Func, false, 0, nil}},
		{"/*Deprecated: too weird\n*/\n// Another Goo\nvar GooVV int", result{"GooVV", Var, true, 0, nil}},
		{"func Ⱋoox(x int) {}", result{"Ⱋoox", Func, false, 0, []Field{{"x", "int"}}}},
	},
}

type result struct {
	name       string
	typ        LexType
	deprecated bool
	result     int
	sig        []Field
}

func okresult(r result, p Candidate) bool {
	if r.name != p.Name || r.typ != p.Type || r.result != int(p.Results) {
		return false
	}
	if r.deprecated != p.Deprecated {
		return false
	}
	if len(r.sig) != len(p.Sig) {
		return false
	}
	for i := 0; i < len(r.sig); i++ {
		if r.sig[i] != p.Sig[i] {
			return false
		}
	}
	return true
}

func TestLookup(t *testing.T) {
	dir := testModCache(t)
	wrtData(t, dir, thedata)
	if _, err := Create(dir); err != nil {
		t.Fatal(err)
	}
	ix, err := Read(dir)
	if err != nil {
		t.Fatal(err)
	}
	if len(ix.Entries) != 1 {
		t.Fatalf("got %d Entries, expected 1", len(ix.Entries))
	}
	// get all the symbols
	p := ix.Lookup("foo", "", true)
	if len(p) > 0 && !strings.Contains(p[0].ImportPath, "Longrunning") {
		t.Errorf("Failed to convert escaped path: %s", p[0].ImportPath)
	}
	if len(p) != len(thedata.items) {
		t.Errorf("got %d possibilities for pkg foo, expected %d", len(p), len(thedata.items))
	}
	for i, r := range thedata.items {
		if !okresult(r.result, p[i]) {
			t.Errorf("got %#v, expected %#v", p[i], r.result)
		}
	}
	// look for the Foo... and check that each is a Foo...
	p = ix.Lookup("foo", "Foo", true)
	if len(p) != 5 {
		t.Errorf("got %d possibilities for foo.Foo*, expected 5", len(p))
	}
	for _, r := range p {
		if !strings.HasPrefix(r.Name, "Foo") {
			t.Errorf("got %s, expected Foo...", r.Name)
		}
	}
	// fail to find something
	p = ix.Lookup("foo", "FooVal", false)
	if len(p) != 0 {
		t.Errorf("got %d possibilities for foo.FooVal, expected 0", len(p))
	}
	// find an exact match
	p = ix.Lookup("foo", "Foo", false)
	if len(p) != 1 {
		t.Errorf("got %d possibilities for foo.Foo, expected 1", len(p))
	}
	// "Foo" is the first test datum
	if !okresult(thedata.items[0].result, p[0]) {
		t.Errorf("got %#v, expected %#v", p[0], thedata.items[0].result)
	}
}

func wrtData(t *testing.T, dir string, data tdata) {
	t.Helper()
	locname := filepath.FromSlash(data.fname)
	if err := os.MkdirAll(filepath.Join(dir, filepath.Dir(locname)), 0755); err != nil {
		t.Fatal(err)
	}
	fd, err := os.Create(filepath.Join(dir, locname))
	if err != nil {
		t.Fatal(err)
	}
	defer fd.Close()
	fmt.Fprintf(fd, "package %s\n", data.pkg)
	for _, item := range data.items {
		fd.WriteString(item.code + "\n")
	}
}

func TestLookupAll(t *testing.T) {
	log.SetFlags(log.Lshortfile)
	dir := testModCache(t)
	wrtModule := func(mod string, nms ...string) {
		dname := filepath.Join(dir, mod)
		if err := os.MkdirAll(dname, 0755); err != nil {
			t.Fatal(err)
		}
		fname := filepath.Join(dname, "foo.go")
		fd, err := os.Create(fname)
		if err != nil {
			t.Fatal(err)
		}
		defer fd.Close()
		if _, err := fmt.Fprintf(fd, "package foo\n"); err != nil {
			t.Fatal(err)
		}
		for _, nm := range nms {
			fmt.Fprintf(fd, "func %s() {}\n", nm)
		}
	}
	wrtModule("a.com/go/x4@v1.1.1", "A", "B", "C", "D")
	wrtModule("b.com/go/x3@v1.2.1", "A", "B", "C")
	wrtModule("c.com/go/x5@v1.3.1", "A", "B", "C", "D", "E")

	if _, err := Create(dir); err != nil {
		t.Fatal(err)
	}
	ix, err := Read(dir)
	if err != nil {
		t.Fatal(err)
	}
	cands := ix.Lookup("foo", "A", false)
	if len(cands) != 3 {
		t.Errorf("got %d candidates for A, expected 3", len(cands))
	}
	got := ix.LookupAll("foo", "A", "B", "C", "D")
	if len(got) != 2 {
		t.Errorf("got %d candidates for A,B,C,D, expected 2", len(got))
	}
	got = ix.LookupAll("foo", []string{"A", "B", "C", "D", "E"}...)
	if len(got) != 1 {
		t.Errorf("got %d candidates for A,B,C,D,E, expected 1", len(got))
	}
}

func TestUniquify(t *testing.T) {
	var v []string
	for i := 1; i < 4; i++ {
		v = append(v, "A")
		w := Uniquify(v)
		if len(w) != 1 {
			t.Errorf("got %d, expected 1", len(w))
		}
	}
	for i := 1; i < 3; i++ {
		v = append(v, "B", "C")
		w := Uniquify(v)
		if len(w) != 3 {
			t.Errorf("got %d, expected 3", len(w))
		}
	}
}