Fix memory corruption bug in impl/memory

impl/memory/gkvlite_utils_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 (
         "testing"
 
         . "github.com/smartystreets/goconvey/convey"
@@ skipping 77 matching lines @@
                         {cat(1), cat("one"), cat(58)},
                         {cat(2), []byte("zoop"), cat("ski", 7)},
                         {cat(3), cat(1.3), cat(1)},
                         {cat(4), nil, cat(1337)},
                         {cat(6), cat(), nil},
                         {cat(20), nil, cat("nerd")},
                 },
         },
 }
 
-func getFilledColl(s *memStore, fill []kv) *memCollection {
+func getFilledColl(fill []kv) memCollection {
         if fill == nil {
                 return nil
         }
-        ret := s.MakePrivateCollection(nil)
+        store := newMemStore()
+        ret := store.GetOrCreateCollection("")
         for _, i := range fill {
                 ret.Set(i.k, i.v)
         }
-        return ret
+        return store.Snapshot().GetCollection("")
 }
 
 func TestCollision(t *testing.T) {
         t.Parallel()
 
         Convey("Test gkvCollide", t, func() {
-                s := newMemStore()
                 for _, tc := range testCollisionCases {
                         Convey(tc.name, func() {
-                                left := getFilledColl(s, tc.left)
-                                right := getFilledColl(s, tc.right)
+                                left := getFilledColl(tc.left)
+                                right := getFilledColl(tc.right)
                                 i := 0
                                 gkvCollide(left, right, func(key, left, right []byte) {
                                         e := tc.expect[i]
                                         So(key, ShouldResemble, e.key)
                                         So(left, ShouldResemble, e.left)
                                         So(right, ShouldResemble, e.right)
                                         i++
                                 })
                                 So(i, ShouldEqual, len(tc.expect))
                         })
                 }
         })
 }