From 013fd4fd1208f2cd1a35be460108ba383dd67d8d Mon Sep 17 00:00:00 2001 From: Bruno Clermont Date: Wed, 8 Feb 2017 18:31:16 +0800 Subject: [PATCH] evaluate error in tests --- src/cypherpunks.ru/govpn/handshake_test.go | 79 ++++++++++++++-------- src/cypherpunks.ru/govpn/peer_test.go | 64 +++++++++++++----- 2 files changed, 99 insertions(+), 44 deletions(-) diff --git a/src/cypherpunks.ru/govpn/handshake_test.go b/src/cypherpunks.ru/govpn/handshake_test.go index 0771465..a0908a5 100644 --- a/src/cypherpunks.ru/govpn/handshake_test.go +++ b/src/cypherpunks.ru/govpn/handshake_test.go @@ -22,58 +22,83 @@ import ( "testing" ) +func testHandshake(t *testing.T, cl, srv *Handshake) { + var err error + if _, err = srv.Server(testCt); err != nil { + t.Error(err) + } + if _, err = cl.Client(testCt); err != nil { + t.Error(err) + } + p, err := srv.Server(testCt) + if p == nil { + t.Fail() + } + if err != nil { + t.Error(err) + } + p, err = cl.Client(testCt) + if p == nil { + t.Fail() + } + if err != nil { + t.Error(err) + } +} + func TestHandshakeSymmetric(t *testing.T) { + var err error // initial values are taken from peer_test.go's init() v := VerifierNew(1<<10, 1<<4, 1, &testPeerID) testConf.Verifier = v - testConf.DSAPriv = v.PasswordApply("does not matter") - hsS := NewHandshake("server", Dummy{&testCt}, testConf) - hsC := HandshakeStart("client", Dummy{&testCt}, testConf) - hsS.Server(testCt) - hsC.Client(testCt) - if hsS.Server(testCt) == nil { - t.Fail() + testConf.DSAPriv, err = v.PasswordApply("does not matter") + if err != nil { + t.Error(err) } - if hsC.Client(testCt) == nil { - t.Fail() + hsS := NewHandshake("server", Dummy{&testCt}, testConf) + hsC, err := HandshakeStart("client", Dummy{&testCt}, testConf) + if err != nil { + t.Error(err) } + testHandshake(t, hsC, hsS) } func TestHandshakeNoiseSymmetric(t *testing.T) { + var err error // initial values are taken from peer_test.go's init() v := VerifierNew(1<<10, 1<<4, 1, &testPeerID) testConf.Verifier = v - testConf.DSAPriv = v.PasswordApply("does not matter") + testConf.DSAPriv, err = v.PasswordApply("does not matter") + if err != nil { + t.Error(err) + } testConf.Noise = true hsS := NewHandshake("server", Dummy{&testCt}, testConf) - hsC := HandshakeStart("client", Dummy{&testCt}, testConf) - hsS.Server(testCt) - hsC.Client(testCt) - if hsS.Server(testCt) == nil { - t.Fail() - } - if hsC.Client(testCt) == nil { - t.Fail() + hsC, err := HandshakeStart("client", Dummy{&testCt}, testConf) + if err != nil { + t.Error(err) } + testHandshake(t, hsC, hsS) testConf.Noise = false } + func TestHandshakeEnclessSymmetric(t *testing.T) { + var err error // initial values are taken from peer_test.go's init() v := VerifierNew(1<<10, 1<<4, 1, &testPeerID) testConf.Verifier = v - testConf.DSAPriv = v.PasswordApply("does not matter") + testConf.DSAPriv, err = v.PasswordApply("does not matter") + if err != nil { + t.Error(err) + } testConf.Encless = true testConf.Noise = true hsS := NewHandshake("server", Dummy{&testCt}, testConf) - hsC := HandshakeStart("client", Dummy{&testCt}, testConf) - hsS.Server(testCt) - hsC.Client(testCt) - if hsS.Server(testCt) == nil { - t.Fail() - } - if hsC.Client(testCt) == nil { - t.Fail() + hsC, err := HandshakeStart("client", Dummy{&testCt}, testConf) + if err != nil { + t.Error(err) } + testHandshake(t, hsC, hsS) testConf.Encless = false testConf.Noise = false } diff --git a/src/cypherpunks.ru/govpn/peer_test.go b/src/cypherpunks.ru/govpn/peer_test.go index 6c16469..89fc0cd 100644 --- a/src/cypherpunks.ru/govpn/peer_test.go +++ b/src/cypherpunks.ru/govpn/peer_test.go @@ -21,7 +21,6 @@ package govpn import ( "testing" "testing/quick" - "time" ) var ( @@ -49,23 +48,32 @@ func init() { testConf = &PeerConf{ ID: &testPeerID, MTU: MTUDefault, - Timeout: time.Second * time.Duration(TimeoutDefault), + Timeout: TimeoutDefault, } testPt = make([]byte, 789) } -func testPeerNew() { - testPeer = newPeer(true, "foo", Dummy{&testCt}, testConf, new([SSize]byte)) +func testPeerNew(t *testing.T) { + var err error + testPeer, err = newPeer(true, "foo", Dummy{&testCt}, testConf, new([SSize]byte)) + if err != nil { + t.Error(err) + } } func TestTransportSymmetric(t *testing.T) { - testPeerNew() - peerd := newPeer(false, "foo", Dummy{nil}, testConf, new([SSize]byte)) + testPeerNew(t) + peerd, err := newPeer(false, "foo", Dummy{nil}, testConf, new([SSize]byte)) + if err != nil { + t.Error(err) + } f := func(payload []byte) bool { if len(payload) == 0 { return true } - testPeer.EthProcess(payload) + if err := testPeer.EthProcess(payload); err != nil { + t.Error(err) + } return peerd.PktProcess(testCt, Dummy{nil}, true) } if err := quick.Check(f, nil); err != nil { @@ -74,15 +82,20 @@ func TestTransportSymmetric(t *testing.T) { } func TestTransportSymmetricNoise(t *testing.T) { - testPeerNew() - peerd := newPeer(false, "foo", Dummy{nil}, testConf, new([SSize]byte)) + testPeerNew(t) + peerd, err := newPeer(false, "foo", Dummy{nil}, testConf, new([SSize]byte)) + if err != nil { + t.Error(err) + } testPeer.NoiseEnable = true peerd.NoiseEnable = true f := func(payload []byte) bool { if len(payload) == 0 { return true } - testPeer.EthProcess(payload) + if err := testPeer.EthProcess(payload); err != nil { + t.Error(err) + } return peerd.PktProcess(testCt, Dummy{nil}, true) } if err := quick.Check(f, nil); err != nil { @@ -92,8 +105,11 @@ func TestTransportSymmetricNoise(t *testing.T) { } func TestTransportSymmetricEncless(t *testing.T) { - testPeerNew() - peerd := newPeer(false, "foo", Dummy{nil}, testConf, new([SSize]byte)) + testPeerNew(t) + peerd, err := newPeer(false, "foo", Dummy{nil}, testConf, new([SSize]byte)) + if err != nil { + t.Error(err) + } testPeer.Encless = true testPeer.NoiseEnable = true peerd.Encless = true @@ -102,7 +118,9 @@ func TestTransportSymmetricEncless(t *testing.T) { if len(payload) == 0 { return true } - testPeer.EthProcess(payload) + if err := testPeer.EthProcess(payload); err != nil { + t.Error(err) + } return peerd.PktProcess(testCt, Dummy{nil}, true) } if err := quick.Check(f, nil); err != nil { @@ -113,15 +131,27 @@ func TestTransportSymmetricEncless(t *testing.T) { } func BenchmarkEnc(b *testing.B) { + var err error for i := 0; i < b.N; i++ { - testPeer.EthProcess(testPt) + if err = testPeer.EthProcess(testPt); err != nil { + b.Error(err) + } } } func BenchmarkDec(b *testing.B) { - testPeer = newPeer(true, "foo", Dummy{&testCt}, testConf, new([SSize]byte)) - testPeer.EthProcess(testPt) - testPeer = newPeer(true, "foo", Dummy{nil}, testConf, new([SSize]byte)) + var err error + testPeer, err = newPeer(true, "foo", Dummy{&testCt}, testConf, new([SSize]byte)) + if err != nil { + b.Error(err) + } + if err := testPeer.EthProcess(testPt); err != nil { + b.Error(err) + } + testPeer, err = newPeer(true, "foo", Dummy{nil}, testConf, new([SSize]byte)) + if err != nil { + b.Error(err) + } orig := make([]byte, len(testCt)) copy(orig, testCt) nonce := new([NonceSize]byte) -- 2.44.0