forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-08-20 10:52:25 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

swarm/storage: delete unused function parameters in tests

Browse source 
'chunksize' and 'processors' were unused; I did a cascading delete.
This commit is contained in:
Ferenc Szabo 2019-02-07 13:29:32 +01:00
parent 6f714ed73e
commit 500a9fbbbb
3 changed files with 55 additions and 79 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
swarm/storage/common_test.go
View file

@ -83,7 +83,7 @@ func newLDBStore(t *testing.T) (*LDBStore, func()) {
return db, cleanup return db, cleanup
} }
func mputRandomChunks(store ChunkStore, n int, chunksize int64) ([]Chunk, error) { func mputRandomChunks(store ChunkStore, n int) ([]Chunk, error) {
return mput(store, n, GenerateRandomChunk) return mput(store, n, GenerateRandomChunk)
} }
@ -159,8 +159,8 @@ func (r *brokenLimitedReader) Read(buf []byte) (int, error) {
return r.lr.Read(buf) return r.lr.Read(buf)
} }
func testStoreRandom(m ChunkStore, n int, chunksize int64, t *testing.T) { func testStoreRandom(m ChunkStore, n int, t *testing.T) {
chunks, err := mputRandomChunks(m, n, chunksize) chunks, err := mputRandomChunks(m, n)
if err != nil { if err != nil {
t.Fatalf("expected no error, got %v", err) t.Fatalf("expected no error, got %v", err)
} }
@ -170,8 +170,8 @@ func testStoreRandom(m ChunkStore, n int, chunksize int64, t *testing.T) {
} }
} }
func testStoreCorrect(m ChunkStore, n int, chunksize int64, t *testing.T) { func testStoreCorrect(m ChunkStore, n int, t *testing.T) {
chunks, err := mputRandomChunks(m, n, chunksize) chunks, err := mputRandomChunks(m, n)
if err != nil { if err != nil {
t.Fatalf("expected no error, got %v", err) t.Fatalf("expected no error, got %v", err)
} }
@ -195,7 +195,7 @@ func testStoreCorrect(m ChunkStore, n int, chunksize int64, t *testing.T) {
} }
} }
func benchmarkStorePut(store ChunkStore, n int, chunksize int64, b *testing.B) { func benchmarkStorePut(store ChunkStore, n int, b *testing.B) {
chunks := make([]Chunk, n) chunks := make([]Chunk, n)
i := 0 i := 0
f := func(dataSize int64) Chunk { f := func(dataSize int64) Chunk {
@ -222,8 +222,8 @@ func benchmarkStorePut(store ChunkStore, n int, chunksize int64, b *testing.B) {
} }
} }
func benchmarkStoreGet(store ChunkStore, n int, chunksize int64, b *testing.B) { func benchmarkStoreGet(store ChunkStore, n int, b *testing.B) {
chunks, err := mputRandomChunks(store, n, chunksize) chunks, err := mputRandomChunks(store, n)
if err != nil { if err != nil {
b.Fatalf("expected no error, got %v", err) b.Fatalf("expected no error, got %v", err)
} }

78
swarm/storage/ldbstore_test.go
View file

@ -78,22 +78,22 @@ func testPoFunc(k Address) (ret uint8) {
return uint8(Proximity(basekey, k[:])) return uint8(Proximity(basekey, k[:]))
} }
func testDbStoreRandom(n int, chunksize int64, mock bool, t *testing.T) { func testDbStoreRandom(n int, mock bool, t *testing.T) {
db, cleanup, err := newTestDbStore(mock, true) db, cleanup, err := newTestDbStore(mock, true)
defer cleanup() defer cleanup()
if err != nil { if err != nil {
t.Fatalf("init dbStore failed: %v", err) t.Fatalf("init dbStore failed: %v", err)
} }
testStoreRandom(db, n, chunksize, t) testStoreRandom(db, n, t)
} }
func testDbStoreCorrect(n int, chunksize int64, mock bool, t *testing.T) { func testDbStoreCorrect(n int, mock bool, t *testing.T) {
db, cleanup, err := newTestDbStore(mock, false) db, cleanup, err := newTestDbStore(mock, false)
defer cleanup() defer cleanup()
if err != nil { if err != nil {
t.Fatalf("init dbStore failed: %v", err) t.Fatalf("init dbStore failed: %v", err)
} }
testStoreCorrect(db, n, chunksize, t) testStoreCorrect(db, n, t)
} }
func TestMarkAccessed(t *testing.T) { func TestMarkAccessed(t *testing.T) {
@ -137,35 +137,35 @@ func TestMarkAccessed(t *testing.T) {
} }
func TestDbStoreRandom_1(t *testing.T) { func TestDbStoreRandom_1(t *testing.T) {
testDbStoreRandom(1, 0, false, t) testDbStoreRandom(1, false, t)
} }
func TestDbStoreCorrect_1(t *testing.T) { func TestDbStoreCorrect_1(t *testing.T) {
testDbStoreCorrect(1, 4096, false, t) testDbStoreCorrect(1, false, t)
} }
func TestDbStoreRandom_1k(t *testing.T) { func TestDbStoreRandom_1k(t *testing.T) {
testDbStoreRandom(1000, 0, false, t) testDbStoreRandom(1000, false, t)
} }
func TestDbStoreCorrect_1k(t *testing.T) { func TestDbStoreCorrect_1k(t *testing.T) {
testDbStoreCorrect(1000, 4096, false, t) testDbStoreCorrect(1000, false, t)
} }
func TestMockDbStoreRandom_1(t *testing.T) { func TestMockDbStoreRandom_1(t *testing.T) {
testDbStoreRandom(1, 0, true, t) testDbStoreRandom(1, true, t)
} }
func TestMockDbStoreCorrect_1(t *testing.T) { func TestMockDbStoreCorrect_1(t *testing.T) {
testDbStoreCorrect(1, 4096, true, t) testDbStoreCorrect(1, true, t)
} }
func TestMockDbStoreRandom_1k(t *testing.T) { func TestMockDbStoreRandom_1k(t *testing.T) {
testDbStoreRandom(1000, 0, true, t) testDbStoreRandom(1000, true, t)
} }
func TestMockDbStoreCorrect_1k(t *testing.T) { func TestMockDbStoreCorrect_1k(t *testing.T) {
testDbStoreCorrect(1000, 4096, true, t) testDbStoreCorrect(1000, true, t)
} }
func testDbStoreNotFound(t *testing.T, mock bool) { func testDbStoreNotFound(t *testing.T, mock bool) {
@ -242,54 +242,38 @@ func TestMockIterator(t *testing.T) {
testIterator(t, true) testIterator(t, true)
} }
func benchmarkDbStorePut(n int, processors int, chunksize int64, mock bool, b *testing.B) { func benchmarkDbStorePut(n int, mock bool, b *testing.B) {
db, cleanup, err := newTestDbStore(mock, true) db, cleanup, err := newTestDbStore(mock, true)
defer cleanup() defer cleanup()
if err != nil { if err != nil {
b.Fatalf("init dbStore failed: %v", err) b.Fatalf("init dbStore failed: %v", err)
} }
benchmarkStorePut(db, n, chunksize, b) benchmarkStorePut(db, n, b)
} }
func benchmarkDbStoreGet(n int, processors int, chunksize int64, mock bool, b *testing.B) { func benchmarkDbStoreGet(n int, mock bool, b *testing.B) {
db, cleanup, err := newTestDbStore(mock, true) db, cleanup, err := newTestDbStore(mock, true)
defer cleanup() defer cleanup()
if err != nil { if err != nil {
b.Fatalf("init dbStore failed: %v", err) b.Fatalf("init dbStore failed: %v", err)
} }
benchmarkStoreGet(db, n, chunksize, b) benchmarkStoreGet(db, n, b)
} }
func BenchmarkDbStorePut_1_500(b *testing.B) { func BenchmarkDbStorePut_500(b *testing.B) {
benchmarkDbStorePut(500, 1, 4096, false, b) benchmarkDbStorePut(500, false, b)
} }
func BenchmarkDbStorePut_8_500(b *testing.B) { func BenchmarkDbStoreGet_500(b *testing.B) {
benchmarkDbStorePut(500, 8, 4096, false, b) benchmarkDbStoreGet(500, false, b)
} }
func BenchmarkDbStoreGet_1_500(b *testing.B) { func BenchmarkMockDbStorePut_500(b *testing.B) {
benchmarkDbStoreGet(500, 1, 4096, false, b) benchmarkDbStorePut(500, true, b)
} }
func BenchmarkDbStoreGet_8_500(b *testing.B) { func BenchmarkMockDbStoreGet_500(b *testing.B) {
benchmarkDbStoreGet(500, 8, 4096, false, b) benchmarkDbStoreGet(500, true, b)
}
func BenchmarkMockDbStorePut_1_500(b *testing.B) {
benchmarkDbStorePut(500, 1, 4096, true, b)
}
func BenchmarkMockDbStorePut_8_500(b *testing.B) {
benchmarkDbStorePut(500, 8, 4096, true, b)
}
func BenchmarkMockDbStoreGet_1_500(b *testing.B) {
benchmarkDbStoreGet(500, 1, 4096, true, b)
}
func BenchmarkMockDbStoreGet_8_500(b *testing.B) {
benchmarkDbStoreGet(500, 8, 4096, true, b)
} }
// TestLDBStoreWithoutCollectGarbage tests that we can put a number of random chunks in the LevelDB store, and // TestLDBStoreWithoutCollectGarbage tests that we can put a number of random chunks in the LevelDB store, and
@ -302,7 +286,7 @@ func TestLDBStoreWithoutCollectGarbage(t *testing.T) {
ldb.setCapacity(uint64(capacity)) ldb.setCapacity(uint64(capacity))
defer cleanup() defer cleanup()
chunks, err := mputRandomChunks(ldb, n, int64(ch.DefaultSize)) chunks, err := mputRandomChunks(ldb, n)
if err != nil { if err != nil {
t.Fatal(err.Error()) t.Fatal(err.Error())
} }
@ -382,7 +366,7 @@ func testLDBStoreCollectGarbage(t *testing.T) {
putCount = roundTarget putCount = roundTarget
} }
remaining -= putCount remaining -= putCount
chunks, err := mputRandomChunks(ldb, putCount, int64(ch.DefaultSize)) chunks, err := mputRandomChunks(ldb, putCount)
if err != nil { if err != nil {
t.Fatal(err.Error()) t.Fatal(err.Error())
} }
@ -429,7 +413,7 @@ func TestLDBStoreAddRemove(t *testing.T) {
defer cleanup() defer cleanup()
n := 100 n := 100
chunks, err := mputRandomChunks(ldb, n, int64(ch.DefaultSize)) chunks, err := mputRandomChunks(ldb, n)
if err != nil { if err != nil {
t.Fatalf(err.Error()) t.Fatalf(err.Error())
} }
@ -576,7 +560,7 @@ func TestLDBStoreCollectGarbageAccessUnlikeIndex(t *testing.T) {
ldb.setCapacity(uint64(capacity)) ldb.setCapacity(uint64(capacity))
defer cleanup() defer cleanup()
chunks, err := mputRandomChunks(ldb, n, int64(ch.DefaultSize)) chunks, err := mputRandomChunks(ldb, n)
if err != nil { if err != nil {
t.Fatal(err.Error()) t.Fatal(err.Error())
} }
@ -589,7 +573,7 @@ func TestLDBStoreCollectGarbageAccessUnlikeIndex(t *testing.T) {
t.Fatalf("fail add chunk #%d - %s: %v", i, chunks[i].Address(), err) t.Fatalf("fail add chunk #%d - %s: %v", i, chunks[i].Address(), err)
} }
} }
_, err = mputRandomChunks(ldb, 2, int64(ch.DefaultSize)) _, err = mputRandomChunks(ldb, 2)
if err != nil { if err != nil {
t.Fatal(err.Error()) t.Fatal(err.Error())
} }
@ -621,7 +605,7 @@ func TestCleanIndex(t *testing.T) {
ldb.setCapacity(uint64(capacity)) ldb.setCapacity(uint64(capacity))
defer cleanup() defer cleanup()
chunks, err := mputRandomChunks(ldb, n, 4096) chunks, err := mputRandomChunks(ldb, n)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -752,7 +736,7 @@ func TestCleanIndex(t *testing.T) {
} }
// check that the iterator quits properly // check that the iterator quits properly
chunks, err = mputRandomChunks(ldb, 4100, 4096) chunks, err = mputRandomChunks(ldb, 4100)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }

40
swarm/storage/memstore_test.go
View file

@ -28,32 +28,32 @@ func newTestMemStore() *MemStore {
return NewMemStore(storeparams, nil) return NewMemStore(storeparams, nil)
} }
func testMemStoreRandom(n int, chunksize int64, t *testing.T) { func testMemStoreRandom(n int, t *testing.T) {
m := newTestMemStore() m := newTestMemStore()
defer m.Close() defer m.Close()
testStoreRandom(m, n, chunksize, t) testStoreRandom(m, n, t)
} }
func testMemStoreCorrect(n int, chunksize int64, t *testing.T) { func testMemStoreCorrect(n int, t *testing.T) {
m := newTestMemStore() m := newTestMemStore()
defer m.Close() defer m.Close()
testStoreCorrect(m, n, chunksize, t) testStoreCorrect(m, n, t)
} }
func TestMemStoreRandom_1(t *testing.T) { func TestMemStoreRandom_1(t *testing.T) {
testMemStoreRandom(1, 0, t) testMemStoreRandom(1, t)
} }
func TestMemStoreCorrect_1(t *testing.T) { func TestMemStoreCorrect_1(t *testing.T) {
testMemStoreCorrect(1, 4104, t) testMemStoreCorrect(1, t)
} }
func TestMemStoreRandom_1k(t *testing.T) { func TestMemStoreRandom_1k(t *testing.T) {
testMemStoreRandom(1000, 0, t) testMemStoreRandom(1000, t)
} }
func TestMemStoreCorrect_1k(t *testing.T) { func TestMemStoreCorrect_1k(t *testing.T) {
testMemStoreCorrect(100, 4096, t) testMemStoreCorrect(100, t)
} }
func TestMemStoreNotFound(t *testing.T) { func TestMemStoreNotFound(t *testing.T) {
@ -66,32 +66,24 @@ func TestMemStoreNotFound(t *testing.T) {
} }
} }
func benchmarkMemStorePut(n int, processors int, chunksize int64, b *testing.B) { func benchmarkMemStorePut(n int, b *testing.B) {
m := newTestMemStore() m := newTestMemStore()
defer m.Close() defer m.Close()
benchmarkStorePut(m, n, chunksize, b) benchmarkStorePut(m, n, b)
} }
func benchmarkMemStoreGet(n int, processors int, chunksize int64, b *testing.B) { func benchmarkMemStoreGet(n int, b *testing.B) {
m := newTestMemStore() m := newTestMemStore()
defer m.Close() defer m.Close()
benchmarkStoreGet(m, n, chunksize, b) benchmarkStoreGet(m, n, b)
} }
func BenchmarkMemStorePut_1_500(b *testing.B) { func BenchmarkMemStorePut_500(b *testing.B) {
benchmarkMemStorePut(500, 1, 4096, b) benchmarkMemStorePut(500, b)
} }
func BenchmarkMemStorePut_8_500(b *testing.B) { func BenchmarkMemStoreGet_500(b *testing.B) {
benchmarkMemStorePut(500, 8, 4096, b) benchmarkMemStoreGet(500, b)
}
func BenchmarkMemStoreGet_1_500(b *testing.B) {
benchmarkMemStoreGet(500, 1, 4096, b)
}
func BenchmarkMemStoreGet_8_500(b *testing.B) {
benchmarkMemStoreGet(500, 8, 4096, b)
} }
func TestMemStoreAndLDBStore(t *testing.T) { func TestMemStoreAndLDBStore(t *testing.T) {