github.com/linapex/ethereum-dpos-chinese@v0.0.0-20190316121959-b78b3a4a1ece/whisper/whisperv6/filter_test.go (about)

     1  
     2  //<developer>
     3  //    <name>linapex 曹一峰</name>
     4  //    <email>linapex@163.com</email>
     5  //    <wx>superexc</wx>
     6  //    <qqgroup>128148617</qqgroup>
     7  //    <url>https://jsq.ink</url>
     8  //    <role>pku engineer</role>
     9  //    <date>2019-03-16 12:09:51</date>
    10  //</624342690527449088>
    11  
    12  //
    13  //
    14  //
    15  //
    16  //
    17  //
    18  //
    19  //
    20  //
    21  //
    22  //
    23  //
    24  //
    25  //
    26  //
    27  
    28  package whisperv6
    29  
    30  import (
    31  	"math/big"
    32  	mrand "math/rand"
    33  	"testing"
    34  	"time"
    35  
    36  	"github.com/ethereum/go-ethereum/common"
    37  	"github.com/ethereum/go-ethereum/crypto"
    38  )
    39  
    40  var seed int64
    41  
    42  //
    43  //
    44  //
    45  func InitSingleTest() {
    46  	seed = time.Now().Unix()
    47  	mrand.Seed(seed)
    48  }
    49  
    50  func InitDebugTest(i int64) {
    51  	seed = i
    52  	mrand.Seed(seed)
    53  }
    54  
    55  type FilterTestCase struct {
    56  	f      *Filter
    57  	id     string
    58  	alive  bool
    59  	msgCnt int
    60  }
    61  
    62  func generateFilter(t *testing.T, symmetric bool) (*Filter, error) {
    63  	var f Filter
    64  	f.Messages = make(map[common.Hash]*ReceivedMessage)
    65  
    66  	const topicNum = 8
    67  	f.Topics = make([][]byte, topicNum)
    68  	for i := 0; i < topicNum; i++ {
    69  		f.Topics[i] = make([]byte, 4)
    70  		mrand.Read(f.Topics[i][:])
    71  		f.Topics[i][0] = 0x01
    72  	}
    73  
    74  	key, err := crypto.GenerateKey()
    75  	if err != nil {
    76  		t.Fatalf("generateFilter 1 failed with seed %d.", seed)
    77  		return nil, err
    78  	}
    79  	f.Src = &key.PublicKey
    80  
    81  	if symmetric {
    82  		f.KeySym = make([]byte, aesKeyLength)
    83  		mrand.Read(f.KeySym)
    84  		f.SymKeyHash = crypto.Keccak256Hash(f.KeySym)
    85  	} else {
    86  		f.KeyAsym, err = crypto.GenerateKey()
    87  		if err != nil {
    88  			t.Fatalf("generateFilter 2 failed with seed %d.", seed)
    89  			return nil, err
    90  		}
    91  	}
    92  
    93  //
    94  	return &f, nil
    95  }
    96  
    97  func generateTestCases(t *testing.T, SizeTestFilters int) []FilterTestCase {
    98  	cases := make([]FilterTestCase, SizeTestFilters)
    99  	for i := 0; i < SizeTestFilters; i++ {
   100  		f, _ := generateFilter(t, true)
   101  		cases[i].f = f
   102  		cases[i].alive = mrand.Int()&int(1) == 0
   103  	}
   104  	return cases
   105  }
   106  
   107  func TestInstallFilters(t *testing.T) {
   108  	InitSingleTest()
   109  
   110  	const SizeTestFilters = 256
   111  	w := New(&Config{})
   112  	filters := NewFilters(w)
   113  	tst := generateTestCases(t, SizeTestFilters)
   114  
   115  	var err error
   116  	var j string
   117  	for i := 0; i < SizeTestFilters; i++ {
   118  		j, err = filters.Install(tst[i].f)
   119  		if err != nil {
   120  			t.Fatalf("seed %d: failed to install filter: %s", seed, err)
   121  		}
   122  		tst[i].id = j
   123  		if len(j) != keyIDSize*2 {
   124  			t.Fatalf("seed %d: wrong filter id size [%d]", seed, len(j))
   125  		}
   126  	}
   127  
   128  	for _, testCase := range tst {
   129  		if !testCase.alive {
   130  			filters.Uninstall(testCase.id)
   131  		}
   132  	}
   133  
   134  	for i, testCase := range tst {
   135  		fil := filters.Get(testCase.id)
   136  		exist := fil != nil
   137  		if exist != testCase.alive {
   138  			t.Fatalf("seed %d: failed alive: %d, %v, %v", seed, i, exist, testCase.alive)
   139  		}
   140  		if exist && fil.PoW != testCase.f.PoW {
   141  			t.Fatalf("seed %d: failed Get: %d, %v, %v", seed, i, exist, testCase.alive)
   142  		}
   143  	}
   144  }
   145  
   146  func TestInstallSymKeyGeneratesHash(t *testing.T) {
   147  	InitSingleTest()
   148  
   149  	w := New(&Config{})
   150  	filters := NewFilters(w)
   151  	filter, _ := generateFilter(t, true)
   152  
   153  //
   154  	initialSymKeyHash := filter.SymKeyHash
   155  
   156  //
   157  	var invalid common.Hash
   158  	filter.SymKeyHash = invalid
   159  
   160  	_, err := filters.Install(filter)
   161  
   162  	if err != nil {
   163  		t.Fatalf("Error installing the filter: %s", err)
   164  	}
   165  
   166  	for i, b := range filter.SymKeyHash {
   167  		if b != initialSymKeyHash[i] {
   168  			t.Fatalf("The filter's symmetric key hash was not properly generated by Install")
   169  		}
   170  	}
   171  }
   172  
   173  func TestInstallIdenticalFilters(t *testing.T) {
   174  	InitSingleTest()
   175  
   176  	w := New(&Config{})
   177  	filters := NewFilters(w)
   178  	filter1, _ := generateFilter(t, true)
   179  
   180  //
   181  //
   182  	filter2 := &Filter{
   183  		KeySym:   filter1.KeySym,
   184  		Topics:   filter1.Topics,
   185  		PoW:      filter1.PoW,
   186  		AllowP2P: filter1.AllowP2P,
   187  		Messages: make(map[common.Hash]*ReceivedMessage),
   188  	}
   189  
   190  	_, err := filters.Install(filter1)
   191  
   192  	if err != nil {
   193  		t.Fatalf("Error installing the first filter with seed %d: %s", seed, err)
   194  	}
   195  
   196  	_, err = filters.Install(filter2)
   197  
   198  	if err != nil {
   199  		t.Fatalf("Error installing the second filter with seed %d: %s", seed, err)
   200  	}
   201  
   202  	params, err := generateMessageParams()
   203  	if err != nil {
   204  		t.Fatalf("Error generating message parameters with seed %d: %s", seed, err)
   205  	}
   206  
   207  	params.KeySym = filter1.KeySym
   208  	params.Topic = BytesToTopic(filter1.Topics[0])
   209  
   210  	filter1.Src = &params.Src.PublicKey
   211  	filter2.Src = &params.Src.PublicKey
   212  
   213  	sentMessage, err := NewSentMessage(params)
   214  	if err != nil {
   215  		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
   216  	}
   217  	env, err := sentMessage.Wrap(params)
   218  	if err != nil {
   219  		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
   220  	}
   221  	msg := env.Open(filter1)
   222  	if msg == nil {
   223  		t.Fatalf("failed to Open with filter1")
   224  	}
   225  
   226  	if !filter1.MatchEnvelope(env) {
   227  		t.Fatalf("failed matching with the first filter")
   228  	}
   229  
   230  	if !filter2.MatchEnvelope(env) {
   231  		t.Fatalf("failed matching with the first filter")
   232  	}
   233  
   234  	if !filter1.MatchMessage(msg) {
   235  		t.Fatalf("failed matching with the second filter")
   236  	}
   237  
   238  	if !filter2.MatchMessage(msg) {
   239  		t.Fatalf("failed matching with the second filter")
   240  	}
   241  }
   242  
   243  func TestInstallFilterWithSymAndAsymKeys(t *testing.T) {
   244  	InitSingleTest()
   245  
   246  	w := New(&Config{})
   247  	filters := NewFilters(w)
   248  	filter1, _ := generateFilter(t, true)
   249  
   250  	asymKey, err := crypto.GenerateKey()
   251  	if err != nil {
   252  		t.Fatalf("Unable to create asymetric keys: %v", err)
   253  	}
   254  
   255  //
   256  //
   257  	filter := &Filter{
   258  		KeySym:   filter1.KeySym,
   259  		KeyAsym:  asymKey,
   260  		Topics:   filter1.Topics,
   261  		PoW:      filter1.PoW,
   262  		AllowP2P: filter1.AllowP2P,
   263  		Messages: make(map[common.Hash]*ReceivedMessage),
   264  	}
   265  
   266  	_, err = filters.Install(filter)
   267  
   268  	if err == nil {
   269  		t.Fatalf("Error detecting that a filter had both an asymmetric and symmetric key, with seed %d", seed)
   270  	}
   271  }
   272  
   273  func TestComparePubKey(t *testing.T) {
   274  	InitSingleTest()
   275  
   276  	key1, err := crypto.GenerateKey()
   277  	if err != nil {
   278  		t.Fatalf("failed to generate first key with seed %d: %s.", seed, err)
   279  	}
   280  	key2, err := crypto.GenerateKey()
   281  	if err != nil {
   282  		t.Fatalf("failed to generate second key with seed %d: %s.", seed, err)
   283  	}
   284  	if IsPubKeyEqual(&key1.PublicKey, &key2.PublicKey) {
   285  		t.Fatalf("public keys are equal, seed %d.", seed)
   286  	}
   287  
   288  //
   289  	mrand.Seed(seed)
   290  	key3, err := crypto.GenerateKey()
   291  	if err != nil {
   292  		t.Fatalf("failed to generate third key with seed %d: %s.", seed, err)
   293  	}
   294  	if IsPubKeyEqual(&key1.PublicKey, &key3.PublicKey) {
   295  		t.Fatalf("key1 == key3, seed %d.", seed)
   296  	}
   297  }
   298  
   299  func TestMatchEnvelope(t *testing.T) {
   300  	InitSingleTest()
   301  
   302  	fsym, err := generateFilter(t, true)
   303  	if err != nil {
   304  		t.Fatalf("failed generateFilter with seed %d: %s.", seed, err)
   305  	}
   306  
   307  	fasym, err := generateFilter(t, false)
   308  	if err != nil {
   309  		t.Fatalf("failed generateFilter() with seed %d: %s.", seed, err)
   310  	}
   311  
   312  	params, err := generateMessageParams()
   313  	if err != nil {
   314  		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
   315  	}
   316  
   317  params.Topic[0] = 0xFF //
   318  
   319  	msg, err := NewSentMessage(params)
   320  	if err != nil {
   321  		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
   322  	}
   323  	env, err := msg.Wrap(params)
   324  	if err != nil {
   325  		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
   326  	}
   327  
   328  //
   329  	i := mrand.Int() % 4
   330  	fsym.Topics[i] = params.Topic[:]
   331  	fasym.Topics[i] = params.Topic[:]
   332  	msg, err = NewSentMessage(params)
   333  	if err != nil {
   334  		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
   335  	}
   336  	env, err = msg.Wrap(params)
   337  	if err != nil {
   338  		t.Fatalf("failed Wrap() with seed %d: %s.", seed, err)
   339  	}
   340  
   341  //
   342  	match := fsym.MatchEnvelope(env)
   343  	if !match {
   344  		t.Fatalf("failed MatchEnvelope() symmetric with seed %d.", seed)
   345  	}
   346  
   347  //
   348  	fsym.PoW = env.PoW() + 1.0
   349  	match = fsym.MatchEnvelope(env)
   350  	if match {
   351  		t.Fatalf("failed MatchEnvelope(symmetric + matching topic + insufficient PoW) asymmetric with seed %d.", seed)
   352  	}
   353  
   354  //
   355  	fsym.PoW = env.PoW() / 2
   356  	match = fsym.MatchEnvelope(env)
   357  	if !match {
   358  		t.Fatalf("failed MatchEnvelope(symmetric + matching topic + sufficient PoW) with seed %d.", seed)
   359  	}
   360  
   361  //
   362  	prevTopics := fsym.Topics
   363  	fsym.Topics = nil
   364  	match = fsym.MatchEnvelope(env)
   365  	if !match {
   366  		t.Fatalf("failed MatchEnvelope(symmetric + topics are nil) with seed %d.", seed)
   367  	}
   368  	fsym.Topics = prevTopics
   369  
   370  //
   371  	key, err := crypto.GenerateKey()
   372  	if err != nil {
   373  		t.Fatalf("failed GenerateKey with seed %d: %s.", seed, err)
   374  	}
   375  	params.KeySym = nil
   376  	params.Dst = &key.PublicKey
   377  	msg, err = NewSentMessage(params)
   378  	if err != nil {
   379  		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
   380  	}
   381  	env, err = msg.Wrap(params)
   382  	if err != nil {
   383  		t.Fatalf("failed Wrap() with seed %d: %s.", seed, err)
   384  	}
   385  
   386  //
   387  	match = fsym.MatchEnvelope(env)
   388  	if match {
   389  		t.Fatalf("failed MatchEnvelope(encryption method mismatch) with seed %d.", seed)
   390  	}
   391  
   392  //
   393  	match = fasym.MatchEnvelope(env)
   394  	if !match {
   395  		t.Fatalf("failed MatchEnvelope(asymmetric + mismatching topic) with seed %d.", seed)
   396  	}
   397  
   398  //
   399  	fasym.Topics[i] = fasym.Topics[i+1]
   400  	match = fasym.MatchEnvelope(env)
   401  	if !match {
   402  		t.Fatalf("failed MatchEnvelope(asymmetric + matching topic) with seed %d.", seed)
   403  	}
   404  
   405  //
   406  	fasym.Topics = nil
   407  	match = fasym.MatchEnvelope(env)
   408  	if !match {
   409  		t.Fatalf("failed MatchEnvelope(asymmetric + filter without topic) with seed %d.", seed)
   410  	}
   411  
   412  //
   413  	fasym.PoW = env.PoW() + 1.0
   414  	match = fasym.MatchEnvelope(env)
   415  	if match {
   416  		t.Fatalf("failed MatchEnvelope(asymmetric + insufficient PoW) with seed %d.", seed)
   417  	}
   418  
   419  //
   420  	fasym.PoW = env.PoW() / 2
   421  	match = fasym.MatchEnvelope(env)
   422  	if !match {
   423  		t.Fatalf("failed MatchEnvelope(asymmetric + sufficient PoW) with seed %d.", seed)
   424  	}
   425  
   426  //
   427  	env.Topic = TopicType{}
   428  	match = fasym.MatchEnvelope(env)
   429  	if !match {
   430  		t.Fatalf("failed MatchEnvelope(filter without topic + envelope without topic) with seed %d.", seed)
   431  	}
   432  
   433  //
   434  	fasym.Topics = fsym.Topics
   435  	match = fasym.MatchEnvelope(env)
   436  	if !match {
   437  //
   438  		t.Fatalf("failed MatchEnvelope(filter without topic + envelope without topic) with seed %d.", seed)
   439  	}
   440  }
   441  
   442  func TestMatchMessageSym(t *testing.T) {
   443  	InitSingleTest()
   444  
   445  	params, err := generateMessageParams()
   446  	if err != nil {
   447  		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
   448  	}
   449  
   450  	f, err := generateFilter(t, true)
   451  	if err != nil {
   452  		t.Fatalf("failed generateFilter with seed %d: %s.", seed, err)
   453  	}
   454  
   455  	const index = 1
   456  	params.KeySym = f.KeySym
   457  	params.Topic = BytesToTopic(f.Topics[index])
   458  
   459  	sentMessage, err := NewSentMessage(params)
   460  	if err != nil {
   461  		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
   462  	}
   463  	env, err := sentMessage.Wrap(params)
   464  	if err != nil {
   465  		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
   466  	}
   467  	msg := env.Open(f)
   468  	if msg == nil {
   469  		t.Fatalf("failed Open with seed %d.", seed)
   470  	}
   471  
   472  //
   473  	*f.Src.X = *params.Src.PublicKey.X
   474  	*f.Src.Y = *params.Src.PublicKey.Y
   475  	if !f.MatchMessage(msg) {
   476  		t.Fatalf("failed MatchEnvelope(src match) with seed %d.", seed)
   477  	}
   478  
   479  //
   480  	f.PoW = msg.PoW + 1.0
   481  	if f.MatchMessage(msg) {
   482  		t.Fatalf("failed MatchEnvelope(insufficient PoW) with seed %d.", seed)
   483  	}
   484  
   485  //
   486  	f.PoW = msg.PoW / 2
   487  	if !f.MatchMessage(msg) {
   488  		t.Fatalf("failed MatchEnvelope(sufficient PoW) with seed %d.", seed)
   489  	}
   490  
   491  //
   492  	f.Topics[index][0]++
   493  	if !f.MatchMessage(msg) {
   494  //
   495  		t.Fatalf("failed MatchEnvelope(topic mismatch) with seed %d.", seed)
   496  	}
   497  	f.Topics[index][0]--
   498  
   499  //
   500  	f.SymKeyHash[0]++
   501  	if f.MatchMessage(msg) {
   502  		t.Fatalf("failed MatchEnvelope(key mismatch) with seed %d.", seed)
   503  	}
   504  	f.SymKeyHash[0]--
   505  
   506  //
   507  	f.Src = nil
   508  	if !f.MatchMessage(msg) {
   509  		t.Fatalf("failed MatchEnvelope(src absent) with seed %d.", seed)
   510  	}
   511  
   512  //
   513  	h := f.SymKeyHash
   514  	f.SymKeyHash = common.Hash{}
   515  	if f.MatchMessage(msg) {
   516  		t.Fatalf("failed MatchEnvelope(key hash mismatch) with seed %d.", seed)
   517  	}
   518  	f.SymKeyHash = h
   519  	if !f.MatchMessage(msg) {
   520  		t.Fatalf("failed MatchEnvelope(key hash match) with seed %d.", seed)
   521  	}
   522  
   523  //
   524  	f.KeySym = nil
   525  	f.KeyAsym, err = crypto.GenerateKey()
   526  	if err != nil {
   527  		t.Fatalf("failed GenerateKey with seed %d: %s.", seed, err)
   528  	}
   529  	if f.MatchMessage(msg) {
   530  		t.Fatalf("failed MatchEnvelope(encryption method mismatch) with seed %d.", seed)
   531  	}
   532  }
   533  
   534  func TestMatchMessageAsym(t *testing.T) {
   535  	InitSingleTest()
   536  
   537  	f, err := generateFilter(t, false)
   538  	if err != nil {
   539  		t.Fatalf("failed generateFilter with seed %d: %s.", seed, err)
   540  	}
   541  
   542  	params, err := generateMessageParams()
   543  	if err != nil {
   544  		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
   545  	}
   546  
   547  	const index = 1
   548  	params.Topic = BytesToTopic(f.Topics[index])
   549  	params.Dst = &f.KeyAsym.PublicKey
   550  	keySymOrig := params.KeySym
   551  	params.KeySym = nil
   552  
   553  	sentMessage, err := NewSentMessage(params)
   554  	if err != nil {
   555  		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
   556  	}
   557  	env, err := sentMessage.Wrap(params)
   558  	if err != nil {
   559  		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
   560  	}
   561  	msg := env.Open(f)
   562  	if msg == nil {
   563  		t.Fatalf("failed to open with seed %d.", seed)
   564  	}
   565  
   566  //
   567  	*f.Src.X = *params.Src.PublicKey.X
   568  	*f.Src.Y = *params.Src.PublicKey.Y
   569  	if !f.MatchMessage(msg) {
   570  		t.Fatalf("failed MatchMessage(src match) with seed %d.", seed)
   571  	}
   572  
   573  //
   574  	f.PoW = msg.PoW + 1.0
   575  	if f.MatchMessage(msg) {
   576  		t.Fatalf("failed MatchEnvelope(insufficient PoW) with seed %d.", seed)
   577  	}
   578  
   579  //
   580  	f.PoW = msg.PoW / 2
   581  	if !f.MatchMessage(msg) {
   582  		t.Fatalf("failed MatchEnvelope(sufficient PoW) with seed %d.", seed)
   583  	}
   584  
   585  //
   586  	f.Topics[index][0]++
   587  	if !f.MatchMessage(msg) {
   588  //
   589  		t.Fatalf("failed MatchEnvelope(topic mismatch) with seed %d.", seed)
   590  	}
   591  	f.Topics[index][0]--
   592  
   593  //
   594  	prev := *f.KeyAsym.PublicKey.X
   595  	zero := *big.NewInt(0)
   596  	*f.KeyAsym.PublicKey.X = zero
   597  	if f.MatchMessage(msg) {
   598  		t.Fatalf("failed MatchEnvelope(key mismatch) with seed %d.", seed)
   599  	}
   600  	*f.KeyAsym.PublicKey.X = prev
   601  
   602  //
   603  	f.Src = nil
   604  	if !f.MatchMessage(msg) {
   605  		t.Fatalf("failed MatchEnvelope(src absent) with seed %d.", seed)
   606  	}
   607  
   608  //
   609  	f.KeySym = keySymOrig
   610  	f.KeyAsym = nil
   611  	if f.MatchMessage(msg) {
   612  		t.Fatalf("failed MatchEnvelope(encryption method mismatch) with seed %d.", seed)
   613  	}
   614  }
   615  
   616  func cloneFilter(orig *Filter) *Filter {
   617  	var clone Filter
   618  	clone.Messages = make(map[common.Hash]*ReceivedMessage)
   619  	clone.Src = orig.Src
   620  	clone.KeyAsym = orig.KeyAsym
   621  	clone.KeySym = orig.KeySym
   622  	clone.Topics = orig.Topics
   623  	clone.PoW = orig.PoW
   624  	clone.AllowP2P = orig.AllowP2P
   625  	clone.SymKeyHash = orig.SymKeyHash
   626  	return &clone
   627  }
   628  
   629  func generateCompatibeEnvelope(t *testing.T, f *Filter) *Envelope {
   630  	params, err := generateMessageParams()
   631  	if err != nil {
   632  		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
   633  		return nil
   634  	}
   635  
   636  	params.KeySym = f.KeySym
   637  	params.Topic = BytesToTopic(f.Topics[2])
   638  	sentMessage, err := NewSentMessage(params)
   639  	if err != nil {
   640  		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
   641  	}
   642  	env, err := sentMessage.Wrap(params)
   643  	if err != nil {
   644  		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
   645  		return nil
   646  	}
   647  	return env
   648  }
   649  
   650  func TestWatchers(t *testing.T) {
   651  	InitSingleTest()
   652  
   653  	const NumFilters = 16
   654  	const NumMessages = 256
   655  	var i int
   656  	var j uint32
   657  	var e *Envelope
   658  	var x, firstID string
   659  	var err error
   660  
   661  	w := New(&Config{})
   662  	filters := NewFilters(w)
   663  	tst := generateTestCases(t, NumFilters)
   664  	for i = 0; i < NumFilters; i++ {
   665  		tst[i].f.Src = nil
   666  		x, err = filters.Install(tst[i].f)
   667  		if err != nil {
   668  			t.Fatalf("failed to install filter with seed %d: %s.", seed, err)
   669  		}
   670  		tst[i].id = x
   671  		if len(firstID) == 0 {
   672  			firstID = x
   673  		}
   674  	}
   675  
   676  	lastID := x
   677  
   678  	var envelopes [NumMessages]*Envelope
   679  	for i = 0; i < NumMessages; i++ {
   680  		j = mrand.Uint32() % NumFilters
   681  		e = generateCompatibeEnvelope(t, tst[j].f)
   682  		envelopes[i] = e
   683  		tst[j].msgCnt++
   684  	}
   685  
   686  	for i = 0; i < NumMessages; i++ {
   687  		filters.NotifyWatchers(envelopes[i], false)
   688  	}
   689  
   690  	var total int
   691  	var mail []*ReceivedMessage
   692  	var count [NumFilters]int
   693  
   694  	for i = 0; i < NumFilters; i++ {
   695  		mail = tst[i].f.Retrieve()
   696  		count[i] = len(mail)
   697  		total += len(mail)
   698  	}
   699  
   700  	if total != NumMessages {
   701  		t.Fatalf("failed with seed %d: total = %d, want: %d.", seed, total, NumMessages)
   702  	}
   703  
   704  	for i = 0; i < NumFilters; i++ {
   705  		mail = tst[i].f.Retrieve()
   706  		if len(mail) != 0 {
   707  			t.Fatalf("failed with seed %d: i = %d.", seed, i)
   708  		}
   709  
   710  		if tst[i].msgCnt != count[i] {
   711  			t.Fatalf("failed with seed %d: count[%d]: get %d, want %d.", seed, i, tst[i].msgCnt, count[i])
   712  		}
   713  	}
   714  
   715  //
   716  
   717  	clone := cloneFilter(tst[0].f)
   718  	filters.Uninstall(lastID)
   719  	total = 0
   720  	last := NumFilters - 1
   721  	tst[last].f = clone
   722  	filters.Install(clone)
   723  	for i = 0; i < NumFilters; i++ {
   724  		tst[i].msgCnt = 0
   725  		count[i] = 0
   726  	}
   727  
   728  //
   729  	e = generateCompatibeEnvelope(t, tst[0].f)
   730  	envelopes[0] = e
   731  	tst[0].msgCnt++
   732  	for i = 1; i < NumMessages; i++ {
   733  		j = mrand.Uint32() % NumFilters
   734  		e = generateCompatibeEnvelope(t, tst[j].f)
   735  		envelopes[i] = e
   736  		tst[j].msgCnt++
   737  	}
   738  
   739  	for i = 0; i < NumMessages; i++ {
   740  		filters.NotifyWatchers(envelopes[i], false)
   741  	}
   742  
   743  	for i = 0; i < NumFilters; i++ {
   744  		mail = tst[i].f.Retrieve()
   745  		count[i] = len(mail)
   746  		total += len(mail)
   747  	}
   748  
   749  	combined := tst[0].msgCnt + tst[last].msgCnt
   750  	if total != NumMessages+count[0] {
   751  		t.Fatalf("failed with seed %d: total = %d, count[0] = %d.", seed, total, count[0])
   752  	}
   753  
   754  	if combined != count[0] {
   755  		t.Fatalf("failed with seed %d: combined = %d, count[0] = %d.", seed, combined, count[0])
   756  	}
   757  
   758  	if combined != count[last] {
   759  		t.Fatalf("failed with seed %d: combined = %d, count[last] = %d.", seed, combined, count[last])
   760  	}
   761  
   762  	for i = 1; i < NumFilters-1; i++ {
   763  		mail = tst[i].f.Retrieve()
   764  		if len(mail) != 0 {
   765  			t.Fatalf("failed with seed %d: i = %d.", seed, i)
   766  		}
   767  
   768  		if tst[i].msgCnt != count[i] {
   769  			t.Fatalf("failed with seed %d: i = %d, get %d, want %d.", seed, i, tst[i].msgCnt, count[i])
   770  		}
   771  	}
   772  
   773  //
   774  
   775  	total = 0
   776  	filters.NotifyWatchers(envelopes[0], true)
   777  
   778  	for i = 0; i < NumFilters; i++ {
   779  		mail = tst[i].f.Retrieve()
   780  		total += len(mail)
   781  	}
   782  
   783  	if total != 0 {
   784  		t.Fatalf("failed with seed %d: total: got %d, want 0.", seed, total)
   785  	}
   786  
   787  	f := filters.Get(firstID)
   788  	if f == nil {
   789  		t.Fatalf("failed to get the filter with seed %d.", seed)
   790  	}
   791  	f.AllowP2P = true
   792  	total = 0
   793  	filters.NotifyWatchers(envelopes[0], true)
   794  
   795  	for i = 0; i < NumFilters; i++ {
   796  		mail = tst[i].f.Retrieve()
   797  		total += len(mail)
   798  	}
   799  
   800  	if total != 1 {
   801  		t.Fatalf("failed with seed %d: total: got %d, want 1.", seed, total)
   802  	}
   803  }
   804  
   805  func TestVariableTopics(t *testing.T) {
   806  	InitSingleTest()
   807  
   808  	const lastTopicByte = 3
   809  	var match bool
   810  	params, err := generateMessageParams()
   811  	if err != nil {
   812  		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
   813  	}
   814  	msg, err := NewSentMessage(params)
   815  	if err != nil {
   816  		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
   817  	}
   818  	env, err := msg.Wrap(params)
   819  	if err != nil {
   820  		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
   821  	}
   822  
   823  	f, err := generateFilter(t, true)
   824  	if err != nil {
   825  		t.Fatalf("failed generateFilter with seed %d: %s.", seed, err)
   826  	}
   827  
   828  	for i := 0; i < 4; i++ {
   829  		env.Topic = BytesToTopic(f.Topics[i])
   830  		match = f.MatchEnvelope(env)
   831  		if !match {
   832  			t.Fatalf("failed MatchEnvelope symmetric with seed %d, step %d.", seed, i)
   833  		}
   834  
   835  		f.Topics[i][lastTopicByte]++
   836  		match = f.MatchEnvelope(env)
   837  		if !match {
   838  //
   839  			t.Fatalf("MatchEnvelope symmetric with seed %d, step %d.", seed, i)
   840  		}
   841  	}
   842  }
   843