impl/memory: Replace gkvlite with "treapstore".

impl/memory/memstore_iter_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 (
         "bytes"
         "testing"
 
         "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/datastore/serialize"
-        "github.com/luci/gkvlite"
+
         "github.com/luci/luci-go/common/data/cmpbin"
+
         . "github.com/smartystreets/goconvey/convey"
 )
 
 func mkNum(n int64) []byte {
         buf := &bytes.Buffer{}
         _, err := cmpbin.WriteInt(buf, n)
         memoryCorruption(err)
 
         return buf.Bytes()
 }
 
 func readNum(data []byte) int64 {
         ret, _, err := cmpbin.ReadInt(bytes.NewBuffer(data))
         memoryCorruption(err)
 
         return ret
 }
 
+func countItems(mc memCollection) int {
+        count := 0
+        mc.ForEachItem(func(_, _ []byte) bool {
+                count++
+                return true
+        })
+        return count
+}
+
 func TestIterator(t *testing.T) {
         t.Parallel()
 
         s := newMemStore()
         c := s.GetOrCreateCollection("zup")
         prev := []byte{}
         for i := 5; i < 100; i++ {
                 data := mkNum(int64(i))
                 c.Set(data, prev)
                 prev = data
         }
         c = s.Snapshot().GetCollection("zup")
 
+        iterCB := func(it *iterator, cb func(k, v []byte)) {
+                for ent := it.next(); ent != nil; ent = it.next() {
+                        cb(ent.key, ent.value)
+                }
+        }
+
         get := func(c C, t *iterator) interface{} {
-                ret := interface{}(nil)
-                t.next(nil, func(i *gkvlite.Item) {
-                        if i != nil {
-                                ret = readNum(i.Key)
-                        }
-                })
-                return ret
+                if ent := t.next(); ent != nil {
+                        return readNum(ent.key)
+                }
+                return nil
         }
 
         skipGet := func(c C, t *iterator, skipTo int64) interface{} {
-                ret := interface{}(nil)
-                t.next(mkNum(skipTo), func(i *gkvlite.Item) {
-                        if i != nil {
-                                ret = readNum(i.Key)
-                        }
+                t.skip(mkNum(skipTo))
+                return get(c, t)
+        }
+
+        didIterate := func(t *iterator) (did bool) {
+                iterCB(t, func(k, v []byte) {
+                        did = true
                 })
-                return ret
+                return
         }
 
         Convey("Test iterator", t, func() {
                 Convey("start at nil", func(ctx C) {
                         t := (&iterDefinition{c: c}).mkIter()
-                        defer t.stop()
                         So(get(ctx, t), ShouldEqual, 5)
                         So(get(ctx, t), ShouldEqual, 6)
                         So(get(ctx, t), ShouldEqual, 7)
 
                         Convey("And can skip", func(ctx C) {
                                 So(skipGet(ctx, t, 10), ShouldEqual, 10)
                                 So(get(ctx, t), ShouldEqual, 11)
 
                                 Convey("But not forever", func(ctx C) {
-                                        t.next(mkNum(200), func(i *gkvlite.Item) {
-                                                ctx.So(i, ShouldBeNil)
-                                        })
-                                        t.next(nil, func(i *gkvlite.Item) {
-                                                ctx.So(i, ShouldBeNil)
-                                        })
+                                        t.skip(mkNum(200))
+                                        So(didIterate(t), ShouldBeFalse)
+                                        So(didIterate(t), ShouldBeFalse)
                                 })
                         })
 
                         Convey("Can iterate explicitly", func(ctx C) {
                                 So(skipGet(ctx, t, 7), ShouldEqual, 8)
                                 So(skipGet(ctx, t, 8), ShouldEqual, 9)
 
                                 // Giving the immediately next key doesn't cause an internal reset.
                                 So(skipGet(ctx, t, 10), ShouldEqual, 10)
                         })
 
-                        Convey("Can stop", func(ctx C) {
-                                t.stop()
-                                t.next(mkNum(200), func(i *gkvlite.Item) {
-                                        ctx.So(i, ShouldBeNil)
-                                })
-                                t.next(nil, func(i *gkvlite.Item) {
-                                        ctx.So(i, ShouldBeNil)
-                                })
-                                So(t.stop, ShouldNotPanic)
-                        })
-
                         Convey("Going backwards is ignored", func(ctx C) {
                                 So(skipGet(ctx, t, 3), ShouldEqual, 8)
                                 So(get(ctx, t), ShouldEqual, 9)
                                 So(skipGet(ctx, t, 20), ShouldEqual, 20)
                                 So(get(ctx, t), ShouldEqual, 21)
                         })
 
                         Convey("will stop at the end of the list", func(ctx C) {
                                 So(skipGet(ctx, t, 95), ShouldEqual, 95)
                                 So(get(ctx, t), ShouldEqual, 96)
                                 So(get(ctx, t), ShouldEqual, 97)
                                 So(get(ctx, t), ShouldEqual, 98)
                                 So(get(ctx, t), ShouldEqual, 99)
                                 So(get(ctx, t), ShouldBeNil)
                                 So(get(ctx, t), ShouldBeNil)
                         })
                 })
 
                 Convey("can have caps on both sides", func(ctx C) {
                         t := (&iterDefinition{c: c, start: mkNum(20), end: mkNum(25)}).mkIter()
                         So(get(ctx, t), ShouldEqual, 20)
                         So(get(ctx, t), ShouldEqual, 21)
                         So(get(ctx, t), ShouldEqual, 22)
                         So(get(ctx, t), ShouldEqual, 23)
                         So(get(ctx, t), ShouldEqual, 24)
-                        t.next(nil, func(i *gkvlite.Item) {
-                                ctx.So(i, ShouldBeNil)
-                        })
+
+                        So(didIterate(t), ShouldBeFalse)
                 })
 
                 Convey("can skip over starting cap", func(ctx C) {
                         t := (&iterDefinition{c: c, start: mkNum(20), end: mkNum(25)}).mkIter()
                         So(skipGet(ctx, t, 22), ShouldEqual, 22)
                         So(get(ctx, t), ShouldEqual, 23)
                         So(get(ctx, t), ShouldEqual, 24)
-                        t.next(nil, func(i *gkvlite.Item) {
-                                ctx.So(i, ShouldBeNil)
-                        })
+
+                        So(didIterate(t), ShouldBeFalse)
                 })
-
         })
 }
 
 func TestMultiIteratorSimple(t *testing.T) {
         t.Parallel()
 
         // Simulate an index with 2 columns (int and int).
         vals := [][]int64{
                 {1, 0},
                 {1, 2},
@@ skipping 117 matching lines @@
                                 So(readNum(suffix), ShouldEqual, vals[i][1])
                                 i++
                                 return datastore.Stop
                         }), shouldBeSuccessful)
                         So(i, ShouldEqual, 1)
                 })
 
         })
 
 }