Clean up callback interfaces.

impl/memory/datastore_query_execution_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"
         "strings"
         "testing"
@@ skipping 306 matching lines @@
                                 }},
                         },
 
                         extraFns: []func(context.Context){
                                 func(c context.Context) {
                                         data := ds.Get(c)
                                         curs := ds.Cursor(nil)
 
                                         q := nq("").Gt("__key__", key("Kind", 2))
 
-                                        err := data.Run(q, func(pm ds.PropertyMap, gc ds.CursorCB) bool {
+                                        err := data.Run(q, func(pm ds.PropertyMap, gc ds.CursorCB) error {
                                                 So(pm, ShouldResemble, pmap(
                                                         "$key", key("Kind", 2, "__entity_group__", 1), Next,
                                                         "__version__", 1))
 
                                                 err := error(nil)
                                                 curs, err = gc()
                                                 So(err, ShouldBeNil)
-                                                return false
+                                                return ds.Stop
                                         })
                                         So(err, ShouldBeNil)
 
-                                        err = data.Run(q.Start(curs), func(pm ds.PropertyMap, gc ds.CursorCB) bool {
+                                        err = data.Run(q.Start(curs), func(pm ds.PropertyMap) error {
                                                 So(pm, ShouldResemble, stage1Data[2])
-                                                return false
+                                                return ds.Stop
                                         })
                                         So(err, ShouldBeNil)
                                 },
 
                                 func(c context.Context) {
                                         data := ds.Get(c)
                                         q := nq("Something").Eq("Does", 2).Order("Not", "-Work")
-                                        So(data.Run(q, func(ds.Key, ds.CursorCB) bool {
-                                                return true
-                                        }), ShouldErrLike, strings.Join([]string{
+                                        So(data.Run(q, func(ds.Key) {}), ShouldErrLike, strings.Join([]string{
                                                 "Consider adding:",
                                                 "- kind: Something",
                                                 "  properties:",
                                                 "  - name: Does",
                                                 "  - name: Not",
                                                 "  - name: Work",
                                                 "    direction: desc",
                                         }, "\n"))
                                 },
 
                                 func(c context.Context) {
                                         data := ds.Get(c)
                                         q := nq("Something").Ancestor(key("Kind", 3)).Order("Val")
-                                        So(data.Run(q, func(ds.Key, ds.CursorCB) bool {
-                                                return true
-                                        }), ShouldErrLike, strings.Join([]string{
+                                        So(data.Run(q, func(ds.Key) {}), ShouldErrLike, strings.Join([]string{
                                                 "Consider adding:",
                                                 "- kind: Something",
                                                 "  ancestor: yes",
                                                 "  properties:",
                                                 "  - name: Val",
                                         }, "\n"))
                                 },
                         },
                 },
 
@@ skipping 139 matching lines @@
                 count, err := data.Count(q)
                 So(err, ShouldErrLike, "Insufficient indexes")
 
                 testing.AutoIndex(true)
 
                 count, err = data.Count(q)
                 So(err, ShouldBeNil)
                 So(count, ShouldEqual, 2)
         })
 }