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") } } } }) }