170 lines
5.5 KiB
Go
170 lines
5.5 KiB
Go
package agentwire
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/binary"
|
|
"errors"
|
|
"testing"
|
|
)
|
|
|
|
func packets(t *testing.T, payload []byte, priority bool) [][]byte {
|
|
t.Helper()
|
|
encoder, err := NewEncoder(payload, 1<<20, true, priority)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var result [][]byte
|
|
for {
|
|
packet, last := encoder.Next()
|
|
if len(packet) > PacketBytes {
|
|
t.Fatal("wire packet exceeds ceiling")
|
|
}
|
|
result = append(result, packet)
|
|
if last {
|
|
return result
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMessageRoundTripAndBoundaries_HP_CHUNK_01(t *testing.T) {
|
|
t.Parallel()
|
|
for _, size := range []int{1, PacketBytes - 1, PacketBytes, PacketBytes + 1, 64 << 10, 1 << 20} {
|
|
payload := bytes.Repeat([]byte{0x53}, size)
|
|
decoder := Decoder{Maximum: 1 << 20}
|
|
encoded := packets(t, payload, false)
|
|
for index, packet := range encoded {
|
|
result, err := decoder.Push(packet)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if index != len(encoded)-1 && result != nil {
|
|
t.Fatal("partial logical message delivered")
|
|
}
|
|
if index == len(encoded)-1 && !bytes.Equal(result, payload) {
|
|
t.Fatalf("message size %d changed", size)
|
|
}
|
|
}
|
|
}
|
|
if _, err := NewEncoder(make([]byte, (1<<20)+1), 1<<20, true, false); !errors.Is(err, ErrMessageTooBig) {
|
|
t.Fatalf("logical ceiling bypassed: %v", err)
|
|
}
|
|
if _, err := NewEncoder(nil, 1<<20, true, false); !errors.Is(err, ErrPacket) {
|
|
t.Fatal("empty logical message accepted")
|
|
}
|
|
}
|
|
|
|
func TestIndependentControlLaneAndDisconnect_REC_CHUNK_01(t *testing.T) {
|
|
t.Parallel()
|
|
large := bytes.Repeat([]byte{0x51}, 200<<10)
|
|
priority := bytes.Repeat([]byte{0x52}, 48<<10)
|
|
dataPackets := packets(t, large, false)
|
|
controlPackets := packets(t, priority, true)
|
|
decoder := Decoder{Maximum: 1 << 20}
|
|
if value, err := decoder.Push(dataPackets[0]); err != nil || value != nil {
|
|
t.Fatalf("first partial packet: %v", err)
|
|
}
|
|
for index, packet := range controlPackets {
|
|
value, err := decoder.Push(packet)
|
|
if err != nil || index == len(controlPackets)-1 && !bytes.Equal(value, priority) {
|
|
t.Fatalf("control lane did not overtake partial data: %v", err)
|
|
}
|
|
}
|
|
ack := []byte("ack")
|
|
if value, err := decoder.Push(packets(t, ack, false)[0]); err != nil || !bytes.Equal(value, ack) {
|
|
t.Fatal("small message blocked behind partial data")
|
|
}
|
|
for index, packet := range dataPackets[1:] {
|
|
value, err := decoder.Push(packet)
|
|
if err != nil || index == len(dataPackets)-2 && !bytes.Equal(value, large) {
|
|
t.Fatalf("preemption changed data: %v", err)
|
|
}
|
|
}
|
|
// A new connection has no partial state. A tail without its prefix fails;
|
|
// a complete durable replay from offset zero succeeds.
|
|
restarted := Decoder{Maximum: 1 << 20}
|
|
if _, err := restarted.Push(dataPackets[1]); !errors.Is(err, ErrPacket) {
|
|
t.Fatal("new connection accepted an old tail")
|
|
}
|
|
restarted = Decoder{Maximum: 1 << 20}
|
|
var result []byte
|
|
for _, packet := range dataPackets {
|
|
var err error
|
|
result, err = restarted.Push(packet)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if !bytes.Equal(result, large) {
|
|
t.Fatal("durable replay changed message")
|
|
}
|
|
}
|
|
|
|
func TestRejectMalformedPacketsWithoutAllocation_BH_CHUNK_01(t *testing.T) {
|
|
t.Parallel()
|
|
base := packets(t, bytes.Repeat([]byte{0x53}, 64<<10), false)
|
|
changed := func(packet []byte, position int, value uint32) []byte {
|
|
result := bytes.Clone(packet)
|
|
binary.BigEndian.PutUint32(result[position:position+4], value)
|
|
return result
|
|
}
|
|
for _, scenario := range []struct {
|
|
name string
|
|
input [][]byte
|
|
want error
|
|
max uint64
|
|
}{
|
|
{name: "empty packet", input: [][]byte{nil}, want: ErrPacket},
|
|
{name: "empty complete", input: [][]byte{{0}}, want: ErrPacket},
|
|
{name: "unknown kind", input: [][]byte{{3, 1}}, want: ErrPacket},
|
|
{name: "short header", input: [][]byte{{1, 0}}, want: ErrPacket},
|
|
{name: "oversized packet", input: [][]byte{make([]byte, PacketBytes+1)}, want: ErrPacket},
|
|
{name: "oversized declaration", input: [][]byte{changed(base[0], 1, 0xffffffff)}, want: ErrMessageTooBig},
|
|
{name: "small fragmented declaration", input: [][]byte{changed(base[0], 1, 1)}, want: ErrPacket},
|
|
{name: "tail first", input: [][]byte{base[1]}, want: ErrPacket},
|
|
{name: "duplicate prefix", input: [][]byte{base[0], base[0]}, want: ErrPacket},
|
|
{name: "gap", input: [][]byte{base[0], base[2]}, want: ErrPacket},
|
|
{name: "changed total", input: [][]byte{base[0], changed(base[1], 1, 65537)}, want: ErrPacket},
|
|
{name: "offset overflow", input: [][]byte{changed(base[0], 5, 0xffffffff)}, want: ErrPacket},
|
|
{name: "configured complete limit", input: [][]byte{{0, 1, 2}}, max: 1, want: ErrMessageTooBig},
|
|
} {
|
|
t.Run(scenario.name, func(t *testing.T) {
|
|
maximum := scenario.max
|
|
if maximum == 0 {
|
|
maximum = 1 << 20
|
|
}
|
|
decoder := Decoder{Maximum: maximum}
|
|
var err error
|
|
for _, packet := range scenario.input {
|
|
_, err = decoder.Push(packet)
|
|
if err != nil {
|
|
break
|
|
}
|
|
}
|
|
if !errors.Is(err, scenario.want) {
|
|
t.Fatalf("error = %v, want %v", err, scenario.want)
|
|
}
|
|
if scenario.name == "oversized declaration" && decoder.lanes[0].bytes != nil {
|
|
t.Fatal("allocated an oversized declared message")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func FuzzDecoder(f *testing.F) {
|
|
f.Add([]byte{0, 1}, []byte{1})
|
|
f.Add([]byte{1, 0, 1, 0, 0, 0, 0, 0, 0, 1}, []byte{0, 1})
|
|
f.Fuzz(func(t *testing.T, first, second []byte) {
|
|
decoder := Decoder{Maximum: 64 << 10}
|
|
for _, packet := range [][]byte{first, second} {
|
|
if _, err := decoder.Push(packet); err != nil {
|
|
return
|
|
}
|
|
for _, lane := range decoder.lanes {
|
|
if cap(lane.bytes) > 64<<10 {
|
|
t.Fatal("reassembly exceeded configured bound")
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|