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 = ¶ms.Src.PublicKey 211 filter2.Src = ¶ms.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