Clean up callback interfaces.

impl/memory/datastore_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 (
         "fmt"
         "testing"
         "time"
@@ skipping 82 matching lines @@
                         })
 
                         Convey("Deleting entities from a nonexistant namespace works", func() {
                                 aid := infoS.Get(c).FullyQualifiedAppID()
                                 keys := make([]*dsS.Key, 10)
                                 for i := range keys {
                                         keys[i] = ds.MakeKey(aid, "noexist", "Kind", i+1)
                                 }
                                 So(ds.DeleteMulti(keys), ShouldBeNil)
                                 count := 0
-                                So(ds.Raw().DeleteMulti(keys, func(err error) {
+                                So(ds.Raw().DeleteMulti(keys, func(err error) error {
                                         count++
                                         So(err, ShouldBeNil)
+                                        return nil
                                 }), ShouldBeNil)
                                 So(count, ShouldEqual, len(keys))
                         })
 
                         Convey("with multiple puts", func() {
                                 So(testGetMeta(c, k), ShouldEqual, 1)
 
                                 foos := make([]Foo, 10)
                                 for i := range foos {
                                         foos[i].Val = 10
                                         foos[i].Parent = k
                                 }
                                 So(ds.PutMulti(foos), ShouldBeNil)
                                 So(testGetMeta(c, k), ShouldEqual, 11)
 
                                 keys := make([]*dsS.Key, len(foos))
                                 for i, f := range foos {
                                         keys[i] = ds.KeyForObj(&f)
                                 }
 
                                 Convey("ensure that group versions persist across deletes", func() {
                                         So(ds.DeleteMulti(append(keys, k)), ShouldBeNil)
 
                                         ds.Testable().CatchupIndexes()
 
                                         count := 0
-                                        So(ds.Run(dsS.NewQuery(""), func(_ *dsS.Key, _ dsS.CursorCB) bool {
+                                        So(ds.Run(dsS.NewQuery(""), func(_ *dsS.Key) {
                                                 count++
-                                                return true
                                         }), ShouldBeNil)
                                         So(count, ShouldEqual, 3)
 
                                         So(testGetMeta(c, k), ShouldEqual, 22)
 
                                         So(ds.Put(&Foo{ID: 1}), ShouldBeNil)
                                         So(testGetMeta(c, k), ShouldEqual, 23)
                                 })
 
                                 Convey("can Get", func() {
@@ skipping 479 matching lines @@
                 So(ds.Put(&Model{ID: 1, Value: []int64{20, 30}}), ShouldBeNil)
 
                 vals := []dsS.PropertyMap{}
                 So(ds.GetAll(dsS.NewQuery("Model").Project("Value"), &vals), ShouldBeNil)
                 So(len(vals), ShouldEqual, 2)
 
                 So(vals[0]["Value"][0].Value(), ShouldEqual, 20)
                 So(vals[1]["Value"][0].Value(), ShouldEqual, 30)
         })
 }