impl/memory: Replace gkvlite with "treapstore".

impl/memory/datastore_index_test.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package memory
 
 import (
         "sort"
         "testing"
         "time"
 
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/datastore/serialize"
-        "github.com/luci/gkvlite"
+
         . "github.com/smartystreets/goconvey/convey"
 )
 
 var fakeKey = key("parentKind", "sid", "knd", 10)
 
 var rgenComplexTime = time.Date(
         1986, time.October, 26, 1, 20, 00, 00, time.UTC)
 var rgenComplexKey = key("kind", "id")
 
 var _, rgenComplexTimeInt = prop(rgenComplexTime).IndexTypeAndValue()
@@ skipping 173 matching lines @@
                 Convey("nil collated", func() {
                         Convey("defaultIndexes (nil)", func() {
                                 idxs := defaultIndexes("knd", ds.PropertyMap(nil))
                                 So(len(idxs), ShouldEqual, 1)
                                 So(idxs[0].String(), ShouldEqual, "B:knd")
                         })
 
                         Convey("indexEntries", func() {
                                 sip := serialize.PropertyMapPartially(fakeKey, nil)
                                 s := indexEntries(fakeKey, sip, defaultIndexes("knd", ds.PropertyMap(nil)))
-                                numItems, _ := s.GetCollection("idx").GetTotals()
-                                So(numItems, ShouldEqual, 1)
-                                itm := s.GetCollection("idx").MinItem(false)
-                                So(itm.Key, ShouldResemble, cat(indx("knd").PrepForIdxTable()))
-                                numItems, _ = s.GetCollection("idx:ns:" + string(itm.Key)).GetTotals()
-                                So(numItems, ShouldEqual, 1)
+                                So(countItems(s.Snapshot().GetCollection("idx")), ShouldEqual, 1)
+                                itm := s.GetCollection("idx").MinItem()
+                                So(itm.key, ShouldResemble, cat(indx("knd").PrepForIdxTable()))
+                                So(countItems(s.Snapshot().GetCollection("idx:ns:"+string(itm.key))), ShouldEqual, 1)
                         })
 
                         Convey("defaultIndexes", func() {
                                 pm := ds.PropertyMap{
                                         "wat":  ds.PropertySlice{propNI("thing"), prop("hat"), prop(100)},
                                         "nerd": prop(103.7),
                                         "spaz": propNI(false),
                                 }
                                 idxs := defaultIndexes("knd", pm)
                                 So(len(idxs), ShouldEqual, 5)
@@ skipping 22 matching lines @@
                                 store := (memStore)(nil)
                                 if tc.withBuiltin {
                                         store = indexEntriesWithBuiltins(fakeKey, tc.pmap, tc.idxs)
                                 } else {
                                         sip := serialize.PropertyMapPartially(fakeKey, tc.pmap)
                                         store = indexEntries(fakeKey, sip, tc.idxs)
                                 }
                                 for colName, vals := range tc.collections {
                                         i := 0
                                         coll := store.Snapshot().GetCollection(colName)
-                                        numItems, _ := coll.GetTotals()
-                                        So(numItems, ShouldEqual, len(tc.collections[colName]))
-                                        coll.VisitItemsAscend(nil, true, func(itm *gkvlite.Item) bool {
-                                                So(itm.Key, ShouldResemble, vals[i])
+                                        So(countItems(coll), ShouldEqual, len(tc.collections[colName]))
+
+                                        coll.ForEachItem(func(k, _ []byte) bool {
+                                                So(k, ShouldResemble, vals[i])
                                                 i++
                                                 return true
                                         })
                                         So(i, ShouldEqual, len(vals))
                                 }
                         })
                 }
         })
 }
 
@@ skipping 95 matching lines @@
                                         prev := tmpLoader[ks]
                                         updateIndexes(store, itm.key, prev, itm.props)
                                         tmpLoader[ks] = itm.props
                                 }
                                 tmpLoader = nil
 
                                 for colName, data := range tc.expected {
                                         coll := store.Snapshot().GetCollection(colName)
                                         So(coll, ShouldNotBeNil)
                                         i := 0
-                                        coll.VisitItemsAscend(nil, false, func(itm *gkvlite.Item) bool {
-                                                So(data[i], ShouldResemble, itm.Key)
+                                        coll.ForEachItem(func(k, _ []byte) bool {
+                                                So(data[i], ShouldResemble, k)
                                                 i++
                                                 return true
                                         })
                                         So(i, ShouldEqual, len(data))
                                 }
                         })
                 }
         })
 }