Fix memory corruption bug in impl/memory

impl/memory/datastore_index_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 (
         "sort"
         "testing"
         "time"
@@ skipping 225 matching lines @@
         t.Parallel()
 
         Convey("Test indexEntriesWithBuiltins", t, func() {
                 for _, tc := range rowGenTestCases {
                         if tc.collections == nil {
                                 Convey(tc.name, nil) // shows up as 'skipped'
                                 continue
                         }
 
                         Convey(tc.name, func() {
-                                store := (*memStore)(nil)
+                                store := (memStore)(nil)
                                 if tc.withBuiltin {
                                         store = indexEntriesWithBuiltins(fakeKey, tc.pmap, tc.idxs)
                                 } else {
                                         sip := serialize.PropertyMapPartially(fakeKey, tc.pmap)
                                         store = indexEntries(sip, fakeKey.Namespace(), tc.idxs)
                                 }
                                 for colName, vals := range tc.collections {
                                         i := 0
-                                        coll := store.GetCollection(colName)
+                                        coll := store.Snapshot().GetCollection(colName)
                                         numItems, _ := coll.GetTotals()
                                         So(numItems, ShouldEqual, len(tc.collections[colName]))
                                         coll.VisitItemsAscend(nil, true, func(itm *gkvlite.Item) bool {
                                                 So(itm.Key, ShouldResemble, vals[i])
                                                 i++
                                                 return true
                                         })
                                         So(i, ShouldEqual, len(vals))
                                 }
                         })
@@ skipping 81 matching lines @@
         },
 }
 
 func TestUpdateIndexes(t *testing.T) {
         t.Parallel()
 
         Convey("Test updateIndexes", t, func() {
                 for _, tc := range updateIndexesTests {
                         Convey(tc.name, func() {
                                 store := newMemStore()
-                                idxColl := store.SetCollection("idx", nil)
+                                idxColl := store.GetOrCreateCollection("idx")
                                 for _, i := range tc.idxs {
                                         idxColl.Set(cat(i.PrepForIdxTable()), []byte{})
                                 }
 
                                 tmpLoader := map[string]ds.PropertyMap{}
                                 for _, itm := range tc.data {
                                         ks := itm.key.String()
                                         prev := tmpLoader[ks]
                                         updateIndexes(store, itm.key, prev, itm.props)
                                         tmpLoader[ks] = itm.props
                                 }
                                 tmpLoader = nil
 
                                 for colName, data := range tc.expected {
-                                        coll := store.GetCollection(colName)
+                                        coll := store.Snapshot().GetCollection(colName)
                                         So(coll, ShouldNotBeNil)
                                         i := 0
                                         coll.VisitItemsAscend(nil, false, func(itm *gkvlite.Item) bool {
                                                 So(data[i], ShouldResemble, itm.Key)
                                                 i++
                                                 return true
                                         })
                                         So(i, ShouldEqual, len(data))
                                 }
                         })
                 }
         })
 }