diff --git a/whisper/shhapi/api_test.go b/whisper/shhapi/api_test.go index 00b7db1888..820d4f01d8 100644 --- a/whisper/shhapi/api_test.go +++ b/whisper/shhapi/api_test.go @@ -30,78 +30,64 @@ func TestBasic(x *testing.T) { var id string = "test" api := NewPublicWhisperAPI() if api == nil { - x.Errorf("failed to create API.") - return + x.Fatalf("failed to create API.") } ver, err := api.Version() if err != nil { - x.Errorf("failed generateFilter: %s.", err) - return + x.Fatalf("failed generateFilter: %s.", err) } if ver.Uint64() != whisperv5.ProtocolVersion { - x.Errorf("wrong version: %d.", ver.Uint64()) - return + x.Fatalf("wrong version: %d.", ver.Uint64()) } var hexnum rpc.HexNumber mail := api.GetFilterChanges(hexnum) if len(mail) != 0 { - x.Errorf("failed GetFilterChanges") - return + x.Fatalf("failed GetFilterChanges") } exist, err := api.HasIdentity(id) if err != nil { - x.Errorf("failed 1 HasIdentity: %s.", err) - return + x.Fatalf("failed test case 1: %s.", err) } if exist { - x.Errorf("failed 2 HasIdentity: false positive.") - return + x.Fatalf("failed test case 2, HasIdentity: false positive.") } err = api.DeleteIdentity(id) if err != nil { - x.Errorf("failed 3 DeleteIdentity: %s.", err) - return + x.Fatalf("failed test case 3: %s.", err) } pub, err := api.NewIdentity() if err != nil { - x.Errorf("failed 4 NewIdentity: %s.", err) - return + x.Fatalf("failed test case 4: %s.", err) } if len(pub) == 0 { - x.Errorf("NewIdentity 5: empty") - return + x.Fatalf("test case 5, NewIdentity: empty") } exist, err = api.HasIdentity(pub) if err != nil { - x.Errorf("failed 6 HasIdentity: %s.", err) - return + x.Fatalf("failed test case 6: %s.", err) } if !exist { - x.Errorf("failed 7 HasIdentity: false negative.") - return + x.Fatalf("failed test case 7, HasIdentity: false negative.") } err = api.DeleteIdentity(pub) if err != nil { - x.Errorf("failed 8 DeleteIdentity: %s.", err) - return + x.Fatalf("failed 8 DeleteIdentity: %s.", err) } exist, err = api.HasIdentity(pub) if err != nil { - x.Errorf("failed 9 HasIdentity: %s.", err) - return + x.Fatalf("failed test case 9: %s.", err) } if exist { - x.Errorf("failed 10 HasIdentity: false positive.") - return + x.Fatalf("failed test case 10, HasIdentity: false positive.") } id = "arbitrary text" @@ -109,66 +95,54 @@ func TestBasic(x *testing.T) { exist, err = api.HasSymKey(id) if err != nil { - x.Errorf("failed 11 HasSymKey: %s.", err) - return + x.Fatalf("failed test case 11: %s.", err) } if exist { - x.Errorf("failed 12 HasSymKey: false positive.") - return + x.Fatalf("failed test case 12, HasSymKey: false positive.") } err = api.GenerateSymKey(id) if err != nil { - x.Errorf("failed 13 GenerateSymKey: %s.", err) - return + x.Fatalf("failed 13 GenerateSymKey: %s.", err) } exist, err = api.HasSymKey(id) if err != nil { - x.Errorf("failed 14 HasSymKey: %s.", err) - return + x.Fatalf("failed test case 14: %s.", err) } if !exist { - x.Errorf("failed 15 HasSymKey: false negative.") - return + x.Fatalf("failed test case 15, HasSymKey: false negative.") } err = api.AddSymKey(id, []byte("some stuff here")) if err == nil { - x.Errorf("failed 16 AddSymKey: %s.", err) - return + x.Fatalf("failed test case 16: %s.", err) } err = api.AddSymKey(id2, []byte("some stuff here")) if err != nil { - x.Errorf("failed 17 AddSymKey: %s.", err) - return + x.Fatalf("failed test case 17: %s.", err) } exist, err = api.HasSymKey(id2) if err != nil { - x.Errorf("failed 18 HasSymKey: %s.", err) - return + x.Fatalf("failed test case 18: %s.", err) } if !exist { - x.Errorf("failed 19 HasSymKey: false negative.") - return + x.Fatalf("failed test case 19, HasSymKey: false negative.") } err = api.DeleteSymKey(id) if err != nil { - x.Errorf("failed 20 DeleteSymKey: %s.", err) - return + x.Fatalf("failed test case 20: %s.", err) } exist, err = api.HasSymKey(id) if err != nil { - x.Errorf("failed 21 HasSymKey: %s.", err) - return + x.Fatalf("failed test case 21: %s.", err) } if exist { - x.Errorf("failed 22 HasSymKey: false positive.") - return + x.Fatalf("failed test case 22, HasSymKey: false positive.") } } @@ -185,57 +159,46 @@ func TestUnmarshalFilterArgs(x *testing.T) { var f WhisperFilterArgs err := f.UnmarshalJSON(s) if err != nil { - x.Errorf("failed UnmarshalJSON: %s.", err) - return + x.Fatalf("failed UnmarshalJSON: %s.", err) } if f.To != "0x70c87d191324e6712a591f304b4eedef6ad9bb9d" { - x.Errorf("wrong To: %x.", f.To) - return + x.Fatalf("wrong To: %x.", f.To) } if f.From != "0x9b2055d370f73ec7d8a03e965129118dc8f5bf83" { - x.Errorf("wrong From: %x.", f.To) - return + x.Fatalf("wrong From: %x.", f.To) } if f.KeyName != "testname" { - x.Errorf("wrong KeyName: %s.", f.KeyName) - return + x.Fatalf("wrong KeyName: %s.", f.KeyName) } if f.PoW != 2.34 { - x.Errorf("wrong pow: %f.", f.PoW) - return + x.Fatalf("wrong pow: %f.", f.PoW) } if !f.AcceptP2P { - x.Errorf("wrong AcceptP2P: %v.", f.AcceptP2P) - return + x.Fatalf("wrong AcceptP2P: %v.", f.AcceptP2P) } if len(f.Topics) != 4 { - x.Errorf("wrong topics number: %d.", len(f.Topics)) - return + x.Fatalf("wrong topics number: %d.", len(f.Topics)) } i := 0 if f.Topics[i] != (whisperv5.TopicType{0x00, 0x00, 0x00, 0x00}) { - x.Errorf("wrong topic[%d]: %x.", i, f.Topics[i]) - return + x.Fatalf("wrong topic[%d]: %x.", i, f.Topics[i]) } i++ if f.Topics[i] != (whisperv5.TopicType{0x00, 0x7f, 0x80, 0xff}) { - x.Errorf("wrong topic[%d]: %x.", i, f.Topics[i]) - return + x.Fatalf("wrong topic[%d]: %x.", i, f.Topics[i]) } i++ if f.Topics[i] != (whisperv5.TopicType{0xff, 0x80, 0x7f, 0x00}) { - x.Errorf("wrong topic[%d]: %x.", i, f.Topics[i]) - return + x.Fatalf("wrong topic[%d]: %x.", i, f.Topics[i]) } i++ if f.Topics[i] != (whisperv5.TopicType{0xf2, 0x6e, 0x77, 0x79}) { - x.Errorf("wrong topic[%d]: %x.", i, f.Topics[i]) - return + x.Fatalf("wrong topic[%d]: %x.", i, f.Topics[i]) } } @@ -257,53 +220,41 @@ func TestUnmarshalPostArgs(x *testing.T) { var a PostArgs err := a.UnmarshalJSON(s) if err != nil { - x.Errorf("failed UnmarshalJSON: %s.", err) - return + x.Fatalf("failed UnmarshalJSON: %s.", err) } if a.TTL != 12345 { - x.Errorf("wrong ttl: %d.", a.TTL) - return + x.Fatalf("wrong ttl: %d.", a.TTL) } if a.From != "0x70c87d191324e6712a591f304b4eedef6ad9bb9d" { - x.Errorf("wrong From: %x.", a.To) - return + x.Fatalf("wrong From: %x.", a.To) } if a.To != "0x9b2055d370f73ec7d8a03e965129118dc8f5bf83" { - x.Errorf("wrong To: %x.", a.To) - return + x.Fatalf("wrong To: %x.", a.To) } if a.KeyName != "shh_test" { - x.Errorf("wrong KeyName: %s.", a.KeyName) - return + x.Fatalf("wrong KeyName: %s.", a.KeyName) } if a.Topic != (whisperv5.TopicType{0xf2, 0x6e, 0x77, 0x79}) { - x.Errorf("wrong topic: %x.", a.Topic) - return + x.Fatalf("wrong topic: %x.", a.Topic) } if string(a.Padding) != "this is my test string" { - x.Errorf("wrong Padding: %s.", string(a.Padding)) - return + x.Fatalf("wrong Padding: %s.", string(a.Padding)) } if string(a.Payload) != "payload should be pseudorandom" { - x.Errorf("wrong Payload: %s.", string(a.Payload)) - return + x.Fatalf("wrong Payload: %s.", string(a.Payload)) } if a.WorkTime != 777 { - x.Errorf("wrong WorkTime: %d.", a.WorkTime) - return + x.Fatalf("wrong WorkTime: %d.", a.WorkTime) } if a.PoW != 3.1416 { - x.Errorf("wrong pow: %f.", a.PoW) - return + x.Fatalf("wrong pow: %f.", a.PoW) } if a.FilterID != 64 { - x.Errorf("wrong FilterID: %d.", a.FilterID) - return + x.Fatalf("wrong FilterID: %d.", a.FilterID) } if bytes.Compare(a.PeerID[:], a.Topic[:]) != 0 { - x.Errorf("wrong PeerID: %x.", a.PeerID) - return + x.Fatalf("wrong PeerID: %x.", a.PeerID) } } @@ -323,38 +274,31 @@ func waitForMessage(api *PublicWhisperAPI, id *rpc.HexNumber, target int) bool { func TestIntegrationAsym(x *testing.T) { api := NewPublicWhisperAPI() if api == nil { - x.Errorf("failed 1 to create API.") - return + x.Fatalf("failed to create API.") } sig, err := api.NewIdentity() if err != nil { - x.Errorf("failed 22 NewIdentity: %s.", err) - return + x.Fatalf("failed test case 22: %s.", err) } if len(sig) == 0 { - x.Errorf("NewIdentity 23: empty") - return + x.Fatalf("failed test case 23") } exist, err := api.HasIdentity(sig) if err != nil { - x.Errorf("failed 24 HasIdentity: %s.", err) - return + x.Fatalf("failed test case 24: %s.", err) } if !exist { - x.Errorf("failed 25 HasIdentity: false negative.") - return + x.Fatalf("failed test case 25, HasIdentity: false negative.") } key, err := api.NewIdentity() if err != nil { - x.Errorf("failed 26 NewIdentity: %s.", err) - return + x.Fatalf("failed test case 26: %s.", err) } if len(key) == 0 { - x.Errorf("failed 27 to generate new identity") - return + x.Fatalf("failed test case 27") } var topics [2]whisperv5.TopicType @@ -369,8 +313,7 @@ func TestIntegrationAsym(x *testing.T) { id, err := api.NewFilter(f) if err != nil { - x.Errorf("failed 31 to create new filter: %s.", err) - return + x.Fatalf("failed to create new filter: %s.", err) } var p PostArgs @@ -385,87 +328,73 @@ func TestIntegrationAsym(x *testing.T) { err = api.Post(p) if err != nil { - x.Errorf("failed 32 to post message: %s.", err) - return + x.Errorf("failed to post message: %s.", err) } ok := waitForMessage(api, id, 1) if !ok { - x.Errorf("failed 33 receive first message: timeout.") - return + x.Fatalf("failed to receive first message: timeout.") } mail := api.GetFilterChanges(*id) if len(mail) != 1 { - x.Errorf("failed 34 to GetFilterChanges: got %d messages.", len(mail)) - return + x.Fatalf("failed to GetFilterChanges: got %d messages.", len(mail)) } text := string(common.FromHex(mail[0].Payload)) if text != string("extended test string") { - x.Errorf("failed 35 to decrypt first message: %s.", text) - return + x.Fatalf("failed to decrypt first message: %s.", text) } p.Padding = []byte("new value") p.Payload = []byte("extended new value") err = api.Post(p) if err != nil { - x.Errorf("failed 42 to post message: %s.", err) - return + x.Fatalf("failed to post next message: %s.", err) } ok = waitForMessage(api, id, 2) if !ok { - x.Errorf("failed 43 receive second message: timeout.") - return + x.Fatalf("failed to receive second message: timeout.") } mail = api.GetFilterChanges(*id) if len(mail) != 1 { - x.Errorf("failed 44 to GetFilterChanges: got %d messages.", len(mail)) - return + x.Fatalf("failed to GetFilterChanges: got %d messages.", len(mail)) } text = string(common.FromHex(mail[0].Payload)) if text != string("extended new value") { - x.Errorf("failed 45 to decrypt second message: %s.", text) - return + x.Fatalf("failed to decrypt second message: %s.", text) } } func TestIntegrationSym(x *testing.T) { api := NewPublicWhisperAPI() if api == nil { - x.Errorf("failed 1 to create API.") - return + x.Fatalf("failed to create API.") } keyname := "schluessel" err := api.GenerateSymKey(keyname) if err != nil { - x.Errorf("failed 2 to GenerateSymKey: %s.", err) - return + x.Fatalf("failed test case 1: %s.", err) } sig, err := api.NewIdentity() if err != nil { - x.Errorf("failed 22 NewIdentity: %s.", err) - return + x.Fatalf("failed test case 2: %s.", err) } if len(sig) == 0 { - x.Errorf("NewIdentity 23: empty") - return + x.Fatalf("failed test case 3") } exist, err := api.HasIdentity(sig) if err != nil { - x.Errorf("failed 24 HasIdentity: %s.", err) - return + x.Fatalf("failed test case 4: %s.", err) } if !exist { - x.Errorf("failed 25 HasIdentity: false negative.") - return + x.Fatalf("failed test case 5, HasIdentity: false negative.") } var topics [2]whisperv5.TopicType @@ -480,8 +409,7 @@ func TestIntegrationSym(x *testing.T) { id, err := api.NewFilter(f) if err != nil { - x.Errorf("failed 31 to create new filter: %s.", err) - return + x.Fatalf("failed 31 to create new filter: %s.", err) } var p PostArgs @@ -496,87 +424,73 @@ func TestIntegrationSym(x *testing.T) { err = api.Post(p) if err != nil { - x.Errorf("failed 32 to post message: %s.", err) - return + x.Fatalf("failed test case 32 (post message): %s.", err) } ok := waitForMessage(api, id, 1) if !ok { - x.Errorf("failed 33 to receive first message: timeout.") - return + x.Fatalf("failed test case 33 (receive first message: timeout).") } mail := api.GetFilterChanges(*id) if len(mail) != 1 { - x.Errorf("failed 34 to GetFilterChanges: got %d messages.", len(mail)) - return + x.Fatalf("failed test case 34 (GetFilterChanges: got %d messages).", len(mail)) } text := string(common.FromHex(mail[0].Payload)) if text != string("extended test string") { - x.Errorf("failed 35 to decrypt first message: %s.", text) - return + x.Fatalf("failed test case 35 (decrypt first message): %s.", text) } p.Padding = []byte("new value") p.Payload = []byte("extended new value") err = api.Post(p) if err != nil { - x.Errorf("failed 42 to post message: %s.", err) - return + x.Fatalf("failed test case 42 (post message): %s.", err) } ok = waitForMessage(api, id, 2) if !ok { - x.Errorf("failed 43 receive second message: timeout.") - return + x.Fatalf("failed test case 43 (receive second message: timeout).") } mail = api.GetFilterChanges(*id) if len(mail) != 1 { - x.Errorf("failed 44 to GetFilterChanges: got %d messages.", len(mail)) - return + x.Fatalf("failed test case 44 (GetFilterChanges: got %d messages).", len(mail)) } text = string(common.FromHex(mail[0].Payload)) if text != string("extended new value") { - x.Errorf("failed 45 to decrypt second message: %s.", text) - return + x.Fatalf("failed test case 45 (decrypt second message: %s).", text) } } func TestIntegrationSymWithFilter(x *testing.T) { api := NewPublicWhisperAPI() if api == nil { - x.Errorf("failed 1 to create API.") - return + x.Fatalf("failed to create API.") } keyname := "schluessel" err := api.GenerateSymKey(keyname) if err != nil { - x.Errorf("failed 2 to GenerateSymKey: %s.", err) - return + x.Fatalf("failed to GenerateSymKey: %s.", err) } sig, err := api.NewIdentity() if err != nil { - x.Errorf("failed 22 NewIdentity: %s.", err) - return + x.Fatalf("failed test case 2: %s.", err) } if len(sig) == 0 { - x.Errorf("NewIdentity 23: empty") - return + x.Fatalf("failed test case 3.") } exist, err := api.HasIdentity(sig) if err != nil { - x.Errorf("failed 24 HasIdentity: %s.", err) - return + x.Fatalf("failed test case 4: %s.", err) } if !exist { - x.Errorf("failed 25 HasIdentity: false negative.") - return + x.Fatalf("failed test case 5.") } var topics [2]whisperv5.TopicType @@ -591,8 +505,7 @@ func TestIntegrationSymWithFilter(x *testing.T) { id, err := api.NewFilter(f) if err != nil { - x.Errorf("failed 31 to create new filter: %s.", err) - return + x.Fatalf("failed to create new filter: %s.", err) } var p PostArgs @@ -607,51 +520,43 @@ func TestIntegrationSymWithFilter(x *testing.T) { err = api.Post(p) if err != nil { - x.Errorf("failed 32 to post message: %s.", err) - return + x.Fatalf("failed to post message: %s.", err) } ok := waitForMessage(api, id, 1) if !ok { - x.Errorf("failed 33 to receive first message: timeout.") - return + x.Fatalf("failed to receive first message: timeout.") } mail := api.GetFilterChanges(*id) if len(mail) != 1 { - x.Errorf("failed 34 to GetFilterChanges: got %d messages.", len(mail)) - return + x.Fatalf("failed to GetFilterChanges: got %d messages.", len(mail)) } text := string(common.FromHex(mail[0].Payload)) if text != string("extended test string") { - x.Errorf("failed 35 to decrypt first message: %s.", text) - return + x.Fatalf("failed to decrypt first message: %s.", text) } p.Padding = []byte("new value") p.Payload = []byte("extended new value") err = api.Post(p) if err != nil { - x.Errorf("failed 42 to post message: %s.", err) - return + x.Fatalf("failed to post next message: %s.", err) } ok = waitForMessage(api, id, 2) if !ok { - x.Errorf("failed 43 receive second message: timeout.") - return + x.Fatalf("failed to receive second message: timeout.") } mail = api.GetFilterChanges(*id) if len(mail) != 1 { - x.Errorf("failed 44 to GetFilterChanges: got %d messages.", len(mail)) - return + x.Fatalf("failed to GetFilterChanges: got %d messages.", len(mail)) } text = string(common.FromHex(mail[0].Payload)) if text != string("extended new value") { - x.Errorf("failed 45 to decrypt second message: %s.", text) - return + x.Fatalf("failed to decrypt second message: %s.", text) } } diff --git a/whisper/whisperv5/benchmarks_test.go b/whisper/whisperv5/benchmarks_test.go index 8bb6c05745..f2eef3c471 100644 --- a/whisper/whisperv5/benchmarks_test.go +++ b/whisper/whisperv5/benchmarks_test.go @@ -40,8 +40,7 @@ func BenchmarkEncryptionSym(b *testing.B) { params, err := generateMessageParams() if err != nil { - b.Errorf("failed generateMessageParams with seed %d: %s.", seed, err) - return + b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) } for i := 0; i < b.N; i++ { @@ -60,13 +59,11 @@ func BenchmarkEncryptionAsym(b *testing.B) { params, err := generateMessageParams() if err != nil { - b.Errorf("failed generateMessageParams with seed %d: %s.", seed, err) - return + b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) } key, err := crypto.GenerateKey() if err != nil { - b.Errorf("failed GenerateKey with seed %d: %s.", seed, err) - return + b.Fatalf("failed GenerateKey with seed %d: %s.", seed, err) } params.KeySym = nil params.Dst = &key.PublicKey @@ -75,8 +72,7 @@ func BenchmarkEncryptionAsym(b *testing.B) { msg := NewSentMessage(params) _, err := msg.Wrap(params) if err != nil { - b.Errorf("failed Wrap with seed %d: %s.", seed, err) - return + b.Fatalf("failed Wrap with seed %d: %s.", seed, err) } } } @@ -86,22 +82,19 @@ func BenchmarkDecryptionSymValid(b *testing.B) { params, err := generateMessageParams() if err != nil { - b.Errorf("failed generateMessageParams with seed %d: %s.", seed, err) - return + b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) } msg := NewSentMessage(params) env, err := msg.Wrap(params) if err != nil { - b.Errorf("failed Wrap with seed %d: %s.", seed, err) - return + b.Fatalf("failed Wrap with seed %d: %s.", seed, err) } f := Filter{KeySym: params.KeySym} for i := 0; i < b.N; i++ { msg := env.Open(&f) if msg == nil { - b.Errorf("failed to open with seed %d.", seed) - return + b.Fatalf("failed to open with seed %d.", seed) } } } @@ -111,22 +104,19 @@ func BenchmarkDecryptionSymInvalid(b *testing.B) { params, err := generateMessageParams() if err != nil { - b.Errorf("failed generateMessageParams with seed %d: %s.", seed, err) - return + b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) } msg := NewSentMessage(params) env, err := msg.Wrap(params) if err != nil { - b.Errorf("failed Wrap with seed %d: %s.", seed, err) - return + b.Fatalf("failed Wrap with seed %d: %s.", seed, err) } f := Filter{KeySym: []byte("arbitrary stuff here")} for i := 0; i < b.N; i++ { msg := env.Open(&f) if msg != nil { - b.Errorf("opened envelope with invalid key, seed: %d.", seed) - return + b.Fatalf("opened envelope with invalid key, seed: %d.", seed) } } } @@ -136,13 +126,11 @@ func BenchmarkDecryptionAsymValid(b *testing.B) { params, err := generateMessageParams() if err != nil { - b.Errorf("failed generateMessageParams with seed %d: %s.", seed, err) - return + b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) } key, err := crypto.GenerateKey() if err != nil { - b.Errorf("failed GenerateKey with seed %d: %s.", seed, err) - return + b.Fatalf("failed GenerateKey with seed %d: %s.", seed, err) } f := Filter{KeyAsym: key} params.KeySym = nil @@ -150,15 +138,13 @@ func BenchmarkDecryptionAsymValid(b *testing.B) { msg := NewSentMessage(params) env, err := msg.Wrap(params) if err != nil { - b.Errorf("failed Wrap with seed %d: %s.", seed, err) - return + b.Fatalf("failed Wrap with seed %d: %s.", seed, err) } for i := 0; i < b.N; i++ { msg := env.Open(&f) if msg == nil { - b.Errorf("fail to open, seed: %d.", seed) - return + b.Fatalf("fail to open, seed: %d.", seed) } } } @@ -168,35 +154,30 @@ func BenchmarkDecryptionAsymInvalid(b *testing.B) { params, err := generateMessageParams() if err != nil { - b.Errorf("failed generateMessageParams with seed %d: %s.", seed, err) - return + b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) } key, err := crypto.GenerateKey() if err != nil { - b.Errorf("failed GenerateKey with seed %d: %s.", seed, err) - return + b.Fatalf("failed GenerateKey with seed %d: %s.", seed, err) } params.KeySym = nil params.Dst = &key.PublicKey msg := NewSentMessage(params) env, err := msg.Wrap(params) if err != nil { - b.Errorf("failed Wrap with seed %d: %s.", seed, err) - return + b.Fatalf("failed Wrap with seed %d: %s.", seed, err) } key, err = crypto.GenerateKey() if err != nil { - b.Errorf("failed GenerateKey with seed %d: %s.", seed, err) - return + b.Fatalf("failed GenerateKey with seed %d: %s.", seed, err) } f := Filter{KeyAsym: key} for i := 0; i < b.N; i++ { msg := env.Open(&f) if msg != nil { - b.Errorf("opened envelope with invalid key, seed: %d.", seed) - return + b.Fatalf("opened envelope with invalid key, seed: %d.", seed) } } } diff --git a/whisper/whisperv5/doc.go b/whisper/whisperv5/doc.go index 14a6c867b2..6bce5a59e5 100644 --- a/whisper/whisperv5/doc.go +++ b/whisper/whisperv5/doc.go @@ -46,9 +46,7 @@ const ( messagesCode = 1 p2pCode = 2 mailRequestCode = 3 - bloomExchangeCode = 4 - reservedCode = 5 - NumberOfMessageCodes = 6 + NumberOfMessageCodes = 10 paddingMask = byte(3) signatureFlag = byte(4) diff --git a/whisper/whisperv5/filter.go b/whisper/whisperv5/filter.go index 350aadba24..2c61bde99f 100644 --- a/whisper/whisperv5/filter.go +++ b/whisper/whisperv5/filter.go @@ -155,21 +155,20 @@ func (f *Filter) MatchEnvelope(envelope *Envelope) bool { return false } - encryptionMethodMatch := false if f.expectsAsymmetricEncryption() && envelope.isAsymmetric() { - encryptionMethodMatch = true - if f.Topics == nil { - // wildcard - return true - } + return f.MatchTopic(envelope.Topic) } else if f.expectsSymmetricEncryption() && envelope.IsSymmetric() { - encryptionMethodMatch = true + return f.MatchTopic(envelope.Topic) } - - return encryptionMethodMatch && f.MatchTopic(envelope.Topic) + return false } func (f *Filter) MatchTopic(topic TopicType) bool { + if len(f.Topics) == 0 { + // any topic matches + return true + } + for _, t := range f.Topics { if t == topic { return true diff --git a/whisper/whisperv5/filter_test.go b/whisper/whisperv5/filter_test.go index 171e68d047..8406d813a0 100644 --- a/whisper/whisperv5/filter_test.go +++ b/whisper/whisperv5/filter_test.go @@ -61,7 +61,7 @@ func generateFilter(x *testing.T, symmetric bool) (*Filter, error) { key, err := crypto.GenerateKey() if err != nil { - x.Errorf("generateFilter failed 1 with seed %d.", seed) + x.Fatalf("generateFilter 1 failed with seed %d.", seed) return nil, err } f.Src = &key.PublicKey @@ -73,7 +73,7 @@ func generateFilter(x *testing.T, symmetric bool) (*Filter, error) { } else { f.KeyAsym, err = crypto.GenerateKey() if err != nil { - x.Errorf("generateFilter failed 2 with seed %d.", seed) + x.Fatalf("generateFilter 2 failed with seed %d.", seed) return nil, err } } @@ -107,8 +107,7 @@ func TestInstallFilters(x *testing.T) { } if j < SizeTestFilters-1 { - x.Errorf("seed %d: wrong index %d", seed, j) - return + x.Fatalf("seed %d: wrong index %d", seed, j) } for _, t := range tst { @@ -121,12 +120,10 @@ func TestInstallFilters(x *testing.T) { fil := filters.Get(t.id) exist := (fil != nil) if exist != t.alive { - x.Errorf("seed %d: failed alive: %d, %v, %v", seed, i, exist, t.alive) - return + x.Fatalf("seed %d: failed alive: %d, %v, %v", seed, i, exist, t.alive) } if exist && fil.PoW != t.f.PoW { - x.Errorf("seed %d: failed Get: %d, %v, %v", seed, i, exist, t.alive) - return + x.Fatalf("seed %d: failed Get: %d, %v, %v", seed, i, exist, t.alive) } } } @@ -136,29 +133,24 @@ func TestComparePubKey(x *testing.T) { key1, err := crypto.GenerateKey() if err != nil { - x.Errorf("failed GenerateKey 1 with seed %d: %s.", seed, err) - return + x.Fatalf("failed GenerateKey 1 with seed %d: %s.", seed, err) } key2, err := crypto.GenerateKey() if err != nil { - x.Errorf("failed GenerateKey 2 with seed %d: %s.", seed, err) - return + x.Fatalf("failed GenerateKey 2 with seed %d: %s.", seed, err) } if isPubKeyEqual(&key1.PublicKey, &key2.PublicKey) { - x.Errorf("failed !equal with seed %d.", seed) - return + x.Fatalf("failed !equal with seed %d.", seed) } // generate key3 == key1 rand.Seed(seed) key3, err := crypto.GenerateKey() if err != nil { - x.Errorf("failed GenerateKey 3 with seed %d: %s.", seed, err) - return + x.Fatalf("failed GenerateKey 3 with seed %d: %s.", seed, err) } if isPubKeyEqual(&key1.PublicKey, &key3.PublicKey) { - x.Errorf("failed equal with seed %d.", seed) - return + x.Fatalf("failed equal with seed %d.", seed) } } @@ -167,20 +159,17 @@ func TestMatchEnvelope(x *testing.T) { fsym, err := generateFilter(x, true) if err != nil { - x.Errorf("failed generateFilter 1 with seed %d: %s.", seed, err) - return + x.Fatalf("failed generateFilter 1 with seed %d: %s.", seed, err) } fasym, err := generateFilter(x, false) if err != nil { - x.Errorf("failed generateFilter 2 with seed %d: %s.", seed, err) - return + x.Fatalf("failed generateFilter 2 with seed %d: %s.", seed, err) } params, err := generateMessageParams() if err != nil { - x.Errorf("failed generateMessageParams 3 with seed %d: %s.", seed, err) - return + x.Fatalf("failed generateMessageParams 3 with seed %d: %s.", seed, err) } params.Topic[0] = 0xFF // ensure mismatch @@ -189,18 +178,15 @@ func TestMatchEnvelope(x *testing.T) { msg := NewSentMessage(params) env, err := msg.Wrap(params) if err != nil { - x.Errorf("failed Wrap 4 with seed %d: %s.", seed, err) - return + x.Fatalf("failed Wrap 4 with seed %d: %s.", seed, err) } match := fsym.MatchEnvelope(env) if match { - x.Errorf("failed test case 5 with seed %d.", seed) - return + x.Fatalf("failed test case 5 with seed %d.", seed) } match = fasym.MatchEnvelope(env) if match { - x.Errorf("failed test case 6 with seed %d.", seed) - return + x.Fatalf("failed test case 6 with seed %d.", seed) } // encrypt symmetrically @@ -210,109 +196,109 @@ func TestMatchEnvelope(x *testing.T) { msg = NewSentMessage(params) env, err = msg.Wrap(params) if err != nil { - x.Errorf("failed test case 7 with seed %d, test case 3: %s.", seed, err) - return + x.Fatalf("failed test case 7 with seed %d, test case 3: %s.", seed, err) } // symmetric + matching topic: match match = fsym.MatchEnvelope(env) if !match { - x.Errorf("failed test case 8 with seed %d.", seed) - return + x.Fatalf("failed test case 8 with seed %d.", seed) } // asymmetric + matching topic: mismatch match = fasym.MatchEnvelope(env) if match { - x.Errorf("failed test case 9 with seed %d.", seed) - return + x.Fatalf("failed test case 9 with seed %d.", seed) } // symmetric + matching topic + insufficient PoW: mismatch fsym.PoW = env.PoW() + 1.0 match = fsym.MatchEnvelope(env) if match { - x.Errorf("failed test case 10 with seed %d.", seed) - return + x.Fatalf("failed test case 10 with seed %d.", seed) } // symmetric + matching topic + sufficient PoW: match fsym.PoW = env.PoW() / 2 match = fsym.MatchEnvelope(env) if !match { - x.Errorf("failed test case 11 with seed %d.", seed) - return + x.Fatalf("failed test case 11 with seed %d.", seed) } - // symmetric + topics are nil: mismatch + // symmetric + topics are nil (wildcard): match prevTopics := fsym.Topics fsym.Topics = nil - match = fasym.MatchEnvelope(env) - if match { - x.Errorf("failed test case 12 with seed %d.", seed) - return + match = fsym.MatchEnvelope(env) + if !match { + x.Fatalf("failed test case 12 with seed %d.", seed) } fsym.Topics = prevTopics // encrypt asymmetrically key, err := crypto.GenerateKey() if err != nil { - x.Errorf("failed GenerateKey 13 with seed %d: %s.", seed, err) - return + x.Fatalf("failed GenerateKey 13 with seed %d: %s.", seed, err) } params.KeySym = nil params.Dst = &key.PublicKey msg = NewSentMessage(params) env, err = msg.Wrap(params) if err != nil { - x.Errorf("failed test case 14 with seed %d, test case 3: %s.", seed, err) - return + x.Fatalf("failed test case 14 with seed %d, test case 3: %s.", seed, err) } // encryption method mismatch match = fsym.MatchEnvelope(env) if match { - x.Errorf("failed test case 15 with seed %d.", seed) - return + x.Fatalf("failed test case 15 with seed %d.", seed) } // asymmetric + mismatching topic: mismatch match = fasym.MatchEnvelope(env) if !match { - x.Errorf("failed test case 16 with seed %d.", seed) - return + x.Fatalf("failed test case 16 with seed %d.", seed) } // asymmetric + matching topic: match fasym.Topics[i] = fasym.Topics[i+1] match = fasym.MatchEnvelope(env) if match { - x.Errorf("failed test case 17 with seed %d.", seed) - return + x.Fatalf("failed test case 17 with seed %d.", seed) } - // asymmetric + topic is nil (wildcard): match + // asymmetric + filter without topic (wildcard): match fasym.Topics = nil match = fasym.MatchEnvelope(env) if !match { - x.Errorf("failed test case 18 with seed %d.", seed) - return + x.Fatalf("failed test case 18 with seed %d.", seed) } // asymmetric + insufficient PoW: mismatch fasym.PoW = env.PoW() + 1.0 match = fasym.MatchEnvelope(env) if match { - x.Errorf("failed test case 19 with seed %d.", seed) - return + x.Fatalf("failed test case 19 with seed %d.", seed) } // asymmetric + sufficient PoW: match fasym.PoW = env.PoW() / 2 match = fasym.MatchEnvelope(env) if !match { - x.Errorf("failed test case 20 with seed %d.", seed) - return + x.Fatalf("failed test case 20 with seed %d.", seed) + } + + // filter without topic + envelope without topic: match + env.Topic = TopicType{} + match = fasym.MatchEnvelope(env) + if !match { + x.Fatalf("failed test case 21 with seed %d.", seed) + } + + // filter with topic + envelope without topic: mismatch + fasym.Topics = fsym.Topics + match = fasym.MatchEnvelope(env) + if match { + x.Fatalf("failed test case 22 with seed %d.", seed) } } @@ -321,14 +307,12 @@ func TestMatchMessageSym(x *testing.T) { params, err := generateMessageParams() if err != nil { - x.Errorf("failed generateMessageParams with seed %d: %s.", seed, err) - return + x.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) } f, err := generateFilter(x, true) if err != nil { - x.Errorf("failed generateFilter 1 with seed %d: %s.", seed, err) - return + x.Fatalf("failed generateFilter 1 with seed %d: %s.", seed, err) } const index = 1 @@ -338,90 +322,77 @@ func TestMatchMessageSym(x *testing.T) { sentMessage := NewSentMessage(params) env, err := sentMessage.Wrap(params) if err != nil { - x.Errorf("failed Wrap 2 with seed %d: %s.", seed, err) - return + x.Fatalf("failed Wrap 2 with seed %d: %s.", seed, err) } msg := env.Open(f) if msg == nil { - x.Errorf("failed to open 3 with seed %d.", seed) - return + x.Fatalf("failed to open 3 with seed %d.", seed) } // Src mismatch if f.MatchMessage(msg) { - x.Errorf("failed test case 4 with seed %d.", seed) - return + x.Fatalf("failed test case 4 with seed %d.", seed) } // Src: match *f.Src.X = *params.Src.PublicKey.X *f.Src.Y = *params.Src.PublicKey.Y if !f.MatchMessage(msg) { - x.Errorf("failed test case 5 with seed %d.", seed) - return + x.Fatalf("failed test case 5 with seed %d.", seed) } // insufficient PoW: mismatch f.PoW = msg.PoW + 1.0 if f.MatchMessage(msg) { - x.Errorf("failed test case 6 with seed %d.", seed) - return + x.Fatalf("failed test case 6 with seed %d.", seed) } // sufficient PoW: match f.PoW = msg.PoW / 2 if !f.MatchMessage(msg) { - x.Errorf("failed test case 7 with seed %d.", seed) - return + x.Fatalf("failed test case 7 with seed %d.", seed) } // topic mismatch f.Topics[index][0]++ if f.MatchMessage(msg) { - x.Errorf("failed test case 8 with seed %d.", seed) - return + x.Fatalf("failed test case 8 with seed %d.", seed) } f.Topics[index][0]-- // key mismatch f.SymKeyHash[0]++ if f.MatchMessage(msg) { - x.Errorf("failed test case 9 with seed %d.", seed) - return + x.Fatalf("failed test case 9 with seed %d.", seed) } f.SymKeyHash[0]-- // Src absent: match f.Src = nil if !f.MatchMessage(msg) { - x.Errorf("failed test case 10 with seed %d.", seed) - return + x.Fatalf("failed test case 10 with seed %d.", seed) } // key hash mismatch mismatch h := f.SymKeyHash f.SymKeyHash = common.Hash{} if f.MatchMessage(msg) { - x.Errorf("failed test case 11 with seed %d.", seed) - return + x.Fatalf("failed test case 11 with seed %d.", seed) } f.SymKeyHash = h if !f.MatchMessage(msg) { - x.Errorf("failed test case 12 with seed %d.", seed) - return + x.Fatalf("failed test case 12 with seed %d.", seed) } // encryption method mismatch f.KeySym = nil f.KeyAsym, err = crypto.GenerateKey() if err != nil { - x.Errorf("failed GenerateKey 13 with seed %d: %s.", seed, err) - return + x.Fatalf("failed GenerateKey 13 with seed %d: %s.", seed, err) } if f.MatchMessage(msg) { - x.Errorf("failed test case 14 with seed %d.", seed) - return + x.Fatalf("failed test case 14 with seed %d.", seed) } } @@ -430,14 +401,12 @@ func TestMatchMessageAsym(x *testing.T) { f, err := generateFilter(x, false) if err != nil { - x.Errorf("failed generateFilter with seed %d: %s.", seed, err) - return + x.Fatalf("failed generateFilter with seed %d: %s.", seed, err) } params, err := generateMessageParams() if err != nil { - x.Errorf("failed generateMessageParams with seed %d: %s.", seed, err) - return + x.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) } const index = 1 @@ -449,49 +418,42 @@ func TestMatchMessageAsym(x *testing.T) { sentMessage := NewSentMessage(params) env, err := sentMessage.Wrap(params) if err != nil { - x.Errorf("failed Wrap with seed %d: %s.", seed, err) - return + x.Fatalf("failed Wrap with seed %d: %s.", seed, err) } msg := env.Open(f) if msg == nil { - x.Errorf("failed to open with seed %d.", seed) - return + x.Fatalf("failed to open with seed %d.", seed) } // Src mismatch if f.MatchMessage(msg) { - x.Errorf("failed test case 4 with seed %d.", seed) - return + x.Fatalf("failed test case 4 with seed %d.", seed) } // Src: match *f.Src.X = *params.Src.PublicKey.X *f.Src.Y = *params.Src.PublicKey.Y if !f.MatchMessage(msg) { - x.Errorf("failed test case 5 with seed %d.", seed) - return + x.Fatalf("failed test case 5 with seed %d.", seed) } // insufficient PoW: mismatch f.PoW = msg.PoW + 1.0 if f.MatchMessage(msg) { - x.Errorf("failed test case 6 with seed %d.", seed) - return + x.Fatalf("failed test case 6 with seed %d.", seed) } // sufficient PoW: match f.PoW = msg.PoW / 2 if !f.MatchMessage(msg) { - x.Errorf("failed test case 7 with seed %d.", seed) - return + x.Fatalf("failed test case 7 with seed %d.", seed) } // topic mismatch f.Topics[index][0]++ if f.MatchMessage(msg) { - x.Errorf("failed test case 8 with seed %d.", seed) - return + x.Fatalf("failed test case 8 with seed %d.", seed) } f.Topics[index][0]-- @@ -500,24 +462,21 @@ func TestMatchMessageAsym(x *testing.T) { zero := *big.NewInt(0) *f.KeyAsym.PublicKey.X = zero if f.MatchMessage(msg) { - x.Errorf("failed test case 9 with seed %d.", seed) - return + x.Fatalf("failed test case 9 with seed %d.", seed) } *f.KeyAsym.PublicKey.X = prev // Src absent: match f.Src = nil if !f.MatchMessage(msg) { - x.Errorf("failed test case 10 with seed %d.", seed) - return + x.Fatalf("failed test case 10 with seed %d.", seed) } // encryption method mismatch f.KeySym = keySymOrig f.KeyAsym = nil if f.MatchMessage(msg) { - x.Errorf("failed test case 11 with seed %d.", seed) - return + x.Fatalf("failed test case 11 with seed %d.", seed) } } @@ -537,7 +496,7 @@ func cloneFilter(orig *Filter) *Filter { func generateCompatibeEnvelope(x *testing.T, f *Filter) *Envelope { params, err := generateMessageParams() if err != nil { - x.Errorf("failed generateMessageParams 77 with seed %d: %s.", seed, err) + x.Fatalf("failed generateMessageParams 77 with seed %d: %s.", seed, err) return nil } @@ -546,7 +505,7 @@ func generateCompatibeEnvelope(x *testing.T, f *Filter) *Envelope { sentMessage := NewSentMessage(params) env, err := sentMessage.Wrap(params) if err != nil { - x.Errorf("failed Wrap 78 with seed %d: %s.", seed, err) + x.Fatalf("failed Wrap 78 with seed %d: %s.", seed, err) return nil } return env @@ -594,20 +553,17 @@ func TestWatchers(x *testing.T) { } if total != NumMessages { - x.Errorf("failed test case 1 with seed %d: total = %d, want: %d.", seed, total, NumMessages) - return + x.Fatalf("failed test case 1 with seed %d: total = %d, want: %d.", seed, total, NumMessages) } for i = 0; i < NumFilters; i++ { mail = tst[i].f.Retrieve() if len(mail) != 0 { - x.Errorf("failed test case 2 with seed %d: i = %d.", seed, i) - return + x.Fatalf("failed test case 2 with seed %d: i = %d.", seed, i) } if tst[i].msgCnt != count[i] { - x.Errorf("failed test case 3 with seed %d: i = %d, get %d, want %d.", seed, i, tst[i].msgCnt, count[i]) - return + x.Fatalf("failed test case 3 with seed %d: i = %d, get %d, want %d.", seed, i, tst[i].msgCnt, count[i]) } } @@ -647,30 +603,25 @@ func TestWatchers(x *testing.T) { combined := tst[0].msgCnt + tst[last].msgCnt if total != NumMessages+count[0] { - x.Errorf("failed test case 4 with seed %d: total = %d, count[0] = %d.", seed, total, count[0]) - return + x.Fatalf("failed test case 4 with seed %d: total = %d, count[0] = %d.", seed, total, count[0]) } if combined != count[0] { - x.Errorf("failed test case 5 with seed %d: combined = %d, count[0] = %d.", seed, combined, count[0]) - return + x.Fatalf("failed test case 5 with seed %d: combined = %d, count[0] = %d.", seed, combined, count[0]) } if combined != count[last] { - x.Errorf("failed test case 6 with seed %d: combined = %d, count[last] = %d.", seed, combined, count[last]) - return + x.Fatalf("failed test case 6 with seed %d: combined = %d, count[last] = %d.", seed, combined, count[last]) } for i = 1; i < NumFilters-1; i++ { mail = tst[i].f.Retrieve() if len(mail) != 0 { - x.Errorf("failed test case 7 with seed %d: i = %d.", seed, i) - return + x.Fatalf("failed test case 7 with seed %d: i = %d.", seed, i) } if tst[i].msgCnt != count[i] { - x.Errorf("failed test case 8 with seed %d: i = %d, get %d, want %d.", seed, i, tst[i].msgCnt, count[i]) - return + x.Fatalf("failed test case 8 with seed %d: i = %d, get %d, want %d.", seed, i, tst[i].msgCnt, count[i]) } } @@ -685,8 +636,7 @@ func TestWatchers(x *testing.T) { } if total != 0 { - x.Errorf("failed test case 9 with seed %d.", seed) - return + x.Fatalf("failed test case 9 with seed %d.", seed) } f := filters.Get(0) @@ -700,7 +650,6 @@ func TestWatchers(x *testing.T) { } if total != 1 { - x.Errorf("failed test case 10 with seed %d: total = %d.", seed, total) - return + x.Fatalf("failed test case 10 with seed %d: total = %d.", seed, total) } } diff --git a/whisper/whisperv5/message_test.go b/whisper/whisperv5/message_test.go index 78041fc1a2..ed180132ed 100644 --- a/whisper/whisperv5/message_test.go +++ b/whisper/whisperv5/message_test.go @@ -60,14 +60,12 @@ func generateMessageParams() (*MessageParams, error) { func singleMessageTest(x *testing.T, symmetric bool) { params, err := generateMessageParams() if err != nil { - x.Errorf("failed generateMessageParams with seed %d: %s.", seed, err) - return + x.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) } key, err := crypto.GenerateKey() if err != nil { - x.Errorf("failed GenerateKey with seed %d: %s.", seed, err) - return + x.Fatalf("failed GenerateKey with seed %d: %s.", seed, err) } if !symmetric { @@ -85,8 +83,7 @@ func singleMessageTest(x *testing.T, symmetric bool) { msg := NewSentMessage(params) env, err := msg.Wrap(params) if err != nil { - x.Errorf("failed Wrap with seed %d: %s.", seed, err) - return + x.Fatalf("failed Wrap with seed %d: %s.", seed, err) } var decrypted *ReceivedMessage @@ -97,35 +94,28 @@ func singleMessageTest(x *testing.T, symmetric bool) { } if err != nil { - x.Errorf("failed to encrypt with seed %d: %s.", seed, err) - return + x.Fatalf("failed to encrypt with seed %d: %s.", seed, err) } if !decrypted.Validate() { - x.Errorf("failed to validate with seed %d.", seed) - return + x.Fatalf("failed to validate with seed %d.", seed) } padsz := len(decrypted.Padding) if bytes.Compare(steg[:padsz], decrypted.Padding) != 0 { - x.Errorf("failed with seed %d: compare padding.", seed) - return + x.Fatalf("failed with seed %d: compare padding.", seed) } if bytes.Compare(text, decrypted.Payload) != 0 { - x.Errorf("failed with seed %d: compare payload.", seed) - return + x.Fatalf("failed with seed %d: compare payload.", seed) } if !isMessageSigned(decrypted.Raw[0]) { - x.Errorf("failed with seed %d: unsigned.", seed) - return + x.Fatalf("failed with seed %d: unsigned.", seed) } if len(decrypted.Signature) != signatureLength { - x.Errorf("failed with seed %d: signature len %d.", seed, len(decrypted.Signature)) - return + x.Fatalf("failed with seed %d: signature len %d.", seed, len(decrypted.Signature)) } if !isPubKeyEqual(decrypted.Src, ¶ms.Src.PublicKey) { - x.Errorf("failed with seed %d: signature mismatch.", seed) - return + x.Fatalf("failed with seed %d: signature mismatch.", seed) } } @@ -146,8 +136,7 @@ func TestMessageWrap(x *testing.T) { params, err := generateMessageParams() if err != nil { - x.Errorf("failed generateMessageParams with seed %d: %s.", seed, err) - return + x.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) } msg := NewSentMessage(params) @@ -156,14 +145,12 @@ func TestMessageWrap(x *testing.T) { params.PoW = target env, err := msg.Wrap(params) if err != nil { - x.Errorf("failed Wrap with seed %d: %s.", seed, err) - return + x.Fatalf("failed Wrap with seed %d: %s.", seed, err) } pow := env.PoW() if pow < target { - x.Errorf("failed Wrap with seed %d: pow < target (%f vs. %f).", seed, pow, target) - return + x.Fatalf("failed Wrap with seed %d: pow < target (%f vs. %f).", seed, pow, target) } } @@ -174,8 +161,7 @@ func TestMessageSeal(x *testing.T) { params, err := generateMessageParams() if err != nil { - x.Errorf("failed generateMessageParams with seed %d: %s.", seed, err) - return + x.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) } msg := NewSentMessage(params) @@ -187,8 +173,7 @@ func TestMessageSeal(x *testing.T) { env := NewEnvelope(params.TTL, params.Topic, salt, aesnonce, msg) if err != nil { - x.Errorf("failed Wrap with seed %d: %s.", seed, err) - return + x.Fatalf("failed Wrap with seed %d: %s.", seed, err) } env.Expiry = uint32(seed) // make it deterministic @@ -200,8 +185,7 @@ func TestMessageSeal(x *testing.T) { env.calculatePoW(0) pow := env.PoW() if pow < target { - x.Errorf("failed Wrap with seed %d: pow < target (%f vs. %f).", seed, pow, target) - return + x.Fatalf("failed Wrap with seed %d: pow < target (%f vs. %f).", seed, pow, target) } params.WorkTime = 1 @@ -210,8 +194,7 @@ func TestMessageSeal(x *testing.T) { env.calculatePoW(0) pow = env.PoW() if pow < 2*target { - x.Errorf("failed Wrap with seed %d: pow too small %f.", seed, pow) - return + x.Fatalf("failed Wrap with seed %d: pow too small %f.", seed, pow) } } @@ -228,14 +211,12 @@ func TestEnvelopeOpen(x *testing.T) { func singleEnvelopeOpenTest(x *testing.T, symmetric bool) { params, err := generateMessageParams() if err != nil { - x.Errorf("failed generateMessageParams with seed %d: %s.", seed, err) - return + x.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) } key, err := crypto.GenerateKey() if err != nil { - x.Errorf("failed GenerateKey with seed %d: %s.", seed, err) - return + x.Fatalf("failed GenerateKey with seed %d: %s.", seed, err) } if !symmetric { @@ -253,54 +234,43 @@ func singleEnvelopeOpenTest(x *testing.T, symmetric bool) { msg := NewSentMessage(params) env, err := msg.Wrap(params) if err != nil { - x.Errorf("failed Wrap with seed %d: %s.", seed, err) - return + x.Fatalf("failed Wrap with seed %d: %s.", seed, err) } f := Filter{KeyAsym: key, KeySym: params.KeySym} decrypted := env.Open(&f) if decrypted == nil { - x.Errorf("failed to open with seed %d.", seed) - return + x.Fatalf("failed to open with seed %d.", seed) } padsz := len(decrypted.Padding) if bytes.Compare(steg[:padsz], decrypted.Padding) != 0 { - x.Errorf("failed with seed %d: compare padding.", seed) - return + x.Fatalf("failed with seed %d: compare padding.", seed) } if bytes.Compare(text, decrypted.Payload) != 0 { - x.Errorf("failed with seed %d: compare payload.", seed) - return + x.Fatalf("failed with seed %d: compare payload.", seed) } if !isMessageSigned(decrypted.Raw[0]) { - x.Errorf("failed with seed %d: unsigned.", seed) - return + x.Fatalf("failed with seed %d: unsigned.", seed) } if len(decrypted.Signature) != signatureLength { - x.Errorf("failed with seed %d: signature len %d.", seed, len(decrypted.Signature)) - return + x.Fatalf("failed with seed %d: signature len %d.", seed, len(decrypted.Signature)) } if !isPubKeyEqual(decrypted.Src, ¶ms.Src.PublicKey) { - x.Errorf("failed with seed %d: signature mismatch.", seed) - return + x.Fatalf("failed with seed %d: signature mismatch.", seed) } if decrypted.isAsymmetricEncryption() == symmetric { - x.Errorf("failed with seed %d: asymmetric %v vs. %v.", seed, decrypted.isAsymmetricEncryption(), symmetric) - return + x.Fatalf("failed with seed %d: asymmetric %v vs. %v.", seed, decrypted.isAsymmetricEncryption(), symmetric) } if decrypted.isSymmetricEncryption() != symmetric { - x.Errorf("failed with seed %d: symmetric %v vs. %v.", seed, decrypted.isSymmetricEncryption(), symmetric) - return + x.Fatalf("failed with seed %d: symmetric %v vs. %v.", seed, decrypted.isSymmetricEncryption(), symmetric) } if !symmetric { if decrypted.Dst == nil { - x.Errorf("failed with seed %d: dst is nil.", seed) - return + x.Fatalf("failed with seed %d: dst is nil.", seed) } if !isPubKeyEqual(decrypted.Dst, &key.PublicKey) { - x.Errorf("failed with seed %d: Dst.", seed) - return + x.Fatalf("failed with seed %d: Dst.", seed) } } } diff --git a/whisper/whisperv5/peer_test.go b/whisper/whisperv5/peer_test.go index 03c4725d8e..d4893bacd7 100644 --- a/whisper/whisperv5/peer_test.go +++ b/whisper/whisperv5/peer_test.go @@ -124,8 +124,7 @@ func initialize(x *testing.T) { node.filerId = node.shh.Watch(&f) node.id, err = crypto.HexToECDSA(keys[i]) if err != nil { - x.Errorf("failed convert the key: %s.", keys[i]) - return + x.Fatalf("failed convert the key: %s.", keys[i]) } port := port0 + i addr := fmt.Sprintf(":%d", port) // e.g. ":30303" @@ -155,8 +154,7 @@ func initialize(x *testing.T) { err = node.server.Start() if err != nil { - x.Errorf("failed to start server %d.", i) - return + x.Fatalf("failed to start server %d.", i) } nodes[i] = &node @@ -187,8 +185,7 @@ func checkPropagation(x *testing.T) { for i := 0; i < NumNodes; i++ { f := nodes[i].shh.GetFilter(nodes[i].filerId) if f == nil { - x.Errorf("failed to get filterId %d from node %d.", nodes[i].filerId, i) - return + x.Fatalf("failed to get filterId %d from node %d.", nodes[i].filerId, i) } mail := f.Retrieve() @@ -197,13 +194,12 @@ func checkPropagation(x *testing.T) { } if isTestComplete() { - return } } } - x.Errorf("Test was not complete: timeout %d seconds.", iterations*cycle/1000) + x.Fatalf("Test was not complete: timeout %d seconds.", iterations*cycle/1000) } func validateMail(x *testing.T, index int, mail []*ReceivedMessage) bool { @@ -219,7 +215,7 @@ func validateMail(x *testing.T, index int, mail []*ReceivedMessage) bool { return true } if cnt > 1 { - x.Errorf("node %d received %d.", index, cnt) + x.Fatalf("node %d received %d.", index, cnt) return false } @@ -228,8 +224,7 @@ func validateMail(x *testing.T, index int, mail []*ReceivedMessage) bool { defer result.mutex.Unlock() result.counter[index] += cnt if result.counter[index] > 1 { - x.Errorf("node %d accumulated %d.", index, result.counter[index]) - return false + x.Fatalf("node %d accumulated %d.", index, result.counter[index]) } } return true @@ -270,14 +265,12 @@ func sendMsg(x *testing.T, expected bool, id int) { msg := NewSentMessage(&opt) envelope, err := msg.Wrap(&opt) if err != nil { - x.Errorf("failed to seal message.") - return + x.Fatalf("failed to seal message.") } err = nodes[id].shh.Send(envelope) if err != nil { - x.Errorf("failed to send message.") - return + x.Fatalf("failed to send message.") } } @@ -286,22 +279,19 @@ func TestPeerBasic(x *testing.T) { params, err := generateMessageParams() if err != nil { - x.Errorf("failed 1 with seed %d.", seed) - return + x.Fatalf("failed generateMessageParams with seed %d.", seed) } params.PoW = 0.001 msg := NewSentMessage(params) env, err := msg.Wrap(params) if err != nil { - x.Errorf("failed 2 with seed %d.", seed) - return + x.Fatalf("failed Wrap with seed %d.", seed) } p := newPeer(nil, nil, nil) p.mark(env) if !p.marked(env) { - x.Errorf("failed 3 with seed %d.", seed) - return + x.Fatalf("failed mark with seed %d.", seed) } } diff --git a/whisper/whisperv5/topic_test.go b/whisper/whisperv5/topic_test.go index c2a940b79a..f3a572afbf 100644 --- a/whisper/whisperv5/topic_test.go +++ b/whisper/whisperv5/topic_test.go @@ -32,7 +32,7 @@ func TestTopicString(x *testing.T) { for i, tst := range topicStringTests { s := tst.topic.String() if s != tst.str { - x.Errorf("failed test %d: have %s, want %s.", i, s, tst.str) + x.Fatalf("failed test %d: have %s, want %s.", i, s, tst.str) } } } @@ -57,7 +57,7 @@ func TestBytesToTopic(x *testing.T) { for i, tst := range bytesToTopicTests { t := BytesToTopic(tst.data) if t != tst.topic { - x.Errorf("failed test %d: have %v, want %v.", i, t, tst.topic) + x.Fatalf("failed test %d: have %v, want %v.", i, t, tst.topic) } } } @@ -104,9 +104,9 @@ func TestUnmarshalTestsGood(x *testing.T) { var t TopicType err := t.UnmarshalJSON(tst.data) if err != nil { - x.Errorf("failed test %d. input: %v.", i, tst.data) + x.Fatalf("failed test %d. input: %v.", i, tst.data) } else if t != tst.topic { - x.Errorf("failed test %d: have %v, want %v.", i, t, tst.topic) + x.Fatalf("failed test %d: have %v, want %v.", i, t, tst.topic) } } } @@ -117,7 +117,7 @@ func TestUnmarshalTestsBad(x *testing.T) { var t TopicType err := t.UnmarshalJSON(tst.data) if err == nil { - x.Errorf("failed test %d. input: %v.", i, tst.data) + x.Fatalf("failed test %d. input: %v.", i, tst.data) } } } @@ -128,9 +128,9 @@ func TestUnmarshalTestsUgly(x *testing.T) { var t TopicType err := t.UnmarshalJSON(tst.data) if err != nil { - x.Errorf("failed test %d. input: %v.", i, tst.data) + x.Fatalf("failed test %d. input: %v.", i, tst.data) } else if t == tst.topic { - x.Errorf("failed test %d: have %v, want %v.", i, t, tst.topic) + x.Fatalf("failed test %d: have %v, want %v.", i, t, tst.topic) } } } diff --git a/whisper/whisperv5/whisper_test.go b/whisper/whisperv5/whisper_test.go index 1db26265a5..4892d2e3a1 100644 --- a/whisper/whisperv5/whisper_test.go +++ b/whisper/whisperv5/whisper_test.go @@ -29,114 +29,92 @@ func TestWhisperBasic(x *testing.T) { p := w.Protocols() shh := p[0] if shh.Name != ProtocolName { - x.Errorf("failed Protocol Name: %v.", shh.Name) - return + x.Fatalf("failed Protocol Name: %v.", shh.Name) } if uint64(shh.Version) != ProtocolVersion { - x.Errorf("failed Protocol Version: %v.", shh.Version) - return + x.Fatalf("failed Protocol Version: %v.", shh.Version) } if shh.Length != NumberOfMessageCodes { - x.Errorf("failed Protocol Length: %v.", shh.Length) - return + x.Fatalf("failed Protocol Length: %v.", shh.Length) } if shh.Run == nil { - x.Errorf("failed shh.Run.") - return + x.Fatalf("failed shh.Run.") } if uint64(w.Version()) != ProtocolVersion { - x.Errorf("failed whisper Version: %v.", shh.Version) - return + x.Fatalf("failed whisper Version: %v.", shh.Version) } if w.GetFilter(0) != nil { - x.Errorf("failed GetFilter.") - return + x.Fatalf("failed GetFilter.") } peerID := make([]byte, 64) randomize(peerID) peer, err := w.getPeer(peerID) if peer != nil { - x.Errorf("failed GetPeer.") - return + x.Fatalf("failed GetPeer.") } err = w.MarkPeerTrusted(peerID) if err == nil { - x.Errorf("failed MarkPeerTrusted.") - return + x.Fatalf("failed MarkPeerTrusted.") } err = w.RequestHistoricMessages(peerID, peerID) if err == nil { - x.Errorf("failed RequestHistoricMessages.") - return + x.Fatalf("failed RequestHistoricMessages.") } err = w.SendP2PMessage(peerID, nil) if err == nil { - x.Errorf("failed SendP2PMessage.") - return + x.Fatalf("failed SendP2PMessage.") } exist := w.HasSymKey("non-existing") if exist { - x.Errorf("failed HasSymKey.") - return + x.Fatalf("failed HasSymKey.") } key := w.GetSymKey("non-existing") if key != nil { - x.Errorf("failed GetSymKey.") - return + x.Fatalf("failed GetSymKey.") } mail := w.Envelopes() if len(mail) != 0 { - x.Errorf("failed w.Envelopes().") - return + x.Fatalf("failed w.Envelopes().") } m := w.Messages(0) if len(m) != 0 { - x.Errorf("failed w.Messages.") - return + x.Fatalf("failed w.Messages.") } var derived []byte ver := uint64(0xDEADBEEF) derived, err = deriveKeyMaterial(peerID, ver) if err != unknownVersionError(ver) { - x.Errorf("failed deriveKeyMaterial 1 with param = %v: %s.", peerID, err) - return + x.Fatalf("failed deriveKeyMaterial test case 1 with param = %v: %s.", peerID, err) } derived, err = deriveKeyMaterial(peerID, 0) if err != nil { - x.Errorf("failed deriveKeyMaterial 2 with param = %v: %s.", peerID, err) - return + x.Fatalf("failed deriveKeyMaterial test case 2 with param = %v: %s.", peerID, err) } if !validateSymmetricKey(derived) { - x.Errorf("failed validateSymmetricKey with param = %v.", derived) - return + x.Fatalf("failed validateSymmetricKey with param = %v.", derived) } if containsOnlyZeros(derived) { - x.Errorf("failed containsOnlyZeros with param = %v.", derived) - return + x.Fatalf("failed containsOnlyZeros with param = %v.", derived) } buf := []byte{0xFF, 0xE5, 0x80, 0x2, 0} le := bytesToIntLittleEndian(buf) be := BytesToIntBigEndian(buf) if le != uint64(0x280e5ff) { - x.Errorf("failed bytesToIntLittleEndian: %d.", le) - return + x.Fatalf("failed bytesToIntLittleEndian: %d.", le) } if be != uint64(0xffe5800200) { - x.Errorf("failed BytesToIntBigEndian: %d.", be) - return + x.Fatalf("failed BytesToIntBigEndian: %d.", be) } pk := w.NewIdentity() if !validatePrivateKey(pk) { - x.Errorf("failed validatePrivateKey: %v.", pk) - return + x.Fatalf("failed validatePrivateKey: %v.", pk) } if !ValidatePublicKey(&pk.PublicKey) { - x.Errorf("failed ValidatePublicKey: %v.", pk) - return + x.Fatalf("failed ValidatePublicKey: %v.", pk) } } @@ -149,20 +127,16 @@ func TestWhisperIdentityManagement(x *testing.T) { pk1 := w.GetIdentity(pub1) pk2 := w.GetIdentity(pub2) if !w.HasIdentity(pub1) { - x.Errorf("failed HasIdentity 1.") - return + x.Fatalf("failed test case 1.") } if !w.HasIdentity(pub2) { - x.Errorf("failed HasIdentity 2.") - return + x.Fatalf("failed test case 2.") } if pk1 != id1 { - x.Errorf("failed GetIdentity 3.") - return + x.Fatalf("failed test case 3.") } if pk2 != id2 { - x.Errorf("failed GetIdentity 4.") - return + x.Fatalf("failed test case 4.") } // Delete one identity @@ -170,20 +144,16 @@ func TestWhisperIdentityManagement(x *testing.T) { pk1 = w.GetIdentity(pub1) pk2 = w.GetIdentity(pub2) if w.HasIdentity(pub1) { - x.Errorf("failed HasIdentity 11.") - return + x.Fatalf("failed test case 11.") } if !w.HasIdentity(pub2) { - x.Errorf("failed HasIdentity 12.") - return + x.Fatalf("failed test case 12.") } if pk1 != nil { - x.Errorf("failed GetIdentity 13.") - return + x.Fatalf("failed test case 13.") } if pk2 != id2 { - x.Errorf("failed GetIdentity 14.") - return + x.Fatalf("failed test case 14.") } // Delete again non-existing identity @@ -191,20 +161,16 @@ func TestWhisperIdentityManagement(x *testing.T) { pk1 = w.GetIdentity(pub1) pk2 = w.GetIdentity(pub2) if w.HasIdentity(pub1) { - x.Errorf("failed HasIdentity 21.") - return + x.Fatalf("failed test case 21.") } if !w.HasIdentity(pub2) { - x.Errorf("failed HasIdentity 22.") - return + x.Fatalf("failed test case 22.") } if pk1 != nil { - x.Errorf("failed GetIdentity 23.") - return + x.Fatalf("failed test case 23.") } if pk2 != id2 { - x.Errorf("failed GetIdentity 24.") - return + x.Fatalf("failed test case 24.") } // Delete second identity @@ -212,20 +178,16 @@ func TestWhisperIdentityManagement(x *testing.T) { pk1 = w.GetIdentity(pub1) pk2 = w.GetIdentity(pub2) if w.HasIdentity(pub1) { - x.Errorf("failed HasIdentity 31.") - return + x.Fatalf("failed test case 31.") } if w.HasIdentity(pub2) { - x.Errorf("failed HasIdentity 32.") - return + x.Fatalf("failed test case 32.") } if pk1 != nil { - x.Errorf("failed GetIdentity 33.") - return + x.Fatalf("failed test case 33.") } if pk2 != nil { - x.Errorf("failed GetIdentity 34.") - return + x.Fatalf("failed test case 34.") } } @@ -239,27 +201,22 @@ func TestWhisperSymKeyManagement(x *testing.T) { err := w.GenerateSymKey(id1) if err != nil { - x.Errorf("failed test case 1 with seed %d: %s.", seed, err) - return + x.Fatalf("failed test case 1 with seed %d: %s.", seed, err) } k1 = w.GetSymKey(id1) k2 = w.GetSymKey(id2) if !w.HasSymKey(id1) { - x.Errorf("failed HasIdentity 2.") - return + x.Fatalf("failed test case 2.") } if w.HasSymKey(id2) { - x.Errorf("failed HasIdentity 3.") - return + x.Fatalf("failed test case 3.") } if k1 == nil { - x.Errorf("failed GetIdentity 4.") - return + x.Fatalf("failed test case 4.") } if k2 != nil { - x.Errorf("failed GetIdentity 5.") - return + x.Fatalf("failed test case 5.") } // add existing id, nothing should change @@ -267,91 +224,72 @@ func TestWhisperSymKeyManagement(x *testing.T) { randomize(randomKey) err = w.AddSymKey(id1, randomKey) if err == nil { - x.Errorf("failed test case 10 with seed %d.", seed) - return + x.Fatalf("failed test case 10 with seed %d.", seed) } k1 = w.GetSymKey(id1) k2 = w.GetSymKey(id2) if !w.HasSymKey(id1) { - x.Errorf("failed HasIdentity 12.") - return + x.Fatalf("failed test case 12.") } if w.HasSymKey(id2) { - x.Errorf("failed HasIdentity 13.") - return + x.Fatalf("failed test case 13.") } if k1 == nil { - x.Errorf("failed GetIdentity 14.") - return + x.Fatalf("failed test case 14.") } if bytes.Compare(k1, randomKey) == 0 { - x.Errorf("failed GetIdentity 15: k1 == randomKey.") - return + x.Fatalf("failed test case 15: k1 == randomKey.") } if k2 != nil { - x.Errorf("failed GetIdentity 16.") - return + x.Fatalf("failed test case 16.") } err = w.AddSymKey(id2, randomKey) // add non-existing (yet) if err != nil { - x.Errorf("failed test case 21 with seed %d: %s.", seed, err) - return + x.Fatalf("failed test case 21 with seed %d: %s.", seed, err) } k1 = w.GetSymKey(id1) k2 = w.GetSymKey(id2) if !w.HasSymKey(id1) { - x.Errorf("failed HasIdentity 22.") - return + x.Fatalf("failed test case 22.") } if !w.HasSymKey(id2) { - x.Errorf("failed HasIdentity 23.") - return + x.Fatalf("failed test case 23.") } if k1 == nil { - x.Errorf("failed GetIdentity 24.") - return + x.Fatalf("failed test case 24.") } if k2 == nil { - x.Errorf("failed GetIdentity 25.") - return + x.Fatalf("failed test case 25.") } if bytes.Compare(k1, k2) == 0 { - x.Errorf("failed GetIdentity 26.") - return + x.Fatalf("failed test case 26.") } if bytes.Compare(k1, randomKey) == 0 { - x.Errorf("failed GetIdentity 27.") - return + x.Fatalf("failed test case 27.") } if len(k1) != aesKeyLength { - x.Errorf("failed GetIdentity 28.") - return + x.Fatalf("failed test case 28.") } if len(k2) != aesKeyLength { - x.Errorf("failed GetIdentity 29.") - return + x.Fatalf("failed test case 29.") } w.DeleteSymKey(id1) k1 = w.GetSymKey(id1) k2 = w.GetSymKey(id2) if w.HasSymKey(id1) { - x.Errorf("failed HasIdentity 31.") - return + x.Fatalf("failed test case 31.") } if !w.HasSymKey(id2) { - x.Errorf("failed HasIdentity 32.") - return + x.Fatalf("failed test case 32.") } if k1 != nil { - x.Errorf("failed GetIdentity 33.") - return + x.Fatalf("failed test case 33.") } if k2 == nil { - x.Errorf("failed GetIdentity 34.") - return + x.Fatalf("failed test case 34.") } w.DeleteSymKey(id1) @@ -359,19 +297,15 @@ func TestWhisperSymKeyManagement(x *testing.T) { k1 = w.GetSymKey(id1) k2 = w.GetSymKey(id2) if w.HasSymKey(id1) { - x.Errorf("failed HasIdentity 41.") - return + x.Fatalf("failed test case 41.") } if w.HasSymKey(id2) { - x.Errorf("failed HasIdentity 42.") - return + x.Fatalf("failed test case 42.") } if k1 != nil { - x.Errorf("failed GetIdentity 43.") - return + x.Fatalf("failed test case 43.") } if k2 != nil { - x.Errorf("failed GetIdentity 44.") - return + x.Fatalf("failed test case 44.") } }