document: benchmark sign and verify (with parsing and formatting)

diff --git a/pkg/document/document_test.go b/pkg/document/document_test.go
index 93b0584..4a3c832 100644 (file)
--- a/pkg/document/document_test.go
+++ b/pkg/document/document_test.go
@@ -3,6 +3,7 @@ package document
 import (
        "bytes"
        "crypto/openpgp"
+       "fmt"
        "testing"
 )
 
@@ -230,24 +231,26 @@ func TestCert(t *testing.T) {
        }
 }
 
-func parsekey(key []byte, t *testing.T) *openpgp.Entity {
+func parsekey(key []byte) (*openpgp.Entity, error) {
        elist, err := openpgp.ReadArmoredKeyRing(bytes.NewBuffer(key))
        if err != nil {
-               t.Error(err)
-               return nil
+               return nil, err
        }
        if len(elist) != 1 {
-               t.Errorf("expected one key, got %d", len(elist))
-               return nil
+               return nil, fmt.Errorf("expected one key, got %d", len(elist))
        }
-       return elist[0]
+       return elist[0], nil
 }
 
 func TestSign(t *testing.T) {
-       k1 := parsekey(skey1, t)
-       k2 := parsekey(pkey2, t)
-       if k1 == nil || k2 == nil {
-               t.Errorf("parsing keys failed")
+       k1, err := parsekey(skey1)
+       if err != nil {
+               t.Errorf("parsing key1 failed: %s", err)
+               return
+       }
+       k2, err := parsekey(pkey2)
+       if err != nil {
+               t.Errorf("parsing key2 failed: %s", err)
                return
        }
        signed, err := Sign([]byte(debitBody), k1)
@@ -265,6 +268,70 @@ func TestSign(t *testing.T) {
        }
 }
 
+func debitcert() (d *DebitCert, err error) {
+       doc, err := ParseDocument([]byte(debitBody))
+       if err != nil {
+               return
+       }
+       iv, err := ParseStruct(doc)
+       if err != nil {
+               return
+       }
+       d, ok := iv.(*DebitCert)
+       if !ok {
+               err = fmt.Errorf("expecetd *DebitCert, got %T", d)
+       }
+       return
+}
+
+func BenchmarkSign(b *testing.B) {
+       d, err := debitcert()
+       if err != nil {
+               panic(err)
+       }
+       b.ResetTimer()
+       for i := 0; i < b.N; i++ {
+               k, err := parsekey(skey1)
+               if err != nil {
+                       panic(err)
+               }
+               _, _, err = Format(d, k)
+               if err != nil {
+                       panic(err)
+               }
+       }
+}
+
+func BenchmarkVerify(b *testing.B) {
+       d, err := debitcert()
+       if err != nil {
+               panic(err)
+       }
+       k, err := parsekey(skey1)
+       if err != nil {
+               panic(err)
+       }
+       s, _, err := Format(d, k)
+       if err != nil {
+               panic(err)
+       }
+       b.ResetTimer()
+       for i := 0; i < b.N; i++ {
+               k, err := parsekey(skey1)
+               if err != nil {
+                       panic(err)
+               }
+               _, signed, err := Parse(s)
+               if err != nil {
+                       panic(err)
+               }
+               err = Verify(signed, openpgp.EntityList{k})
+               if err != nil {
+                       panic(err)
+               }
+       }
+}
+
 var skey1 = []byte(`-----BEGIN PGP PRIVATE KEY BLOCK-----
 
 xcD7BAAAAAARBACk0rlXXCXw5iK4aUOHEop5PhrSfRL/9LW6EaN879Mck1vLsKlE