Fix overflow on 32bit which causes tests to fail on 32bit.

go/src/infra/gae/libs/wrapper/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"
         "infra/gae/libs/meta"
         "infra/gae/libs/wrapper"
-        "math"
         "testing"
 
         . "github.com/smartystreets/goconvey/convey"
         "golang.org/x/net/context"
 
         "appengine/datastore"
 )
 
 func TestDatastoreKinder(t *testing.T) {
         t.Parallel()
@@ skipping 495 matching lines @@
                                                 So(ds.Get(f), ShouldBeNil)
                                                 So(f.Val, ShouldEqual, 10)
                                         })
                                 })
                         })
                 })
 
         })
 }
 
+const MaxUint = ^uint(0)
+const MaxInt = int(MaxUint >> 1)
+
 func TestDatastoreQueryer(t *testing.T) {
         Convey("Datastore Query suport", t, func() {
                 c := Use(context.Background())
                 ds := wrapper.GetDS(c)
                 So(ds, ShouldNotBeNil)
 
                 Convey("can create good queries", func() {
                         q := ds.NewQuery("Foo").KeysOnly().Limit(10).Offset(39)
                         q = q.Start(queryCursor("kosmik")).End(queryCursor("krabs"))
                         So(q, ShouldNotBeNil)
@@ skipping 50 matching lines @@
                         })
                         Convey("bad order", func() {
                                 q := q.Order("+Bob")
                                 So(q.(*queryImpl).err.Error(), ShouldContainSubstring, "invalid order")
                         })
                         Convey("empty", func() {
                                 q := q.Order("")
                                 So(q.(*queryImpl).err.Error(), ShouldContainSubstring, "empty order")
                         })
                         Convey("OOB limit", func() {
-                                q := q.Limit(math.MaxInt64)
+                                q := q.Limit(MaxInt)
                                 So(q.(*queryImpl).err.Error(), ShouldContainSubstring, "query limit overflow")
                         })
                         Convey("underflow offset", func() {
                                 q := q.Offset(-29)
                                 So(q.(*queryImpl).err.Error(), ShouldContainSubstring, "negative query offset")
                         })
                         Convey("OOB offset", func() {
-                                q := q.Offset(math.MaxInt64)
+                                q := q.Offset(MaxInt)
                                 So(q.(*queryImpl).err.Error(), ShouldContainSubstring, "query offset overflow")
                         })
                         Convey("Bad cursors", func() {
                                 q := q.Start(queryCursor("")).End(queryCursor(""))
                                 So(q.(*queryImpl).err.Error(), ShouldContainSubstring, "invalid cursor")
                         })
                         Convey("Bad ancestors", func() {
                                 q := q.Ancestor(ds.NewKey("Goop", "wat", 10, nil))
                                 So(q, ShouldNotBeNil)
                                 qi := q.(*queryImpl).checkCorrectness("", false)
@@ skipping 47 matching lines @@
                         })
                         Convey("kindless with decending-__key__ orders", func() {
                                 q := ds.NewQuery("").Order("-__key__")
                                 qi := q.(*queryImpl).checkCorrectness("", false)
                                 So(qi.err.Error(), ShouldContainSubstring, "kind is required for all orders")
                         })
                 })
 
         })
 }