evaluate error in tests

[govpn.git] / src / cypherpunks.ru / govpn / peer_test.go

diff --git a/src/cypherpunks.ru/govpn/peer_test.go b/src/cypherpunks.ru/govpn/peer_test.go
index 7fa8aab8438a7fd04eaccf53972064edd91b8792..89fc0cd230051b5f295e4d12136061226565bac2 100644 (file)
--- a/src/cypherpunks.ru/govpn/peer_test.go
+++ b/src/cypherpunks.ru/govpn/peer_test.go
@@ -1,6 +1,6 @@
 /*
 GoVPN -- simple secure free software virtual private network daemon
-Copyright (C) 2014-2016 Sergey Matveev <stargrave@stargrave.org>
+Copyright (C) 2014-2017 Sergey Matveev <stargrave@stargrave.org>
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -21,14 +21,13 @@ package govpn
 import (
        "testing"
        "testing/quick"
-       "time"
 )
 
 var (
        testPeer   *Peer
        testPt     []byte
        testCt     []byte
-       testPeerId PeerId
+       testPeerID PeerID
        testConf   *PeerConf
 )
 
@@ -45,23 +44,36 @@ func (d Dummy) Write(b []byte) (int, error) {
 
 func init() {
        id := new([IDSize]byte)
-       testPeerId = PeerId(*id)
+       testPeerID = PeerID(*id)
        testConf = &PeerConf{
-               Id:      &testPeerId,
+               ID:      &testPeerID,
                MTU:     MTUDefault,
-               Timeout: time.Second * time.Duration(TimeoutDefault),
+               Timeout: TimeoutDefault,
        }
-       testPeer = newPeer(true, "foo", Dummy{&testCt}, testConf, new([SSize]byte))
        testPt = make([]byte, 789)
 }
 
+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) {
-       peerd := newPeer(true, "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 {
@@ -70,14 +82,20 @@ func TestTransportSymmetric(t *testing.T) {
 }
 
 func TestTransportSymmetricNoise(t *testing.T) {
-       peerd := newPeer(true, "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 {
@@ -87,7 +105,11 @@ func TestTransportSymmetricNoise(t *testing.T) {
 }
 
 func TestTransportSymmetricEncless(t *testing.T) {
-       peerd := newPeer(true, "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
@@ -96,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 {
@@ -107,22 +131,37 @@ func TestTransportSymmetricEncless(t *testing.T) {
 }
 
 func BenchmarkEnc(b *testing.B) {
-       b.ResetTimer()
+       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)
+       copy(nonce[:], testCt[len(testCt)-NonceSize:])
        b.ResetTimer()
        for i := 0; i < b.N; i++ {
-               testPeer.nonceBucket0 = make(map[uint64]struct{}, 1)
-               testPeer.nonceBucket1 = make(map[uint64]struct{}, 1)
+               testPeer.nonceBucketL = make(map[[NonceSize]byte]struct{}, 1)
+               testPeer.nonceBucketM = make(map[[NonceSize]byte]struct{}, 1)
+               testPeer.nonceBucketH = make(map[[NonceSize]byte]struct{}, 1)
+               testPeer.nonceBucketL[*nonce] = struct{}{}
                copy(testCt, orig)
                if !testPeer.PktProcess(testCt, Dummy{nil}, true) {
                        b.Fail()