func testRepoStore_Defs_ByCommitIDs(t *testing.T, rs RepoStoreImporter) {
const numCommits = 3
for c := 1; c <= numCommits; c++ {
unit := &unit.SourceUnit{Type: "t", Name: "u"}
data := graph.Output{Defs: []*graph.Def{{DefKey: graph.DefKey{Path: "p"}}}}
commitID := fmt.Sprintf("c%d", c)
if err := rs.Import(commitID, unit, data); err != nil {
t.Errorf("%s: Import(%s, %v, data): %s", rs, commitID, unit, err)
}
if rs, ok := rs.(RepoIndexer); ok {
if err := rs.Index(commitID); err != nil {
t.Fatalf("%s: Index: %s", rs, err)
}
}
}
want := []*graph.Def{
{DefKey: graph.DefKey{CommitID: "c1", UnitType: "t", Unit: "u", Path: "p"}},
{DefKey: graph.DefKey{CommitID: "c3", UnitType: "t", Unit: "u", Path: "p"}},
}
defs, err := rs.Defs(ByCommitIDs("c1", "c3"))
if err != nil {
t.Fatalf("%s: Defs: %s", rs, err)
}
sort.Sort(graph.Defs(defs))
sort.Sort(graph.Defs(want))
if !reflect.DeepEqual(defs, want) {
t.Errorf("%s: Defs: got defs %v, want %v", rs, defs, want)
}
}
func testMultiRepoStore_Defs_ByRepoCommitIDs(t *testing.T, mrs MultiRepoStoreImporter) {
repos := []string{"r1", "r2", "r3"}
commitIDs := []string{"c1", "c2"}
for _, repo := range repos {
for _, commitID := range commitIDs {
if err := mrs.Import(repo, commitID, &unit.SourceUnit{Type: "t", Name: "u"}, graph.Output{Defs: []*graph.Def{
{DefKey: graph.DefKey{Path: "p"}},
}}); err != nil {
t.Errorf("%s: Import: %s", mrs, err)
}
if mrs, ok := mrs.(MultiRepoIndexer); ok {
if err := mrs.Index(repo, commitID); err != nil {
t.Fatalf("%s: Index: %s", mrs, err)
}
}
}
}
want := []*graph.Def{
{DefKey: graph.DefKey{Repo: "r1", CommitID: "c2", UnitType: "t", Unit: "u", Path: "p"}},
{DefKey: graph.DefKey{Repo: "r3", CommitID: "c1", UnitType: "t", Unit: "u", Path: "p"}},
}
defs, err := mrs.Defs(ByRepoCommitIDs(Version{Repo: "r1", CommitID: "c2"}, Version{Repo: "r3", CommitID: "c1"}))
if err != nil {
t.Errorf("%s: Defs: %s", mrs, err)
}
sort.Sort(graph.Defs(defs))
sort.Sort(graph.Defs(want))
if !reflect.DeepEqual(defs, want) {
t.Errorf("%s: Defs: got defs %v, want %v", mrs, defs, want)
}
}
func sortedOutput(o *graph.Output) *graph.Output {
sort.Sort(graph.Defs(o.Defs))
sort.Sort(graph.Refs(o.Refs))
sort.Sort(graph.Docs(o.Docs))
sort.Sort(ann.Anns(o.Anns))
return o
}
// defsAtOffsets reads the defs at the given serialized byte offsets
// from the def data file and returns them in arbitrary order.
func (s *fsUnitStore) defsAtOffsets(ofs byteOffsets, fs []DefFilter) (defs []*graph.Def, err error) {
vlog.Printf("%s: reading defs at %d offsets with filters %v...", s, len(ofs), fs)
f, err := openFetcherOrOpen(s.fs, unitDefsFilename)
if err != nil {
return nil, err
}
defer func() {
err2 := f.Close()
if err == nil {
err = err2
}
}()
ffs := DefFilters(fs)
p := parFetches(s.fs, fs)
if p == 0 {
return nil, nil
}
var defsLock sync.Mutex
par := parallel.NewRun(p)
for _, ofs_ := range ofs {
ofs := ofs_
par.Acquire()
go func() {
defer par.Release()
if _, moreOK := LimitRemaining(fs); !moreOK {
return
}
// Guess how many bytes this def is. The s3vfs (if that's the
// VFS impl in use) will autofetch beyond that if needed.
const byteEstimate = 2 * decodeBufSize
r, err := rangeReader(s.fs, unitDefsFilename, f, ofs, byteEstimate)
if err != nil {
par.Error(err)
return
}
dec := Codec.NewDecoder(r)
var def graph.Def
if _, err := dec.Decode(&def); err != nil {
par.Error(err)
return
}
if ffs.SelectDef(&def) {
defsLock.Lock()
defs = append(defs, &def)
defsLock.Unlock()
}
}()
}
if err := par.Wait(); err != nil {
return defs, err
}
sort.Sort(graph.Defs(defs))
vlog.Printf("%s: read %v defs at %d offsets with filters %v.", s, len(defs), len(ofs), fs)
return defs, nil
}
func testMultiRepoStore_Defs_ByRepoCommitIDs_ByDefQuery(t *testing.T, mrs MultiRepoStoreImporter) {
repos := []string{"r1", "r2", "r3"}
commitIDs := []string{"c1", "c2"}
for _, repo := range repos {
for _, commitID := range commitIDs {
data := graph.Output{
Defs: []*graph.Def{
{DefKey: graph.DefKey{Path: "p1"}, Name: "abc-" + repo},
{DefKey: graph.DefKey{Path: "p2"}, Name: "xyz-" + repo},
},
}
if err := mrs.Import(repo, commitID, &unit.SourceUnit{Key: unit.Key{Type: "t", Name: "u"}}, data); err != nil {
t.Errorf("%s: Import: %s", mrs, err)
}
if mrs, ok := mrs.(MultiRepoIndexer); ok {
if err := mrs.Index(repo, commitID); err != nil {
t.Fatalf("%s: Index: %s", mrs, err)
}
}
if err := mrs.CreateVersion(repo, commitID); err != nil {
t.Errorf("%s: CreateVersion: %s", mrs, err)
}
}
}
c_defQueryTreeIndex_getByQuery.set(0)
want := []*graph.Def{
{DefKey: graph.DefKey{Repo: "r1", CommitID: "c2", UnitType: "t", Unit: "u", Path: "p1"}, Name: "abc-r1"},
{DefKey: graph.DefKey{Repo: "r3", CommitID: "c1", UnitType: "t", Unit: "u", Path: "p1"}, Name: "abc-r3"},
}
defs, err := mrs.Defs(ByRepoCommitIDs(Version{Repo: "r1", CommitID: "c2"}, Version{Repo: "r3", CommitID: "c1"}), ByDefQuery("abc"))
if err != nil {
t.Errorf("%s: Defs: %s", mrs, err)
}
sort.Sort(graph.Defs(defs))
sort.Sort(graph.Defs(want))
if !deepEqual(defs, want) {
t.Errorf("%s: Defs: got defs %v, want %v", mrs, defs, want)
}
if isIndexedStore(mrs) {
if want := 2; c_defQueryTreeIndex_getByQuery.get() != want {
t.Errorf("%s: Defs: got %d index hits on tree def query index, want %d", mrs, c_defQueryTreeIndex_getByQuery.get(), want)
}
}
}
func testTreeStore_Defs_ByUnits(t *testing.T, ts TreeStoreImporter) {
units := []*unit.SourceUnit{
{Key: unit.Key{Type: "t1", Name: "u1"}},
{Key: unit.Key{Type: "t2", Name: "u2"}},
{Key: unit.Key{Type: "t3", Name: "u3"}},
}
for i, unit := range units {
data := graph.Output{
Defs: []*graph.Def{{DefKey: graph.DefKey{Path: fmt.Sprintf("p%d", i+1)}}},
}
if err := ts.Import(unit, data); err != nil {
t.Errorf("%s: Import(%v, data): %s", ts, unit, err)
}
}
if ts, ok := ts.(TreeIndexer); ok {
if err := ts.Index(); err != nil {
t.Fatalf("%s: Index: %s", ts, err)
}
}
want := []*graph.Def{
{DefKey: graph.DefKey{UnitType: "t1", Unit: "u1", Path: "p1"}},
{DefKey: graph.DefKey{UnitType: "t3", Unit: "u3", Path: "p3"}},
}
c_fsTreeStore_unitsOpened.set(0)
defs, err := ts.Defs(ByUnits(unit.ID2{Type: "t3", Name: "u3"}, unit.ID2{Type: "t1", Name: "u1"}))
if err != nil {
t.Errorf("%s: Defs(ByUnits): %s", ts, err)
}
sort.Sort(graph.Defs(defs))
sort.Sort(graph.Defs(want))
if !deepEqual(defs, want) {
t.Errorf("%s: Defs(ByUnits): got defs %v, want %v", ts, defs, want)
}
if isIndexedStore(ts) {
if c_fsTreeStore_unitsOpened.get() != 0 {
t.Errorf("%s: Defs(ByUnits): got %d units opened, want none (should be able to use ByUnits filter to avoid needing to open any units)", ts, c_fsTreeStore_unitsOpened.get())
}
}
}
func (ds DefsSortByKey) DefsSort(defs []*graph.Def) {
sort.Sort(graph.Defs(defs))
}