mleku/wazero
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
cfc2b25b9fcb3118f39f15be13e6f4430f9d90c7
wazero/internal/leb128/leb128_test.go
Crypt Keeper 329ccca6b1 Switches from gofmt to gofumpt (#848) 
This switches to gofumpt and applies changes, as I've noticed working
in dapr (who uses this) that it finds some things that are annoying,
such as inconsistent block formatting in test tables.

Signed-off-by: Adrian Cole <adrian@tetrate.io>
2022-11-09 05:48:24 +01:00

231 lines
7.1 KiB
Go
Raw Blame History

package leb128
import (
"bytes"
"fmt"
"math"
"testing"
"github.com/tetratelabs/wazero/internal/testing/require"
)
func TestEncode_DecodeInt32(t *testing.T) {
for _, c := range []struct {
input int32
expected []byte
}{
{input: -165675008, expected: []byte{0x80, 0x80, 0x80, 0xb1, 0x7f}},
{input: -624485, expected: []byte{0x9b, 0xf1, 0x59}},
{input: -16256, expected: []byte{0x80, 0x81, 0x7f}},
{input: -4, expected: []byte{0x7c}},
{input: -1, expected: []byte{0x7f}},
{input: 0, expected: []byte{0x00}},
{input: 1, expected: []byte{0x01}},
{input: 4, expected: []byte{0x04}},
{input: 16256, expected: []byte{0x80, 0xff, 0x0}},
{input: 624485, expected: []byte{0xe5, 0x8e, 0x26}},
{input: 165675008, expected: []byte{0x80, 0x80, 0x80, 0xcf, 0x0}},
{input: int32(math.MaxInt32), expected: []byte{0xff, 0xff, 0xff, 0xff, 0x7}},
} {
require.Equal(t, c.expected, EncodeInt32(c.input))
decoded, _, err := LoadInt32(c.expected)
require.NoError(t, err)
require.Equal(t, c.input, decoded)
}
}
func TestEncode_DecodeInt64(t *testing.T) {
for _, c := range []struct {
input int64
expected []byte
}{
{input: -math.MaxInt32, expected: []byte{0x81, 0x80, 0x80, 0x80, 0x78}},
{input: -165675008, expected: []byte{0x80, 0x80, 0x80, 0xb1, 0x7f}},
{input: -624485, expected: []byte{0x9b, 0xf1, 0x59}},
{input: -16256, expected: []byte{0x80, 0x81, 0x7f}},
{input: -4, expected: []byte{0x7c}},
{input: -1, expected: []byte{0x7f}},
{input: 0, expected: []byte{0x00}},
{input: 1, expected: []byte{0x01}},
{input: 4, expected: []byte{0x04}},
{input: 16256, expected: []byte{0x80, 0xff, 0x0}},
{input: 624485, expected: []byte{0xe5, 0x8e, 0x26}},
{input: 165675008, expected: []byte{0x80, 0x80, 0x80, 0xcf, 0x0}},
{input: math.MaxInt32, expected: []byte{0xff, 0xff, 0xff, 0xff, 0x7}},
{input: math.MaxInt64, expected: []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0}},
} {
require.Equal(t, c.expected, EncodeInt64(c.input))
decoded, _, err := LoadInt64(c.expected)
require.NoError(t, err)
require.Equal(t, c.input, decoded)
}
}
func TestEncodeUint32(t *testing.T) {
for _, c := range []struct {
input uint32
expected []byte
}{
{input: 0, expected: []byte{0x00}},
{input: 1, expected: []byte{0x01}},
{input: 4, expected: []byte{0x04}},
{input: 16256, expected: []byte{0x80, 0x7f}},
{input: 624485, expected: []byte{0xe5, 0x8e, 0x26}},
{input: 165675008, expected: []byte{0x80, 0x80, 0x80, 0x4f}},
{input: uint32(math.MaxUint32), expected: []byte{0xff, 0xff, 0xff, 0xff, 0xf}},
} {
require.Equal(t, c.expected, EncodeUint32(c.input))
}
}
func TestEncodeUint64(t *testing.T) {
for _, c := range []struct {
input uint64
expected []byte
}{
{input: 0, expected: []byte{0x00}},
{input: 1, expected: []byte{0x01}},
{input: 4, expected: []byte{0x04}},
{input: 16256, expected: []byte{0x80, 0x7f}},
{input: 624485, expected: []byte{0xe5, 0x8e, 0x26}},
{input: 165675008, expected: []byte{0x80, 0x80, 0x80, 0x4f}},
{input: math.MaxUint32, expected: []byte{0xff, 0xff, 0xff, 0xff, 0xf}},
{input: math.MaxUint64, expected: []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1}},
} {
require.Equal(t, c.expected, EncodeUint64(c.input))
}
}
func TestDecodeUint32(t *testing.T) {
for _, c := range []struct {
bytes []byte
exp uint32
expErr bool
}{
{bytes: []byte{0xff, 0xff, 0xff, 0xff, 0xf}, exp: 0xffffffff},
{bytes: []byte{0x00}, exp: 0},
{bytes: []byte{0x04}, exp: 4},
{bytes: []byte{0x01}, exp: 1},
{bytes: []byte{0x80, 0}, exp: 0},
{bytes: []byte{0x80, 0x7f}, exp: 16256},
{bytes: []byte{0xe5, 0x8e, 0x26}, exp: 624485},
{bytes: []byte{0x80, 0x80, 0x80, 0x4f}, exp: 165675008},
{bytes: []byte{0xff, 0xff, 0xff, 0xff, 0xf}, exp: math.MaxUint32},
{bytes: []byte{0x83, 0x80, 0x80, 0x80, 0x80, 0x00}, expErr: true},
{bytes: []byte{0x82, 0x80, 0x80, 0x80, 0x70}, expErr: true},
{bytes: []byte{0x80, 0x80, 0x80, 0x80, 0x80, 0x00}, expErr: true},
} {
actual, num, err := LoadUint32(c.bytes)
if c.expErr {
require.Error(t, err)
} else {
require.NoError(t, err)
require.Equal(t, c.exp, actual)
require.Equal(t, uint64(len(c.bytes)), num)
}
}
}
func TestDecodeUint64(t *testing.T) {
for _, c := range []struct {
bytes []byte
exp uint64
expErr bool
}{
{bytes: []byte{0x04}, exp: 4},
{bytes: []byte{0x80, 0x7f}, exp: 16256},
{bytes: []byte{0xe5, 0x8e, 0x26}, exp: 624485},
{bytes: []byte{0x80, 0x80, 0x80, 0x4f}, exp: 165675008},
{bytes: []byte{0xff, 0xff, 0xff, 0xff, 0xf}, exp: math.MaxUint32},
{bytes: []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1}, exp: math.MaxUint64},
{bytes: []byte{0x89, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x71}, expErr: true},
} {
actual, num, err := LoadUint64(c.bytes)
if c.expErr {
require.Error(t, err)
} else {
require.NoError(t, err)
require.Equal(t, c.exp, actual)
require.Equal(t, uint64(len(c.bytes)), num)
}
}
}
func TestDecodeInt32(t *testing.T) {
for i, c := range []struct {
bytes []byte
exp int32
expErr bool
}{
{bytes: []byte{0x13}, exp: 19},
{bytes: []byte{0x00}, exp: 0},
{bytes: []byte{0x04}, exp: 4},
{bytes: []byte{0xFF, 0x00}, exp: 127},
{bytes: []byte{0x81, 0x01}, exp: 129},
{bytes: []byte{0x7f}, exp: -1},
{bytes: []byte{0x81, 0x7f}, exp: -127},
{bytes: []byte{0xFF, 0x7e}, exp: -129},
{bytes: []byte{0xff, 0xff, 0xff, 0xff, 0x0f}, expErr: true},
{bytes: []byte{0xff, 0xff, 0xff, 0xff, 0x4f}, expErr: true},
{bytes: []byte{0x80, 0x80, 0x80, 0x80, 0x70}, expErr: true},
} {
actual, num, err := LoadInt32(c.bytes)
if c.expErr {
require.Error(t, err, fmt.Sprintf("%d-th got value %d", i, actual))
} else {
require.NoError(t, err, i)
require.Equal(t, c.exp, actual, i)
require.Equal(t, uint64(len(c.bytes)), num, i)
}
}
}
func TestDecodeInt33AsInt64(t *testing.T) {
for _, c := range []struct {
bytes []byte
exp int64
}{
{bytes: []byte{0x00}, exp: 0},
{bytes: []byte{0x04}, exp: 4},
{bytes: []byte{0x40}, exp: -64},
{bytes: []byte{0x7f}, exp: -1},
{bytes: []byte{0x7e}, exp: -2},
{bytes: []byte{0x7d}, exp: -3},
{bytes: []byte{0x7c}, exp: -4},
{bytes: []byte{0xFF, 0x00}, exp: 127},
{bytes: []byte{0x81, 0x01}, exp: 129},
{bytes: []byte{0x7f}, exp: -1},
{bytes: []byte{0x81, 0x7f}, exp: -127},
{bytes: []byte{0xFF, 0x7e}, exp: -129},
} {
actual, num, err := DecodeInt33AsInt64(bytes.NewReader(c.bytes))
require.NoError(t, err)
require.Equal(t, c.exp, actual)
require.Equal(t, uint64(len(c.bytes)), num)
}
}
func TestDecodeInt64(t *testing.T) {
for _, c := range []struct {
bytes []byte
exp int64
}{
{bytes: []byte{0x00}, exp: 0},
{bytes: []byte{0x04}, exp: 4},
{bytes: []byte{0xFF, 0x00}, exp: 127},
{bytes: []byte{0x81, 0x01}, exp: 129},
{bytes: []byte{0x7f}, exp: -1},
{bytes: []byte{0x81, 0x7f}, exp: -127},
{bytes: []byte{0xFF, 0x7e}, exp: -129},
{
bytes: []byte{0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7f},
exp: -9223372036854775808,
},
} {
actual, num, err := LoadInt64(c.bytes)
require.NoError(t, err)
require.Equal(t, c.exp, actual)
require.Equal(t, uint64(len(c.bytes)), num)
}
}
Reference in New Issue View Git Blame Copy Permalink