126 lines
3.3 KiB
Go
126 lines
3.3 KiB
Go
// Copyright (c) 2017-2026 Lethean (https://lt.hn)
|
|
//
|
|
// Licensed under the European Union Public Licence (EUPL) version 1.2.
|
|
// SPDX-License-Identifier: EUPL-1.2
|
|
|
|
package wire
|
|
|
|
import (
|
|
"math"
|
|
"testing"
|
|
)
|
|
|
|
func TestVarint_EncodeVarint_Good(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
value uint64
|
|
want []byte
|
|
}{
|
|
{"zero", 0, []byte{0x00}},
|
|
{"one", 1, []byte{0x01}},
|
|
{"max_single_byte", 127, []byte{0x7f}},
|
|
{"128", 128, []byte{0x80, 0x01}},
|
|
{"255", 255, []byte{0xff, 0x01}},
|
|
{"256", 256, []byte{0x80, 0x02}},
|
|
{"16384", 16384, []byte{0x80, 0x80, 0x01}},
|
|
{"65535", 65535, []byte{0xff, 0xff, 0x03}},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got := EncodeVarint(tt.value)
|
|
if len(got) != len(tt.want) {
|
|
t.Fatalf("EncodeVarint(%d) = %x (len %d), want %x (len %d)",
|
|
tt.value, got, len(got), tt.want, len(tt.want))
|
|
}
|
|
for i := range got {
|
|
if got[i] != tt.want[i] {
|
|
t.Errorf("EncodeVarint(%d)[%d] = 0x%02x, want 0x%02x",
|
|
tt.value, i, got[i], tt.want[i])
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestVarint_DecodeVarint_Good(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
data []byte
|
|
wantVal uint64
|
|
wantLen int
|
|
}{
|
|
{"zero", []byte{0x00}, 0, 1},
|
|
{"one", []byte{0x01}, 1, 1},
|
|
{"127", []byte{0x7f}, 127, 1},
|
|
{"128", []byte{0x80, 0x01}, 128, 2},
|
|
{"16384", []byte{0x80, 0x80, 0x01}, 16384, 3},
|
|
// With trailing data — should only consume the varint bytes.
|
|
{"with_trailing", []byte{0x01, 0xff, 0xff}, 1, 1},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
val, n, err := DecodeVarint(tt.data)
|
|
if err != nil {
|
|
t.Fatalf("DecodeVarint(%x) returned error: %v", tt.data, err)
|
|
}
|
|
if val != tt.wantVal {
|
|
t.Errorf("DecodeVarint(%x) value = %d, want %d", tt.data, val, tt.wantVal)
|
|
}
|
|
if n != tt.wantLen {
|
|
t.Errorf("DecodeVarint(%x) length = %d, want %d", tt.data, n, tt.wantLen)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestVarint_VarintRoundTrip_Good(t *testing.T) {
|
|
values := []uint64{
|
|
0, 1, 127, 128, 255, 256, 1000, 65535, 65536,
|
|
1<<14 - 1, 1 << 14, 1<<21 - 1, 1 << 21,
|
|
1<<28 - 1, 1 << 28, 1<<35 - 1, 1 << 35,
|
|
1<<42 - 1, 1 << 42, 1<<49 - 1, 1 << 49,
|
|
1<<56 - 1, 1 << 56, math.MaxUint64,
|
|
}
|
|
|
|
for _, v := range values {
|
|
encoded := EncodeVarint(v)
|
|
decoded, n, err := DecodeVarint(encoded)
|
|
if err != nil {
|
|
t.Errorf("round-trip failed for %d: encode→%x, decode error: %v", v, encoded, err)
|
|
continue
|
|
}
|
|
if decoded != v {
|
|
t.Errorf("round-trip failed for %d: encode→%x, decode→%d", v, encoded, decoded)
|
|
}
|
|
if n != len(encoded) {
|
|
t.Errorf("round-trip for %d: consumed %d bytes, encoded %d bytes", v, n, len(encoded))
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestVarint_DecodeVarint_Bad(t *testing.T) {
|
|
// Empty input.
|
|
_, _, err := DecodeVarint(nil)
|
|
if err != ErrVarintEmpty {
|
|
t.Errorf("DecodeVarint(nil) error = %v, want ErrVarintEmpty", err)
|
|
}
|
|
|
|
_, _, err = DecodeVarint([]byte{})
|
|
if err != ErrVarintEmpty {
|
|
t.Errorf("DecodeVarint([]) error = %v, want ErrVarintEmpty", err)
|
|
}
|
|
}
|
|
|
|
func TestVarint_DecodeVarint_Ugly(t *testing.T) {
|
|
// A varint with all continuation bits set for 11 bytes (overflow).
|
|
overflow := make([]byte, 11)
|
|
for i := range overflow {
|
|
overflow[i] = 0x80
|
|
}
|
|
_, _, err := DecodeVarint(overflow)
|
|
if err != ErrVarintOverflow {
|
|
t.Errorf("DecodeVarint(overflow) error = %v, want ErrVarintOverflow", err)
|
|
}
|
|
}
|