diff --git a/modules/video_coding/packet_buffer_unittest.cc b/modules/video_coding/packet_buffer_unittest.cc index b47ceece32..9da432cb3c 100644 --- a/modules/video_coding/packet_buffer_unittest.cc +++ b/modules/video_coding/packet_buffer_unittest.cc @@ -11,11 +11,11 @@ #include #include -#include -#include +#include #include #include +#include "api/array_view.h" #include "common_video/h264/h264_common.h" #include "modules/video_coding/frame_object.h" #include "rtc_base/random.h" @@ -29,12 +29,18 @@ namespace video_coding { namespace { using ::testing::ElementsAre; +using ::testing::ElementsAreArray; using ::testing::IsEmpty; +using ::testing::Matches; +using ::testing::Pointee; using ::testing::SizeIs; +constexpr int kStartSize = 16; +constexpr int kMaxSize = 64; + void IgnoreResult(PacketBuffer::InsertResult /*result*/) {} -std::vector FirstSeqNums( +std::vector StartSeqNums( rtc::ArrayView> frames) { std::vector result; for (const auto& frame : frames) { @@ -43,6 +49,14 @@ std::vector FirstSeqNums( return result; } +MATCHER_P(StartSeqNumsAre, seq_num, "") { + return Matches(ElementsAre(seq_num))(StartSeqNums(arg.frames)); +} + +MATCHER_P2(StartSeqNumsAre, seq_num1, seq_num2, "") { + return Matches(ElementsAre(seq_num1, seq_num2))(StartSeqNums(arg.frames)); +} + MATCHER(KeyFrame, "") { return arg->frame_type() == VideoFrameType::kVideoFrameKey; } @@ -51,6 +65,32 @@ MATCHER(DeltaFrame, "") { return arg->frame_type() == VideoFrameType::kVideoFrameDelta; } +struct PacketBufferInsertResult : public PacketBuffer::InsertResult { + explicit PacketBufferInsertResult(PacketBuffer::InsertResult result) + : InsertResult(std::move(result)) {} +}; + +void PrintTo(const PacketBufferInsertResult& result, std::ostream* os) { + *os << "frames: { "; + for (size_t i = 0; i < result.frames.size(); ++i) { + const RtpFrameObject& frame = *result.frames[i]; + if (i > 0) { + *os << ", "; + } + *os << "{sn: "; + if (frame.first_seq_num() == frame.last_seq_num()) { + *os << frame.first_seq_num(); + } else { + *os << "[" << frame.first_seq_num() << "-" << frame.last_seq_num() << "]"; + } + *os << "}"; + } + *os << " }"; + if (result.buffer_cleared) { + *os << ", buffer_cleared"; + } +} + class PacketBufferTest : public ::testing::Test { protected: explicit PacketBufferTest(std::string field_trials = "") @@ -61,30 +101,17 @@ class PacketBufferTest : public ::testing::Test { uint16_t Rand() { return rand_.Rand(); } - void OnAssembledFrame(std::unique_ptr frame) { - uint16_t first_seq_num = frame->first_seq_num(); - if (frames_from_callback_.find(first_seq_num) != - frames_from_callback_.end()) { - ADD_FAILURE() << "Already received frame with first sequence number " - << first_seq_num << "."; - return; - } - - frames_from_callback_.insert( - std::make_pair(frame->first_seq_num(), std::move(frame))); - } - enum IsKeyFrame { kKeyFrame, kDeltaFrame }; enum IsFirst { kFirst, kNotFirst }; enum IsLast { kLast, kNotLast }; - bool Insert(uint16_t seq_num, // packet sequence number - IsKeyFrame keyframe, // is keyframe - IsFirst first, // is first packet of frame - IsLast last, // is last packet of frame - int data_size = 0, // size of data - uint8_t* data = nullptr, // data pointer - uint32_t timestamp = 123u) { // rtp timestamp + PacketBufferInsertResult Insert(uint16_t seq_num, // packet sequence number + IsKeyFrame keyframe, // is keyframe + IsFirst first, // is first packet of frame + IsLast last, // is last packet of frame + int data_size = 0, // size of data + uint8_t* data = nullptr, // data pointer + uint32_t timestamp = 123u) { // rtp timestamp VCMPacket packet; packet.video_header.codec = kVideoCodecGeneric; packet.timestamp = timestamp; @@ -97,100 +124,60 @@ class PacketBufferTest : public ::testing::Test { packet.sizeBytes = data_size; packet.dataPtr = data; - return HandleResult(packet_buffer_.InsertPacket(&packet)); + return PacketBufferInsertResult(packet_buffer_.InsertPacket(&packet)); } - // TODO(danilchap): Instead of using this helper, update all tests to validate - // result of the InsertPacket/InsertPadding directly for cleaner expectations - // and error messages when test fail. - bool HandleResult(PacketBuffer::InsertResult result) { - for (auto& frame : result.frames) { - OnAssembledFrame(std::move(frame)); - } - return !result.buffer_cleared; - } - - void CheckFrame(uint16_t first_seq_num) { - auto frame_it = frames_from_callback_.find(first_seq_num); - ASSERT_FALSE(frame_it == frames_from_callback_.end()) - << "Could not find frame with first sequence number " << first_seq_num - << "."; - } - - void DeleteFrame(uint16_t first_seq_num) { - auto frame_it = frames_from_callback_.find(first_seq_num); - ASSERT_FALSE(frame_it == frames_from_callback_.end()) - << "Could not find frame with first sequence number " << first_seq_num - << "."; - frames_from_callback_.erase(frame_it); - } - - static constexpr int kStartSize = 16; - static constexpr int kMaxSize = 64; - const test::ScopedFieldTrials scoped_field_trials_; - Random rand_; std::unique_ptr clock_; PacketBuffer packet_buffer_; - std::map> frames_from_callback_; }; TEST_F(PacketBufferTest, InsertOnePacket) { const uint16_t seq_num = Rand(); - EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kLast)); + EXPECT_THAT(Insert(seq_num, kKeyFrame, kFirst, kLast).frames, SizeIs(1)); } TEST_F(PacketBufferTest, InsertMultiplePackets) { const uint16_t seq_num = Rand(); - EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kLast)); - EXPECT_TRUE(Insert(seq_num + 1, kKeyFrame, kFirst, kLast)); - EXPECT_TRUE(Insert(seq_num + 2, kKeyFrame, kFirst, kLast)); - EXPECT_TRUE(Insert(seq_num + 3, kKeyFrame, kFirst, kLast)); + EXPECT_THAT(Insert(seq_num, kKeyFrame, kFirst, kLast).frames, SizeIs(1)); + EXPECT_THAT(Insert(seq_num + 1, kKeyFrame, kFirst, kLast).frames, SizeIs(1)); + EXPECT_THAT(Insert(seq_num + 2, kKeyFrame, kFirst, kLast).frames, SizeIs(1)); + EXPECT_THAT(Insert(seq_num + 3, kKeyFrame, kFirst, kLast).frames, SizeIs(1)); } TEST_F(PacketBufferTest, InsertDuplicatePacket) { const uint16_t seq_num = Rand(); - EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast)); - EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast)); - EXPECT_TRUE(Insert(seq_num + 1, kKeyFrame, kNotFirst, kLast)); + EXPECT_THAT(Insert(seq_num, kKeyFrame, kFirst, kNotLast).frames, IsEmpty()); + EXPECT_THAT(Insert(seq_num, kKeyFrame, kFirst, kNotLast).frames, IsEmpty()); + EXPECT_THAT(Insert(seq_num + 1, kKeyFrame, kNotFirst, kLast).frames, + SizeIs(1)); } TEST_F(PacketBufferTest, SeqNumWrapOneFrame) { - EXPECT_TRUE(Insert(0xFFFF, kKeyFrame, kFirst, kNotLast)); - EXPECT_TRUE(Insert(0x0, kKeyFrame, kNotFirst, kLast)); - - CheckFrame(0xFFFF); + Insert(0xFFFF, kKeyFrame, kFirst, kNotLast); + EXPECT_THAT(Insert(0x0, kKeyFrame, kNotFirst, kLast), + StartSeqNumsAre(0xFFFF)); } TEST_F(PacketBufferTest, SeqNumWrapTwoFrames) { - EXPECT_TRUE(Insert(0xFFFF, kKeyFrame, kFirst, kLast)); - EXPECT_TRUE(Insert(0x0, kKeyFrame, kFirst, kLast)); - - CheckFrame(0xFFFF); - CheckFrame(0x0); + EXPECT_THAT(Insert(0xFFFF, kKeyFrame, kFirst, kLast), + StartSeqNumsAre(0xFFFF)); + EXPECT_THAT(Insert(0x0, kKeyFrame, kFirst, kLast), StartSeqNumsAre(0x0)); } TEST_F(PacketBufferTest, InsertOldPackets) { - const uint16_t seq_num = Rand(); + EXPECT_THAT(Insert(100, kKeyFrame, kFirst, kNotLast).frames, IsEmpty()); + EXPECT_THAT(Insert(102, kDeltaFrame, kFirst, kLast).frames, SizeIs(1)); + EXPECT_THAT(Insert(101, kKeyFrame, kNotFirst, kLast).frames, SizeIs(1)); - EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast)); - EXPECT_TRUE(Insert(seq_num + 2, kDeltaFrame, kFirst, kLast)); - EXPECT_TRUE(Insert(seq_num + 1, kKeyFrame, kNotFirst, kLast)); - ASSERT_EQ(2UL, frames_from_callback_.size()); + EXPECT_THAT(Insert(100, kKeyFrame, kFirst, kNotLast).frames, IsEmpty()); + EXPECT_THAT(Insert(100, kKeyFrame, kFirst, kNotLast).frames, IsEmpty()); + EXPECT_THAT(Insert(102, kDeltaFrame, kFirst, kLast).frames, SizeIs(1)); - frames_from_callback_.erase(seq_num + 2); - EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast)); - ASSERT_EQ(1UL, frames_from_callback_.size()); - - frames_from_callback_.erase(frames_from_callback_.find(seq_num)); - ASSERT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast)); - EXPECT_TRUE(Insert(seq_num + 2, kDeltaFrame, kFirst, kLast)); - - packet_buffer_.ClearTo(seq_num + 2); - EXPECT_TRUE(Insert(seq_num + 2, kDeltaFrame, kFirst, kLast)); - EXPECT_TRUE(Insert(seq_num + 3, kDeltaFrame, kFirst, kLast)); - ASSERT_EQ(2UL, frames_from_callback_.size()); + packet_buffer_.ClearTo(102); + EXPECT_THAT(Insert(102, kDeltaFrame, kFirst, kLast).frames, IsEmpty()); + EXPECT_THAT(Insert(103, kDeltaFrame, kFirst, kLast).frames, SizeIs(1)); } TEST_F(PacketBufferTest, NackCount) { @@ -231,46 +218,38 @@ TEST_F(PacketBufferTest, FrameSize) { uint8_t* data3 = new uint8_t[5](); uint8_t* data4 = new uint8_t[5](); - EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast, 5, data1)); - EXPECT_TRUE(Insert(seq_num + 1, kKeyFrame, kNotFirst, kNotLast, 5, data2)); - EXPECT_TRUE(Insert(seq_num + 2, kKeyFrame, kNotFirst, kNotLast, 5, data3)); - EXPECT_TRUE(Insert(seq_num + 3, kKeyFrame, kNotFirst, kLast, 5, data4)); - - ASSERT_EQ(1UL, frames_from_callback_.size()); - EXPECT_EQ(20UL, frames_from_callback_.begin()->second->size()); + Insert(seq_num, kKeyFrame, kFirst, kNotLast, 5, data1); + Insert(seq_num + 1, kKeyFrame, kNotFirst, kNotLast, 5, data2); + Insert(seq_num + 2, kKeyFrame, kNotFirst, kNotLast, 5, data3); + EXPECT_THAT(Insert(seq_num + 3, kKeyFrame, kNotFirst, kLast, 5, data4).frames, + ElementsAre(Pointee(SizeIs(20)))); } TEST_F(PacketBufferTest, CountsUniqueFrames) { const uint16_t seq_num = Rand(); - ASSERT_EQ(0, packet_buffer_.GetUniqueFramesSeen()); + ASSERT_EQ(packet_buffer_.GetUniqueFramesSeen(), 0); - EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast, 0, nullptr, 100)); - ASSERT_EQ(1, packet_buffer_.GetUniqueFramesSeen()); + Insert(seq_num, kKeyFrame, kFirst, kNotLast, 0, nullptr, 100); + ASSERT_EQ(packet_buffer_.GetUniqueFramesSeen(), 1); // Still the same frame. - EXPECT_TRUE( - Insert(seq_num + 1, kKeyFrame, kNotFirst, kLast, 0, nullptr, 100)); - ASSERT_EQ(1, packet_buffer_.GetUniqueFramesSeen()); + Insert(seq_num + 1, kKeyFrame, kNotFirst, kLast, 0, nullptr, 100); + ASSERT_EQ(packet_buffer_.GetUniqueFramesSeen(), 1); // Second frame. - EXPECT_TRUE( - Insert(seq_num + 2, kKeyFrame, kFirst, kNotLast, 0, nullptr, 200)); - ASSERT_EQ(2, packet_buffer_.GetUniqueFramesSeen()); - EXPECT_TRUE( - Insert(seq_num + 3, kKeyFrame, kNotFirst, kLast, 0, nullptr, 200)); - ASSERT_EQ(2, packet_buffer_.GetUniqueFramesSeen()); + Insert(seq_num + 2, kKeyFrame, kFirst, kNotLast, 0, nullptr, 200); + ASSERT_EQ(packet_buffer_.GetUniqueFramesSeen(), 2); + Insert(seq_num + 3, kKeyFrame, kNotFirst, kLast, 0, nullptr, 200); + ASSERT_EQ(packet_buffer_.GetUniqueFramesSeen(), 2); // Old packet. - EXPECT_TRUE( - Insert(seq_num + 1, kKeyFrame, kNotFirst, kLast, 0, nullptr, 100)); - ASSERT_EQ(2, packet_buffer_.GetUniqueFramesSeen()); + Insert(seq_num + 1, kKeyFrame, kNotFirst, kLast, 0, nullptr, 100); + ASSERT_EQ(packet_buffer_.GetUniqueFramesSeen(), 2); // Missing middle packet. - EXPECT_TRUE( - Insert(seq_num + 4, kKeyFrame, kFirst, kNotLast, 0, nullptr, 300)); - EXPECT_TRUE( - Insert(seq_num + 6, kKeyFrame, kNotFirst, kLast, 0, nullptr, 300)); - ASSERT_EQ(3, packet_buffer_.GetUniqueFramesSeen()); + Insert(seq_num + 4, kKeyFrame, kFirst, kNotLast, 0, nullptr, 300); + Insert(seq_num + 6, kKeyFrame, kNotFirst, kLast, 0, nullptr, 300); + ASSERT_EQ(packet_buffer_.GetUniqueFramesSeen(), 3); } TEST_F(PacketBufferTest, HasHistoryOfUniqueFrames) { @@ -283,179 +262,168 @@ TEST_F(PacketBufferTest, HasHistoryOfUniqueFrames) { Insert(seq_num + i, kKeyFrame, kFirst, kNotLast, 0, nullptr, timestamp + 10 * i); } - ASSERT_EQ(kNumFrames, packet_buffer_.GetUniqueFramesSeen()); + EXPECT_EQ(packet_buffer_.GetUniqueFramesSeen(), kNumFrames); // Old packets within history should not affect number of seen unique frames. for (int i = kNumFrames - kRequiredHistoryLength; i < kNumFrames; ++i) { Insert(seq_num + i, kKeyFrame, kFirst, kNotLast, 0, nullptr, timestamp + 10 * i); } - ASSERT_EQ(kNumFrames, packet_buffer_.GetUniqueFramesSeen()); + EXPECT_EQ(packet_buffer_.GetUniqueFramesSeen(), kNumFrames); // Very old packets should be treated as unique. Insert(seq_num, kKeyFrame, kFirst, kNotLast, 0, nullptr, timestamp); - ASSERT_EQ(kNumFrames + 1, packet_buffer_.GetUniqueFramesSeen()); + EXPECT_EQ(packet_buffer_.GetUniqueFramesSeen(), kNumFrames + 1); } TEST_F(PacketBufferTest, ExpandBuffer) { const uint16_t seq_num = Rand(); - EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast)); + Insert(seq_num, kKeyFrame, kFirst, kNotLast); for (int i = 1; i < kStartSize; ++i) - EXPECT_TRUE(Insert(seq_num + i, kKeyFrame, kNotFirst, kNotLast)); + EXPECT_FALSE( + Insert(seq_num + i, kKeyFrame, kNotFirst, kNotLast).buffer_cleared); // Already inserted kStartSize number of packets, inserting the last packet // should increase the buffer size and also result in an assembled frame. - EXPECT_TRUE(Insert(seq_num + kStartSize, kKeyFrame, kNotFirst, kLast)); + EXPECT_FALSE( + Insert(seq_num + kStartSize, kKeyFrame, kNotFirst, kLast).buffer_cleared); } TEST_F(PacketBufferTest, SingleFrameExpandsBuffer) { const uint16_t seq_num = Rand(); - EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast)); + Insert(seq_num, kKeyFrame, kFirst, kNotLast); for (int i = 1; i < kStartSize; ++i) - EXPECT_TRUE(Insert(seq_num + i, kKeyFrame, kNotFirst, kNotLast)); - EXPECT_TRUE(Insert(seq_num + kStartSize, kKeyFrame, kNotFirst, kLast)); - - ASSERT_EQ(1UL, frames_from_callback_.size()); - CheckFrame(seq_num); + Insert(seq_num + i, kKeyFrame, kNotFirst, kNotLast); + EXPECT_THAT(Insert(seq_num + kStartSize, kKeyFrame, kNotFirst, kLast), + StartSeqNumsAre(seq_num)); } TEST_F(PacketBufferTest, ExpandBufferOverflow) { const uint16_t seq_num = Rand(); - EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast)); + EXPECT_FALSE(Insert(seq_num, kKeyFrame, kFirst, kNotLast).buffer_cleared); for (int i = 1; i < kMaxSize; ++i) - EXPECT_TRUE(Insert(seq_num + i, kKeyFrame, kNotFirst, kNotLast)); + EXPECT_FALSE( + Insert(seq_num + i, kKeyFrame, kNotFirst, kNotLast).buffer_cleared); // Already inserted kMaxSize number of packets, inserting the last packet // should overflow the buffer and result in false being returned. - EXPECT_FALSE(Insert(seq_num + kMaxSize, kKeyFrame, kNotFirst, kLast)); + EXPECT_TRUE( + Insert(seq_num + kMaxSize, kKeyFrame, kNotFirst, kLast).buffer_cleared); } TEST_F(PacketBufferTest, OnePacketOneFrame) { const uint16_t seq_num = Rand(); - EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kLast)); - ASSERT_EQ(1UL, frames_from_callback_.size()); - CheckFrame(seq_num); + EXPECT_THAT(Insert(seq_num, kKeyFrame, kFirst, kLast), + StartSeqNumsAre(seq_num)); } TEST_F(PacketBufferTest, TwoPacketsTwoFrames) { const uint16_t seq_num = Rand(); - EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kLast)); - EXPECT_TRUE(Insert(seq_num + 1, kKeyFrame, kFirst, kLast)); - - EXPECT_EQ(2UL, frames_from_callback_.size()); - CheckFrame(seq_num); - CheckFrame(seq_num + 1); + EXPECT_THAT(Insert(seq_num, kKeyFrame, kFirst, kLast), + StartSeqNumsAre(seq_num)); + EXPECT_THAT(Insert(seq_num + 1, kKeyFrame, kFirst, kLast), + StartSeqNumsAre(seq_num + 1)); } TEST_F(PacketBufferTest, TwoPacketsOneFrames) { const uint16_t seq_num = Rand(); - EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast)); - EXPECT_TRUE(Insert(seq_num + 1, kKeyFrame, kNotFirst, kLast)); - - EXPECT_EQ(1UL, frames_from_callback_.size()); - CheckFrame(seq_num); + EXPECT_THAT(Insert(seq_num, kKeyFrame, kFirst, kNotLast).frames, IsEmpty()); + EXPECT_THAT(Insert(seq_num + 1, kKeyFrame, kNotFirst, kLast), + StartSeqNumsAre(seq_num)); } TEST_F(PacketBufferTest, ThreePacketReorderingOneFrame) { const uint16_t seq_num = Rand(); - EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast)); - EXPECT_TRUE(Insert(seq_num + 2, kKeyFrame, kNotFirst, kLast)); - EXPECT_TRUE(Insert(seq_num + 1, kKeyFrame, kNotFirst, kNotLast)); - - EXPECT_EQ(1UL, frames_from_callback_.size()); - CheckFrame(seq_num); + EXPECT_THAT(Insert(seq_num, kKeyFrame, kFirst, kNotLast).frames, IsEmpty()); + EXPECT_THAT(Insert(seq_num + 2, kKeyFrame, kNotFirst, kLast).frames, + IsEmpty()); + EXPECT_THAT(Insert(seq_num + 1, kKeyFrame, kNotFirst, kNotLast), + StartSeqNumsAre(seq_num)); } TEST_F(PacketBufferTest, Frames) { const uint16_t seq_num = Rand(); - EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kLast)); - EXPECT_TRUE(Insert(seq_num + 1, kDeltaFrame, kFirst, kLast)); - EXPECT_TRUE(Insert(seq_num + 2, kDeltaFrame, kFirst, kLast)); - EXPECT_TRUE(Insert(seq_num + 3, kDeltaFrame, kFirst, kLast)); - - ASSERT_EQ(4UL, frames_from_callback_.size()); - CheckFrame(seq_num); - CheckFrame(seq_num + 1); - CheckFrame(seq_num + 2); - CheckFrame(seq_num + 3); + EXPECT_THAT(Insert(seq_num, kKeyFrame, kFirst, kLast), + StartSeqNumsAre(seq_num)); + EXPECT_THAT(Insert(seq_num + 1, kDeltaFrame, kFirst, kLast), + StartSeqNumsAre(seq_num + 1)); + EXPECT_THAT(Insert(seq_num + 2, kDeltaFrame, kFirst, kLast), + StartSeqNumsAre(seq_num + 2)); + EXPECT_THAT(Insert(seq_num + 3, kDeltaFrame, kFirst, kLast), + StartSeqNumsAre(seq_num + 3)); } TEST_F(PacketBufferTest, ClearSinglePacket) { const uint16_t seq_num = Rand(); for (int i = 0; i < kMaxSize; ++i) - EXPECT_TRUE(Insert(seq_num + i, kDeltaFrame, kFirst, kLast)); + Insert(seq_num + i, kDeltaFrame, kFirst, kLast); packet_buffer_.ClearTo(seq_num); - EXPECT_TRUE(Insert(seq_num + kMaxSize, kDeltaFrame, kFirst, kLast)); + EXPECT_FALSE( + Insert(seq_num + kMaxSize, kDeltaFrame, kFirst, kLast).buffer_cleared); } TEST_F(PacketBufferTest, ClearFullBuffer) { for (int i = 0; i < kMaxSize; ++i) - EXPECT_TRUE(Insert(i, kDeltaFrame, kFirst, kLast)); + Insert(i, kDeltaFrame, kFirst, kLast); packet_buffer_.ClearTo(kMaxSize - 1); for (int i = kMaxSize; i < 2 * kMaxSize; ++i) - EXPECT_TRUE(Insert(i, kDeltaFrame, kFirst, kLast)); + EXPECT_FALSE(Insert(i, kDeltaFrame, kFirst, kLast).buffer_cleared); } TEST_F(PacketBufferTest, DontClearNewerPacket) { - EXPECT_TRUE(Insert(0, kKeyFrame, kFirst, kLast)); + EXPECT_THAT(Insert(0, kKeyFrame, kFirst, kLast), StartSeqNumsAre(0)); packet_buffer_.ClearTo(0); - EXPECT_TRUE(Insert(2 * kStartSize, kKeyFrame, kFirst, kLast)); - EXPECT_TRUE(Insert(3 * kStartSize + 1, kKeyFrame, kFirst, kNotLast)); + EXPECT_THAT(Insert(2 * kStartSize, kKeyFrame, kFirst, kLast), + StartSeqNumsAre(2 * kStartSize)); + EXPECT_THAT(Insert(3 * kStartSize + 1, kKeyFrame, kFirst, kNotLast).frames, + IsEmpty()); packet_buffer_.ClearTo(2 * kStartSize); - EXPECT_TRUE(Insert(3 * kStartSize + 2, kKeyFrame, kNotFirst, kLast)); - - ASSERT_EQ(3UL, frames_from_callback_.size()); - CheckFrame(0); - CheckFrame(2 * kStartSize); - CheckFrame(3 * kStartSize + 1); + EXPECT_THAT(Insert(3 * kStartSize + 2, kKeyFrame, kNotFirst, kLast), + StartSeqNumsAre(3 * kStartSize + 1)); } TEST_F(PacketBufferTest, OneIncompleteFrame) { const uint16_t seq_num = Rand(); - EXPECT_TRUE(Insert(seq_num, kDeltaFrame, kFirst, kNotLast)); - EXPECT_TRUE(Insert(seq_num + 1, kDeltaFrame, kNotFirst, kLast)); - EXPECT_TRUE(Insert(seq_num - 1, kDeltaFrame, kNotFirst, kLast)); - - ASSERT_EQ(1UL, frames_from_callback_.size()); - CheckFrame(seq_num); + EXPECT_THAT(Insert(seq_num, kDeltaFrame, kFirst, kNotLast).frames, IsEmpty()); + EXPECT_THAT(Insert(seq_num + 1, kDeltaFrame, kNotFirst, kLast), + StartSeqNumsAre(seq_num)); + EXPECT_THAT(Insert(seq_num - 1, kDeltaFrame, kNotFirst, kLast).frames, + IsEmpty()); } TEST_F(PacketBufferTest, TwoIncompleteFramesFullBuffer) { const uint16_t seq_num = Rand(); for (int i = 1; i < kMaxSize - 1; ++i) - EXPECT_TRUE(Insert(seq_num + i, kDeltaFrame, kNotFirst, kNotLast)); - EXPECT_TRUE(Insert(seq_num, kDeltaFrame, kFirst, kNotLast)); - EXPECT_TRUE(Insert(seq_num - 1, kDeltaFrame, kNotFirst, kLast)); - - ASSERT_EQ(0UL, frames_from_callback_.size()); + Insert(seq_num + i, kDeltaFrame, kNotFirst, kNotLast); + EXPECT_THAT(Insert(seq_num, kDeltaFrame, kFirst, kNotLast).frames, IsEmpty()); + EXPECT_THAT(Insert(seq_num - 1, kDeltaFrame, kNotFirst, kLast).frames, + IsEmpty()); } TEST_F(PacketBufferTest, FramesReordered) { const uint16_t seq_num = Rand(); - EXPECT_TRUE(Insert(seq_num + 1, kDeltaFrame, kFirst, kLast)); - EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kLast)); - EXPECT_TRUE(Insert(seq_num + 3, kDeltaFrame, kFirst, kLast)); - EXPECT_TRUE(Insert(seq_num + 2, kDeltaFrame, kFirst, kLast)); - - ASSERT_EQ(4UL, frames_from_callback_.size()); - CheckFrame(seq_num); - CheckFrame(seq_num + 1); - CheckFrame(seq_num + 2); - CheckFrame(seq_num + 3); + EXPECT_THAT(Insert(seq_num + 1, kDeltaFrame, kFirst, kLast), + StartSeqNumsAre(seq_num + 1)); + EXPECT_THAT(Insert(seq_num, kKeyFrame, kFirst, kLast), + StartSeqNumsAre(seq_num)); + EXPECT_THAT(Insert(seq_num + 3, kDeltaFrame, kFirst, kLast), + StartSeqNumsAre(seq_num + 3)); + EXPECT_THAT(Insert(seq_num + 2, kDeltaFrame, kFirst, kLast), + StartSeqNumsAre(seq_num + 2)); } TEST_F(PacketBufferTest, GetBitstream) { @@ -476,26 +444,21 @@ TEST_F(PacketBufferTest, GetBitstream) { memcpy(such, such_data, sizeof(such_data)); memcpy(data, data_data, sizeof(data_data)); - const size_t result_length = sizeof(many_data) + sizeof(bitstream_data) + - sizeof(such_data) + sizeof(data_data); - const uint16_t seq_num = Rand(); - EXPECT_TRUE( - Insert(seq_num, kKeyFrame, kFirst, kNotLast, sizeof(many_data), many)); - EXPECT_TRUE(Insert(seq_num + 1, kDeltaFrame, kNotFirst, kNotLast, - sizeof(bitstream_data), bitstream)); - EXPECT_TRUE(Insert(seq_num + 2, kDeltaFrame, kNotFirst, kNotLast, - sizeof(such_data), such)); - EXPECT_TRUE(Insert(seq_num + 3, kDeltaFrame, kNotFirst, kLast, - sizeof(data_data), data)); + Insert(seq_num, kKeyFrame, kFirst, kNotLast, sizeof(many_data), many); + Insert(seq_num + 1, kDeltaFrame, kNotFirst, kNotLast, sizeof(bitstream_data), + bitstream); + Insert(seq_num + 2, kDeltaFrame, kNotFirst, kNotLast, sizeof(such_data), + such); + auto frames = Insert(seq_num + 3, kDeltaFrame, kNotFirst, kLast, + sizeof(data_data), data) + .frames; - ASSERT_EQ(1UL, frames_from_callback_.size()); - CheckFrame(seq_num); - EXPECT_EQ(frames_from_callback_[seq_num]->size(), result_length); - EXPECT_EQ(memcmp(frames_from_callback_[seq_num]->data(), - "many bitstream, such data", result_length), - 0); + ASSERT_THAT(frames, SizeIs(1)); + EXPECT_EQ(frames[0]->first_seq_num(), seq_num); + EXPECT_THAT(rtc::MakeArrayView(frames[0]->data(), frames[0]->size()), + ElementsAreArray("many bitstream, such data")); } TEST_F(PacketBufferTest, GetBitstreamOneFrameOnePacket) { @@ -503,15 +466,11 @@ TEST_F(PacketBufferTest, GetBitstreamOneFrameOnePacket) { uint8_t* data = new uint8_t[sizeof(bitstream_data)]; memcpy(data, bitstream_data, sizeof(bitstream_data)); - EXPECT_TRUE( - Insert(0, kKeyFrame, kFirst, kLast, sizeof(bitstream_data), data)); - - ASSERT_EQ(1UL, frames_from_callback_.size()); - CheckFrame(0); - EXPECT_EQ(frames_from_callback_[0]->size(), sizeof(bitstream_data)); - EXPECT_EQ(memcmp(frames_from_callback_[0]->data(), bitstream_data, - sizeof(bitstream_data)), - 0); + auto frames = + Insert(0, kKeyFrame, kFirst, kLast, sizeof(bitstream_data), data).frames; + ASSERT_THAT(StartSeqNums(frames), ElementsAre(0)); + EXPECT_THAT(rtc::MakeArrayView(frames[0]->data(), frames[0]->size()), + ElementsAreArray(bitstream_data)); } TEST_F(PacketBufferTest, GetBitstreamOneFrameFullBuffer) { @@ -524,19 +483,19 @@ TEST_F(PacketBufferTest, GetBitstreamOneFrameFullBuffer) { expected[i] = i; } - EXPECT_TRUE(Insert(0, kKeyFrame, kFirst, kNotLast, 1, data_arr[0])); + Insert(0, kKeyFrame, kFirst, kNotLast, 1, data_arr[0]); for (uint8_t i = 1; i < kStartSize - 1; ++i) - EXPECT_TRUE(Insert(i, kKeyFrame, kNotFirst, kNotLast, 1, data_arr[i])); - EXPECT_TRUE(Insert(kStartSize - 1, kKeyFrame, kNotFirst, kLast, 1, - data_arr[kStartSize - 1])); + Insert(i, kKeyFrame, kNotFirst, kNotLast, 1, data_arr[i]); + auto frames = Insert(kStartSize - 1, kKeyFrame, kNotFirst, kLast, 1, + data_arr[kStartSize - 1]) + .frames; - ASSERT_EQ(1UL, frames_from_callback_.size()); - CheckFrame(0); - EXPECT_EQ(frames_from_callback_[0]->size(), static_cast(kStartSize)); - EXPECT_EQ(memcmp(frames_from_callback_[0]->data(), expected, kStartSize), 0); + ASSERT_THAT(StartSeqNums(frames), ElementsAre(0)); + EXPECT_THAT(rtc::MakeArrayView(frames[0]->data(), frames[0]->size()), + ElementsAreArray(expected)); } -TEST_F(PacketBufferTest, InsertPacketAfterOldFrameObjectIsRemoved) { +TEST_F(PacketBufferTest, InsertPacketAfterSequenceNumberWrapAround) { uint16_t kFirstSeqNum = 0; uint32_t kTimestampDelta = 100; uint32_t timestamp = 10000; @@ -553,20 +512,15 @@ TEST_F(PacketBufferTest, InsertPacketAfterOldFrameObjectIsRemoved) { timestamp += kTimestampDelta; } - size_t number_of_frames = frames_from_callback_.size(); - // Delete old frame object while receiving frame with overlapping sequence - // numbers. + // Receive frame with overlapping sequence numbers. Insert(seq_num++, kKeyFrame, kFirst, kNotLast, 0, nullptr, timestamp); for (int i = 0; i < 5; ++i) { Insert(seq_num++, kKeyFrame, kNotFirst, kNotLast, 0, nullptr, timestamp); } - // Delete FrameObject connected to packets that have already been cleared. - DeleteFrame(kFirstSeqNum); - Insert(seq_num++, kKeyFrame, kNotFirst, kLast, 0, nullptr, timestamp); - - // Regardless of the initial size, the number of frames should be constant - // after removing and then adding a new frame object. - EXPECT_EQ(number_of_frames, frames_from_callback_.size()); + EXPECT_THAT( + Insert(seq_num++, kKeyFrame, kNotFirst, kLast, 0, nullptr, timestamp) + .frames, + SizeIs(1)); } // If |sps_pps_idr_is_keyframe| is true, we require keyframes to contain @@ -581,15 +535,16 @@ class PacketBufferH264Test : public PacketBufferTest { : ""), sps_pps_idr_is_keyframe_(sps_pps_idr_is_keyframe) {} - bool InsertH264(uint16_t seq_num, // packet sequence number - IsKeyFrame keyframe, // is keyframe - IsFirst first, // is first packet of frame - IsLast last, // is last packet of frame - uint32_t timestamp, // rtp timestamp - int data_size = 0, // size of data - uint8_t* data = nullptr, // data pointer - uint32_t width = 0, // width of frame (SPS/IDR) - uint32_t height = 0) { // height of frame (SPS/IDR) + PacketBufferInsertResult InsertH264( + uint16_t seq_num, // packet sequence number + IsKeyFrame keyframe, // is keyframe + IsFirst first, // is first packet of frame + IsLast last, // is last packet of frame + uint32_t timestamp, // rtp timestamp + int data_size = 0, // size of data + uint8_t* data = nullptr, // data pointer + uint32_t width = 0, // width of frame (SPS/IDR) + uint32_t height = 0) { // height of frame (SPS/IDR) VCMPacket packet; packet.video_header.codec = kVideoCodecH264; auto& h264_header = @@ -614,10 +569,10 @@ class PacketBufferH264Test : public PacketBufferTest { packet.sizeBytes = data_size; packet.dataPtr = data; - return HandleResult(packet_buffer_.InsertPacket(&packet)); + return PacketBufferInsertResult(packet_buffer_.InsertPacket(&packet)); } - bool InsertH264KeyFrameWithAud( + PacketBufferInsertResult InsertH264KeyFrameWithAud( uint16_t seq_num, // packet sequence number IsKeyFrame keyframe, // is keyframe IsFirst first, // is first packet of frame @@ -634,10 +589,8 @@ class PacketBufferH264Test : public PacketBufferTest { packet.seqNum = seq_num; packet.timestamp = timestamp; - // this should be the start of frame - if (kFirst != first) { - return false; - } + // this should be the start of frame. + RTC_CHECK(first == kFirst); // Insert a AUD NALU / packet without width/height. h264_header.nalus[0].type = H264::NaluType::kAud; @@ -646,12 +599,10 @@ class PacketBufferH264Test : public PacketBufferTest { packet.video_header.is_last_packet_in_frame = false; packet.sizeBytes = 0; packet.dataPtr = nullptr; - if (HandleResult(packet_buffer_.InsertPacket(&packet))) { - // insert IDR - return InsertH264(seq_num + 1, keyframe, kNotFirst, last, timestamp, - data_size, data, width, height); - } - return false; + IgnoreResult(packet_buffer_.InsertPacket(&packet)); + // insert IDR + return InsertH264(seq_num + 1, keyframe, kNotFirst, last, timestamp, + data_size, data, width, height); } const bool sps_pps_idr_is_keyframe_; @@ -671,13 +622,12 @@ INSTANTIATE_TEST_SUITE_P(SpsPpsIdrIsKeyframe, ::testing::Bool()); TEST_P(PacketBufferH264ParameterizedTest, DontRemoveMissingPacketOnClearTo) { - EXPECT_TRUE(InsertH264(0, kKeyFrame, kFirst, kLast, 0)); - EXPECT_TRUE(InsertH264(2, kDeltaFrame, kFirst, kNotLast, 2)); + InsertH264(0, kKeyFrame, kFirst, kLast, 0); + InsertH264(2, kDeltaFrame, kFirst, kNotLast, 2); packet_buffer_.ClearTo(0); - EXPECT_TRUE(InsertH264(3, kDeltaFrame, kNotFirst, kLast, 2)); - - ASSERT_EQ(1UL, frames_from_callback_.size()); - CheckFrame(0); + // Expect no frame because of missing of packet #1 + EXPECT_THAT(InsertH264(3, kDeltaFrame, kNotFirst, kLast, 2).frames, + IsEmpty()); } TEST_P(PacketBufferH264ParameterizedTest, GetBitstreamOneFrameFullBuffer) { @@ -690,18 +640,17 @@ TEST_P(PacketBufferH264ParameterizedTest, GetBitstreamOneFrameFullBuffer) { expected[i] = i; } - EXPECT_TRUE(InsertH264(0, kKeyFrame, kFirst, kNotLast, 1, 1, data_arr[0])); + InsertH264(0, kKeyFrame, kFirst, kNotLast, 1, 1, data_arr[0]); for (uint8_t i = 1; i < kStartSize - 1; ++i) { - EXPECT_TRUE( - InsertH264(i, kKeyFrame, kNotFirst, kNotLast, 1, 1, data_arr[i])); + InsertH264(i, kKeyFrame, kNotFirst, kNotLast, 1, 1, data_arr[i]); } - EXPECT_TRUE(InsertH264(kStartSize - 1, kKeyFrame, kNotFirst, kLast, 1, 1, - data_arr[kStartSize - 1])); - ASSERT_EQ(1UL, frames_from_callback_.size()); - CheckFrame(0); - EXPECT_EQ(frames_from_callback_[0]->size(), static_cast(kStartSize)); - EXPECT_EQ(memcmp(frames_from_callback_[0]->data(), expected, kStartSize), 0); + auto frames = InsertH264(kStartSize - 1, kKeyFrame, kNotFirst, kLast, 1, 1, + data_arr[kStartSize - 1]) + .frames; + ASSERT_THAT(StartSeqNums(frames), ElementsAre(0)); + EXPECT_THAT(rtc::MakeArrayView(frames[0]->data(), frames[0]->size()), + ElementsAreArray(expected)); } TEST_P(PacketBufferH264ParameterizedTest, GetBitstreamBufferPadding) { @@ -729,7 +678,8 @@ TEST_P(PacketBufferH264ParameterizedTest, GetBitstreamBufferPadding) { EXPECT_EQ(frames[0]->first_seq_num(), seq_num); EXPECT_EQ(frames[0]->EncodedImage().size(), sizeof(data_data)); EXPECT_EQ(frames[0]->EncodedImage().capacity(), sizeof(data_data)); - EXPECT_EQ(memcmp(frames[0]->data(), data_data, sizeof(data_data)), 0); + EXPECT_THAT(rtc::MakeArrayView(frames[0]->data(), frames[0]->size()), + ElementsAreArray(data_data)); } TEST_P(PacketBufferH264ParameterizedTest, FrameResolution) { @@ -741,21 +691,15 @@ TEST_P(PacketBufferH264ParameterizedTest, FrameResolution) { uint32_t height = 360; uint32_t timestamp = 1000; - EXPECT_TRUE(InsertH264(seq_num, kKeyFrame, kFirst, kLast, timestamp, - sizeof(data_data), data, width, height)); + auto frames = InsertH264(seq_num, kKeyFrame, kFirst, kLast, timestamp, + sizeof(data_data), data, width, height) + .frames; - ASSERT_EQ(1UL, frames_from_callback_.size()); - EXPECT_EQ(frames_from_callback_[seq_num]->EncodedImage().size(), - sizeof(data_data)); - EXPECT_EQ(frames_from_callback_[seq_num]->EncodedImage().capacity(), - sizeof(data_data)); - EXPECT_EQ(width, - frames_from_callback_[seq_num]->EncodedImage()._encodedWidth); - EXPECT_EQ(height, - frames_from_callback_[seq_num]->EncodedImage()._encodedHeight); - EXPECT_EQ(memcmp(frames_from_callback_[seq_num]->data(), data_data, - sizeof(data_data)), - 0); + ASSERT_THAT(frames, SizeIs(1)); + EXPECT_THAT(rtc::MakeArrayView(frames[0]->data(), frames[0]->size()), + ElementsAreArray(data_data)); + EXPECT_EQ(frames[0]->EncodedImage()._encodedWidth, width); + EXPECT_EQ(frames[0]->EncodedImage()._encodedHeight, height); } TEST_P(PacketBufferH264ParameterizedTest, FrameResolutionNaluBeforeSPS) { @@ -767,83 +711,65 @@ TEST_P(PacketBufferH264ParameterizedTest, FrameResolutionNaluBeforeSPS) { uint32_t height = 360; uint32_t timestamp = 1000; - EXPECT_TRUE(InsertH264KeyFrameWithAud(seq_num, kKeyFrame, kFirst, kLast, - timestamp, sizeof(data_data), data, - width, height)); + auto frames = + InsertH264KeyFrameWithAud(seq_num, kKeyFrame, kFirst, kLast, timestamp, + sizeof(data_data), data, width, height) + .frames; - CheckFrame(seq_num); - ASSERT_EQ(1UL, frames_from_callback_.size()); - EXPECT_EQ(frames_from_callback_[seq_num]->EncodedImage().size(), - sizeof(data_data)); - EXPECT_EQ(frames_from_callback_[seq_num]->EncodedImage().capacity(), - sizeof(data_data)); - EXPECT_EQ(width, - frames_from_callback_[seq_num]->EncodedImage()._encodedWidth); - EXPECT_EQ(height, - frames_from_callback_[seq_num]->EncodedImage()._encodedHeight); + ASSERT_THAT(StartSeqNums(frames), ElementsAre(seq_num)); - EXPECT_EQ(memcmp(frames_from_callback_[seq_num]->data(), data_data, - sizeof(data_data)), - 0); + EXPECT_EQ(frames[0]->EncodedImage().size(), sizeof(data_data)); + EXPECT_EQ(frames[0]->EncodedImage().capacity(), sizeof(data_data)); + EXPECT_EQ(frames[0]->EncodedImage()._encodedWidth, width); + EXPECT_EQ(frames[0]->EncodedImage()._encodedHeight, height); + EXPECT_THAT(rtc::MakeArrayView(frames[0]->data(), frames[0]->size()), + ElementsAreArray(data_data)); } TEST_F(PacketBufferTest, FreeSlotsOnFrameCreation) { const uint16_t seq_num = Rand(); - EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast)); - EXPECT_TRUE(Insert(seq_num + 1, kDeltaFrame, kNotFirst, kNotLast)); - EXPECT_TRUE(Insert(seq_num + 2, kDeltaFrame, kNotFirst, kLast)); - EXPECT_EQ(1UL, frames_from_callback_.size()); - CheckFrame(seq_num); + Insert(seq_num, kKeyFrame, kFirst, kNotLast); + Insert(seq_num + 1, kDeltaFrame, kNotFirst, kNotLast); + EXPECT_THAT(Insert(seq_num + 2, kDeltaFrame, kNotFirst, kLast), + StartSeqNumsAre(seq_num)); // Insert frame that fills the whole buffer. - EXPECT_TRUE(Insert(seq_num + 3, kKeyFrame, kFirst, kNotLast)); + Insert(seq_num + 3, kKeyFrame, kFirst, kNotLast); for (int i = 0; i < kMaxSize - 2; ++i) - EXPECT_TRUE(Insert(seq_num + i + 4, kDeltaFrame, kNotFirst, kNotLast)); - EXPECT_TRUE(Insert(seq_num + kMaxSize + 2, kKeyFrame, kNotFirst, kLast)); - EXPECT_EQ(2UL, frames_from_callback_.size()); - CheckFrame(seq_num + 3); - - frames_from_callback_.clear(); + Insert(seq_num + i + 4, kDeltaFrame, kNotFirst, kNotLast); + EXPECT_THAT(Insert(seq_num + kMaxSize + 2, kKeyFrame, kNotFirst, kLast), + StartSeqNumsAre(seq_num + 3)); } TEST_F(PacketBufferTest, Clear) { const uint16_t seq_num = Rand(); - EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast)); - EXPECT_TRUE(Insert(seq_num + 1, kDeltaFrame, kNotFirst, kNotLast)); - EXPECT_TRUE(Insert(seq_num + 2, kDeltaFrame, kNotFirst, kLast)); - EXPECT_EQ(1UL, frames_from_callback_.size()); - CheckFrame(seq_num); + Insert(seq_num, kKeyFrame, kFirst, kNotLast); + Insert(seq_num + 1, kDeltaFrame, kNotFirst, kNotLast); + EXPECT_THAT(Insert(seq_num + 2, kDeltaFrame, kNotFirst, kLast), + StartSeqNumsAre(seq_num)); packet_buffer_.Clear(); - EXPECT_TRUE(Insert(seq_num + kStartSize, kKeyFrame, kFirst, kNotLast)); - EXPECT_TRUE( - Insert(seq_num + kStartSize + 1, kDeltaFrame, kNotFirst, kNotLast)); - EXPECT_TRUE(Insert(seq_num + kStartSize + 2, kDeltaFrame, kNotFirst, kLast)); - EXPECT_EQ(2UL, frames_from_callback_.size()); - CheckFrame(seq_num + kStartSize); + Insert(seq_num + kStartSize, kKeyFrame, kFirst, kNotLast); + Insert(seq_num + kStartSize + 1, kDeltaFrame, kNotFirst, kNotLast); + EXPECT_THAT(Insert(seq_num + kStartSize + 2, kDeltaFrame, kNotFirst, kLast), + StartSeqNumsAre(seq_num + kStartSize)); } TEST_F(PacketBufferTest, FramesAfterClear) { Insert(9025, kDeltaFrame, kFirst, kLast); Insert(9024, kKeyFrame, kFirst, kLast); packet_buffer_.ClearTo(9025); - Insert(9057, kDeltaFrame, kFirst, kLast); - Insert(9026, kDeltaFrame, kFirst, kLast); - - CheckFrame(9024); - CheckFrame(9025); - CheckFrame(9026); - CheckFrame(9057); + EXPECT_THAT(Insert(9057, kDeltaFrame, kFirst, kLast).frames, SizeIs(1)); + EXPECT_THAT(Insert(9026, kDeltaFrame, kFirst, kLast).frames, SizeIs(1)); } TEST_F(PacketBufferTest, SameFrameDifferentTimestamps) { Insert(0, kKeyFrame, kFirst, kNotLast, 0, nullptr, 1000); - Insert(1, kKeyFrame, kNotFirst, kLast, 0, nullptr, 1001); - - ASSERT_EQ(0UL, frames_from_callback_.size()); + EXPECT_THAT(Insert(1, kKeyFrame, kNotFirst, kLast, 0, nullptr, 1001).frames, + IsEmpty()); } TEST_F(PacketBufferTest, DontLeakPayloadData) { @@ -855,26 +781,23 @@ TEST_F(PacketBufferTest, DontLeakPayloadData) { uint8_t* data4 = new uint8_t[5]; // Expected to free data1 upon PacketBuffer destruction. - EXPECT_TRUE(Insert(2, kKeyFrame, kFirst, kNotLast, 5, data1)); + Insert(2, kKeyFrame, kFirst, kNotLast, 5, data1); // Expect to free data2 upon insertion. - EXPECT_TRUE(Insert(2, kKeyFrame, kFirst, kNotLast, 5, data2)); + Insert(2, kKeyFrame, kFirst, kNotLast, 5, data2); // Expect to free data3 upon insertion (old packet). packet_buffer_.ClearTo(1); - EXPECT_TRUE(Insert(1, kKeyFrame, kFirst, kNotLast, 5, data3)); + Insert(1, kKeyFrame, kFirst, kNotLast, 5, data3); // Expect to free data4 upon insertion (packet buffer is full). - EXPECT_FALSE(Insert(2 + kMaxSize, kKeyFrame, kFirst, kNotLast, 5, data4)); + Insert(2 + kMaxSize, kKeyFrame, kFirst, kNotLast, 5, data4); } TEST_F(PacketBufferTest, ContinuousSeqNumDoubleMarkerBit) { Insert(2, kKeyFrame, kNotFirst, kNotLast); Insert(1, kKeyFrame, kFirst, kLast); - frames_from_callback_.clear(); - Insert(3, kKeyFrame, kNotFirst, kLast); - - EXPECT_EQ(0UL, frames_from_callback_.size()); + EXPECT_THAT(Insert(3, kKeyFrame, kNotFirst, kLast).frames, IsEmpty()); } TEST_F(PacketBufferTest, PacketTimestamps) { @@ -887,7 +810,7 @@ TEST_F(PacketBufferTest, PacketTimestamps) { EXPECT_FALSE(packet_keyframe_ms); int64_t keyframe_ms = clock_->TimeInMilliseconds(); - EXPECT_TRUE(Insert(100, kKeyFrame, kFirst, kLast)); + Insert(100, kKeyFrame, kFirst, kLast); packet_ms = packet_buffer_.LastReceivedPacketMs(); packet_keyframe_ms = packet_buffer_.LastReceivedKeyframePacketMs(); EXPECT_TRUE(packet_ms); @@ -897,7 +820,7 @@ TEST_F(PacketBufferTest, PacketTimestamps) { clock_->AdvanceTimeMilliseconds(100); int64_t delta_ms = clock_->TimeInMilliseconds(); - EXPECT_TRUE(Insert(101, kDeltaFrame, kFirst, kLast)); + Insert(101, kDeltaFrame, kFirst, kLast); packet_ms = packet_buffer_.LastReceivedPacketMs(); packet_keyframe_ms = packet_buffer_.LastReceivedKeyframePacketMs(); EXPECT_TRUE(packet_ms); @@ -962,35 +885,30 @@ TEST_P(PacketBufferH264ParameterizedTest, OneFrameFillBuffer) { InsertH264(0, kKeyFrame, kFirst, kNotLast, 1000); for (int i = 1; i < kStartSize - 1; ++i) InsertH264(i, kKeyFrame, kNotFirst, kNotLast, 1000); - InsertH264(kStartSize - 1, kKeyFrame, kNotFirst, kLast, 1000); - - EXPECT_EQ(1UL, frames_from_callback_.size()); - CheckFrame(0); + EXPECT_THAT(InsertH264(kStartSize - 1, kKeyFrame, kNotFirst, kLast, 1000), + StartSeqNumsAre(0)); } TEST_P(PacketBufferH264ParameterizedTest, CreateFramesAfterFilledBuffer) { - InsertH264(kStartSize - 2, kKeyFrame, kFirst, kLast, 0); - ASSERT_EQ(1UL, frames_from_callback_.size()); - frames_from_callback_.clear(); + EXPECT_THAT(InsertH264(kStartSize - 2, kKeyFrame, kFirst, kLast, 0).frames, + SizeIs(1)); InsertH264(kStartSize, kDeltaFrame, kFirst, kNotLast, 2000); for (int i = 1; i < kStartSize; ++i) InsertH264(kStartSize + i, kDeltaFrame, kNotFirst, kNotLast, 2000); - InsertH264(kStartSize + kStartSize, kDeltaFrame, kNotFirst, kLast, 2000); - ASSERT_EQ(0UL, frames_from_callback_.size()); + EXPECT_THAT( + InsertH264(kStartSize + kStartSize, kDeltaFrame, kNotFirst, kLast, 2000) + .frames, + IsEmpty()); - InsertH264(kStartSize - 1, kKeyFrame, kFirst, kLast, 1000); - ASSERT_EQ(2UL, frames_from_callback_.size()); - CheckFrame(kStartSize - 1); - CheckFrame(kStartSize); + EXPECT_THAT(InsertH264(kStartSize - 1, kKeyFrame, kFirst, kLast, 1000), + StartSeqNumsAre(kStartSize - 1, kStartSize)); } TEST_P(PacketBufferH264ParameterizedTest, OneFrameMaxSeqNum) { InsertH264(65534, kKeyFrame, kFirst, kNotLast, 1000); - InsertH264(65535, kKeyFrame, kNotFirst, kLast, 1000); - - EXPECT_EQ(1UL, frames_from_callback_.size()); - CheckFrame(65534); + EXPECT_THAT(InsertH264(65535, kKeyFrame, kNotFirst, kLast, 1000), + StartSeqNumsAre(65534)); } TEST_P(PacketBufferH264ParameterizedTest, ClearMissingPacketsOnKeyframe) { @@ -999,26 +917,17 @@ TEST_P(PacketBufferH264ParameterizedTest, ClearMissingPacketsOnKeyframe) { InsertH264(3, kDeltaFrame, kFirst, kNotLast, 4000); InsertH264(4, kDeltaFrame, kNotFirst, kLast, 4000); - ASSERT_EQ(3UL, frames_from_callback_.size()); - - InsertH264(kStartSize + 1, kKeyFrame, kFirst, kLast, 18000); - - ASSERT_EQ(4UL, frames_from_callback_.size()); - CheckFrame(0); - CheckFrame(2); - CheckFrame(3); - CheckFrame(kStartSize + 1); + EXPECT_THAT(InsertH264(kStartSize + 1, kKeyFrame, kFirst, kLast, 18000), + StartSeqNumsAre(kStartSize + 1)); } TEST_P(PacketBufferH264ParameterizedTest, FindFramesOnPadding) { - InsertH264(0, kKeyFrame, kFirst, kLast, 1000); - InsertH264(2, kDeltaFrame, kFirst, kLast, 1000); + EXPECT_THAT(InsertH264(0, kKeyFrame, kFirst, kLast, 1000), + StartSeqNumsAre(0)); + EXPECT_THAT(InsertH264(2, kDeltaFrame, kFirst, kLast, 1000).frames, + IsEmpty()); - ASSERT_EQ(1UL, frames_from_callback_.size()); - CheckFrame(0); - - EXPECT_THAT(FirstSeqNums(packet_buffer_.InsertPadding(1).frames), - ElementsAre(2)); + EXPECT_THAT(packet_buffer_.InsertPadding(1), StartSeqNumsAre(2)); } class PacketBufferH264XIsKeyframeTest : public PacketBufferH264Test {