github.com/arieschain/arieschain@v0.0.0-20191023063405-37c074544356/qct/filters/filter_test.go (about)

     1  package filters
     2  
     3  import (
     4  	"context"
     5  	"io/ioutil"
     6  	"math/big"
     7  	"os"
     8  	"testing"
     9  
    10  	"github.com/quickchainproject/quickchain/common"
    11  	"github.com/quickchainproject/quickchain/consensus/qcthash"
    12  	"github.com/quickchainproject/quickchain/core"
    13  	"github.com/quickchainproject/quickchain/core/types"
    14  	"github.com/quickchainproject/quickchain/crypto"
    15  	"github.com/quickchainproject/quickchain/event"
    16  	"github.com/quickchainproject/quickchain/qctdb"
    17  	"github.com/quickchainproject/quickchain/params"
    18  )
    19  
    20  func makeReceipt(addr common.Address) *types.Receipt {
    21  	receipt := types.NewReceipt(nil, false, 0)
    22  	receipt.Logs = []*types.Log{
    23  		{Address: addr},
    24  	}
    25  	receipt.Bloom = types.CreateBloom(types.Receipts{receipt})
    26  	return receipt
    27  }
    28  
    29  func BenchmarkFilters(b *testing.B) {
    30  	dir, err := ioutil.TempDir("", "filtertest")
    31  	if err != nil {
    32  		b.Fatal(err)
    33  	}
    34  	defer os.RemoveAll(dir)
    35  
    36  	var (
    37  		db, _      = qctdb.NewLDBDatabase(dir, 0, 0)
    38  		mux        = new(event.TypeMux)
    39  		txFeed     = new(event.Feed)
    40  		rmLogsFeed = new(event.Feed)
    41  		logsFeed   = new(event.Feed)
    42  		chainFeed  = new(event.Feed)
    43  		backend    = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed}
    44  		key1, _    = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
    45  		addr1      = crypto.PubkeyToAddress(key1.PublicKey)
    46  		addr2      = common.BytesToAddress([]byte("jeff"))
    47  		addr3      = common.BytesToAddress([]byte("quickchain"))
    48  		addr4      = common.BytesToAddress([]byte("random addresses please"))
    49  	)
    50  	defer db.Close()
    51  
    52  	genesis := core.GenesisBlockForTesting(db, addr1, big.NewInt(1000000))
    53  	chain, receipts := core.GenerateChain(params.TestChainConfig, genesis, qcthash.NewFaker(), db, 100010, func(i int, gen *core.BlockGen) {
    54  		switch i {
    55  		case 2403:
    56  			receipt := makeReceipt(addr1)
    57  			gen.AddUncheckedReceipt(receipt)
    58  		case 1034:
    59  			receipt := makeReceipt(addr2)
    60  			gen.AddUncheckedReceipt(receipt)
    61  		case 34:
    62  			receipt := makeReceipt(addr3)
    63  			gen.AddUncheckedReceipt(receipt)
    64  		case 99999:
    65  			receipt := makeReceipt(addr4)
    66  			gen.AddUncheckedReceipt(receipt)
    67  
    68  		}
    69  	})
    70  	for i, block := range chain {
    71  		core.WriteBlock(db, block)
    72  		if err := core.WriteCanonicalHash(db, block.Hash(), block.NumberU64()); err != nil {
    73  			b.Fatalf("failed to insert block number: %v", err)
    74  		}
    75  		if err := core.WriteHeadBlockHash(db, block.Hash()); err != nil {
    76  			b.Fatalf("failed to insert block number: %v", err)
    77  		}
    78  		if err := core.WriteBlockReceipts(db, block.Hash(), block.NumberU64(), receipts[i]); err != nil {
    79  			b.Fatal("error writing block receipts:", err)
    80  		}
    81  	}
    82  	b.ResetTimer()
    83  
    84  	filter := New(backend, 0, -1, []common.Address{addr1, addr2, addr3, addr4}, nil)
    85  
    86  	for i := 0; i < b.N; i++ {
    87  		logs, _ := filter.Logs(context.Background())
    88  		if len(logs) != 4 {
    89  			b.Fatal("expected 4 logs, got", len(logs))
    90  		}
    91  	}
    92  }
    93  
    94  func TestFilters(t *testing.T) {
    95  	dir, err := ioutil.TempDir("", "filtertest")
    96  	if err != nil {
    97  		t.Fatal(err)
    98  	}
    99  	defer os.RemoveAll(dir)
   100  
   101  	var (
   102  		db, _      = qctdb.NewLDBDatabase(dir, 0, 0)
   103  		mux        = new(event.TypeMux)
   104  		txFeed     = new(event.Feed)
   105  		rmLogsFeed = new(event.Feed)
   106  		logsFeed   = new(event.Feed)
   107  		chainFeed  = new(event.Feed)
   108  		backend    = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed}
   109  		key1, _    = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
   110  		addr       = crypto.PubkeyToAddress(key1.PublicKey)
   111  
   112  		hash1 = common.BytesToHash([]byte("topic1"))
   113  		hash2 = common.BytesToHash([]byte("topic2"))
   114  		hash3 = common.BytesToHash([]byte("topic3"))
   115  		hash4 = common.BytesToHash([]byte("topic4"))
   116  	)
   117  	defer db.Close()
   118  
   119  	genesis := core.GenesisBlockForTesting(db, addr, big.NewInt(1000000))
   120  	chain, receipts := core.GenerateChain(params.TestChainConfig, genesis, qcthash.NewFaker(), db, 1000, func(i int, gen *core.BlockGen) {
   121  		switch i {
   122  		case 1:
   123  			receipt := types.NewReceipt(nil, false, 0)
   124  			receipt.Logs = []*types.Log{
   125  				{
   126  					Address: addr,
   127  					Topics:  []common.Hash{hash1},
   128  				},
   129  			}
   130  			gen.AddUncheckedReceipt(receipt)
   131  		case 2:
   132  			receipt := types.NewReceipt(nil, false, 0)
   133  			receipt.Logs = []*types.Log{
   134  				{
   135  					Address: addr,
   136  					Topics:  []common.Hash{hash2},
   137  				},
   138  			}
   139  			gen.AddUncheckedReceipt(receipt)
   140  		case 998:
   141  			receipt := types.NewReceipt(nil, false, 0)
   142  			receipt.Logs = []*types.Log{
   143  				{
   144  					Address: addr,
   145  					Topics:  []common.Hash{hash3},
   146  				},
   147  			}
   148  			gen.AddUncheckedReceipt(receipt)
   149  		case 999:
   150  			receipt := types.NewReceipt(nil, false, 0)
   151  			receipt.Logs = []*types.Log{
   152  				{
   153  					Address: addr,
   154  					Topics:  []common.Hash{hash4},
   155  				},
   156  			}
   157  			gen.AddUncheckedReceipt(receipt)
   158  		}
   159  	})
   160  	for i, block := range chain {
   161  		core.WriteBlock(db, block)
   162  		if err := core.WriteCanonicalHash(db, block.Hash(), block.NumberU64()); err != nil {
   163  			t.Fatalf("failed to insert block number: %v", err)
   164  		}
   165  		if err := core.WriteHeadBlockHash(db, block.Hash()); err != nil {
   166  			t.Fatalf("failed to insert block number: %v", err)
   167  		}
   168  		if err := core.WriteBlockReceipts(db, block.Hash(), block.NumberU64(), receipts[i]); err != nil {
   169  			t.Fatal("error writing block receipts:", err)
   170  		}
   171  	}
   172  
   173  	filter := New(backend, 0, -1, []common.Address{addr}, [][]common.Hash{{hash1, hash2, hash3, hash4}})
   174  
   175  	logs, _ := filter.Logs(context.Background())
   176  	if len(logs) != 4 {
   177  		t.Error("expected 4 log, got", len(logs))
   178  	}
   179  
   180  	filter = New(backend, 900, 999, []common.Address{addr}, [][]common.Hash{{hash3}})
   181  	logs, _ = filter.Logs(context.Background())
   182  	if len(logs) != 1 {
   183  		t.Error("expected 1 log, got", len(logs))
   184  	}
   185  	if len(logs) > 0 && logs[0].Topics[0] != hash3 {
   186  		t.Errorf("expected log[0].Topics[0] to be %x, got %x", hash3, logs[0].Topics[0])
   187  	}
   188  
   189  	filter = New(backend, 990, -1, []common.Address{addr}, [][]common.Hash{{hash3}})
   190  	logs, _ = filter.Logs(context.Background())
   191  	if len(logs) != 1 {
   192  		t.Error("expected 1 log, got", len(logs))
   193  	}
   194  	if len(logs) > 0 && logs[0].Topics[0] != hash3 {
   195  		t.Errorf("expected log[0].Topics[0] to be %x, got %x", hash3, logs[0].Topics[0])
   196  	}
   197  
   198  	filter = New(backend, 1, 10, nil, [][]common.Hash{{hash1, hash2}})
   199  
   200  	logs, _ = filter.Logs(context.Background())
   201  	if len(logs) != 2 {
   202  		t.Error("expected 2 log, got", len(logs))
   203  	}
   204  
   205  	failHash := common.BytesToHash([]byte("fail"))
   206  	filter = New(backend, 0, -1, nil, [][]common.Hash{{failHash}})
   207  
   208  	logs, _ = filter.Logs(context.Background())
   209  	if len(logs) != 0 {
   210  		t.Error("expected 0 log, got", len(logs))
   211  	}
   212  
   213  	failAddr := common.BytesToAddress([]byte("failmenow"))
   214  	filter = New(backend, 0, -1, []common.Address{failAddr}, nil)
   215  
   216  	logs, _ = filter.Logs(context.Background())
   217  	if len(logs) != 0 {
   218  		t.Error("expected 0 log, got", len(logs))
   219  	}
   220  
   221  	filter = New(backend, 0, -1, nil, [][]common.Hash{{failHash}, {hash1}})
   222  
   223  	logs, _ = filter.Logs(context.Background())
   224  	if len(logs) != 0 {
   225  		t.Error("expected 0 log, got", len(logs))
   226  	}
   227  }