evaluate error in tests

diff --git a/src/cypherpunks.ru/govpn/handshake_test.go b/src/cypherpunks.ru/govpn/handshake_test.go
index 077146583c654c5fb726aaab70e03430b14cf104..a0908a517a9dbfae1b927a4e34ac4e774aeeb7aa 100644 (file)
--- 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 6c16469f18c008298918d43f34e902fd965dacec..89fc0cd230051b5f295e4d12136061226565bac2 100644 (file)
--- 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)