mirror of https://github.com/q191201771/naza
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
321 lines
7.9 KiB
Go
321 lines
7.9 KiB
Go
// Copyright 2019, Chef. All rights reserved.
|
|
// https://github.com/q191201771/naza
|
|
//
|
|
// Use of this source code is governed by a MIT-style license
|
|
// that can be found in the License file.
|
|
//
|
|
// Author: Chef (191201771@qq.com)
|
|
|
|
package bele
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/binary"
|
|
"testing"
|
|
|
|
"github.com/q191201771/naza/pkg/assert"
|
|
)
|
|
|
|
func TestBEUint16(t *testing.T) {
|
|
vector := []struct {
|
|
input []byte
|
|
output uint16
|
|
}{
|
|
{input: []byte{0, 0}, output: 0},
|
|
{input: []byte{0, 1}, output: 1},
|
|
{input: []byte{0, 255}, output: 255},
|
|
{input: []byte{1, 0}, output: 256},
|
|
{input: []byte{255, 0}, output: 255 * 256},
|
|
{input: []byte{12, 34}, output: 12*256 + 34},
|
|
}
|
|
|
|
for i := 0; i < len(vector); i++ {
|
|
assert.Equal(t, vector[i].output, BEUint16(vector[i].input))
|
|
}
|
|
}
|
|
|
|
func TestBEUint24(t *testing.T) {
|
|
vector := []struct {
|
|
input []byte
|
|
output uint32
|
|
}{
|
|
{input: []byte{0, 0, 0}, output: 0},
|
|
{input: []byte{0, 0, 1}, output: 1},
|
|
{input: []byte{0, 1, 0}, output: 256},
|
|
{input: []byte{1, 0, 0}, output: 1 * 256 * 256},
|
|
{input: []byte{12, 34, 56}, output: 12*256*256 + 34*256 + 56},
|
|
}
|
|
|
|
for i := 0; i < len(vector); i++ {
|
|
assert.Equal(t, vector[i].output, BEUint24(vector[i].input))
|
|
}
|
|
}
|
|
|
|
func TestBEUint32(t *testing.T) {
|
|
vector := []struct {
|
|
input []byte
|
|
output uint32
|
|
}{
|
|
{input: []byte{0, 0, 0, 0}, output: 0},
|
|
{input: []byte{0, 0, 1, 0}, output: 1 * 256},
|
|
{input: []byte{0, 1, 0, 0}, output: 1 * 256 * 256},
|
|
{input: []byte{1, 0, 0, 0}, output: 1 * 256 * 256 * 256},
|
|
{input: []byte{12, 34, 56, 78}, output: 12*256*256*256 + 34*256*256 + 56*256 + 78},
|
|
}
|
|
|
|
for i := 0; i < len(vector); i++ {
|
|
assert.Equal(t, vector[i].output, BEUint32(vector[i].input))
|
|
}
|
|
}
|
|
|
|
func TestBEUint64(t *testing.T) {
|
|
vector := []struct {
|
|
input []byte
|
|
output uint64
|
|
}{
|
|
{input: []byte{0, 0, 0, 0, 0, 0, 0, 0}, output: 0},
|
|
{input: []byte{0, 0, 0, 0, 1, 0, 0, 0}, output: 1 * 256 * 256 * 256},
|
|
{input: []byte{0, 0, 0, 0, 12, 34, 56, 78}, output: 12*256*256*256 + 34*256*256 + 56*256 + 78},
|
|
{input: []byte{0, 12, 34, 56, 78, 0, 0, 0}, output: 12*256*256*256*256*256*256 + 34*256*256*256*256*256 + 56*256*256*256*256 + 78*256*256*256},
|
|
}
|
|
|
|
for i := 0; i < len(vector); i++ {
|
|
assert.Equal(t, vector[i].output, BEUint64(vector[i].input))
|
|
}
|
|
}
|
|
|
|
func TestBEFloat64(t *testing.T) {
|
|
vector := []int{
|
|
1,
|
|
0xFF,
|
|
0xFFFF,
|
|
0xFFFFFF,
|
|
}
|
|
for i := 0; i < len(vector); i++ {
|
|
b := &bytes.Buffer{}
|
|
err := binary.Write(b, binary.BigEndian, float64(vector[i]))
|
|
assert.Equal(t, nil, err)
|
|
assert.Equal(t, vector[i], int(BEFloat64(b.Bytes())))
|
|
}
|
|
}
|
|
|
|
func TestLEUint32(t *testing.T) {
|
|
vector := []struct {
|
|
input []byte
|
|
output uint32
|
|
}{
|
|
{input: []byte{0, 0, 0, 0}, output: 0},
|
|
{input: []byte{0, 0, 1, 0}, output: 1 * 256 * 256},
|
|
{input: []byte{0, 1, 0, 0}, output: 1 * 256},
|
|
{input: []byte{1, 0, 0, 0}, output: 1},
|
|
{input: []byte{12, 34, 56, 78}, output: 12 + 34*256 + 56*256*256 + 78*256*256*256},
|
|
}
|
|
|
|
for i := 0; i < len(vector); i++ {
|
|
assert.Equal(t, vector[i].output, LEUint32(vector[i].input))
|
|
}
|
|
}
|
|
|
|
func TestBEPutUint24(t *testing.T) {
|
|
vector := []struct {
|
|
input uint32
|
|
output []byte
|
|
}{
|
|
{input: 0, output: []byte{0, 0, 0}},
|
|
{input: 1, output: []byte{0, 0, 1}},
|
|
{input: 256, output: []byte{0, 1, 0}},
|
|
{input: 1 * 256 * 256, output: []byte{1, 0, 0}},
|
|
{input: 12*256*256 + 34*256 + 56, output: []byte{12, 34, 56}},
|
|
}
|
|
|
|
out := make([]byte, 3)
|
|
for i := 0; i < len(vector); i++ {
|
|
BEPutUint24(out, vector[i].input)
|
|
assert.Equal(t, vector[i].output, out)
|
|
}
|
|
}
|
|
|
|
func TestBEPutUint32(t *testing.T) {
|
|
vector := []struct {
|
|
input uint32
|
|
output []byte
|
|
}{
|
|
{input: 0, output: []byte{0, 0, 0, 0}},
|
|
{input: 1 * 256, output: []byte{0, 0, 1, 0}},
|
|
{input: 1 * 256 * 256, output: []byte{0, 1, 0, 0}},
|
|
{input: 1 * 256 * 256 * 256, output: []byte{1, 0, 0, 0}},
|
|
{input: 12*256*256*256 + 34*256*256 + 56*256 + 78, output: []byte{12, 34, 56, 78}},
|
|
}
|
|
|
|
out := make([]byte, 4)
|
|
for i := 0; i < len(vector); i++ {
|
|
BEPutUint32(out, vector[i].input)
|
|
assert.Equal(t, vector[i].output, out)
|
|
}
|
|
}
|
|
|
|
func TestLEPutUint32(t *testing.T) {
|
|
vector := []struct {
|
|
input uint32
|
|
output []byte
|
|
}{
|
|
{input: 0, output: []byte{0, 0, 0, 0}},
|
|
{input: 1 * 256 * 256, output: []byte{0, 0, 1, 0}},
|
|
{input: 1 * 256, output: []byte{0, 1, 0, 0}},
|
|
{input: 1, output: []byte{1, 0, 0, 0}},
|
|
{input: 78*256*256*256 + 56*256*256 + 34*256 + 12, output: []byte{12, 34, 56, 78}},
|
|
}
|
|
|
|
out := make([]byte, 4)
|
|
for i := 0; i < len(vector); i++ {
|
|
LEPutUint32(out, vector[i].input)
|
|
assert.Equal(t, vector[i].output, out)
|
|
}
|
|
}
|
|
|
|
func TestWriteBEUint24(t *testing.T) {
|
|
vector := []struct {
|
|
input uint32
|
|
output []byte
|
|
}{
|
|
{input: 0, output: []byte{0, 0, 0}},
|
|
{input: 1, output: []byte{0, 0, 1}},
|
|
{input: 256, output: []byte{0, 1, 0}},
|
|
{input: 1 * 256 * 256, output: []byte{1, 0, 0}},
|
|
{input: 12*256*256 + 34*256 + 56, output: []byte{12, 34, 56}},
|
|
}
|
|
|
|
for i := 0; i < len(vector); i++ {
|
|
out := &bytes.Buffer{}
|
|
err := WriteBEUint24(out, vector[i].input)
|
|
assert.Equal(t, nil, err)
|
|
assert.Equal(t, vector[i].output, out.Bytes())
|
|
}
|
|
}
|
|
|
|
func TestWriteBE(t *testing.T) {
|
|
vector := []struct {
|
|
input interface{}
|
|
output []byte
|
|
}{
|
|
{input: uint32(1), output: []byte{0, 0, 0, 1}},
|
|
{input: uint64(1), output: []byte{0, 0, 0, 0, 0, 0, 0, 1}},
|
|
}
|
|
for i := 0; i < len(vector); i++ {
|
|
out := &bytes.Buffer{}
|
|
err := WriteBE(out, vector[i].input)
|
|
assert.Equal(t, nil, err)
|
|
assert.Equal(t, vector[i].output, out.Bytes())
|
|
}
|
|
}
|
|
|
|
func TestWriteLE(t *testing.T) {
|
|
vector := []struct {
|
|
input interface{}
|
|
output []byte
|
|
}{
|
|
{input: uint32(1), output: []byte{1, 0, 0, 0}},
|
|
{input: uint64(1), output: []byte{1, 0, 0, 0, 0, 0, 0, 0}},
|
|
}
|
|
for i := 0; i < len(vector); i++ {
|
|
out := &bytes.Buffer{}
|
|
err := WriteLE(out, vector[i].input)
|
|
assert.Equal(t, nil, err)
|
|
assert.Equal(t, vector[i].output, out.Bytes())
|
|
}
|
|
}
|
|
|
|
func TestReadBytes(t *testing.T) {
|
|
var buf bytes.Buffer
|
|
buf.Write([]byte{'1', '2', '3'})
|
|
b, err := ReadBytes(&buf, 2)
|
|
assert.Equal(t, []byte{'1', '2'}, b)
|
|
assert.Equal(t, nil, err)
|
|
b, err = ReadBytes(&buf, 2)
|
|
assert.Equal(t, []byte{'3', 0}, b)
|
|
assert.IsNotNil(t, err)
|
|
b, err = ReadBytes(&buf, 2)
|
|
assert.Equal(t, nil, b)
|
|
assert.IsNotNil(t, err)
|
|
}
|
|
|
|
func TestRead(t *testing.T) {
|
|
var err error
|
|
b := &bytes.Buffer{}
|
|
_, err = ReadUint8(b)
|
|
assert.IsNotNil(t, err)
|
|
_, err = ReadBEUint16(b)
|
|
assert.IsNotNil(t, err)
|
|
_, err = ReadBEUint24(b)
|
|
assert.IsNotNil(t, err)
|
|
_, err = ReadBEUint32(b)
|
|
assert.IsNotNil(t, err)
|
|
_, err = ReadBEUint64(b)
|
|
assert.IsNotNil(t, err)
|
|
_, err = ReadLEUint32(b)
|
|
assert.IsNotNil(t, err)
|
|
|
|
b.Write([]byte{1})
|
|
i8, err := ReadUint8(b)
|
|
assert.Equal(t, uint8(1), i8)
|
|
assert.Equal(t, nil, err)
|
|
b.Write([]byte{1, 2})
|
|
i16, err := ReadBEUint16(b)
|
|
assert.Equal(t, BEUint16([]byte{1, 2}), i16)
|
|
assert.Equal(t, nil, err)
|
|
b.Write([]byte{1, 2, 3})
|
|
i24, err := ReadBEUint24(b)
|
|
assert.Equal(t, BEUint24([]byte{1, 2, 3}), i24)
|
|
assert.Equal(t, nil, err)
|
|
b.Write([]byte{1, 2, 3, 4})
|
|
i32, err := ReadBEUint32(b)
|
|
assert.Equal(t, BEUint32([]byte{1, 2, 3, 4}), i32)
|
|
assert.Equal(t, nil, err)
|
|
b.Write([]byte{1, 2, 3, 4, 5, 6, 7, 8})
|
|
i64, err := ReadBEUint64(b)
|
|
assert.Equal(t, BEUint64([]byte{1, 2, 3, 4, 5, 6, 7, 8}), i64)
|
|
assert.Equal(t, nil, err)
|
|
|
|
b.Write([]byte{1, 0, 0, 0})
|
|
i32, err = ReadLEUint32(b)
|
|
assert.Equal(t, uint32(1), i32)
|
|
assert.Equal(t, nil, err)
|
|
}
|
|
|
|
func TestReadString(t *testing.T) {
|
|
var buf bytes.Buffer
|
|
str, err := ReadString(&buf, 2)
|
|
assert.Equal(t, "", str)
|
|
assert.IsNotNil(t, err)
|
|
}
|
|
|
|
func BenchmarkBEFloat64(b *testing.B) {
|
|
buf := &bytes.Buffer{}
|
|
_ = binary.Write(buf, binary.BigEndian, float64(123.4))
|
|
for i := 0; i < b.N; i++ {
|
|
BEFloat64(buf.Bytes())
|
|
}
|
|
}
|
|
|
|
func BenchmarkBEPutUint24(b *testing.B) {
|
|
out := make([]byte, 3)
|
|
for i := 0; i < b.N; i++ {
|
|
BEPutUint24(out, uint32(i))
|
|
}
|
|
}
|
|
|
|
func BenchmarkBEUint24(b *testing.B) {
|
|
buf := []byte{1, 2, 3}
|
|
for i := 0; i < b.N; i++ {
|
|
BEUint24(buf)
|
|
}
|
|
}
|
|
|
|
func BenchmarkWriteBE(b *testing.B) {
|
|
out := &bytes.Buffer{}
|
|
in := uint64(123)
|
|
for i := 0; i < b.N; i++ {
|
|
_ = WriteBE(out, in)
|
|
}
|
|
}
|