github.com/sberex/go-sberex@v1.8.2-0.20181113200658-ed96ac38f7d7/swarm/storage/dpa_test.go (about)

     1  // This file is part of the go-sberex library. The go-sberex library is 
     2  // free software: you can redistribute it and/or modify it under the terms 
     3  // of the GNU Lesser General Public License as published by the Free 
     4  // Software Foundation, either version 3 of the License, or (at your option)
     5  // any later version.
     6  //
     7  // The go-sberex library is distributed in the hope that it will be useful, 
     8  // but WITHOUT ANY WARRANTY; without even the implied warranty of
     9  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser 
    10  // General Public License <http://www.gnu.org/licenses/> for more details.
    11  
    12  package storage
    13  
    14  import (
    15  	"bytes"
    16  	"io"
    17  	"io/ioutil"
    18  	"os"
    19  	"sync"
    20  	"testing"
    21  )
    22  
    23  const testDataSize = 0x1000000
    24  
    25  func TestDPArandom(t *testing.T) {
    26  	dbStore := initDbStore(t)
    27  	dbStore.setCapacity(50000)
    28  	memStore := NewMemStore(dbStore, defaultCacheCapacity)
    29  	localStore := &LocalStore{
    30  		memStore,
    31  		dbStore,
    32  	}
    33  	chunker := NewTreeChunker(NewChunkerParams())
    34  	dpa := &DPA{
    35  		Chunker:    chunker,
    36  		ChunkStore: localStore,
    37  	}
    38  	dpa.Start()
    39  	defer dpa.Stop()
    40  	defer os.RemoveAll("/tmp/bzz")
    41  
    42  	reader, slice := testDataReaderAndSlice(testDataSize)
    43  	wg := &sync.WaitGroup{}
    44  	key, err := dpa.Store(reader, testDataSize, wg, nil)
    45  	if err != nil {
    46  		t.Errorf("Store error: %v", err)
    47  	}
    48  	wg.Wait()
    49  	resultReader := dpa.Retrieve(key)
    50  	resultSlice := make([]byte, len(slice))
    51  	n, err := resultReader.ReadAt(resultSlice, 0)
    52  	if err != io.EOF {
    53  		t.Errorf("Retrieve error: %v", err)
    54  	}
    55  	if n != len(slice) {
    56  		t.Errorf("Slice size error got %d, expected %d.", n, len(slice))
    57  	}
    58  	if !bytes.Equal(slice, resultSlice) {
    59  		t.Errorf("Comparison error.")
    60  	}
    61  	ioutil.WriteFile("/tmp/slice.bzz.16M", slice, 0666)
    62  	ioutil.WriteFile("/tmp/result.bzz.16M", resultSlice, 0666)
    63  	localStore.memStore = NewMemStore(dbStore, defaultCacheCapacity)
    64  	resultReader = dpa.Retrieve(key)
    65  	for i := range resultSlice {
    66  		resultSlice[i] = 0
    67  	}
    68  	n, err = resultReader.ReadAt(resultSlice, 0)
    69  	if err != io.EOF {
    70  		t.Errorf("Retrieve error after removing memStore: %v", err)
    71  	}
    72  	if n != len(slice) {
    73  		t.Errorf("Slice size error after removing memStore got %d, expected %d.", n, len(slice))
    74  	}
    75  	if !bytes.Equal(slice, resultSlice) {
    76  		t.Errorf("Comparison error after removing memStore.")
    77  	}
    78  }
    79  
    80  func TestDPA_capacity(t *testing.T) {
    81  	dbStore := initDbStore(t)
    82  	memStore := NewMemStore(dbStore, defaultCacheCapacity)
    83  	localStore := &LocalStore{
    84  		memStore,
    85  		dbStore,
    86  	}
    87  	memStore.setCapacity(0)
    88  	chunker := NewTreeChunker(NewChunkerParams())
    89  	dpa := &DPA{
    90  		Chunker:    chunker,
    91  		ChunkStore: localStore,
    92  	}
    93  	dpa.Start()
    94  	reader, slice := testDataReaderAndSlice(testDataSize)
    95  	wg := &sync.WaitGroup{}
    96  	key, err := dpa.Store(reader, testDataSize, wg, nil)
    97  	if err != nil {
    98  		t.Errorf("Store error: %v", err)
    99  	}
   100  	wg.Wait()
   101  	resultReader := dpa.Retrieve(key)
   102  	resultSlice := make([]byte, len(slice))
   103  	n, err := resultReader.ReadAt(resultSlice, 0)
   104  	if err != io.EOF {
   105  		t.Errorf("Retrieve error: %v", err)
   106  	}
   107  	if n != len(slice) {
   108  		t.Errorf("Slice size error got %d, expected %d.", n, len(slice))
   109  	}
   110  	if !bytes.Equal(slice, resultSlice) {
   111  		t.Errorf("Comparison error.")
   112  	}
   113  	// Clear memStore
   114  	memStore.setCapacity(0)
   115  	// check whether it is, indeed, empty
   116  	dpa.ChunkStore = memStore
   117  	resultReader = dpa.Retrieve(key)
   118  	if _, err = resultReader.ReadAt(resultSlice, 0); err == nil {
   119  		t.Errorf("Was able to read %d bytes from an empty memStore.", len(slice))
   120  	}
   121  	// check how it works with localStore
   122  	dpa.ChunkStore = localStore
   123  	//	localStore.dbStore.setCapacity(0)
   124  	resultReader = dpa.Retrieve(key)
   125  	for i := range resultSlice {
   126  		resultSlice[i] = 0
   127  	}
   128  	n, err = resultReader.ReadAt(resultSlice, 0)
   129  	if err != io.EOF {
   130  		t.Errorf("Retrieve error after clearing memStore: %v", err)
   131  	}
   132  	if n != len(slice) {
   133  		t.Errorf("Slice size error after clearing memStore got %d, expected %d.", n, len(slice))
   134  	}
   135  	if !bytes.Equal(slice, resultSlice) {
   136  		t.Errorf("Comparison error after clearing memStore.")
   137  	}
   138  }