Add rtcp::TransportFeedback::GetReceivedPackets()

webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback_unittest.cc

 /*
  *  Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 
 #include <limits>
 #include <memory>
 
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
+#include "webrtc/test/gmock.h"
 #include "webrtc/test/gtest.h"
 
-using webrtc::rtcp::TransportFeedback;
-
 namespace webrtc {
 namespace {
 
+using ::testing::ElementsAreArray;
+using rtcp::TransportFeedback;
+
 static const int kHeaderSize = 20;
 static const int kStatusChunkSize = 2;
 static const int kSmallDeltaSize = 1;
 static const int kLargeDeltaSize = 2;
 
 static const int64_t kDeltaLimit = 0xFF * TransportFeedback::kDeltaScaleFactor;
 
 class FeedbackTester {
  public:
   FeedbackTester()
@@ skipping 53 matching lines @@
 
  private:
   void VerifyInternal() {
     if (expected_size_ != kAnySize) {
       // Round up to whole 32-bit words.
       size_t expected_size_words = (expected_size_ + 3) / 4;
       size_t expected_size_bytes = expected_size_words * 4;
       EXPECT_EQ(expected_size_bytes, serialized_.size());
     }
 
-    std::vector<TransportFeedback::StatusSymbol> symbols =
-        feedback_->GetStatusVector();
-    uint16_t seq = feedback_->GetBaseSequence();
-    auto seq_it = expected_seq_.begin();
-    for (TransportFeedback::StatusSymbol symbol : symbols) {
-      bool received =
-          (symbol == TransportFeedback::StatusSymbol::kReceivedSmallDelta ||
-           symbol == TransportFeedback::StatusSymbol::kReceivedLargeDelta);
-      if (seq_it != expected_seq_.end()) {
-        if (seq == *seq_it) {
-          ASSERT_NE(expected_seq_.end(), seq_it);
-          ASSERT_TRUE(received) << "Expected received packet @ " << seq;
-          ++seq_it;
-        } else {
-          ASSERT_FALSE(received) << "Did not expect received packet @ " << seq;
-        }
-      }
-      ++seq;
+    std::vector<uint16_t> actual_seq_nos;
+    std::vector<int64_t> actual_deltas_us;
+    for (const auto& packet : feedback_->GetReceivedPackets()) {
+      actual_seq_nos.push_back(packet.sequence_number());
+      actual_deltas_us.push_back(packet.delta_us());
     }
-    ASSERT_EQ(expected_seq_.end(), seq_it);
-
-    std::vector<int64_t> deltas = feedback_->GetReceiveDeltasUs();
-    ASSERT_EQ(expected_deltas_.size(), deltas.size());
-    for (size_t i = 0; i < expected_deltas_.size(); ++i)
-      EXPECT_EQ(expected_deltas_[i], deltas[i]) << "Delta mismatch @ " << i;
+    EXPECT_THAT(actual_seq_nos, ElementsAreArray(expected_seq_));
+    EXPECT_THAT(actual_deltas_us, ElementsAreArray(expected_deltas_));
   }
 
   void GenerateDeltas(const uint16_t seq[],
                       const size_t length,
                       int64_t* deltas) {
     uint16_t last_seq = seq[0];
     int64_t offset = 0;
 
     for (size_t i = 0; i < length; ++i) {
       if (seq[i] < last_seq)
@@ skipping 205 matching lines @@
   TransportFeedback feedback;
   feedback.SetBase(0, 0);
 
   const int kSamples = 100;
   const int64_t kTooSmallDelta = TransportFeedback::kDeltaScaleFactor / 3;
 
   for (int i = 0; i < kSamples; ++i)
     feedback.AddReceivedPacket(i, i * kTooSmallDelta);
 
   feedback.Build();
-  std::vector<int64_t> deltas = feedback.GetReceiveDeltasUs();
 
   int64_t accumulated_delta = 0;
   int num_samples = 0;
-  for (int64_t delta : deltas) {
-    accumulated_delta += delta;
+  for (const auto& packet : feedback.GetReceivedPackets()) {
+    accumulated_delta += packet.delta_us();
     int64_t expected_time = num_samples * kTooSmallDelta;
     ++num_samples;
 
     EXPECT_NEAR(expected_time, accumulated_delta,
                 TransportFeedback::kDeltaScaleFactor / 2);
   }
 }
 
 TEST(RtcpPacketTest, TransportFeedback_Limits) {
   // Sequence number wrap above 0x8000.
@@ skipping 114 matching lines @@
     rtc::Buffer serialized_packet = feedback.Build();
     std::unique_ptr<TransportFeedback> deserialized_packet =
         TransportFeedback::ParseFrom(serialized_packet.data(),
                                      serialized_packet.size());
     EXPECT_TRUE(deserialized_packet.get() != nullptr);
   }
 }
 
 }  // namespace
 }  // namespace webrtc