Refactor serialization helpers from impl/memory -> service/datastore/serialize

impl/memory/gkvlite_iter_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 (
         "bytes"
         "testing"
 
+        "github.com/luci/gae/service/datastore/serialize"
         "github.com/luci/gkvlite"
         "github.com/luci/luci-go/common/cmpbin"
         . "github.com/smartystreets/goconvey/convey"
 )
 
 func mkNum(n int64) []byte {
         buf := &bytes.Buffer{}
         _, err := cmpbin.WriteInt(buf, n)
         memoryCorruption(err)
 
@@ skipping 136 matching lines @@
                 {3, 10},
                 {3, 11},
         }
 
         valBytes := make([][]byte, len(vals))
         for i, nms := range vals {
                 numbs := make([][]byte, len(nms))
                 for j, n := range nms {
                         numbs[j] = mkNum(n)
                 }
-                valBytes[i] = bjoin(numbs...)
+                valBytes[i] = serialize.Join(numbs...)
         }
 
         otherVals := [][]int64{
                 {3, 0},
                 {4, 10},
                 {19, 7},
                 {20, 2},
                 {20, 3},
                 {20, 4},
                 {20, 8},
                 {20, 11},
         }
 
         otherValBytes := make([][]byte, len(otherVals))
         for i, nms := range otherVals {
                 numbs := make([][]byte, len(nms))
                 for i, n := range nms {
                         numbs[i] = mkNum(n)
                 }
-                otherValBytes[i] = bjoin(numbs...)
+                otherValBytes[i] = serialize.Join(numbs...)
         }
 
         Convey("Test MultiIterator", t, func() {
                 s := newMemStore()
                 c := s.SetCollection("zup1", nil)
                 for _, row := range valBytes {
                         c.Set(row, []byte{})
                 }
                 c2 := s.SetCollection("zup2", nil)
                 for _, row := range otherValBytes {
@@ skipping 71 matching lines @@
                                 So(readNum(suffix), ShouldEqual, vals[i][1])
                                 i++
                                 return false
                         })
                         So(i, ShouldEqual, 1)
                 })
 
         })
 
 }