swarm: CI race detector test adjustments (#19017)

frncmx · nonsense · commit 27e3f968194e · 2019-02-08T17:07:11.000+01:00
diff --git a/swarm/network/networkid_test.go b/swarm/network/networkid_test.go
@@ -44,7 +44,7 @@ var (
 
 const (
 	NumberOfNets = 4
-	MaxTimeout   = 6
+	MaxTimeout   = 15 * time.Second
 )
 
 func init() {
@@ -146,7 +146,7 @@ func setupNetwork(numnodes int) (net *simulations.Network, err error) {
 			return nil, fmt.Errorf("create node %d rpc client fail: %v", i, err)
 		}
 		//now setup and start event watching in order to know when we can upload
-		ctx, watchCancel := context.WithTimeout(context.Background(), MaxTimeout*time.Second)
+		ctx, watchCancel := context.WithTimeout(context.Background(), MaxTimeout)
 		defer watchCancel()
 		watchSubscriptionEvents(ctx, nodes[i].ID(), client, errc, quitC)
 		//on every iteration we connect to all previous ones
diff --git a/swarm/network/simulations/overlay_test.go b/swarm/network/simulations/overlay_test.go
@@ -32,7 +32,7 @@ import (
 )
 
 var (
-	nodeCount = 16
+	nodeCount = 10
 )
 
 //This test is used to test the overlay simulation.
diff --git a/swarm/network/stream/snapshot_retrieval_test.go b/swarm/network/stream/snapshot_retrieval_test.go
@@ -151,7 +151,7 @@ func runFileRetrievalTest(nodeCount int) error {
 		return err
 	}
 
-	ctx, cancelSimRun := context.WithTimeout(context.Background(), 1*time.Minute)
+	ctx, cancelSimRun := context.WithTimeout(context.Background(), 3*time.Minute)
 	defer cancelSimRun()
 
 	result := sim.Run(ctx, func(ctx context.Context, sim *simulation.Simulation) error {
diff --git a/swarm/storage/common_test.go b/swarm/storage/common_test.go
@@ -83,15 +83,15 @@ func newLDBStore(t *testing.T) (*LDBStore, func()) {
 	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)
 }
 
 func mput(store ChunkStore, n int, f func(i int64) Chunk) (hs []Chunk, err error) {
 	// put to localstore and wait for stored channel
 	// does not check delivery error state
 	errc := make(chan error)
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Minute)
 	defer cancel()
 	for i := int64(0); i < int64(n); i++ {
 		chunk := f(ch.DefaultSize)
@@ -159,8 +159,8 @@ func (r *brokenLimitedReader) Read(buf []byte) (int, error) {
 	return r.lr.Read(buf)
 }
 
-func testStoreRandom(m ChunkStore, n int, chunksize int64, t *testing.T) {
-	chunks, err := mputRandomChunks(m, n, chunksize)
+func testStoreRandom(m ChunkStore, n int, t *testing.T) {
+	chunks, err := mputRandomChunks(m, n)
 	if err != nil {
 		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) {
-	chunks, err := mputRandomChunks(m, n, chunksize)
+func testStoreCorrect(m ChunkStore, n int, t *testing.T) {
+	chunks, err := mputRandomChunks(m, n)
 	if err != nil {
 		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)
 	i := 0
 	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) {
-	chunks, err := mputRandomChunks(store, n, chunksize)
+func benchmarkStoreGet(store ChunkStore, n int, b *testing.B) {
+	chunks, err := mputRandomChunks(store, n)
 	if err != nil {
 		b.Fatalf("expected no error, got %v", err)
 	}
diff --git a/swarm/storage/ldbstore_test.go b/swarm/storage/ldbstore_test.go
@@ -78,22 +78,22 @@ func testPoFunc(k Address) (ret uint8) {
 	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)
 	defer cleanup()
 	if err != nil {
 		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)
 	defer cleanup()
 	if err != nil {
 		t.Fatalf("init dbStore failed: %v", err)
 	}
-	testStoreCorrect(db, n, chunksize, t)
+	testStoreCorrect(db, n, t)
 }
 
 func TestMarkAccessed(t *testing.T) {
@@ -137,35 +137,35 @@ func TestMarkAccessed(t *testing.T) {
 }
 
 func TestDbStoreRandom_1(t *testing.T) {
-	testDbStoreRandom(1, 0, false, t)
+	testDbStoreRandom(1, false, t)
 }
 
 func TestDbStoreCorrect_1(t *testing.T) {
-	testDbStoreCorrect(1, 4096, false, t)
+	testDbStoreCorrect(1, false, t)
 }
 
 func TestDbStoreRandom_1k(t *testing.T) {
-	testDbStoreRandom(1000, 0, false, t)
+	testDbStoreRandom(1000, false, t)
 }
 
 func TestDbStoreCorrect_1k(t *testing.T) {
-	testDbStoreCorrect(1000, 4096, false, t)
+	testDbStoreCorrect(1000, false, t)
 }
 
 func TestMockDbStoreRandom_1(t *testing.T) {
-	testDbStoreRandom(1, 0, true, t)
+	testDbStoreRandom(1, true, t)
 }
 
 func TestMockDbStoreCorrect_1(t *testing.T) {
-	testDbStoreCorrect(1, 4096, true, t)
+	testDbStoreCorrect(1, true, t)
 }
 
 func TestMockDbStoreRandom_1k(t *testing.T) {
-	testDbStoreRandom(1000, 0, true, t)
+	testDbStoreRandom(1000, true, t)
 }
 
 func TestMockDbStoreCorrect_1k(t *testing.T) {
-	testDbStoreCorrect(1000, 4096, true, t)
+	testDbStoreCorrect(1000, true, t)
 }
 
 func testDbStoreNotFound(t *testing.T, mock bool) {
@@ -242,54 +242,38 @@ func TestMockIterator(t *testing.T) {
 	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)
 	defer cleanup()
 	if err != nil {
 		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)
 	defer cleanup()
 	if err != nil {
 		b.Fatalf("init dbStore failed: %v", err)
 	}
-	benchmarkStoreGet(db, n, chunksize, b)
+	benchmarkStoreGet(db, n, b)
 }
 
-func BenchmarkDbStorePut_1_500(b *testing.B) {
-	benchmarkDbStorePut(500, 1, 4096, false, b)
+func BenchmarkDbStorePut_500(b *testing.B) {
+	benchmarkDbStorePut(500, false, b)
 }
 
-func BenchmarkDbStorePut_8_500(b *testing.B) {
-	benchmarkDbStorePut(500, 8, 4096, false, b)
+func BenchmarkDbStoreGet_500(b *testing.B) {
+	benchmarkDbStoreGet(500, false, b)
 }
 
-func BenchmarkDbStoreGet_1_500(b *testing.B) {
-	benchmarkDbStoreGet(500, 1, 4096, false, b)
+func BenchmarkMockDbStorePut_500(b *testing.B) {
+	benchmarkDbStorePut(500, true, b)
 }
 
-func BenchmarkDbStoreGet_8_500(b *testing.B) {
-	benchmarkDbStoreGet(500, 8, 4096, false, 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)
+func BenchmarkMockDbStoreGet_500(b *testing.B) {
+	benchmarkDbStoreGet(500, true, b)
 }
 
 // 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))
 	defer cleanup()
 
-	chunks, err := mputRandomChunks(ldb, n, int64(ch.DefaultSize))
+	chunks, err := mputRandomChunks(ldb, n)
 	if err != nil {
 		t.Fatal(err.Error())
 	}
@@ -382,7 +366,7 @@ func testLDBStoreCollectGarbage(t *testing.T) {
 			putCount = roundTarget
 		}
 		remaining -= putCount
-		chunks, err := mputRandomChunks(ldb, putCount, int64(ch.DefaultSize))
+		chunks, err := mputRandomChunks(ldb, putCount)
 		if err != nil {
 			t.Fatal(err.Error())
 		}
@@ -429,7 +413,7 @@ func TestLDBStoreAddRemove(t *testing.T) {
 	defer cleanup()
 
 	n := 100
-	chunks, err := mputRandomChunks(ldb, n, int64(ch.DefaultSize))
+	chunks, err := mputRandomChunks(ldb, n)
 	if err != nil {
 		t.Fatalf(err.Error())
 	}
@@ -576,7 +560,7 @@ func TestLDBStoreCollectGarbageAccessUnlikeIndex(t *testing.T) {
 	ldb.setCapacity(uint64(capacity))
 	defer cleanup()
 
-	chunks, err := mputRandomChunks(ldb, n, int64(ch.DefaultSize))
+	chunks, err := mputRandomChunks(ldb, n)
 	if err != nil {
 		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)
 		}
 	}
-	_, err = mputRandomChunks(ldb, 2, int64(ch.DefaultSize))
+	_, err = mputRandomChunks(ldb, 2)
 	if err != nil {
 		t.Fatal(err.Error())
 	}
@@ -621,7 +605,7 @@ func TestCleanIndex(t *testing.T) {
 	ldb.setCapacity(uint64(capacity))
 	defer cleanup()
 
-	chunks, err := mputRandomChunks(ldb, n, 4096)
+	chunks, err := mputRandomChunks(ldb, n)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -752,7 +736,7 @@ func TestCleanIndex(t *testing.T) {
 	}
 
 	// check that the iterator quits properly
-	chunks, err = mputRandomChunks(ldb, 4100, 4096)
+	chunks, err = mputRandomChunks(ldb, 4100)
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/swarm/storage/memstore_test.go b/swarm/storage/memstore_test.go
@@ -28,32 +28,32 @@ func newTestMemStore() *MemStore {
 	return NewMemStore(storeparams, nil)
 }
 
-func testMemStoreRandom(n int, chunksize int64, t *testing.T) {
+func testMemStoreRandom(n int, t *testing.T) {
 	m := newTestMemStore()
 	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()
 	defer m.Close()
-	testStoreCorrect(m, n, chunksize, t)
+	testStoreCorrect(m, n, t)
 }
 
 func TestMemStoreRandom_1(t *testing.T) {
-	testMemStoreRandom(1, 0, t)
+	testMemStoreRandom(1, t)
 }
 
 func TestMemStoreCorrect_1(t *testing.T) {
-	testMemStoreCorrect(1, 4104, t)
+	testMemStoreCorrect(1, t)
 }
 
 func TestMemStoreRandom_1k(t *testing.T) {
-	testMemStoreRandom(1000, 0, t)
+	testMemStoreRandom(1000, t)
 }
 
 func TestMemStoreCorrect_1k(t *testing.T) {
-	testMemStoreCorrect(100, 4096, t)
+	testMemStoreCorrect(100, 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()
 	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()
 	defer m.Close()
-	benchmarkStoreGet(m, n, chunksize, b)
+	benchmarkStoreGet(m, n, b)
 }
 
-func BenchmarkMemStorePut_1_500(b *testing.B) {
-	benchmarkMemStorePut(500, 1, 4096, b)
+func BenchmarkMemStorePut_500(b *testing.B) {
+	benchmarkMemStorePut(500, b)
 }
 
-func BenchmarkMemStorePut_8_500(b *testing.B) {
-	benchmarkMemStorePut(500, 8, 4096, 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 BenchmarkMemStoreGet_500(b *testing.B) {
+	benchmarkMemStoreGet(500, b)
 }
 
 func TestMemStoreAndLDBStore(t *testing.T) {

Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ import (`
`32`	`32`	`)`
`33`	`33`
`34`	`34`	`var (`
`35`		`- nodeCount = 16`
	`35`	`+ nodeCount = 10`
`36`	`36`	`)`
`37`	`37`
`38`	`38`	`//This test is used to test the overlay simulation.`
Original file line number	Diff line number	Diff line change
`@@ -151,7 +151,7 @@ func runFileRetrievalTest(nodeCount int) error {`
`151`	`151`	`return err`
`152`	`152`	`}`
`153`	`153`
`154`		`- ctx, cancelSimRun := context.WithTimeout(context.Background(), 1*time.Minute)`
	`154`	`+ ctx, cancelSimRun := context.WithTimeout(context.Background(), 3*time.Minute)`
`155`	`155`	`defer cancelSimRun()`
`156`	`156`
`157`	`157`	`result := sim.Run(ctx, func(ctx context.Context, sim *simulation.Simulation) error {`
Original file line number	Diff line number	Diff line change
`@@ -83,15 +83,15 @@ func newLDBStore(t testing.T) (LDBStore, func()) {`
`83`	`83`	`return db, cleanup`
`84`	`84`	`}`
`85`	`85`
`86`		`-func mputRandomChunks(store ChunkStore, n int, chunksize int64) ([]Chunk, error) {`
	`86`	`+func mputRandomChunks(store ChunkStore, n int) ([]Chunk, error) {`
`87`	`87`	`return mput(store, n, GenerateRandomChunk)`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`func mput(store ChunkStore, n int, f func(i int64) Chunk) (hs []Chunk, err error) {`
`91`	`91`	`// put to localstore and wait for stored channel`
`92`	`92`	`// does not check delivery error state`
`93`	`93`	`errc := make(chan error)`
`94`		`- ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)`
	`94`	`+ ctx, cancel := context.WithTimeout(context.Background(), 1*time.Minute)`
`95`	`95`	`defer cancel()`
`96`	`96`	`for i := int64(0); i < int64(n); i++ {`
`97`	`97`	`chunk := f(ch.DefaultSize)`
`@@ -159,8 +159,8 @@ func (r *brokenLimitedReader) Read(buf []byte) (int, error) {`
`159`	`159`	`return r.lr.Read(buf)`
`160`	`160`	`}`
`161`	`161`
`162`		`-func testStoreRandom(m ChunkStore, n int, chunksize int64, t *testing.T) {`
`163`		`- chunks, err := mputRandomChunks(m, n, chunksize)`
	`162`	`+func testStoreRandom(m ChunkStore, n int, t *testing.T) {`
	`163`	`+ chunks, err := mputRandomChunks(m, n)`
`164`	`164`	`if err != nil {`
`165`	`165`	`t.Fatalf("expected no error, got %v", err)`
`166`	`166`	`}`
`@@ -170,8 +170,8 @@ func testStoreRandom(m ChunkStore, n int, chunksize int64, t *testing.T) {`
`170`	`170`	`}`
`171`	`171`	`}`
`172`	`172`
`173`		`-func testStoreCorrect(m ChunkStore, n int, chunksize int64, t *testing.T) {`
`174`		`- chunks, err := mputRandomChunks(m, n, chunksize)`
	`173`	`+func testStoreCorrect(m ChunkStore, n int, t *testing.T) {`
	`174`	`+ chunks, err := mputRandomChunks(m, n)`
`175`	`175`	`if err != nil {`
`176`	`176`	`t.Fatalf("expected no error, got %v", err)`
`177`	`177`	`}`
`@@ -195,7 +195,7 @@ func testStoreCorrect(m ChunkStore, n int, chunksize int64, t *testing.T) {`
`195`	`195`	`}`
`196`	`196`	`}`
`197`	`197`
`198`		`-func benchmarkStorePut(store ChunkStore, n int, chunksize int64, b *testing.B) {`
	`198`	`+func benchmarkStorePut(store ChunkStore, n int, b *testing.B) {`
`199`	`199`	`chunks := make([]Chunk, n)`
`200`	`200`	`i := 0`
`201`	`201`	`f := func(dataSize int64) Chunk {`
`@@ -222,8 +222,8 @@ func benchmarkStorePut(store ChunkStore, n int, chunksize int64, b *testing.B) {`
`222`	`222`	`}`
`223`	`223`	`}`
`224`	`224`
`225`		`-func benchmarkStoreGet(store ChunkStore, n int, chunksize int64, b *testing.B) {`
`226`		`- chunks, err := mputRandomChunks(store, n, chunksize)`
	`225`	`+func benchmarkStoreGet(store ChunkStore, n int, b *testing.B) {`
	`226`	`+ chunks, err := mputRandomChunks(store, n)`
`227`	`227`	`if err != nil {`
`228`	`228`	`b.Fatalf("expected no error, got %v", err)`
`229`	`229`	`}`
Original file line number	Diff line number	Diff line change
`@@ -78,22 +78,22 @@ func testPoFunc(k Address) (ret uint8) {`
`78`	`78`	`return uint8(Proximity(basekey, k[:]))`
`79`	`79`	`}`
`80`	`80`
`81`		`-func testDbStoreRandom(n int, chunksize int64, mock bool, t *testing.T) {`
	`81`	`+func testDbStoreRandom(n int, mock bool, t *testing.T) {`
`82`	`82`	`db, cleanup, err := newTestDbStore(mock, true)`
`83`	`83`	`defer cleanup()`
`84`	`84`	`if err != nil {`
`85`	`85`	`t.Fatalf("init dbStore failed: %v", err)`
`86`	`86`	`}`
`87`		`- testStoreRandom(db, n, chunksize, t)`
	`87`	`+ testStoreRandom(db, n, t)`
`88`	`88`	`}`
`89`	`89`
`90`		`-func testDbStoreCorrect(n int, chunksize int64, mock bool, t *testing.T) {`
	`90`	`+func testDbStoreCorrect(n int, mock bool, t *testing.T) {`
`91`	`91`	`db, cleanup, err := newTestDbStore(mock, false)`
`92`	`92`	`defer cleanup()`
`93`	`93`	`if err != nil {`
`94`	`94`	`t.Fatalf("init dbStore failed: %v", err)`
`95`	`95`	`}`
`96`		`- testStoreCorrect(db, n, chunksize, t)`
	`96`	`+ testStoreCorrect(db, n, t)`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`func TestMarkAccessed(t *testing.T) {`
`@@ -137,35 +137,35 @@ func TestMarkAccessed(t *testing.T) {`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`func TestDbStoreRandom_1(t *testing.T) {`
`140`		`- testDbStoreRandom(1, 0, false, t)`
	`140`	`+ testDbStoreRandom(1, false, t)`
`141`	`141`	`}`
`142`	`142`
`143`	`143`	`func TestDbStoreCorrect_1(t *testing.T) {`
`144`		`- testDbStoreCorrect(1, 4096, false, t)`
	`144`	`+ testDbStoreCorrect(1, false, t)`
`145`	`145`	`}`
`146`	`146`
`147`	`147`	`func TestDbStoreRandom_1k(t *testing.T) {`
`148`		`- testDbStoreRandom(1000, 0, false, t)`
	`148`	`+ testDbStoreRandom(1000, false, t)`
`149`	`149`	`}`
`150`	`150`
`151`	`151`	`func TestDbStoreCorrect_1k(t *testing.T) {`
`152`		`- testDbStoreCorrect(1000, 4096, false, t)`
	`152`	`+ testDbStoreCorrect(1000, false, t)`
`153`	`153`	`}`
`154`	`154`
`155`	`155`	`func TestMockDbStoreRandom_1(t *testing.T) {`
`156`		`- testDbStoreRandom(1, 0, true, t)`
	`156`	`+ testDbStoreRandom(1, true, t)`
`157`	`157`	`}`
`158`	`158`
`159`	`159`	`func TestMockDbStoreCorrect_1(t *testing.T) {`
`160`		`- testDbStoreCorrect(1, 4096, true, t)`
	`160`	`+ testDbStoreCorrect(1, true, t)`
`161`	`161`	`}`
`162`	`162`
`163`	`163`	`func TestMockDbStoreRandom_1k(t *testing.T) {`
`164`		`- testDbStoreRandom(1000, 0, true, t)`
	`164`	`+ testDbStoreRandom(1000, true, t)`
`165`	`165`	`}`
`166`	`166`
`167`	`167`	`func TestMockDbStoreCorrect_1k(t *testing.T) {`
`168`		`- testDbStoreCorrect(1000, 4096, true, t)`
	`168`	`+ testDbStoreCorrect(1000, true, t)`
`169`	`169`	`}`
`170`	`170`
`171`	`171`	`func testDbStoreNotFound(t *testing.T, mock bool) {`
`@@ -242,54 +242,38 @@ func TestMockIterator(t *testing.T) {`
`242`	`242`	`testIterator(t, true)`
`243`	`243`	`}`
`244`	`244`
`245`		`-func benchmarkDbStorePut(n int, processors int, chunksize int64, mock bool, b *testing.B) {`
	`245`	`+func benchmarkDbStorePut(n int, mock bool, b *testing.B) {`
`246`	`246`	`db, cleanup, err := newTestDbStore(mock, true)`
`247`	`247`	`defer cleanup()`
`248`	`248`	`if err != nil {`
`249`	`249`	`b.Fatalf("init dbStore failed: %v", err)`
`250`	`250`	`}`
`251`		`- benchmarkStorePut(db, n, chunksize, b)`
	`251`	`+ benchmarkStorePut(db, n, b)`
`252`	`252`	`}`
`253`	`253`
`254`		`-func benchmarkDbStoreGet(n int, processors int, chunksize int64, mock bool, b *testing.B) {`
	`254`	`+func benchmarkDbStoreGet(n int, mock bool, b *testing.B) {`
`255`	`255`	`db, cleanup, err := newTestDbStore(mock, true)`
`256`	`256`	`defer cleanup()`
`257`	`257`	`if err != nil {`
`258`	`258`	`b.Fatalf("init dbStore failed: %v", err)`
`259`	`259`	`}`
`260`		`- benchmarkStoreGet(db, n, chunksize, b)`
	`260`	`+ benchmarkStoreGet(db, n, b)`
`261`	`261`	`}`
`262`	`262`
`263`		`-func BenchmarkDbStorePut_1_500(b *testing.B) {`
`264`		`- benchmarkDbStorePut(500, 1, 4096, false, b)`
	`263`	`+func BenchmarkDbStorePut_500(b *testing.B) {`
	`264`	`+ benchmarkDbStorePut(500, false, b)`
`265`	`265`	`}`
`266`	`266`
`267`		`-func BenchmarkDbStorePut_8_500(b *testing.B) {`
`268`		`- benchmarkDbStorePut(500, 8, 4096, false, b)`
	`267`	`+func BenchmarkDbStoreGet_500(b *testing.B) {`
	`268`	`+ benchmarkDbStoreGet(500, false, b)`
`269`	`269`	`}`
`270`	`270`
`271`		`-func BenchmarkDbStoreGet_1_500(b *testing.B) {`
`272`		`- benchmarkDbStoreGet(500, 1, 4096, false, b)`
	`271`	`+func BenchmarkMockDbStorePut_500(b *testing.B) {`
	`272`	`+ benchmarkDbStorePut(500, true, b)`
`273`	`273`	`}`
`274`	`274`
`275`		`-func BenchmarkDbStoreGet_8_500(b *testing.B) {`
`276`		`- benchmarkDbStoreGet(500, 8, 4096, false, b)`
`277`		`-}`
`278`		`-`
`279`		`-func BenchmarkMockDbStorePut_1_500(b *testing.B) {`
`280`		`- benchmarkDbStorePut(500, 1, 4096, true, b)`
`281`		`-}`
`282`		`-`
`283`		`-func BenchmarkMockDbStorePut_8_500(b *testing.B) {`
`284`		`- benchmarkDbStorePut(500, 8, 4096, true, b)`
`285`		`-}`
`286`		`-`
`287`		`-func BenchmarkMockDbStoreGet_1_500(b *testing.B) {`
`288`		`- benchmarkDbStoreGet(500, 1, 4096, true, b)`
`289`		`-}`
`290`		`-`
`291`		`-func BenchmarkMockDbStoreGet_8_500(b *testing.B) {`
`292`		`- benchmarkDbStoreGet(500, 8, 4096, true, b)`
	`275`	`+func BenchmarkMockDbStoreGet_500(b *testing.B) {`
	`276`	`+ benchmarkDbStoreGet(500, true, b)`
`293`	`277`	`}`
`294`	`278`
`295`	`279`	`// 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) {`
`302`	`286`	`ldb.setCapacity(uint64(capacity))`
`303`	`287`	`defer cleanup()`
`304`	`288`
`305`		`- chunks, err := mputRandomChunks(ldb, n, int64(ch.DefaultSize))`
	`289`	`+ chunks, err := mputRandomChunks(ldb, n)`
`306`	`290`	`if err != nil {`
`307`	`291`	`t.Fatal(err.Error())`
`308`	`292`	`}`
`@@ -382,7 +366,7 @@ func testLDBStoreCollectGarbage(t *testing.T) {`
`382`	`366`	`putCount = roundTarget`
`383`	`367`	`}`
`384`	`368`	`remaining -= putCount`
`385`		`- chunks, err := mputRandomChunks(ldb, putCount, int64(ch.DefaultSize))`
	`369`	`+ chunks, err := mputRandomChunks(ldb, putCount)`
`386`	`370`	`if err != nil {`
`387`	`371`	`t.Fatal(err.Error())`
`388`	`372`	`}`
`@@ -429,7 +413,7 @@ func TestLDBStoreAddRemove(t *testing.T) {`
`429`	`413`	`defer cleanup()`
`430`	`414`
`431`	`415`	`n := 100`
`432`		`- chunks, err := mputRandomChunks(ldb, n, int64(ch.DefaultSize))`
	`416`	`+ chunks, err := mputRandomChunks(ldb, n)`
`433`	`417`	`if err != nil {`
`434`	`418`	`t.Fatalf(err.Error())`
`435`	`419`	`}`
`@@ -576,7 +560,7 @@ func TestLDBStoreCollectGarbageAccessUnlikeIndex(t *testing.T) {`
`576`	`560`	`ldb.setCapacity(uint64(capacity))`
`577`	`561`	`defer cleanup()`
`578`	`562`
`579`		`- chunks, err := mputRandomChunks(ldb, n, int64(ch.DefaultSize))`
	`563`	`+ chunks, err := mputRandomChunks(ldb, n)`
`580`	`564`	`if err != nil {`
`581`	`565`	`t.Fatal(err.Error())`
`582`	`566`	`}`
`@@ -589,7 +573,7 @@ func TestLDBStoreCollectGarbageAccessUnlikeIndex(t *testing.T) {`
`589`	`573`	`t.Fatalf("fail add chunk #%d - %s: %v", i, chunks[i].Address(), err)`
`590`	`574`	`}`
`591`	`575`	`}`
`592`		`- _, err = mputRandomChunks(ldb, 2, int64(ch.DefaultSize))`
	`576`	`+ _, err = mputRandomChunks(ldb, 2)`
`593`	`577`	`if err != nil {`
`594`	`578`	`t.Fatal(err.Error())`
`595`	`579`	`}`
`@@ -621,7 +605,7 @@ func TestCleanIndex(t *testing.T) {`
`621`	`605`	`ldb.setCapacity(uint64(capacity))`
`622`	`606`	`defer cleanup()`
`623`	`607`
`624`		`- chunks, err := mputRandomChunks(ldb, n, 4096)`
	`608`	`+ chunks, err := mputRandomChunks(ldb, n)`
`625`	`609`	`if err != nil {`
`626`	`610`	`t.Fatal(err)`
`627`	`611`	`}`
`@@ -752,7 +736,7 @@ func TestCleanIndex(t *testing.T) {`
`752`	`736`	`}`
`753`	`737`
`754`	`738`	`// check that the iterator quits properly`
`755`		`- chunks, err = mputRandomChunks(ldb, 4100, 4096)`
	`739`	`+ chunks, err = mputRandomChunks(ldb, 4100)`
`756`	`740`	`if err != nil {`
`757`	`741`	`t.Fatal(err)`
`758`	`742`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,32 +28,32 @@ func newTestMemStore() *MemStore {`
`28`	`28`	`return NewMemStore(storeparams, nil)`
`29`	`29`	`}`
`30`	`30`
`31`		`-func testMemStoreRandom(n int, chunksize int64, t *testing.T) {`
	`31`	`+func testMemStoreRandom(n int, t *testing.T) {`
`32`	`32`	`m := newTestMemStore()`
`33`	`33`	`defer m.Close()`
`34`		`- testStoreRandom(m, n, chunksize, t)`
	`34`	`+ testStoreRandom(m, n, t)`
`35`	`35`	`}`
`36`	`36`
`37`		`-func testMemStoreCorrect(n int, chunksize int64, t *testing.T) {`
	`37`	`+func testMemStoreCorrect(n int, t *testing.T) {`
`38`	`38`	`m := newTestMemStore()`
`39`	`39`	`defer m.Close()`
`40`		`- testStoreCorrect(m, n, chunksize, t)`
	`40`	`+ testStoreCorrect(m, n, t)`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`func TestMemStoreRandom_1(t *testing.T) {`
`44`		`- testMemStoreRandom(1, 0, t)`
	`44`	`+ testMemStoreRandom(1, t)`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`func TestMemStoreCorrect_1(t *testing.T) {`
`48`		`- testMemStoreCorrect(1, 4104, t)`
	`48`	`+ testMemStoreCorrect(1, t)`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`func TestMemStoreRandom_1k(t *testing.T) {`
`52`		`- testMemStoreRandom(1000, 0, t)`
	`52`	`+ testMemStoreRandom(1000, t)`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`func TestMemStoreCorrect_1k(t *testing.T) {`
`56`		`- testMemStoreCorrect(100, 4096, t)`
	`56`	`+ testMemStoreCorrect(100, t)`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`func TestMemStoreNotFound(t *testing.T) {`
`@@ -66,32 +66,24 @@ func TestMemStoreNotFound(t *testing.T) {`
`66`	`66`	`}`
`67`	`67`	`}`
`68`	`68`
`69`		`-func benchmarkMemStorePut(n int, processors int, chunksize int64, b *testing.B) {`
	`69`	`+func benchmarkMemStorePut(n int, b *testing.B) {`
`70`	`70`	`m := newTestMemStore()`
`71`	`71`	`defer m.Close()`
`72`		`- benchmarkStorePut(m, n, chunksize, b)`
	`72`	`+ benchmarkStorePut(m, n, b)`
`73`	`73`	`}`
`74`	`74`
`75`		`-func benchmarkMemStoreGet(n int, processors int, chunksize int64, b *testing.B) {`
	`75`	`+func benchmarkMemStoreGet(n int, b *testing.B) {`
`76`	`76`	`m := newTestMemStore()`
`77`	`77`	`defer m.Close()`
`78`		`- benchmarkStoreGet(m, n, chunksize, b)`
	`78`	`+ benchmarkStoreGet(m, n, b)`
`79`	`79`	`}`
`80`	`80`
`81`		`-func BenchmarkMemStorePut_1_500(b *testing.B) {`
`82`		`- benchmarkMemStorePut(500, 1, 4096, b)`
	`81`	`+func BenchmarkMemStorePut_500(b *testing.B) {`
	`82`	`+ benchmarkMemStorePut(500, b)`
`83`	`83`	`}`
`84`	`84`
`85`		`-func BenchmarkMemStorePut_8_500(b *testing.B) {`
`86`		`- benchmarkMemStorePut(500, 8, 4096, b)`
`87`		`-}`
`88`		`-`
`89`		`-func BenchmarkMemStoreGet_1_500(b *testing.B) {`
`90`		`- benchmarkMemStoreGet(500, 1, 4096, b)`
`91`		`-}`
`92`		`-`
`93`		`-func BenchmarkMemStoreGet_8_500(b *testing.B) {`
`94`		`- benchmarkMemStoreGet(500, 8, 4096, b)`
	`85`	`+func BenchmarkMemStoreGet_500(b *testing.B) {`
	`86`	`+ benchmarkMemStoreGet(500, b)`
`95`	`87`	`}`
`96`	`88`
`97`	`89`	`func TestMemStoreAndLDBStore(t *testing.T) {`