forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-07-19 19:30:44 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

abstract out testStore + randomChunks into common_test

Browse source
This commit is contained in:
zelig 2015-02-04 13:55:59 +01:00
parent 8e6ef48a28
commit 60931dfaa3
4 changed files with 101 additions and 162 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

97
bzz/common_test.go Normal file
View file

@ -0,0 +1,97 @@
package bzz
import (
"crypto/rand"
"testing"
)
func randomChunks(l int64, branches int64, chunkC chan *Chunk) (key Key, errC chan error) {
chunker := &TreeChunker{
Branches: branches,
}
chunker.Init()
key = make([]byte, 32)
b := make([]byte, l)
_, err := rand.Read(b)
if err != nil {
panic("no rand")
}
errC = chunker.Split(key, NewChunkReaderFromBytes(b), chunkC)
return
}
func testStore(m ChunkStore, l int64, branches int64, t *testing.T) {
chunkC := make(chan *Chunk)
key, errC := randomChunks(l, branches, chunkC)
SPLIT:
for {
select {
case chunk := <-chunkC:
chunk.Data = make([]byte, chunk.Reader.Size())
chunk.Reader.ReadAt(chunk.Data, 0)
m.Put(chunk)
case err, ok := <-errC:
if err != nil {
t.Errorf("Chunker error: %v", err)
return
}
if !ok {
t.Logf("quitting SPLIT loop\n")
break SPLIT
}
}
}
chunker := &TreeChunker{
Branches: branches,
}
chunker.Init()
chunkC = make(chan *Chunk)
var r LazySectionReader
r, errC = chunker.Join(key, chunkC)
quit := make(chan bool)
go func() {
JOIN:
for {
select {
case chunk := <-chunkC:
go func() {
storedChunk, err := m.Get(chunk.Key)
if err == notFound {
t.Errorf("Chunk not found: %v", err)
return
}
if err != nil {
t.Errorf("GET error: %v", err)
return
}
chunk.Reader = NewChunkReaderFromBytes(storedChunk.Data)
chunk.Size = storedChunk.Size
close(chunk.C)
}()
case err, ok := <-errC:
if err != nil {
t.Errorf("Chunker error: %v", err)
return
}
if !ok {
break JOIN
}
case <-quit:
break JOIN
}
}
}()
b := make([]byte, l)
n, err := r.ReadAt(b, 0)
if err != nil {
t.Errorf("read error (%v/%v) %v", n, l, err)
close(quit)
}
}

73
bzz/dbstore_test.go
View file

@ -15,78 +15,7 @@ func testDbStore(l int64, branches int64, t *testing.T) {
panic("no dbStore")
}
defer m.close()
chunkC := make(chan *Chunk)
key, errC := randomChunks(l, branches, chunkC)
SPLIT:
for {
select {
case chunk := <-chunkC:
chunk.Data = make([]byte, chunk.Reader.Size())
chunk.Reader.ReadAt(chunk.Data, 0)
m.Put(chunk)
case err, ok := <-errC:
if err != nil {
t.Errorf("Chunker error: %v", err)
return
}
if !ok {
t.Logf("quitting SPLIT loop\n")
break SPLIT
}
}
}
chunker := &TreeChunker{
Branches: branches,
}
chunker.Init()
chunkC = make(chan *Chunk)
var r LazySectionReader
r, errC = chunker.Join(key, chunkC)
quit := make(chan bool)
go func() {
JOIN:
for {
select {
case chunk := <-chunkC:
go func() {
storedChunk, err := m.Get(chunk.Key)
if err == notFound {
t.Errorf("Chunk not found: %v", err)
return
}
if err != nil {
t.Errorf("GET error: %v", err)
return
}
chunk.Reader = NewChunkReaderFromBytes(storedChunk.Data)
chunk.Size = storedChunk.Size
close(chunk.C)
}()
case err, ok := <-errC:
if err != nil {
t.Errorf("Chunker error: %v", err)
return
}
if !ok {
break JOIN
}
case <-quit:
break JOIN
}
}
}()
b := make([]byte, l)
n, err := r.ReadAt(b, 0)
if err != nil {
t.Errorf("read error (%v/%v) %v", n, l, err)
close(quit)
}
testStore(m, l, branches, t)
}
func TestDbStore128_10000(t *testing.T) {

4
bzz/dpa.go
View file

@ -56,7 +56,7 @@ type Chunk struct {
type ChunkStore interface {
Put(*Chunk) // effectively there is no error even if there is no error
Get() (*Chunk, error)
Get(Key) (*Chunk, error)
}
func (self *DPA) Retrieve(key Key) (data LazySectionReader, err error) {
@ -151,7 +151,7 @@ func (self *DPA) retrieveLoop() {
for chunk := range self.retrieveC {
go func() {
for _, store := range self.Stores {
if _, err := store.Get(); err != nil { // no waiting/blocking here
if _, err := store.Get(chunk.Key); err != nil { // no waiting/blocking here
dpaLogger.DebugDetailf("%v retrieving chunk %x: %v", store, chunk.Key, err)
}
}

89
bzz/memstore_test.go
View file

@ -1,101 +1,14 @@
package bzz
import (
"crypto/rand"
"testing"
"github.com/ethereum/go-ethereum/bzz/test"
)
func randomChunks(l int64, branches int64, chunkC chan *Chunk) (key Key, errC chan error) {
chunker := &TreeChunker{
Branches: branches,
}
chunker.Init()
key = make([]byte, 32)
b := make([]byte, l)
_, err := rand.Read(b)
if err != nil {
panic("no rand")
}
errC = chunker.Split(key, NewChunkReaderFromBytes(b), chunkC)
return
}
func testMemStore(l int64, branches int64, t *testing.T) {
m := newMemStore(nil)
chunkC := make(chan *Chunk)
key, errC := randomChunks(l, branches, chunkC)
SPLIT:
for {
select {
case chunk := <-chunkC:
chunk.Data = make([]byte, chunk.Reader.Size())
chunk.Reader.ReadAt(chunk.Data, 0)
m.Put(chunk)
case err, ok := <-errC:
if err != nil {
t.Errorf("Chunker error: %v", err)
return
}
if !ok {
t.Logf("quitting SPLIT loop\n")
break SPLIT
}
}
}
chunker := &TreeChunker{
Branches: branches,
}
chunker.Init()
chunkC = make(chan *Chunk)
var r LazySectionReader
r, errC = chunker.Join(key, chunkC)
quit := make(chan bool)
go func() {
JOIN:
for {
select {
case chunk := <-chunkC:
go func() {
storedChunk, err := m.Get(chunk.Key)
if err == notFound {
t.Errorf("Chunk not found: %v", err)
return
}
if err != nil {
t.Errorf("GET error: %v", err)
return
}
chunk.Reader = NewChunkReaderFromBytes(storedChunk.Data)
chunk.Size = storedChunk.Size
close(chunk.C)
}()
case err, ok := <-errC:
if err != nil {
t.Errorf("Chunker error: %v", err)
return
}
if !ok {
break JOIN
}
case <-quit:
break JOIN
}
}
}()
b := make([]byte, l)
n, err := r.ReadAt(b, 0)
if err != nil {
t.Errorf("read error (%v/%v) %v", n, l, err)
close(quit)
}
testStore(m, l, branches, t)
}
func TestMemStore128_10000(t *testing.T) {