Add support for uint8, uint16 and uint32 in luci/gae

service/datastore/pls_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.
 
 // adapted from github.com/golang/appengine/datastore
 
 package datastore
 
 import (
         "bytes"
@@ skipping 136 matching lines @@
         Other    string
 }
 
 type N2 struct {
         N1    `gae:"red"`
         Green N1 `gae:"green"`
         Blue  N1
         White N1 `gae:"-"`
 }
 
+type N3 struct {
+        ID uint32 `gae:"$id,200"`
+}
+
 type O0 struct {
         I int64
 }
 
 type O1 struct {
         I int32
 }
 
 type U0 struct {
-        U uint
+        U uint32
 }
 
 type U1 struct {
-        U string
+        U byte
+}
+
+type U2 struct {
+        U int64
 }
 
 type T struct {
         T time.Time
 }
 
 type X0 struct {
         S string
         I int
         i int
@@ skipping 599 matching lines @@
                 want: &T{T: time.Unix(1e9, 0).UTC()},
         },
         {
                 desc: "time as props",
                 src:  &T{T: time.Unix(1e9, 0).UTC()},
                 want: PropertyMap{
                         "T": {mp(time.Unix(1e9, 0).UTC())},
                 },
         },
         {
-                desc:   "uint save",
-                src:    &U0{U: 1},
-                plsErr: `field "U" has invalid type: uint`,
+                desc: "uint32 save",
+                src:  &U0{U: 1},
+                want: PropertyMap{
+                        "U": {mp(1)},
+                },
         },
         {
-                desc:       "uint load",
-                src:        &U1{U: "not a uint"},
-                want:       &U0{},
-                plsLoadErr: `field "U" has invalid type: uint`,
+                desc: "uint32 load",
+                src:  &U2{U: 100},
+                want: &U0{U: 100},
+        },
+        {
+                desc:    "uint32 load oob (neg)",
+                src:     &U2{U: -1},
+                want:    &U0{},
+                loadErr: "overflow",
+        },
+        {
+                desc:    "uint32 load oob (huge)",
+                src:     &U2{U: math.MaxInt64},
+                want:    &U0{},
+                loadErr: "overflow",
+        },
+        {
+                desc: "byte save",
+                src:  &U1{U: 1},
+                want: PropertyMap{
+                        "U": {mp(1)},
+                },
+        },
+        {
+                desc: "byte load",
+                src:  &U2{U: 100},
+                want: &U1{U: 100},
+        },
+        {
+                desc:    "byte load oob (neg)",
+                src:     &U2{U: -1},
+                want:    &U1{},
+                loadErr: "overflow",
+        },
+        {
+                desc:    "byte load oob (huge)",
+                src:     &U2{U: math.MaxInt64},
+                want:    &U1{},
+                loadErr: "overflow",
         },
         {
                 desc: "zero",
                 src:  &X0{},
                 want: &X0{},
         },
         {
                 desc: "basic",
                 src:  &X0{S: "one", I: 2, i: 3},
                 want: &X0{S: "one", I: 2},
@@ skipping 785 matching lines @@
                 desc: "json.RawMessage to myBlob",
                 src: &struct {
                         B json.RawMessage
                 }{
                         B: json.RawMessage("rawr"),
                 },
                 want: &B2{B: myBlob("rawr")},
         },
 }
 
