Skip to content

Commit 49ce3d2

Browse files
fxamackerfxamacker
committed
Fix tests
1 parent 62ad954 commit 49ce3d2

File tree

3 files changed

+31
-31
lines changed

3 files changed

+31
-31
lines changed

‎storage.go

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1531,7 +1531,7 @@ func (s *PersistentSlabStorage) getAllChildReferences(slab Slab) (
15311531

15321532
// BatchPreload decodeds and caches slabs of given ids in parallel.
15331533
// This is useful for storage health or data validation in migration programs.
1534-
func (s *PersistentSlabStorage) BatchPreload(ids []SlabID, numWorkers int) error {
1534+
func (s *PersistentSlabStorage) BatchPreload(ids []StorageID, numWorkers int) error {
15351535
if len(ids) == 0 {
15361536
return nil
15371537
}
@@ -1566,12 +1566,12 @@ func (s *PersistentSlabStorage) BatchPreload(ids []SlabID, numWorkers int) error
15661566
}
15671567

15681568
type slabToBeDecoded struct {
1569-
slabID SlabID
1569+
slabID StorageID
15701570
data []byte
15711571
}
15721572

15731573
type decodedSlab struct {
1574-
slabID SlabID
1574+
slabID StorageID
15751575
slab Slab
15761576
err error
15771577
}
@@ -1628,7 +1628,7 @@ func (s *PersistentSlabStorage) BatchPreload(ids []SlabID, numWorkers int) error
16281628

16291629
// Preallocate cache map if empty
16301630
if len(s.cache) == 0 {
1631-
s.cache = make(map[SlabID]Slab, len(ids))
1631+
s.cache = make(map[StorageID]Slab, len(ids))
16321632
}
16331633

16341634
// Launch workers

‎storage_bench_test.go

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -143,19 +143,19 @@ func benchmarkRetrieve(b *testing.B, seed int64, numberOfSlabs int) {
143143
decMode, err := cbor.DecOptions{}.DecMode()
144144
require.NoError(b, err)
145145

146-
encodedSlabs := make(map[SlabID][]byte)
147-
ids := make([]SlabID, 0, numberOfSlabs)
146+
encodedSlabs := make(map[StorageID][]byte)
147+
ids := make([]StorageID, 0, numberOfSlabs)
148148
for i := 0; i < numberOfSlabs; i++ {
149149
addr := generateRandomAddress(r)
150150

151-
var index SlabIndex
151+
var index StorageIndex
152152
binary.BigEndian.PutUint64(index[:], uint64(i))
153153

154-
id := SlabID{addr, index}
154+
id := StorageID{addr, index}
155155

156156
slab := generateLargeSlab(id)
157157

158-
data, err := EncodeSlab(slab, encMode)
158+
data, err := Encode(slab, encMode)
159159
require.NoError(b, err)
160160

161161
encodedSlabs[id] = data
@@ -190,19 +190,19 @@ func benchmarkBatchPreload(b *testing.B, seed int64, numberOfSlabs int) {
190190
decMode, err := cbor.DecOptions{}.DecMode()
191191
require.NoError(b, err)
192192

193-
encodedSlabs := make(map[SlabID][]byte)
194-
ids := make([]SlabID, 0, numberOfSlabs)
193+
encodedSlabs := make(map[StorageID][]byte)
194+
ids := make([]StorageID, 0, numberOfSlabs)
195195
for i := 0; i < numberOfSlabs; i++ {
196196
addr := generateRandomAddress(r)
197197

198-
var index SlabIndex
198+
var index StorageIndex
199199
binary.BigEndian.PutUint64(index[:], uint64(i))
200200

201-
id := SlabID{addr, index}
201+
id := StorageID{addr, index}
202202

203203
slab := generateLargeSlab(id)
204204

205-
data, err := EncodeSlab(slab, encMode)
205+
data, err := Encode(slab, encMode)
206206
require.NoError(b, err)
207207

208208
encodedSlabs[id] = data

‎storage_test.go

Lines changed: 17 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -4970,15 +4970,15 @@ func testStorageBatchPreload(t *testing.T, numberOfAccounts int, numberOfSlabsPe
49704970

49714971
indexesByAddress := make(map[Address]uint64)
49724972

4973-
generateSlabID := func(address Address) SlabID {
4973+
generateSlabID := func(address Address) StorageID {
49744974
nextIndex := indexesByAddress[address] + 1
49754975

4976-
var idx SlabIndex
4976+
var idx StorageIndex
49774977
binary.BigEndian.PutUint64(idx[:], nextIndex)
49784978

49794979
indexesByAddress[address] = nextIndex
49804980

4981-
return NewSlabID(address, idx)
4981+
return NewStorageID(address, idx)
49824982
}
49834983

49844984
encMode, err := cbor.EncOptions{}.EncMode()
@@ -4989,7 +4989,7 @@ func testStorageBatchPreload(t *testing.T, numberOfAccounts int, numberOfSlabsPe
49894989

49904990
r := newRand(t)
49914991

4992-
encodedSlabs := make(map[SlabID][]byte)
4992+
encodedSlabs := make(map[StorageID][]byte)
49934993

49944994
// Generate and encode slabs
49954995
for i := 0; i < numberOfAccounts; i++ {
@@ -5002,15 +5002,15 @@ func testStorageBatchPreload(t *testing.T, numberOfAccounts int, numberOfSlabsPe
50025002

50035003
slab := generateRandomSlab(slabID, r)
50045004

5005-
encodedSlabs[slabID], err = EncodeSlab(slab, encMode)
5005+
encodedSlabs[slabID], err = Encode(slab, encMode)
50065006
require.NoError(t, err)
50075007
}
50085008
}
50095009

50105010
baseStorage := NewInMemBaseStorageFromMap(encodedSlabs)
50115011
storage := NewPersistentSlabStorage(baseStorage, encMode, decMode, decodeStorable, decodeTypeInfo)
50125012

5013-
ids := make([]SlabID, 0, len(encodedSlabs))
5013+
ids := make([]StorageID, 0, len(encodedSlabs))
50145014
for id := range encodedSlabs {
50155015
ids = append(ids, id)
50165016
}
@@ -5023,7 +5023,7 @@ func testStorageBatchPreload(t *testing.T, numberOfAccounts int, numberOfSlabsPe
50235023

50245024
// Compare encoded data
50255025
for id, data := range encodedSlabs {
5026-
cachedData, err := EncodeSlab(storage.cache[id], encMode)
5026+
cachedData, err := Encode(storage.cache[id], encMode)
50275027
require.NoError(t, err)
50285028

50295029
require.Equal(t, cachedData, data)
@@ -5043,12 +5043,12 @@ func TestStorageBatchPreloadNotFoundSlabs(t *testing.T) {
50435043
t.Run("empty storage", func(t *testing.T) {
50445044
const numberOfSlabs = 10
50455045

5046-
ids := make([]SlabID, numberOfSlabs)
5046+
ids := make([]StorageID, numberOfSlabs)
50475047
for i := 0; i < numberOfSlabs; i++ {
5048-
var index SlabIndex
5048+
var index StorageIndex
50495049
binary.BigEndian.PutUint64(index[:], uint64(i))
50505050

5051-
ids[i] = NewSlabID(generateRandomAddress(r), index)
5051+
ids[i] = NewStorageID(generateRandomAddress(r), index)
50525052
}
50535053

50545054
baseStorage := NewInMemBaseStorage()
@@ -5064,25 +5064,25 @@ func TestStorageBatchPreloadNotFoundSlabs(t *testing.T) {
50645064
t.Run("non-empty storage", func(t *testing.T) {
50655065
const numberOfSlabs = 10
50665066

5067-
ids := make([]SlabID, numberOfSlabs)
5068-
encodedSlabs := make(map[SlabID][]byte)
5067+
ids := make([]StorageID, numberOfSlabs)
5068+
encodedSlabs := make(map[StorageID][]byte)
50695069

50705070
for i := 0; i < numberOfSlabs; i++ {
5071-
var index SlabIndex
5071+
var index StorageIndex
50725072
binary.BigEndian.PutUint64(index[:], uint64(i))
50735073

5074-
id := NewSlabID(generateRandomAddress(r), index)
5074+
id := NewStorageID(generateRandomAddress(r), index)
50755075

50765076
slab := generateRandomSlab(id, r)
50775077

5078-
encodedSlabs[id], err = EncodeSlab(slab, encMode)
5078+
encodedSlabs[id], err = Encode(slab, encMode)
50795079
require.NoError(t, err)
50805080

50815081
ids[i] = id
50825082
}
50835083

50845084
// Append a slab ID that doesn't exist in storage.
5085-
ids = append(ids, NewSlabID(generateRandomAddress(r), SlabIndex{numberOfSlabs}))
5085+
ids = append(ids, NewStorageID(generateRandomAddress(r), StorageIndex{numberOfSlabs}))
50865086

50875087
baseStorage := NewInMemBaseStorageFromMap(encodedSlabs)
50885088
storage := NewPersistentSlabStorage(baseStorage, encMode, decMode, decodeStorable, decodeTypeInfo)
@@ -5095,7 +5095,7 @@ func TestStorageBatchPreloadNotFoundSlabs(t *testing.T) {
50955095

50965096
// Compare encoded data
50975097
for id, data := range encodedSlabs {
5098-
cachedData, err := EncodeSlab(storage.cache[id], encMode)
5098+
cachedData, err := Encode(storage.cache[id], encMode)
50995099
require.NoError(t, err)
51005100

51015101
require.Equal(t, cachedData, data)

0 commit comments

Comments
 (0)