Clean up callback interfaces.

impl/memory/gkvlite_iter_test.go

 // Copyright 2015 The Chromium 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 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/cmpbin"
         . "github.com/smartystreets/goconvey/convey"
 )
 
 func mkNum(n int64) []byte {
         buf := &bytes.Buffer{}
         _, err := cmpbin.WriteInt(buf, n)
         memoryCorruption(err)
@@ skipping 181 matching lines @@
                 Convey("can join the same collection twice", func() {
                         // get just the (1, *)
                         // starting at (1, 2) (i.e. >= 2)
                         // ending at (1, 4) (i.e. < 7)
                         defs := []*iterDefinition{
                                 {c: c, prefix: mkNum(1), prefixLen: len(mkNum(1)), start: mkNum(2), end: mkNum(7)},
                                 {c: c, prefix: mkNum(1), prefixLen: len(mkNum(1)), start: mkNum(2), end: mkNum(7)},
                         }
 
                         i := 1
-                        multiIterate(defs, func(suffix []byte) bool {
+                        So(multiIterate(defs, func(suffix []byte) error {
                                 So(readNum(suffix), ShouldEqual, vals[i][1])
                                 i++
-                                return true
-                        })
+                                return nil
+                        }), ShouldBeNil)
 
                         So(i, ShouldEqual, 3)
                 })
 
                 Convey("can make empty iteration", func() {
                         // get just the (20, *) (doesn't exist)
                         defs := []*iterDefinition{
                                 {c: c, prefix: mkNum(20)},
                                 {c: c, prefix: mkNum(20)},
                         }
 
                         i := 0
-                        multiIterate(defs, func(suffix []byte) bool {
+                        So(multiIterate(defs, func(suffix []byte) error {
                                 panic("never")
-                        })
+                        }), ShouldBeNil)
 
                         So(i, ShouldEqual, 0)
                 })
 
                 Convey("can join (other, val, val)", func() {
                         // 'other' must start with 20, 'vals' must start with 1
                         // no range constraints
                         defs := []*iterDefinition{
                                 {c: c2, prefix: mkNum(20)},
                                 {c: c, prefix: mkNum(1)},
                                 {c: c, prefix: mkNum(1)},
                         }
 
                         expect := []int64{2, 4}
                         i := 0
-                        multiIterate(defs, func(suffix []byte) bool {
+                        So(multiIterate(defs, func(suffix []byte) error {
                                 So(readNum(suffix), ShouldEqual, expect[i])
                                 i++
-                                return true
-                        })
+                                return nil
+                        }), ShouldBeNil)
                 })
 
                 Convey("Can stop early", func() {
                         defs := []*iterDefinition{
                                 {c: c, prefix: mkNum(1), prefixLen: len(mkNum(1))},
                                 {c: c, prefix: mkNum(1), prefixLen: len(mkNum(1))},
                         }
 
                         i := 0
-                        multiIterate(defs, func(suffix []byte) bool {
+                        So(multiIterate(defs, func(suffix []byte) error {
                                 So(readNum(suffix), ShouldEqual, vals[i][1])
                                 i++
-                                return true
-                        })
+                                return nil
+                        }), ShouldBeNil)
                         So(i, ShouldEqual, 5)
 
                         i = 0
-                        multiIterate(defs, func(suffix []byte) bool {
+                        So(multiIterate(defs, func(suffix []byte) error {
                                 So(readNum(suffix), ShouldEqual, vals[i][1])
                                 i++
-                                return false
-                        })
+                                return datastore.Stop
+                        }), ShouldBeNil)
                         So(i, ShouldEqual, 1)
                 })
 
         })
 
 }