Fix tests to run on 32 bits.

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 497 matching lines @@
                                         })
                                 })
                         })
                 })
 
         })
 }
 
 const MaxUint = ^uint(0)
 const MaxInt = int(MaxUint >> 1)
+const IntIs32Bits = MaxInt < math.MaxInt64
 
 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"))
@@ skipping 51 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(MaxInt)
-                                So(q.(*queryImpl).err.Error(), ShouldContainSubstring, "query limit overflow")
+                                // this is supremely stupid. The SDK uses 'int' which measn we have to

[M-A Ruel, 2015/06/01 13:08:20]

means

+                                // use it too, but then THEY BOUNDS CHECK IT FOR 32 BITS... *sigh*

[M-A Ruel, 2015/06/01 13:08:19]

bah, 2 millions items is large. it's probably more a limitation of the query
system underneath, I wouldn't say this is stupid.

+                                if !IntIs32Bits {
+                                        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(MaxInt)
-                                So(q.(*queryImpl).err.Error(), ShouldContainSubstring, "query offset overflow")
+                                if !IntIs32Bits {
+                                        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)
                                 So(qi.err, ShouldEqual, datastore.ErrInvalidKey)
@@ skipping 46 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")
                         })
                 })
 
         })
 }