541 lines
16 KiB
Go
541 lines
16 KiB
Go
package address
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/base32"
|
|
"fmt"
|
|
"math"
|
|
"math/rand"
|
|
"strconv"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/filecoin-project/go-bls-sigs"
|
|
"github.com/filecoin-project/go-leb128"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/filecoin-project/lotus/lib/crypto"
|
|
)
|
|
|
|
func init() {
|
|
rand.Seed(time.Now().Unix())
|
|
}
|
|
|
|
func TestRandomIDAddress(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
addr, err := NewIDAddress(uint64(rand.Int()))
|
|
assert.NoError(err)
|
|
assert.Equal(ID, addr.Protocol())
|
|
|
|
str, err := encode(Testnet, addr)
|
|
assert.NoError(err)
|
|
|
|
maybe, err := decode(str)
|
|
assert.NoError(err)
|
|
assert.Equal(addr, maybe)
|
|
|
|
}
|
|
|
|
var allTestAddresses = []string{
|
|
"t00",
|
|
"t01",
|
|
"t010",
|
|
"t0150",
|
|
"t0499",
|
|
"t01024",
|
|
"t01729",
|
|
"t0999999",
|
|
"t15ihq5ibzwki2b4ep2f46avlkrqzhpqgtga7pdrq",
|
|
"t12fiakbhe2gwd5cnmrenekasyn6v5tnaxaqizq6a",
|
|
"t1wbxhu3ypkuo6eyp6hjx6davuelxaxrvwb2kuwva",
|
|
"t1xtwapqc6nh4si2hcwpr3656iotzmlwumogqbuaa",
|
|
"t1xcbgdhkgkwht3hrrnui3jdopeejsoatkzmoltqy",
|
|
"t17uoq6tp427uzv7fztkbsnn64iwotfrristwpryy",
|
|
"t24vg6ut43yw2h2jqydgbg2xq7x6f4kub3bg6as6i",
|
|
"t25nml2cfbljvn4goqtclhifepvfnicv6g7mfmmvq",
|
|
"t2nuqrg7vuysaue2pistjjnt3fadsdzvyuatqtfei",
|
|
"t24dd4ox4c2vpf5vk5wkadgyyn6qtuvgcpxxon64a",
|
|
"t2gfvuyh7v2sx3patm5k23wdzmhyhtmqctasbr23y",
|
|
"t3vvmn62lofvhjd2ugzca6sof2j2ubwok6cj4xxbfzz4yuxfkgobpihhd2thlanmsh3w2ptld2gqkn2jvlss4a",
|
|
"t3wmuu6crofhqmm3v4enos73okk2l366ck6yc4owxwbdtkmpk42ohkqxfitcpa57pjdcftql4tojda2poeruwa",
|
|
"t3s2q2hzhkpiknjgmf4zq3ejab2rh62qbndueslmsdzervrhapxr7dftie4kpnpdiv2n6tvkr743ndhrsw6d3a",
|
|
"t3q22fijmmlckhl56rn5nkyamkph3mcfu5ed6dheq53c244hfmnq2i7efdma3cj5voxenwiummf2ajlsbxc65a",
|
|
"t3u5zgwa4ael3vuocgc5mfgygo4yuqocrntuuhcklf4xzg5tcaqwbyfabxetwtj4tsam3pbhnwghyhijr5mixa",
|
|
}
|
|
|
|
func TestVectorsIDAddress(t *testing.T) {
|
|
testCases := []struct {
|
|
input uint64
|
|
expected string
|
|
}{
|
|
{uint64(0), "t00"},
|
|
{uint64(1), "t01"},
|
|
{uint64(10), "t010"},
|
|
{uint64(150), "t0150"},
|
|
{uint64(499), "t0499"},
|
|
{uint64(1024), "t01024"},
|
|
{uint64(1729), "t01729"},
|
|
{uint64(999999), "t0999999"},
|
|
{math.MaxUint64, fmt.Sprintf("t0%s", strconv.FormatUint(math.MaxUint64, 10))},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
tc := tc
|
|
t.Run(fmt.Sprintf("testing actorID address: %s", tc.expected), func(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
// Round trip encoding and decoding from string
|
|
addr, err := NewIDAddress(tc.input)
|
|
assert.NoError(err)
|
|
assert.Equal(tc.expected, addr.String())
|
|
|
|
maybeAddr, err := NewFromString(tc.expected)
|
|
assert.NoError(err)
|
|
assert.Equal(ID, maybeAddr.Protocol())
|
|
assert.Equal(tc.input, leb128.ToUInt64(maybeAddr.Payload()))
|
|
|
|
// Round trip to and from bytes
|
|
maybeAddrBytes, err := NewFromBytes(maybeAddr.Bytes())
|
|
assert.NoError(err)
|
|
assert.Equal(maybeAddr, maybeAddrBytes)
|
|
|
|
// Round trip encoding and decoding json
|
|
b, err := addr.MarshalJSON()
|
|
assert.NoError(err)
|
|
|
|
var newAddr Address
|
|
err = newAddr.UnmarshalJSON(b)
|
|
assert.NoError(err)
|
|
assert.Equal(addr, newAddr)
|
|
})
|
|
}
|
|
|
|
}
|
|
|
|
func TestSecp256k1Address(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
sk, err := crypto.GenerateKey()
|
|
assert.NoError(err)
|
|
|
|
addr, err := NewSecp256k1Address(crypto.PublicKey(sk))
|
|
assert.NoError(err)
|
|
assert.Equal(SECP256K1, addr.Protocol())
|
|
|
|
str, err := encode(Mainnet, addr)
|
|
assert.NoError(err)
|
|
|
|
maybe, err := decode(str)
|
|
assert.NoError(err)
|
|
assert.Equal(addr, maybe)
|
|
|
|
}
|
|
|
|
func TestVectorSecp256k1Address(t *testing.T) {
|
|
testCases := []struct {
|
|
input []byte
|
|
expected string
|
|
}{
|
|
{[]byte{4, 148, 2, 250, 195, 126, 100, 50, 164, 22, 163, 160, 202, 84,
|
|
38, 181, 24, 90, 179, 178, 79, 97, 52, 239, 162, 92, 228, 135, 200,
|
|
45, 46, 78, 19, 191, 69, 37, 17, 224, 210, 36, 84, 33, 248, 97, 59,
|
|
193, 13, 114, 250, 33, 102, 102, 169, 108, 59, 193, 57, 32, 211,
|
|
255, 35, 63, 208, 188, 5},
|
|
"t15ihq5ibzwki2b4ep2f46avlkrqzhpqgtga7pdrq"},
|
|
|
|
{[]byte{4, 118, 135, 185, 16, 55, 155, 242, 140, 190, 58, 234, 103, 75,
|
|
18, 0, 12, 107, 125, 186, 70, 255, 192, 95, 108, 148, 254, 42, 34,
|
|
187, 204, 38, 2, 255, 127, 92, 118, 242, 28, 165, 93, 54, 149, 145,
|
|
82, 176, 225, 232, 135, 145, 124, 57, 53, 118, 238, 240, 147, 246,
|
|
30, 189, 58, 208, 111, 127, 218},
|
|
"t12fiakbhe2gwd5cnmrenekasyn6v5tnaxaqizq6a"},
|
|
{[]byte{4, 222, 253, 208, 16, 1, 239, 184, 110, 1, 222, 213, 206, 52,
|
|
248, 71, 167, 58, 20, 129, 158, 230, 65, 188, 182, 11, 185, 41, 147,
|
|
89, 111, 5, 220, 45, 96, 95, 41, 133, 248, 209, 37, 129, 45, 172,
|
|
65, 99, 163, 150, 52, 155, 35, 193, 28, 194, 255, 53, 157, 229, 75,
|
|
226, 135, 234, 98, 49, 155},
|
|
"t1wbxhu3ypkuo6eyp6hjx6davuelxaxrvwb2kuwva"},
|
|
{[]byte{4, 3, 237, 18, 200, 20, 182, 177, 13, 46, 224, 157, 149, 180,
|
|
104, 141, 178, 209, 128, 208, 169, 163, 122, 107, 106, 125, 182, 61,
|
|
41, 129, 30, 233, 115, 4, 121, 216, 239, 145, 57, 233, 18, 73, 202,
|
|
189, 57, 50, 145, 207, 229, 210, 119, 186, 118, 222, 69, 227, 224,
|
|
133, 163, 118, 129, 191, 54, 69, 210},
|
|
"t1xtwapqc6nh4si2hcwpr3656iotzmlwumogqbuaa"},
|
|
{[]byte{4, 247, 150, 129, 154, 142, 39, 22, 49, 175, 124, 24, 151, 151,
|
|
181, 69, 214, 2, 37, 147, 97, 71, 230, 1, 14, 101, 98, 179, 206, 158,
|
|
254, 139, 16, 20, 65, 97, 169, 30, 208, 180, 236, 137, 8, 0, 37, 63,
|
|
166, 252, 32, 172, 144, 251, 241, 251, 242, 113, 48, 164, 236, 195,
|
|
228, 3, 183, 5, 118},
|
|
"t1xcbgdhkgkwht3hrrnui3jdopeejsoatkzmoltqy"},
|
|
{[]byte{4, 66, 131, 43, 248, 124, 206, 158, 163, 69, 185, 3, 80, 222,
|
|
125, 52, 149, 133, 156, 164, 73, 5, 156, 94, 136, 221, 231, 66, 133,
|
|
223, 251, 158, 192, 30, 186, 188, 95, 200, 98, 104, 207, 234, 235,
|
|
167, 174, 5, 191, 184, 214, 142, 183, 90, 82, 104, 120, 44, 248, 111,
|
|
200, 112, 43, 239, 138, 31, 224},
|
|
"t17uoq6tp427uzv7fztkbsnn64iwotfrristwpryy"},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
tc := tc
|
|
t.Run(fmt.Sprintf("testing secp256k1 address: %s", tc.expected), func(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
// Round trip encoding and decoding from string
|
|
addr, err := NewSecp256k1Address(tc.input)
|
|
assert.NoError(err)
|
|
assert.Equal(tc.expected, addr.String())
|
|
|
|
maybeAddr, err := NewFromString(tc.expected)
|
|
assert.NoError(err)
|
|
assert.Equal(SECP256K1, maybeAddr.Protocol())
|
|
assert.Equal(addressHash(tc.input), maybeAddr.Payload())
|
|
|
|
// Round trip to and from bytes
|
|
maybeAddrBytes, err := NewFromBytes(maybeAddr.Bytes())
|
|
assert.NoError(err)
|
|
assert.Equal(maybeAddr, maybeAddrBytes)
|
|
|
|
// Round trip encoding and decoding json
|
|
b, err := addr.MarshalJSON()
|
|
assert.NoError(err)
|
|
|
|
var newAddr Address
|
|
err = newAddr.UnmarshalJSON(b)
|
|
assert.NoError(err)
|
|
assert.Equal(addr, newAddr)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestRandomActorAddress(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
actorMsg := make([]byte, 20)
|
|
rand.Read(actorMsg)
|
|
|
|
addr, err := NewActorAddress(actorMsg)
|
|
assert.NoError(err)
|
|
assert.Equal(Actor, addr.Protocol())
|
|
|
|
str, err := encode(Mainnet, addr)
|
|
assert.NoError(err)
|
|
|
|
maybe, err := decode(str)
|
|
assert.NoError(err)
|
|
assert.Equal(addr, maybe)
|
|
|
|
}
|
|
|
|
func TestVectorActorAddress(t *testing.T) {
|
|
testCases := []struct {
|
|
input []byte
|
|
expected string
|
|
}{
|
|
{[]byte{118, 18, 129, 144, 205, 240, 104, 209, 65, 128, 68, 172, 192,
|
|
62, 11, 103, 129, 151, 13, 96},
|
|
"t24vg6ut43yw2h2jqydgbg2xq7x6f4kub3bg6as6i"},
|
|
{[]byte{44, 175, 184, 226, 224, 107, 186, 152, 234, 101, 124, 92, 245,
|
|
244, 32, 35, 170, 35, 232, 142},
|
|
"t25nml2cfbljvn4goqtclhifepvfnicv6g7mfmmvq"},
|
|
{[]byte{2, 44, 158, 14, 162, 157, 143, 64, 197, 106, 190, 195, 92, 141,
|
|
88, 125, 160, 166, 76, 24},
|
|
"t2nuqrg7vuysaue2pistjjnt3fadsdzvyuatqtfei"},
|
|
{[]byte{223, 236, 3, 14, 32, 79, 15, 89, 216, 15, 29, 94, 233, 29, 253,
|
|
6, 109, 127, 99, 189},
|
|
"t24dd4ox4c2vpf5vk5wkadgyyn6qtuvgcpxxon64a"},
|
|
{[]byte{61, 58, 137, 232, 221, 171, 84, 120, 50, 113, 108, 109, 70, 140,
|
|
53, 96, 201, 244, 127, 216},
|
|
"t2gfvuyh7v2sx3patm5k23wdzmhyhtmqctasbr23y"},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
tc := tc
|
|
t.Run(fmt.Sprintf("testing Actor address: %s", tc.expected), func(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
// Round trip encoding and decoding from string
|
|
addr, err := NewActorAddress(tc.input)
|
|
assert.NoError(err)
|
|
assert.Equal(tc.expected, addr.String())
|
|
|
|
maybeAddr, err := NewFromString(tc.expected)
|
|
assert.NoError(err)
|
|
assert.Equal(Actor, maybeAddr.Protocol())
|
|
assert.Equal(addressHash(tc.input), maybeAddr.Payload())
|
|
|
|
// Round trip to and from bytes
|
|
maybeAddrBytes, err := NewFromBytes(maybeAddr.Bytes())
|
|
assert.NoError(err)
|
|
assert.Equal(maybeAddr, maybeAddrBytes)
|
|
|
|
// Round trip encoding and decoding json
|
|
b, err := addr.MarshalJSON()
|
|
assert.NoError(err)
|
|
|
|
var newAddr Address
|
|
err = newAddr.UnmarshalJSON(b)
|
|
assert.NoError(err)
|
|
assert.Equal(addr, newAddr)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestRandomBLSAddress(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
pk := bls.PrivateKeyPublicKey(bls.PrivateKeyGenerate())
|
|
|
|
addr, err := NewBLSAddress(pk[:])
|
|
assert.NoError(err)
|
|
assert.Equal(BLS, addr.Protocol())
|
|
|
|
str, err := encode(Mainnet, addr)
|
|
assert.NoError(err)
|
|
|
|
maybe, err := decode(str)
|
|
assert.NoError(err)
|
|
assert.Equal(addr, maybe)
|
|
|
|
}
|
|
|
|
func TestVectorBLSAddress(t *testing.T) {
|
|
testCases := []struct {
|
|
input []byte
|
|
expected string
|
|
}{
|
|
{[]byte{173, 88, 223, 105, 110, 45, 78, 145, 234, 134, 200, 129, 233, 56,
|
|
186, 78, 168, 27, 57, 94, 18, 121, 123, 132, 185, 207, 49, 75, 149, 70,
|
|
112, 94, 131, 156, 122, 153, 214, 6, 178, 71, 221, 180, 249, 172, 122,
|
|
52, 20, 221},
|
|
"t3vvmn62lofvhjd2ugzca6sof2j2ubwok6cj4xxbfzz4yuxfkgobpihhd2thlanmsh3w2ptld2gqkn2jvlss4a"},
|
|
{[]byte{179, 41, 79, 10, 46, 41, 224, 198, 110, 188, 35, 93, 47, 237,
|
|
202, 86, 151, 191, 120, 74, 246, 5, 199, 90, 246, 8, 230, 166, 61, 92,
|
|
211, 142, 168, 92, 168, 152, 158, 14, 253, 233, 24, 139, 56, 47,
|
|
147, 114, 70, 13},
|
|
"t3wmuu6crofhqmm3v4enos73okk2l366ck6yc4owxwbdtkmpk42ohkqxfitcpa57pjdcftql4tojda2poeruwa"},
|
|
{[]byte{150, 161, 163, 228, 234, 122, 20, 212, 153, 133, 230, 97, 178,
|
|
36, 1, 212, 79, 237, 64, 45, 29, 9, 37, 178, 67, 201, 35, 88, 156,
|
|
15, 188, 126, 50, 205, 4, 226, 158, 215, 141, 21, 211, 125, 58, 170,
|
|
63, 230, 218, 51},
|
|
"t3s2q2hzhkpiknjgmf4zq3ejab2rh62qbndueslmsdzervrhapxr7dftie4kpnpdiv2n6tvkr743ndhrsw6d3a"},
|
|
{[]byte{134, 180, 84, 37, 140, 88, 148, 117, 247, 209, 111, 90, 172, 1,
|
|
138, 121, 246, 193, 22, 157, 32, 252, 51, 146, 29, 216, 181, 206, 28,
|
|
172, 108, 52, 143, 144, 163, 96, 54, 36, 246, 174, 185, 27, 100, 81,
|
|
140, 46, 128, 149},
|
|
"t3q22fijmmlckhl56rn5nkyamkph3mcfu5ed6dheq53c244hfmnq2i7efdma3cj5voxenwiummf2ajlsbxc65a"},
|
|
{[]byte{167, 114, 107, 3, 128, 34, 247, 90, 56, 70, 23, 88, 83, 96, 206,
|
|
230, 41, 7, 10, 45, 157, 40, 113, 41, 101, 229, 242, 110, 204, 64,
|
|
133, 131, 130, 128, 55, 36, 237, 52, 242, 114, 3, 54, 240, 157, 182,
|
|
49, 240, 116},
|
|
"t3u5zgwa4ael3vuocgc5mfgygo4yuqocrntuuhcklf4xzg5tcaqwbyfabxetwtj4tsam3pbhnwghyhijr5mixa"},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
tc := tc
|
|
t.Run(fmt.Sprintf("testing bls address: %s", tc.expected), func(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
// Round trip encoding and decoding from string
|
|
addr, err := NewBLSAddress(tc.input)
|
|
assert.NoError(err)
|
|
assert.Equal(tc.expected, addr.String())
|
|
|
|
maybeAddr, err := NewFromString(tc.expected)
|
|
assert.NoError(err)
|
|
assert.Equal(BLS, maybeAddr.Protocol())
|
|
assert.Equal(tc.input, maybeAddr.Payload())
|
|
|
|
// Round trip to and from bytes
|
|
maybeAddrBytes, err := NewFromBytes(maybeAddr.Bytes())
|
|
assert.NoError(err)
|
|
assert.Equal(maybeAddr, maybeAddrBytes)
|
|
|
|
// Round trip encoding and decoding json
|
|
b, err := addr.MarshalJSON()
|
|
assert.NoError(err)
|
|
|
|
var newAddr Address
|
|
err = newAddr.UnmarshalJSON(b)
|
|
assert.NoError(err)
|
|
assert.Equal(addr, newAddr)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestInvalidStringAddresses(t *testing.T) {
|
|
testCases := []struct {
|
|
input string
|
|
expetErr error
|
|
}{
|
|
{"Q2gfvuyh7v2sx3patm5k23wdzmhyhtmqctasbr23y", ErrUnknownNetwork},
|
|
{"t4gfvuyh7v2sx3patm5k23wdzmhyhtmqctasbr23y", ErrUnknownProtocol},
|
|
{"t2gfvuyh7v2sx3patm5k23wdzmhyhtmqctasbr24y", ErrInvalidChecksum},
|
|
{"t0banananananannnnnnnnn", ErrInvalidLength},
|
|
{"t0banananananannnnnnnn", ErrInvalidPayload},
|
|
{"t2gfvuyh7v2sx3patm1k23wdzmhyhtmqctasbr24y", base32.CorruptInputError(16)}, // '1' is not in base32 alphabet
|
|
{"t2gfvuyh7v2sx3paTm1k23wdzmhyhtmqctasbr24y", base32.CorruptInputError(14)}, // 'T' is not in base32 alphabet
|
|
{"t2", ErrInvalidLength},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
tc := tc
|
|
t.Run(fmt.Sprintf("testing string address: %s", tc.expetErr), func(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
_, err := NewFromString(tc.input)
|
|
assert.Equal(tc.expetErr, err)
|
|
})
|
|
}
|
|
|
|
}
|
|
|
|
func TestInvalidByteAddresses(t *testing.T) {
|
|
testCases := []struct {
|
|
input []byte
|
|
expetErr error
|
|
}{
|
|
// Unknown Protocol
|
|
{[]byte{4, 4, 4}, ErrUnknownProtocol},
|
|
|
|
// ID protocol
|
|
{[]byte{0}, ErrInvalidLength},
|
|
|
|
// SECP256K1 Protocol
|
|
{append([]byte{1}, make([]byte, PayloadHashLength-1)...), ErrInvalidPayload},
|
|
{append([]byte{1}, make([]byte, PayloadHashLength+1)...), ErrInvalidPayload},
|
|
// Actor Protocol
|
|
{append([]byte{2}, make([]byte, PayloadHashLength-1)...), ErrInvalidPayload},
|
|
{append([]byte{2}, make([]byte, PayloadHashLength+1)...), ErrInvalidPayload},
|
|
|
|
// BLS Protocol
|
|
{append([]byte{3}, make([]byte, bls.PublicKeyBytes-1)...), ErrInvalidPayload},
|
|
{append([]byte{3}, make([]byte, bls.PrivateKeyBytes+1)...), ErrInvalidPayload},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
tc := tc
|
|
t.Run(fmt.Sprintf("testing byte address: %s", tc.expetErr), func(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
_, err := NewFromBytes(tc.input)
|
|
assert.Equal(tc.expetErr, err)
|
|
})
|
|
}
|
|
|
|
}
|
|
|
|
func TestChecksum(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
data := []byte("helloworld")
|
|
bata := []byte("kittinmittins")
|
|
|
|
cksm := Checksum(data)
|
|
assert.Len(cksm, ChecksumHashLength)
|
|
|
|
assert.True(ValidateChecksum(data, cksm))
|
|
assert.False(ValidateChecksum(bata, cksm))
|
|
|
|
}
|
|
|
|
func TestAddressFormat(t *testing.T) {
|
|
assert := assert.New(t)
|
|
require := require.New(t)
|
|
|
|
a, err := NewActorAddress([]byte("hello"))
|
|
require.NoError(err)
|
|
|
|
assert.Equal("t2wvjry4bx6bwj6kkhcmvgu5zafqyi5cjzbtet3va", a.String())
|
|
assert.Equal("02B5531C7037F06C9F2947132A6A77202C308E8939", fmt.Sprintf("%X", a))
|
|
assert.Equal("[2 - b5531c7037f06c9f2947132a6a77202c308e8939]", fmt.Sprintf("%v", a))
|
|
|
|
assert.Equal("", fmt.Sprintf("%X", Undef))
|
|
assert.Equal(UndefAddressString, Undef.String())
|
|
assert.Equal(UndefAddressString, fmt.Sprintf("%v", Undef))
|
|
}
|
|
|
|
func TestCborMarshal(t *testing.T) {
|
|
for _, a := range allTestAddresses {
|
|
addr, err := NewFromString(a)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
buf := new(bytes.Buffer)
|
|
if err := addr.MarshalCBOR(buf); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
/*
|
|
// Note: this is commented out because we're currently serializing addresses as cbor "text strings", not "byte strings".
|
|
// This is to get around the restriction that refmt only allows string keys in maps.
|
|
// if you change it to serialize to byte strings and uncomment this, the tests pass fine
|
|
oldbytes, err := cbor.DumpObject(addr)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if !bytes.Equal(oldbytes, buf.Bytes()) {
|
|
t.Fatalf("serialization doesnt match old serialization: %s", a)
|
|
}
|
|
*/
|
|
|
|
var out Address
|
|
if err := out.UnmarshalCBOR(buf); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if out != addr {
|
|
t.Fatalf("failed to round trip %s", a)
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkCborMarshal(b *testing.B) {
|
|
addr, err := NewFromString("t15ihq5ibzwki2b4ep2f46avlkrqzhpqgtga7pdrq")
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
|
|
b.ReportAllocs()
|
|
b.ResetTimer()
|
|
|
|
buf := new(bytes.Buffer)
|
|
for i := 0; i < b.N; i++ {
|
|
buf.Reset()
|
|
if err := addr.MarshalCBOR(buf); err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkCborUnmarshal(b *testing.B) {
|
|
addr, err := NewFromString("t15ihq5ibzwki2b4ep2f46avlkrqzhpqgtga7pdrq")
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
|
|
buf := new(bytes.Buffer)
|
|
if err := addr.MarshalCBOR(buf); err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
|
|
b.ReportAllocs()
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
var a Address
|
|
if err := a.UnmarshalCBOR(bytes.NewReader(buf.Bytes())); err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestIDEdgeCase(t *testing.T) {
|
|
a, err := NewFromBytes([]byte{0, 0x80})
|
|
_ = a.String()
|
|
assert.Error(t, err)
|
|
}
|