156 lines
3.5 KiB
Go
156 lines
3.5 KiB
Go
package varn_test
|
|
|
|
import (
|
|
"io"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
|
|
"git.intruders.space/public/opentimestamps/varn"
|
|
)
|
|
|
|
func TestNewBuffer(t *testing.T) {
|
|
data := []byte{0x01, 0x02, 0x03}
|
|
buf := varn.NewBuffer(data)
|
|
|
|
// Test the first byte to verify initialization
|
|
b, err := buf.ReadByte()
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, byte(0x01), b)
|
|
|
|
// Test reading the second byte
|
|
b, err = buf.ReadByte()
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, byte(0x02), b)
|
|
|
|
// Test reading the third byte
|
|
b, err = buf.ReadByte()
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, byte(0x03), b)
|
|
|
|
// Test reading beyond the buffer
|
|
_, err = buf.ReadByte()
|
|
assert.ErrorIs(t, err, io.EOF)
|
|
|
|
// Test reading from an empty buffer
|
|
emptyBuf := varn.NewBuffer([]byte{})
|
|
_, err = emptyBuf.ReadByte()
|
|
assert.ErrorIs(t, err, io.EOF)
|
|
|
|
// Test reading from a nil buffer
|
|
nilBuf := varn.NewBuffer(nil)
|
|
_, err = nilBuf.ReadByte()
|
|
assert.ErrorIs(t, err, io.EOF)
|
|
|
|
// Test reading from a buffer with a single byte
|
|
singleByteBuf := varn.NewBuffer([]byte{0xFF})
|
|
b, err = singleByteBuf.ReadByte()
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, byte(0xFF), b)
|
|
}
|
|
|
|
func TestReadBytes(t *testing.T) {
|
|
data := []byte{0x01, 0x02, 0x03, 0x04, 0x05}
|
|
buf := varn.NewBuffer(data)
|
|
|
|
// Read 3 bytes
|
|
bytes, err := buf.ReadBytes(3)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, []byte{0x01, 0x02, 0x03}, bytes)
|
|
|
|
// Read 2 more bytes
|
|
bytes, err = buf.ReadBytes(2)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, []byte{0x04, 0x05}, bytes)
|
|
|
|
// Try to read beyond the buffer
|
|
_, err = buf.ReadBytes(1)
|
|
assert.ErrorIs(t, err, io.EOF)
|
|
}
|
|
|
|
func TestReadByte(t *testing.T) {
|
|
data := []byte{0x0A, 0x0B}
|
|
buf := varn.NewBuffer(data)
|
|
|
|
// Read first byte
|
|
b, err := buf.ReadByte()
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, byte(0x0A), b)
|
|
|
|
// Read second byte
|
|
b, err = buf.ReadByte()
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, byte(0x0B), b)
|
|
|
|
// Try to read beyond the buffer
|
|
_, err = buf.ReadByte()
|
|
assert.ErrorIs(t, err, io.EOF)
|
|
}
|
|
|
|
func TestReadVarUint(t *testing.T) {
|
|
testCases := []struct {
|
|
name string
|
|
input []byte
|
|
expected uint64
|
|
}{
|
|
{
|
|
name: "Single byte",
|
|
input: []byte{0x01},
|
|
expected: 1,
|
|
},
|
|
{
|
|
name: "Two bytes",
|
|
input: []byte{0x81, 0x01}, // 129 in varint encoding
|
|
expected: 129,
|
|
},
|
|
{
|
|
name: "Large number",
|
|
input: []byte{0xFF, 0xFF, 0xFF, 0xFF, 0x01}, // 536870911 in varint encoding
|
|
expected: 536870911,
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
buf := varn.NewBuffer(tc.input)
|
|
val, err := buf.ReadVarUint()
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, tc.expected, val)
|
|
})
|
|
}
|
|
|
|
// Test EOF
|
|
buf := varn.NewBuffer([]byte{0x81}) // Incomplete varint
|
|
_, err := buf.ReadVarUint()
|
|
assert.ErrorIs(t, err, io.EOF)
|
|
}
|
|
|
|
func TestReadVarBytes(t *testing.T) {
|
|
// Test normal case: length followed by data
|
|
data := []byte{0x03, 0x0A, 0x0B, 0x0C, 0x0D}
|
|
buf := varn.NewBuffer(data)
|
|
|
|
bytes, err := buf.ReadVarBytes()
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, []byte{0x0A, 0x0B, 0x0C}, bytes)
|
|
|
|
// Test empty array
|
|
data = []byte{0x00, 0x01}
|
|
buf = varn.NewBuffer(data)
|
|
|
|
bytes, err = buf.ReadVarBytes()
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, []byte{}, bytes)
|
|
|
|
// Test EOF during length read
|
|
buf = varn.NewBuffer([]byte{})
|
|
_, err = buf.ReadVarBytes()
|
|
assert.ErrorIs(t, err, io.EOF)
|
|
|
|
// Test error during data read (insufficient bytes)
|
|
data = []byte{0x03, 0x01}
|
|
buf = varn.NewBuffer(data)
|
|
_, err = buf.ReadVarBytes()
|
|
assert.ErrorIs(t, err, io.ErrUnexpectedEOF)
|
|
}
|