5cea53af26
```
goos: linux
goarch: amd64
pkg: github.com/ucan-wg/go-varsig
cpu: 13th Gen Intel(R) Core(TM) i7-1360P
│ old.txt │ new.txt │
│ sec/op │ sec/op vs base │
DecodeHashAlgorithm-16 145.65n ± 10% 59.62n ± 30% -59.07% (p=0.000 n=10)
DecodePayloadEncoding-16 136.65n ± 46% 50.02n ± 5% -63.40% (p=0.000 n=10)
geomean 141.1n 54.60n -61.29%
│ old.txt │ new.txt │
│ B/op │ B/op vs base │
DecodeHashAlgorithm-16 48.00 ± 0% 48.00 ± 0% ~ (p=1.000 n=10) ¹
DecodePayloadEncoding-16 48.00 ± 0% 48.00 ± 0% ~ (p=1.000 n=10) ¹
geomean 48.00 48.00 +0.00%
¹ all samples are equal
│ old.txt │ new.txt │
│ allocs/op │ allocs/op vs base │
DecodeHashAlgorithm-16 1.000 ± 0% 1.000 ± 0% ~ (p=1.000 n=10) ¹
DecodePayloadEncoding-16 1.000 ± 0% 1.000 ± 0% ~ (p=1.000 n=10) ¹
geomean 1.000 1.000 +0.00%
¹ all samples are equal
```
124 lines
2.8 KiB
Go
124 lines
2.8 KiB
Go
package varsig_test
|
|
|
|
import (
|
|
"bytes"
|
|
"io"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/ucan-wg/go-varsig"
|
|
)
|
|
|
|
func TestDecodeHashAlgorithm(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
t.Run("passes", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
hashAlg, err := varsig.DecodeHashAlgorithm(bytes.NewReader([]byte{0x12}))
|
|
require.NoError(t, err)
|
|
require.Equal(t, varsig.HashAlgorithmSHA256, hashAlg)
|
|
})
|
|
|
|
t.Run("fails - truncated varsig (no bytes)", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
hashAlg, err := varsig.DecodeHashAlgorithm(bytes.NewReader([]byte{}))
|
|
require.ErrorIs(t, err, varsig.ErrUnknownHashAlgorithm)
|
|
require.ErrorIs(t, err, io.EOF)
|
|
require.Equal(t, varsig.HashAlgorithmUnspecified, hashAlg)
|
|
})
|
|
|
|
t.Run("fails - unknown hash algorithm", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
hashAlg, err := varsig.DecodeHashAlgorithm(bytes.NewReader([]byte{0x42}))
|
|
require.ErrorIs(t, err, varsig.ErrUnknownHashAlgorithm)
|
|
require.Equal(t, varsig.HashAlgorithmUnspecified, hashAlg)
|
|
})
|
|
}
|
|
|
|
func BenchmarkDecodeHashAlgorithm(b *testing.B) {
|
|
b.ReportAllocs()
|
|
data := []byte{0x12}
|
|
for i := 0; i < b.N; i++ {
|
|
_, _ = varsig.DecodeHashAlgorithm(bytes.NewReader(data))
|
|
}
|
|
}
|
|
|
|
func TestDecodePayloadEncoding(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
t.Run("passes", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
t.Run("v0", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
payEnc, err := varsig.DecodePayloadEncoding(bytes.NewReader([]byte{0x5f}), varsig.Version1)
|
|
require.NoError(t, err)
|
|
require.Equal(t, varsig.PayloadEncodingVerbatim, payEnc)
|
|
})
|
|
|
|
t.Run("v1", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
payEnc, err := varsig.DecodePayloadEncoding(bytes.NewReader([]byte{0x5f}), varsig.Version1)
|
|
require.NoError(t, err)
|
|
require.Equal(t, varsig.PayloadEncodingVerbatim, payEnc)
|
|
})
|
|
})
|
|
|
|
t.Run("fails", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
name string
|
|
data []byte
|
|
vers varsig.Version
|
|
err error
|
|
}{
|
|
{
|
|
name: "unsupported encoding - v0",
|
|
data: []byte{0x42}, // random
|
|
vers: varsig.Version0,
|
|
err: varsig.ErrUnsupportedPayloadEncoding,
|
|
},
|
|
{
|
|
name: "unsupported encoding - v1",
|
|
data: []byte{0x6a, 0x77}, // JWT
|
|
vers: varsig.Version1,
|
|
err: varsig.ErrUnsupportedPayloadEncoding,
|
|
},
|
|
{
|
|
name: "unsupported version",
|
|
data: []byte{0x5f}, // Verbatim
|
|
vers: 99, // random
|
|
err: varsig.ErrUnsupportedVersion,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
tt := tt
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
r := bytes.NewReader(tt.data)
|
|
_, err := varsig.DecodePayloadEncoding(r, tt.vers)
|
|
require.ErrorIs(t, err, tt.err)
|
|
// t.Log(err)
|
|
// t.Fail()
|
|
})
|
|
}
|
|
})
|
|
}
|
|
|
|
func BenchmarkDecodePayloadEncoding(b *testing.B) {
|
|
b.ReportAllocs()
|
|
data := []byte{0x5f}
|
|
for i := 0; i < b.N; i++ {
|
|
_, _ = varsig.DecodePayloadEncoding(bytes.NewReader(data), varsig.Version1)
|
|
}
|
|
}
|