pw_rpc_transport/simple_framing_test.cc - pigweed/pigweed - Git at Google

 // Copyright 2023 The Pigweed Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
 // use this file except in compliance with the License. You may obtain a copy of
 // the License at
 //
 //     https://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 // License for the specific language governing permissions and limitations under
 // the License.

 #include "pw_rpc_transport/simple_framing.h"

 #include <algorithm>
 #include <array>
 #include <random>

 #include "pw_bytes/span.h"
 #include "pw_log/log.h"
 #include "pw_status/status.h"
 #include "pw_unit_test/framework.h"

 namespace pw::rpc {
 namespace {

 constexpr size_t kMaxPacketSize = 256;

 struct TestParams {
   size_t packet_size = 0;
   size_t max_frame_size = 0;
 };

 constexpr std::array<TestParams, 8> kTestCases = {
     // Packet fits in one frame.
     TestParams{.packet_size = 5, .max_frame_size = 100},
     // Typical parameters for RPC packet and mailbox frame size.
     TestParams{.packet_size = 100, .max_frame_size = 128},
     // Smallest packet.
     TestParams{.packet_size = 1, .max_frame_size = 16},
     // Small packet, small frame.
     TestParams{.packet_size = 16, .max_frame_size = 5},
     // Odd-sized packet, small frame.
     TestParams{.packet_size = 77, .max_frame_size = 16},
     // Frame size and packet size off by one.
     TestParams{.packet_size = 11, .max_frame_size = 10},
     // Almost at the limit.
     TestParams{.packet_size = kMaxPacketSize - 1,
                .max_frame_size = kMaxPacketSize - 2},
     // At the limit.
     TestParams{.packet_size = kMaxPacketSize,
                .max_frame_size = kMaxPacketSize}};

 void MakePacket(ByteSpan dst_buffer) {
   static uint32_t rg_seed = 0x123;
   unsigned char c = 0;
   for (auto& i : dst_buffer) {
     i = std::byte{c++};
   }
   std::mt19937 rg(rg_seed++);
   std::shuffle(dst_buffer.begin(), dst_buffer.end(), rg);
 }

 void CopyFrame(RpcFrame frame, std::vector<std::byte>& dst) {
   std::copy(frame.header.begin(), frame.header.end(), std::back_inserter(dst));
   std::copy(
       frame.payload.begin(), frame.payload.end(), std::back_inserter(dst));
 }

 TEST(SimpleRpcFrameEncodeDecodeTest, EncodeThenDecode) {
   for (auto test_case : kTestCases) {
     const size_t packet_size = test_case.packet_size;
     const size_t max_frame_size = test_case.max_frame_size;
     PW_LOG_INFO("EncodeThenDecode: packet_size = %d, max_frame_size = %d",
                 static_cast<int>(packet_size),
                 static_cast<int>(max_frame_size));

     std::vector<std::byte> src(packet_size);
     MakePacket(src);

     std::vector<std::byte> encoded;
     std::vector<std::byte> decoded;

     SimpleRpcPacketEncoder<kMaxPacketSize> encoder;

     ASSERT_EQ(encoder.Encode(src,
                              max_frame_size,
                              [&encoded](RpcFrame& frame) {
                                CopyFrame(frame, encoded);
                                return OkStatus();
                              }),
               OkStatus());

     SimpleRpcPacketDecoder<kMaxPacketSize> decoder;

     ASSERT_EQ(decoder.Decode(encoded,
                              [&decoded](ConstByteSpan packet) {
                                std::copy(packet.begin(),
                                          packet.end(),
                                          std::back_inserter(decoded));
                              }),
               OkStatus());

     EXPECT_TRUE(std::equal(src.begin(), src.end(), decoded.begin()));
   }
 }

 TEST(SimpleRpcFrameEncodeDecodeTest, OneByteAtTimeDecoding) {
   for (auto test_case : kTestCases) {
     const size_t packet_size = test_case.packet_size;
     const size_t max_frame_size = test_case.max_frame_size;
     PW_LOG_INFO("EncodeThenDecode: packet_size = %d, max_frame_size = %d",
                 static_cast<int>(packet_size),
                 static_cast<int>(max_frame_size));

     std::vector<std::byte> src(packet_size);
     MakePacket(src);

     std::vector<std::byte> encoded;
     std::vector<std::byte> decoded;

     SimpleRpcPacketEncoder<kMaxPacketSize> encoder;

     ASSERT_EQ(encoder.Encode(src,
                              max_frame_size,
                              [&encoded](RpcFrame& frame) {
                                CopyFrame(frame, encoded);
                                return OkStatus();
                              }),
               OkStatus());

     SimpleRpcPacketDecoder<kMaxPacketSize> decoder;

     for (std::byte b : encoded) {
       auto buffer_span = span(&b, 1);
       ASSERT_EQ(decoder.Decode(buffer_span,
                                [&decoded](ConstByteSpan packet) {
                                  std::copy(packet.begin(),
                                            packet.end(),
                                            std::back_inserter(decoded));
                                }),
                 OkStatus());
     }

     EXPECT_TRUE(std::equal(src.begin(), src.end(), decoded.begin()));
   }
 }

 TEST(SimpleRpcFrameTest, MissingFirstFrame) {
   // Sends two packets, the first packet is missing its first frame. The decoder
   // ignores the remaining frames of the first packet but still picks up the
   // second packet.
   constexpr size_t kPacketSize = 77;
   constexpr size_t kMaxFrameSize = 16;

   std::vector<std::byte> src1(kPacketSize);
   MakePacket(src1);

   std::vector<std::byte> src2(kPacketSize);
   MakePacket(src2);

   std::vector<std::byte> decoded;

   SimpleRpcPacketEncoder<kMaxPacketSize> encoder;
   struct EncodeState {
     size_t frame_counter = 0;
     std::vector<std::byte> encoded;
   } state;

   ASSERT_EQ(encoder.Encode(src1,
                            kMaxFrameSize,
                            [&state](RpcFrame& frame) {
                              state.frame_counter++;
                              if (state.frame_counter > 1) {
                                // Skip the first frame.
                                CopyFrame(frame, state.encoded);
                              }
                              return OkStatus();
                            }),
             OkStatus());

   ASSERT_EQ(encoder.Encode(src2,
                            kMaxFrameSize,
                            [&state](RpcFrame& frame) {
                              CopyFrame(frame, state.encoded);
                              return OkStatus();
                            }),
             OkStatus());

   SimpleRpcPacketDecoder<kMaxPacketSize> decoder;

   ASSERT_EQ(decoder.Decode(state.encoded,
                            [&decoded](ConstByteSpan packet) {
                              std::copy(packet.begin(),
                                        packet.end(),
                                        std::back_inserter(decoded));
                            }),
             OkStatus());

   EXPECT_TRUE(std::equal(src2.begin(), src2.end(), decoded.begin()));
 }

 TEST(SimpleRpcFrameTest, MissingInternalFrame) {
   // Sends two packets, the first packet is missing its second frame. The
   // decoder ignores the remaining frames of the first packet and the second
   // packet as well but eventually stumbles upon the frame header in the third
   // packet and processes that packet.
   constexpr size_t kPacketSize = 77;
   constexpr size_t kMaxFrameSize = 16;

   std::vector<std::byte> src1(kPacketSize);
   MakePacket(src1);

   std::vector<std::byte> src2(kPacketSize);
   MakePacket(src2);

   std::vector<std::byte> src3(kPacketSize);
   MakePacket(src3);

   std::vector<std::byte> decoded;

   SimpleRpcPacketEncoder<kMaxPacketSize> encoder;
   struct EncodeState {
     size_t frame_counter = 0;
     std::vector<std::byte> encoded;
   } encode_state;

   ASSERT_EQ(encoder.Encode(src1,
                            kMaxFrameSize,
                            [&encode_state](RpcFrame& frame) {
                              encode_state.frame_counter++;
                              if (encode_state.frame_counter != 2) {
                                // Skip the second frame.
                                CopyFrame(frame, encode_state.encoded);
                              }
                              return OkStatus();
                            }),
             OkStatus());

   ASSERT_EQ(encoder.Encode(src2,
                            kMaxFrameSize,
                            [&encode_state](RpcFrame& frame) {
                              CopyFrame(frame, encode_state.encoded);
                              return OkStatus();
                            }),
             OkStatus());

   ASSERT_EQ(encoder.Encode(src3,
                            kMaxFrameSize,
                            [&encode_state](RpcFrame& frame) {
                              CopyFrame(frame, encode_state.encoded);
                              return OkStatus();
                            }),
             OkStatus());

   SimpleRpcPacketDecoder<kMaxPacketSize> decoder;

   // First packet is decoded but it doesn't have correct bytes, as one of its
   // frames has never been received. Second packet is not received because its
   // header has been consumed by the first packet. By that point the decoder
   // knows that something is wrong and tries to recover as soon as it receives
   // bytes that look as the valid header. So we eventually receive the third
   // packet and it is correct.
   struct DecodeState {
     std::vector<std::byte> decoded1;
     std::vector<std::byte> decoded2;
     size_t packet_counter = 0;
   } decode_state;

   ASSERT_EQ(
       decoder.Decode(encode_state.encoded,
                      [&decode_state](ConstByteSpan packet) {
                        decode_state.packet_counter++;
                        if (decode_state.packet_counter == 1) {
                          std::copy(packet.begin(),
                                    packet.end(),
                                    std::back_inserter(decode_state.decoded1));
                        }
                        if (decode_state.packet_counter == 2) {
                          std::copy(packet.begin(),
                                    packet.end(),
                                    std::back_inserter(decode_state.decoded2));
                        }
                      }),
       OkStatus());

   EXPECT_EQ(decode_state.packet_counter, 2ul);

   EXPECT_EQ(decode_state.decoded1.size(), src1.size());
   EXPECT_FALSE(
       std::equal(src1.begin(), src1.end(), decode_state.decoded1.begin()));

   EXPECT_TRUE(
       std::equal(src3.begin(), src3.end(), decode_state.decoded2.begin()));
 }

 TEST(SimpleRpcPacketEncoder, PacketTooBig) {
   SimpleRpcPacketEncoder<kMaxPacketSize> encoder;
   constexpr size_t kMaxFrameSize = 100;
   std::array<std::byte, kMaxPacketSize + 1> src{};

   EXPECT_EQ(
       encoder.Encode(src, kMaxFrameSize, [](RpcFrame&) { return OkStatus(); }),
       Status::FailedPrecondition());
 }

 TEST(SimpleRpcPacketEncoder, MaxFrameSizeTooSmall) {
   SimpleRpcPacketEncoder<kMaxPacketSize> encoder;
   std::array<std::byte, kMaxPacketSize> src{};

   EXPECT_EQ(encoder.Encode(
                 src, encoder.kHeaderSize, [](RpcFrame&) { return OkStatus(); }),
             Status::FailedPrecondition());

   EXPECT_EQ(
       encoder.Encode(
           src, encoder.kHeaderSize + 1, [](RpcFrame&) { return OkStatus(); }),
       OkStatus());
 }

 TEST(SimpleRpcFrameTest, EncoderBufferLargerThanDecoderBuffer) {
   constexpr size_t kLargePacketSize = 150;
   constexpr size_t kSmallPacketSize = 120;
   constexpr size_t kMaxFrameSize = 16;

   // Decoder isn't able to receive the whole packet because it needs to be
   // buffered but the internal buffer is too small; the packet is thus
   // discarded. The second packet is received without issues as it's small
   // enough to fit in the decoder buffer.
   constexpr size_t kEncoderMaxPacketSize = 256;
   constexpr size_t kDecoderMaxPacketSize = 128;

   std::vector<std::byte> src1(kLargePacketSize);
   MakePacket(src1);

   std::vector<std::byte> src2(kSmallPacketSize);
   MakePacket(src1);

   std::vector<std::byte> encoded;
   std::vector<std::byte> decoded;

   SimpleRpcPacketEncoder<kEncoderMaxPacketSize> encoder;

   ASSERT_EQ(encoder.Encode(src1,
                            kMaxFrameSize,
                            [&encoded](RpcFrame& frame) {
                              CopyFrame(frame, encoded);
                              return OkStatus();
                            }),
             OkStatus());

   ASSERT_EQ(encoder.Encode(src2,
                            kMaxFrameSize,
                            [&encoded](RpcFrame& frame) {
                              CopyFrame(frame, encoded);
                              return OkStatus();
                            }),
             OkStatus());

   SimpleRpcPacketDecoder<kDecoderMaxPacketSize> decoder;

   // We have to decode piecemeal here because otherwise the decoder can just
   // pluck the packet from `encoded` without internally buffering it.
   for (std::byte b : encoded) {
     auto buffer_span = span(&b, 1);
     ASSERT_EQ(decoder.Decode(buffer_span,
                              [&decoded](ConstByteSpan packet) {
                                std::copy(packet.begin(),
                                          packet.end(),
                                          std::back_inserter(decoded));
                              }),
               OkStatus());
   }

   EXPECT_TRUE(std::equal(src2.begin(), src2.end(), decoded.begin()));
 }

 }  // namespace
 }  // namespace pw::rpc
	// Copyright 2023 The Pigweed Authors
	//
	// Licensed under the Apache License, Version 2.0 (the "License"); you may not
	// use this file except in compliance with the License. You may obtain a copy of
	// the License at
	//
	// https://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	// License for the specific language governing permissions and limitations under
	// the License.

	#include "pw_rpc_transport/simple_framing.h"

	#include <algorithm>
	#include <array>
	#include <random>

	#include "pw_bytes/span.h"
	#include "pw_log/log.h"
	#include "pw_status/status.h"
	#include "pw_unit_test/framework.h"

	namespace pw::rpc {
	namespace {

	constexpr size_t kMaxPacketSize = 256;

	struct TestParams {
	size_t packet_size = 0;
	size_t max_frame_size = 0;
	};

	constexpr std::array<TestParams, 8> kTestCases = {
	// Packet fits in one frame.
	TestParams{.packet_size = 5, .max_frame_size = 100},
	// Typical parameters for RPC packet and mailbox frame size.
	TestParams{.packet_size = 100, .max_frame_size = 128},
	// Smallest packet.
	TestParams{.packet_size = 1, .max_frame_size = 16},
	// Small packet, small frame.
	TestParams{.packet_size = 16, .max_frame_size = 5},
	// Odd-sized packet, small frame.
	TestParams{.packet_size = 77, .max_frame_size = 16},
	// Frame size and packet size off by one.
	TestParams{.packet_size = 11, .max_frame_size = 10},
	// Almost at the limit.
	TestParams{.packet_size = kMaxPacketSize - 1,
	.max_frame_size = kMaxPacketSize - 2},
	// At the limit.
	TestParams{.packet_size = kMaxPacketSize,
	.max_frame_size = kMaxPacketSize}};

	void MakePacket(ByteSpan dst_buffer) {
	static uint32_t rg_seed = 0x123;
	unsigned char c = 0;
	for (auto& i : dst_buffer) {
	i = std::byte{c++};
	}
	std::mt19937 rg(rg_seed++);
	std::shuffle(dst_buffer.begin(), dst_buffer.end(), rg);
	}

	void CopyFrame(RpcFrame frame, std::vector<std::byte>& dst) {
	std::copy(frame.header.begin(), frame.header.end(), std::back_inserter(dst));
	std::copy(
	frame.payload.begin(), frame.payload.end(), std::back_inserter(dst));
	}

	TEST(SimpleRpcFrameEncodeDecodeTest, EncodeThenDecode) {
	for (auto test_case : kTestCases) {
	const size_t packet_size = test_case.packet_size;
	const size_t max_frame_size = test_case.max_frame_size;
	PW_LOG_INFO("EncodeThenDecode: packet_size = %d, max_frame_size = %d",
	static_cast<int>(packet_size),
	static_cast<int>(max_frame_size));

	std::vector<std::byte> src(packet_size);
	MakePacket(src);

	std::vector<std::byte> encoded;
	std::vector<std::byte> decoded;

	SimpleRpcPacketEncoder<kMaxPacketSize> encoder;

	ASSERT_EQ(encoder.Encode(src,
	max_frame_size,
	[&encoded](RpcFrame& frame) {
	CopyFrame(frame, encoded);
	return OkStatus();
	}),
	OkStatus());

	SimpleRpcPacketDecoder<kMaxPacketSize> decoder;

	ASSERT_EQ(decoder.Decode(encoded,
	[&decoded](ConstByteSpan packet) {
	std::copy(packet.begin(),
	packet.end(),
	std::back_inserter(decoded));
	}),
	OkStatus());

	EXPECT_TRUE(std::equal(src.begin(), src.end(), decoded.begin()));
	}
	}

	TEST(SimpleRpcFrameEncodeDecodeTest, OneByteAtTimeDecoding) {
	for (auto test_case : kTestCases) {
	const size_t packet_size = test_case.packet_size;
	const size_t max_frame_size = test_case.max_frame_size;
	PW_LOG_INFO("EncodeThenDecode: packet_size = %d, max_frame_size = %d",
	static_cast<int>(packet_size),
	static_cast<int>(max_frame_size));

	std::vector<std::byte> src(packet_size);
	MakePacket(src);

	std::vector<std::byte> encoded;
	std::vector<std::byte> decoded;

	SimpleRpcPacketEncoder<kMaxPacketSize> encoder;

	ASSERT_EQ(encoder.Encode(src,
	max_frame_size,
	[&encoded](RpcFrame& frame) {
	CopyFrame(frame, encoded);
	return OkStatus();
	}),
	OkStatus());

	SimpleRpcPacketDecoder<kMaxPacketSize> decoder;

	for (std::byte b : encoded) {
	auto buffer_span = span(&b, 1);
	ASSERT_EQ(decoder.Decode(buffer_span,
	[&decoded](ConstByteSpan packet) {
	std::copy(packet.begin(),
	packet.end(),
	std::back_inserter(decoded));
	}),
	OkStatus());
	}

	EXPECT_TRUE(std::equal(src.begin(), src.end(), decoded.begin()));
	}
	}

	TEST(SimpleRpcFrameTest, MissingFirstFrame) {
	// Sends two packets, the first packet is missing its first frame. The decoder
	// ignores the remaining frames of the first packet but still picks up the
	// second packet.
	constexpr size_t kPacketSize = 77;
	constexpr size_t kMaxFrameSize = 16;

	std::vector<std::byte> src1(kPacketSize);
	MakePacket(src1);

	std::vector<std::byte> src2(kPacketSize);
	MakePacket(src2);

	std::vector<std::byte> decoded;

	SimpleRpcPacketEncoder<kMaxPacketSize> encoder;
	struct EncodeState {
	size_t frame_counter = 0;
	std::vector<std::byte> encoded;
	} state;

	ASSERT_EQ(encoder.Encode(src1,
	kMaxFrameSize,
	[&state](RpcFrame& frame) {
	state.frame_counter++;
	if (state.frame_counter > 1) {
	// Skip the first frame.
	CopyFrame(frame, state.encoded);
	}
	return OkStatus();
	}),
	OkStatus());

	ASSERT_EQ(encoder.Encode(src2,
	kMaxFrameSize,
	[&state](RpcFrame& frame) {
	CopyFrame(frame, state.encoded);
	return OkStatus();
	}),
	OkStatus());

	SimpleRpcPacketDecoder<kMaxPacketSize> decoder;

	ASSERT_EQ(decoder.Decode(state.encoded,
	[&decoded](ConstByteSpan packet) {
	std::copy(packet.begin(),
	packet.end(),
	std::back_inserter(decoded));
	}),
	OkStatus());

	EXPECT_TRUE(std::equal(src2.begin(), src2.end(), decoded.begin()));
	}

	TEST(SimpleRpcFrameTest, MissingInternalFrame) {
	// Sends two packets, the first packet is missing its second frame. The
	// decoder ignores the remaining frames of the first packet and the second
	// packet as well but eventually stumbles upon the frame header in the third
	// packet and processes that packet.
	constexpr size_t kPacketSize = 77;
	constexpr size_t kMaxFrameSize = 16;

	std::vector<std::byte> src1(kPacketSize);
	MakePacket(src1);

	std::vector<std::byte> src2(kPacketSize);
	MakePacket(src2);

	std::vector<std::byte> src3(kPacketSize);
	MakePacket(src3);

	std::vector<std::byte> decoded;

	SimpleRpcPacketEncoder<kMaxPacketSize> encoder;
	struct EncodeState {
	size_t frame_counter = 0;
	std::vector<std::byte> encoded;
	} encode_state;

	ASSERT_EQ(encoder.Encode(src1,
	kMaxFrameSize,
	[&encode_state](RpcFrame& frame) {
	encode_state.frame_counter++;
	if (encode_state.frame_counter != 2) {
	// Skip the second frame.
	CopyFrame(frame, encode_state.encoded);
	}
	return OkStatus();
	}),
	OkStatus());

	ASSERT_EQ(encoder.Encode(src2,
	kMaxFrameSize,
	[&encode_state](RpcFrame& frame) {
	CopyFrame(frame, encode_state.encoded);
	return OkStatus();
	}),
	OkStatus());

	ASSERT_EQ(encoder.Encode(src3,
	kMaxFrameSize,
	[&encode_state](RpcFrame& frame) {
	CopyFrame(frame, encode_state.encoded);
	return OkStatus();
	}),
	OkStatus());

	SimpleRpcPacketDecoder<kMaxPacketSize> decoder;

	// First packet is decoded but it doesn't have correct bytes, as one of its
	// frames has never been received. Second packet is not received because its
	// header has been consumed by the first packet. By that point the decoder
	// knows that something is wrong and tries to recover as soon as it receives
	// bytes that look as the valid header. So we eventually receive the third
	// packet and it is correct.
	struct DecodeState {
	std::vector<std::byte> decoded1;
	std::vector<std::byte> decoded2;
	size_t packet_counter = 0;
	} decode_state;

	ASSERT_EQ(
	decoder.Decode(encode_state.encoded,
	[&decode_state](ConstByteSpan packet) {
	decode_state.packet_counter++;
	if (decode_state.packet_counter == 1) {
	std::copy(packet.begin(),
	packet.end(),
	std::back_inserter(decode_state.decoded1));
	}
	if (decode_state.packet_counter == 2) {
	std::copy(packet.begin(),
	packet.end(),
	std::back_inserter(decode_state.decoded2));
	}
	}),
	OkStatus());

	EXPECT_EQ(decode_state.packet_counter, 2ul);

	EXPECT_EQ(decode_state.decoded1.size(), src1.size());
	EXPECT_FALSE(
	std::equal(src1.begin(), src1.end(), decode_state.decoded1.begin()));

	EXPECT_TRUE(
	std::equal(src3.begin(), src3.end(), decode_state.decoded2.begin()));
	}

	TEST(SimpleRpcPacketEncoder, PacketTooBig) {
	SimpleRpcPacketEncoder<kMaxPacketSize> encoder;
	constexpr size_t kMaxFrameSize = 100;
	std::array<std::byte, kMaxPacketSize + 1> src{};

	EXPECT_EQ(
	encoder.Encode(src, kMaxFrameSize, [](RpcFrame&) { return OkStatus(); }),
	Status::FailedPrecondition());
	}

	TEST(SimpleRpcPacketEncoder, MaxFrameSizeTooSmall) {
	SimpleRpcPacketEncoder<kMaxPacketSize> encoder;
	std::array<std::byte, kMaxPacketSize> src{};

	EXPECT_EQ(encoder.Encode(
	src, encoder.kHeaderSize, [](RpcFrame&) { return OkStatus(); }),
	Status::FailedPrecondition());

	EXPECT_EQ(
	encoder.Encode(
	src, encoder.kHeaderSize + 1, [](RpcFrame&) { return OkStatus(); }),
	OkStatus());
	}

	TEST(SimpleRpcFrameTest, EncoderBufferLargerThanDecoderBuffer) {
	constexpr size_t kLargePacketSize = 150;
	constexpr size_t kSmallPacketSize = 120;
	constexpr size_t kMaxFrameSize = 16;

	// Decoder isn't able to receive the whole packet because it needs to be
	// buffered but the internal buffer is too small; the packet is thus
	// discarded. The second packet is received without issues as it's small
	// enough to fit in the decoder buffer.
	constexpr size_t kEncoderMaxPacketSize = 256;
	constexpr size_t kDecoderMaxPacketSize = 128;

	std::vector<std::byte> src1(kLargePacketSize);
	MakePacket(src1);

	std::vector<std::byte> src2(kSmallPacketSize);
	MakePacket(src1);

	std::vector<std::byte> encoded;
	std::vector<std::byte> decoded;

	SimpleRpcPacketEncoder<kEncoderMaxPacketSize> encoder;

	ASSERT_EQ(encoder.Encode(src1,
	kMaxFrameSize,
	[&encoded](RpcFrame& frame) {
	CopyFrame(frame, encoded);
	return OkStatus();
	}),
	OkStatus());

	ASSERT_EQ(encoder.Encode(src2,
	kMaxFrameSize,
	[&encoded](RpcFrame& frame) {
	CopyFrame(frame, encoded);
	return OkStatus();
	}),
	OkStatus());

	SimpleRpcPacketDecoder<kDecoderMaxPacketSize> decoder;

	// We have to decode piecemeal here because otherwise the decoder can just
	// pluck the packet from `encoded` without internally buffering it.
	for (std::byte b : encoded) {
	auto buffer_span = span(&b, 1);
	ASSERT_EQ(decoder.Decode(buffer_span,
	[&decoded](ConstByteSpan packet) {
	std::copy(packet.begin(),
	packet.end(),
	std::back_inserter(decoded));
	}),
	OkStatus());
	}

	EXPECT_TRUE(std::equal(src2.begin(), src2.end(), decoded.begin()));
	}

	} // namespace
	} // namespace pw::rpc