Revert "Refactor current GAE abstraction library to be free of the SDK*"

go/src/infra/gae/libs/wrapper/memory/memcache_test.go

Index: go/src/infra/gae/libs/wrapper/memory/memcache_test.go
diff --git a/go/src/infra/gae/libs/gae/memory/memcache_test.go b/go/src/infra/gae/libs/wrapper/memory/memcache_test.go
similarity index 59%
rename from go/src/infra/gae/libs/gae/memory/memcache_test.go
rename to go/src/infra/gae/libs/wrapper/memory/memcache_test.go
index 0829aa40185f6da07d4d7b1ec71ddfdcaaa19da0..ab1934c7aea78b8a39f47e86d67d223e6ab8764c 100644
--- a/go/src/infra/gae/libs/gae/memory/memcache_test.go
+++ b/go/src/infra/gae/libs/wrapper/memory/memcache_test.go
@@ -5,14 +5,16 @@
 package memory
 
 import (
-	"golang.org/x/net/context"
-	"infra/gae/libs/gae"
+	"infra/gae/libs/wrapper"
+	"infra/gae/libs/wrapper/unsafe"
+	"infra/libs/clock/testclock"
 	"testing"
 	"time"
 
-	"github.com/luci/luci-go/common/clock/testclock"
-
 	. "github.com/smartystreets/goconvey/convey"
+	"golang.org/x/net/context"
+
+	"appengine/memcache"
 )
 
 func TestMemcache(t *testing.T) {
@@ -22,45 +24,45 @@ func TestMemcache(t *testing.T) {
 		now := time.Date(2015, 1, 1, 0, 0, 0, 0, time.UTC)
 		c, tc := testclock.UseTime(context.Background(), now)
 		c = Use(c)
-		mc := gae.GetMC(c)
-		mci := gae.GetMC(c).(*memcacheImpl)
+		mc := wrapper.GetMC(c)
+		mci := wrapper.GetMC(c).(*memcacheImpl)
 		So(mc, ShouldNotEqual, mci) // two impls with the same memcacheData
 
 		Convey("implements MCSingleReadWriter", func() {
 			Convey("Add", func() {
-				itm := &mcItem{
-					key:        "sup",
-					value:      []byte("cool"),
-					expiration: time.Second,
+				itm := &memcache.Item{
+					Key:        "sup",
+					Value:      []byte("cool"),
+					Expiration: time.Second,
 				}
 				err := mc.Add(itm)
 				So(err, ShouldBeNil)
 				Convey("which rejects objects already there", func() {
 					err := mc.Add(itm)
-					So(err, ShouldEqual, gae.ErrMCNotStored)
+					So(err, ShouldEqual, memcache.ErrNotStored)
 				})
 
 				Convey("which can be broken intentionally", func() {
 					mci.BreakFeatures(nil, "Add")
 					err := mc.Add(itm)
-					So(err, ShouldEqual, gae.ErrMCServerError)
+					So(err, ShouldEqual, memcache.ErrServerError)
 				})
 			})
 
 			Convey("Get", func() {
-				itm := &mcItem{
-					key:        "sup",
-					value:      []byte("cool"),
-					expiration: time.Second,
+				itm := &memcache.Item{
+					Key:        "sup",
+					Value:      []byte("cool"),
+					Expiration: time.Second,
 				}
 				err := mc.Add(itm)
 				So(err, ShouldBeNil)
 
-				testItem := &mcItem{
-					key:   "sup",
-					value: []byte("cool"),
-					CasID: 1,
+				testItem := &memcache.Item{
+					Key:   "sup",
+					Value: []byte("cool"),
 				}
+				unsafe.MCSetCasID(testItem, 1)
 				i, err := mc.Get("sup")
 				So(err, ShouldBeNil)
 				So(i, ShouldResemble, testItem)
@@ -68,23 +70,23 @@ func TestMemcache(t *testing.T) {
 				Convey("which can expire", func() {
 					tc.Add(time.Second * 4)
 					i, err := mc.Get("sup")
-					So(err, ShouldEqual, gae.ErrMCCacheMiss)
+					So(err, ShouldEqual, memcache.ErrCacheMiss)
 					So(i, ShouldBeNil)
 				})
 
 				Convey("which can be broken intentionally", func() {
 					mci.BreakFeatures(nil, "Get")
 					_, err := mc.Get("sup")
-					So(err, ShouldEqual, gae.ErrMCServerError)
+					So(err, ShouldEqual, memcache.ErrServerError)
 				})
 			})
 
 			Convey("Delete", func() {
 				Convey("works if it's there", func() {
-					itm := &mcItem{
-						key:        "sup",
-						value:      []byte("cool"),
-						expiration: time.Second,
+					itm := &memcache.Item{
+						Key:        "sup",
+						Value:      []byte("cool"),
+						Expiration: time.Second,
 					}
 					err := mc.Add(itm)
 					So(err, ShouldBeNil)
@@ -93,40 +95,40 @@ func TestMemcache(t *testing.T) {
 					So(err, ShouldBeNil)
 
 					i, err := mc.Get("sup")
-					So(err, ShouldEqual, gae.ErrMCCacheMiss)
+					So(err, ShouldEqual, memcache.ErrCacheMiss)
 					So(i, ShouldBeNil)
 				})
 
 				Convey("but not if it's not there", func() {
 					err := mc.Delete("sup")
-					So(err, ShouldEqual, gae.ErrMCCacheMiss)
+					So(err, ShouldEqual, memcache.ErrCacheMiss)
 				})
 
 				Convey("and can be broken", func() {
 					mci.BreakFeatures(nil, "Delete")
 					err := mc.Delete("sup")
-					So(err, ShouldEqual, gae.ErrMCServerError)
+					So(err, ShouldEqual, memcache.ErrServerError)
 				})
 			})
 
 			Convey("Set", func() {
-				itm := &mcItem{
-					key:        "sup",
-					value:      []byte("cool"),
-					expiration: time.Second,
+				itm := &memcache.Item{
+					Key:        "sup",
+					Value:      []byte("cool"),
+					Expiration: time.Second,
 				}
 				err := mc.Add(itm)
 				So(err, ShouldBeNil)
 
-				itm.SetValue([]byte("newp"))
+				itm.Value = []byte("newp")
 				err = mc.Set(itm)
 				So(err, ShouldBeNil)
 
-				testItem := &mcItem{
-					key:   "sup",
-					value: []byte("newp"),
-					CasID: 2,
+				testItem := &memcache.Item{
+					Key:   "sup",
+					Value: []byte("newp"),
 				}
+				unsafe.MCSetCasID(testItem, 2)
 				i, err := mc.Get("sup")
 				So(err, ShouldBeNil)
 				So(i, ShouldResemble, testItem)
@@ -134,66 +136,66 @@ func TestMemcache(t *testing.T) {
 				Convey("and can be broken", func() {
 					mci.BreakFeatures(nil, "Set")
 					err := mc.Set(itm)
-					So(err, ShouldEqual, gae.ErrMCServerError)
+					So(err, ShouldEqual, memcache.ErrServerError)
 				})
 			})
 
 			Convey("CompareAndSwap", func() {
-				itm := gae.MCItem(&mcItem{
-					key:        "sup",
-					value:      []byte("cool"),
-					expiration: time.Second * 2,
-				})
+				itm := &memcache.Item{
+					Key:        "sup",
+					Value:      []byte("cool"),
+					Expiration: time.Second * 2,
+				}
 				err := mc.Add(itm)
 				So(err, ShouldBeNil)
 
 				Convey("works after a Get", func() {
 					itm, err = mc.Get("sup")
 					So(err, ShouldBeNil)
-					So(itm.(*mcItem).CasID, ShouldEqual, 1)
+					So(unsafe.MCGetCasID(itm), ShouldEqual, 1)
 
-					itm.SetValue([]byte("newp"))
+					itm.Value = []byte("newp")
 					err = mc.CompareAndSwap(itm)
 					So(err, ShouldBeNil)
 				})
 
 				Convey("but fails if you don't", func() {
-					itm.SetValue([]byte("newp"))
+					itm.Value = []byte("newp")
 					err = mc.CompareAndSwap(itm)
-					So(err, ShouldEqual, gae.ErrMCCASConflict)
+					So(err, ShouldEqual, memcache.ErrCASConflict)
 				})
 
 				Convey("and fails if the item is expired/gone", func() {
 					tc.Add(3 * time.Second)
-					itm.SetValue([]byte("newp"))
+					itm.Value = []byte("newp")
 					err = mc.CompareAndSwap(itm)
-					So(err, ShouldEqual, gae.ErrMCNotStored)
+					So(err, ShouldEqual, memcache.ErrNotStored)
 				})
 
 				Convey("and can be broken", func() {
 					mci.BreakFeatures(nil, "CompareAndSwap")
 					err = mc.CompareAndSwap(itm)
-					So(err, ShouldEqual, gae.ErrMCServerError)
+					So(err, ShouldEqual, memcache.ErrServerError)
 				})
 			})
 		})
 
 		Convey("check that the internal implementation is sane", func() {
 			curTime := now
-			err := mc.Add(&mcItem{
-				key:        "sup",
-				value:      []byte("cool"),
-				expiration: time.Second * 2,
+			err := mc.Add(&memcache.Item{
+				Key:        "sup",
+				Value:      []byte("cool"),
+				Expiration: time.Second * 2,
 			})
 
 			So(err, ShouldBeNil)
 			So(len(mci.data.items), ShouldEqual, 1)
 			So(mci.data.casID, ShouldEqual, 1)
-			So(mci.data.items["sup"], ShouldResemble, &mcItem{
-				key:        "sup",
-				value:      []byte("cool"),
-				expiration: time.Duration(curTime.Add(time.Second * 2).UnixNano()),
+			So(mci.data.items["sup"], ShouldResemble, &unsafe.Item{
+				Key:        "sup",
+				Value:      []byte("cool"),
 				CasID:      1,
+				Expiration: time.Duration(curTime.Add(time.Second * 2).UnixNano()),
 			})
 
 			el, err := mc.Get("sup")
@@ -201,11 +203,11 @@ func TestMemcache(t *testing.T) {
 			So(len(mci.data.items), ShouldEqual, 1)
 			So(mci.data.casID, ShouldEqual, 1)
 
-			testItem := &mcItem{
-				key:   "sup",
-				value: []byte("cool"),
-				CasID: 1,
+			testItem := &memcache.Item{
+				Key:   "sup",
+				Value: []byte("cool"),
 			}
+			unsafe.MCSetCasID(testItem, 1)
 			So(el, ShouldResemble, testItem)
 		})