136 lines
3.0 KiB
Go
136 lines
3.0 KiB
Go
package apdu
|
|
|
|
import (
|
|
"bytes"
|
|
"testing"
|
|
|
|
"github.com/status-im/keycard-go/hexutils"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestFindTag(t *testing.T) {
|
|
var (
|
|
tagData []byte
|
|
err error
|
|
)
|
|
|
|
data := hexutils.HexToBytes("C1 02 BB CC C2 04 C3 02 11 22 C3 02 88 99")
|
|
|
|
tagData, err = FindTag(data, Tag{0xC1})
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, "BB CC", hexutils.BytesToHexWithSpaces(tagData))
|
|
|
|
tagData, err = FindTag(data, Tag{0xC2})
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, "C3 02 11 22", hexutils.BytesToHexWithSpaces(tagData))
|
|
|
|
tagData, err = FindTag(data, Tag{0xC3})
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, "88 99", hexutils.BytesToHexWithSpaces(tagData))
|
|
|
|
tagData, err = FindTag(data, Tag{0xC2}, Tag{0xC3})
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, "11 22", hexutils.BytesToHexWithSpaces(tagData))
|
|
|
|
// tag not found
|
|
data = hexutils.HexToBytes("C1 00")
|
|
_, err = FindTag(data, Tag{0xC2})
|
|
assert.Equal(t, &ErrTagNotFound{Tag{0xC2}}, err)
|
|
|
|
// sub-tag not found
|
|
data = hexutils.HexToBytes("C1 02 C2 00")
|
|
_, err = FindTag(data, Tag{0xC1}, Tag{0xC3})
|
|
assert.Equal(t, &ErrTagNotFound{Tag{0xC3}}, err)
|
|
}
|
|
|
|
func TestParseLength(t *testing.T) {
|
|
scenarios := []struct {
|
|
data []byte
|
|
expectedLength uint32
|
|
err error
|
|
}{
|
|
{
|
|
data: []byte{0x01, 0xAA},
|
|
expectedLength: 1,
|
|
err: nil,
|
|
},
|
|
{
|
|
data: []byte{0x7F, 0xAA},
|
|
expectedLength: 127,
|
|
err: nil,
|
|
},
|
|
{
|
|
data: []byte{0x81, 0x80, 0xAA},
|
|
expectedLength: 128,
|
|
err: nil,
|
|
},
|
|
{
|
|
data: []byte{0x82, 0x80, 0x80, 0xAA},
|
|
expectedLength: 32896,
|
|
err: nil,
|
|
},
|
|
{
|
|
data: []byte{0x83, 0x80, 0x80, 0x80, 0xAA},
|
|
expectedLength: 8421504,
|
|
err: nil,
|
|
},
|
|
{
|
|
data: []byte{0x80, 0xAA},
|
|
expectedLength: 0,
|
|
err: ErrUnsupportedLenth80,
|
|
},
|
|
{
|
|
data: []byte{0x84, 0xAA},
|
|
expectedLength: 0,
|
|
err: ErrLengthTooBig,
|
|
},
|
|
}
|
|
|
|
for _, s := range scenarios {
|
|
buf := bytes.NewBuffer(s.data)
|
|
length, _, err := parseLength(buf)
|
|
if s.err == nil {
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, s.expectedLength, length)
|
|
} else {
|
|
assert.Equal(t, s.err, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestFindTagN(t *testing.T) {
|
|
data := hexutils.HexToBytes("0A 01 A1 0A 01 A2")
|
|
|
|
tagData, err := FindTagN(data, 0, Tag{0x0A})
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, "A1", hexutils.BytesToHexWithSpaces(tagData))
|
|
|
|
tagData, err = FindTagN(data, 1, Tag{0x0A})
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, "A2", hexutils.BytesToHexWithSpaces(tagData))
|
|
}
|
|
|
|
func TestParseTag(t *testing.T) {
|
|
scenarios := []struct {
|
|
rawTag []byte
|
|
expectedTag Tag
|
|
}{
|
|
{
|
|
rawTag: []byte{0x01, 0x02},
|
|
expectedTag: Tag{0x01},
|
|
},
|
|
{
|
|
rawTag: []byte{0x9F, 0x70, 0x01},
|
|
expectedTag: Tag{0x9f, 0x70},
|
|
},
|
|
}
|
|
|
|
for _, s := range scenarios {
|
|
buf := bytes.NewBuffer(s.rawTag)
|
|
tag, _, err := parseTag(buf)
|
|
require.Nil(t, err)
|
|
assert.Equal(t, s.expectedTag, tag)
|
|
}
|
|
}
|