-// checkErr returns the empty string if either both want and err are zero,
-// or if want is a non-empty substring of err's string representation.
-func checkErr(want string, err error) string {
-        if err != nil {
-                got := err.Error()
-                if want == "" || strings.Index(got, want) == -1 {
-                        return got
-                }
-        } else if want != "" {
-                return fmt.Sprintf("want error %q", want)
-        }
-        return ""
-}
-
 func TestRoundTrip(t *testing.T) {
         t.Parallel()
 
-        checkErr := func(actual interface{}, expected string) bool {
-                if expected == "" {
-                        So(actual, ShouldErrLike, nil)
-                } else {
-                        So(actual, ShouldErrLike, expected)
-                }
-                return expected != ""
-        }
-
         getPLSErr := func(obj interface{}) (pls PropertyLoadSaver, err error) {
                 defer func() {
                         if v := recover(); v != nil {
                                 err = v.(error)
                         }
                 }()
                 pls = GetPLS(obj)
                 return
         }
 
         Convey("Test round-trip", t, func() {
                 for _, tc := range testCases {
                         tc := tc
                         Convey(tc.desc, func() {
                                 pls, ok := tc.src.(PropertyLoadSaver)
                                 if !ok {
                                         var err error
                                         pls, err = getPLSErr(tc.src)
-                                        if checkErr(err, tc.plsErr) {
+                                        if tc.plsErr != "" {
+                                                So(err, ShouldErrLike, tc.plsErr)
                                                 return
                                         }
                                 }
                                 So(pls, ShouldNotBeNil)
 
                                 savedProps, err := pls.Save(false)
-                                if checkErr(err, tc.saveErr) {
+                                if tc.saveErr != "" {
+                                        So(err, ShouldErrLike, tc.saveErr)
                                         return
                                 }
                                 So(savedProps, ShouldNotBeNil)
 
                                 var got interface{}
                                 if _, ok := tc.want.(PropertyMap); ok {
                                         pls = PropertyMap{}
                                         got = pls
                                 } else {
                                         got = reflect.New(reflect.TypeOf(tc.want).Elem()).Interface()
                                         if pls, ok = got.(PropertyLoadSaver); !ok {
                                                 var err error
                                                 pls, err = getPLSErr(got)
-                                                if checkErr(err, tc.plsLoadErr) {
+                                                if tc.plsLoadErr != "" {
+                                                        So(err, ShouldErrLike, tc.plsLoadErr)
                                                         return
                                                 }
                                         }
                                 }
 
                                 So(pls, ShouldNotBeNil)
 
                                 err = pls.Load(savedProps)
-                                if checkErr(err, tc.loadErr) {
+                                if tc.loadErr != "" {
+                                        So(err, ShouldErrLike, tc.loadErr)
                                         return
                                 }
                                 if tc.want == nil {
                                         return
                                 }
 
                                 if gotT, ok := got.(*T); ok {
                                         // Round tripping a time.Time can result in a different time.Location: Local instead of UTC.
                                         // We therefore test equality explicitly, instead of relying on reflect.DeepEqual.
                                         So(gotT.T.Equal(tc.want.(*T).T), ShouldBeTrue)
@@ skipping 49 matching lines @@
                         So(mgs.SetMeta("id", int64(200)), ShouldBeTrue)
                         So(o.ID, ShouldEqual, 200)
                 })
 
                 Convey("assigning to unsassiagnable fields returns !ok", func() {
                         o := &N0{ID: 100}
                         mgs := getMGS(o)
                         So(mgs.SetMeta("kind", "hi"), ShouldBeFalse)
                         So(mgs.SetMeta("noob", "hi"), ShouldBeFalse)
                 })
+
+                Convey("unsigned int meta fields work", func() {
+                        o := &N3{}
+                        mgs := getMGS(o)
+                        v, ok := mgs.GetMeta("id")
+                        So(v, ShouldEqual, int64(200))
+                        So(ok, ShouldBeTrue)
+
+                        So(mgs.SetMeta("id", 20), ShouldBeTrue)
+                        So(o.ID, ShouldEqual, 20)
+
+                        So(mgs.SetMeta("id", math.MaxInt64), ShouldBeFalse)
+                        So(o.ID, ShouldEqual, 20)
+
+                        So(mgs.SetMeta("id", math.MaxUint32), ShouldBeTrue)
+                        So(o.ID, ShouldEqual, math.MaxUint32)
+                })
         })
 
         Convey("StructPLS Miscellaneous", t, func() {
                 Convey("a simple struct has a default $kind", func() {
                         So(GetPLS(&Simple{}).GetAllMeta(), ShouldResemble, PropertyMap{
                                 "$kind": []Property{mpNI("Simple")},
                         })
                 })
 
                 Convey("multiple overlapping fields is an error", func() {
@@ skipping 195 matching lines @@
                         So(pls.SetMeta("id", "sup|1337"), ShouldBeTrue)
                         So(ide.EmbeddedID, ShouldResemble, EmbeddedID{"sup", 1337})
 
                         So(pls.GetAllMeta(), ShouldResembleV, PropertyMap{
                                 "$id":   {mpNI("sup|1337")},
                                 "$kind": {mpNI("IDEmbedder")},
                         })
                 })
         })
 }