Split LogRtpHeader and LogRtcpPacket into separate versions for incoming and outgoing packets.

logging/rtc_event_log/rtc_event_log_unittest_helper.cc

 /*
  *  Copyright (c) 2016 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 "logging/rtc_event_log/rtc_event_log_unittest_helper.h"
 
 #include <string.h>
 
 #include <string>
 #include <vector>
 
 #include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
 #include "modules/remote_bitrate_estimator/include/bwe_defines.h"
 #include "rtc_base/checks.h"
+#include "test/gmock.h"
 #include "test/gtest.h"
 #include "test/testsupport/fileutils.h"
 
 // Files generated at build-time by the protobuf compiler.
 #ifdef WEBRTC_ANDROID_PLATFORM_BUILD
 #include "external/webrtc/webrtc/logging/rtc_event_log/rtc_event_log.pb.h"
 #else
 #include "logging/rtc_event_log/rtc_event_log.pb.h"
 #endif
 
@@ skipping 311 matching lines @@
     int id = sender_config.header_extensions(i).id();
     EXPECT_EQ(config.rtp_extensions[i].id, id);
     EXPECT_EQ(config.rtp_extensions[i].uri, name);
   }
 
   // Check consistency of the parser.
   rtclog::StreamConfig parsed_config = parsed_log.GetAudioSendConfig(index);
   VerifyStreamConfigsAreEqual(config, parsed_config);
 }
 
-void RtcEventLogTestHelper::VerifyRtpEvent(const ParsedRtcEventLog& parsed_log,
-                                           size_t index,
-                                           PacketDirection direction,
-                                           const uint8_t* header,
-                                           size_t header_size,
-                                           size_t total_size) {
+void RtcEventLogTestHelper::VerifyIncomingRtpEvent(
+    const ParsedRtcEventLog& parsed_log,
+    size_t index,
+    const RtpPacketReceived& expected_packet) {
   const rtclog::Event& event = parsed_log.events_[index];
   ASSERT_TRUE(IsValidBasicEvent(event));
   ASSERT_EQ(rtclog::Event::RTP_EVENT, event.type());
   const rtclog::RtpPacket& rtp_packet = event.rtp_packet();
   ASSERT_TRUE(rtp_packet.has_incoming());
-  EXPECT_EQ(direction == kIncomingPacket, rtp_packet.incoming());
+  EXPECT_EQ(true, rtp_packet.incoming());
   ASSERT_TRUE(rtp_packet.has_packet_length());
-  EXPECT_EQ(total_size, rtp_packet.packet_length());
+  EXPECT_EQ(expected_packet.size(), rtp_packet.packet_length());
+  size_t header_size = expected_packet.headers_size();
   ASSERT_TRUE(rtp_packet.has_header());
-  ASSERT_EQ(header_size, rtp_packet.header().size());
-  for (size_t i = 0; i < header_size; i++) {
-    EXPECT_EQ(header[i], static_cast<uint8_t>(rtp_packet.header()[i]));
-  }
+  EXPECT_THAT(testing::make_tuple(expected_packet.data(), header_size),
+              testing::ElementsAreArray(rtp_packet.header().data(),
+                                        rtp_packet.header().size()));
 
   // Check consistency of the parser.
   PacketDirection parsed_direction;
   uint8_t parsed_header[1500];
   size_t parsed_header_size, parsed_total_size;
   parsed_log.GetRtpHeader(index, &parsed_direction, parsed_header,
                           &parsed_header_size, &parsed_total_size);
-  EXPECT_EQ(direction, parsed_direction);
-  ASSERT_EQ(header_size, parsed_header_size);
-  EXPECT_EQ(0, std::memcmp(header, parsed_header, header_size));
-  EXPECT_EQ(total_size, parsed_total_size);
+  EXPECT_EQ(kIncomingPacket, parsed_direction);
+  EXPECT_THAT(testing::make_tuple(expected_packet.data(), header_size),
+              testing::ElementsAreArray(parsed_header, parsed_header_size));
+  EXPECT_EQ(expected_packet.size(), parsed_total_size);
+}
+
+void RtcEventLogTestHelper::VerifyOutgoingRtpEvent(
+    const ParsedRtcEventLog& parsed_log,
+    size_t index,
+    const RtpPacketToSend& expected_packet) {
+  const rtclog::Event& event = parsed_log.events_[index];
+  ASSERT_TRUE(IsValidBasicEvent(event));
+  ASSERT_EQ(rtclog::Event::RTP_EVENT, event.type());
+  const rtclog::RtpPacket& rtp_packet = event.rtp_packet();
+  ASSERT_TRUE(rtp_packet.has_incoming());
+  EXPECT_EQ(false, rtp_packet.incoming());
+  ASSERT_TRUE(rtp_packet.has_packet_length());
+  EXPECT_EQ(expected_packet.size(), rtp_packet.packet_length());
+  size_t header_size = expected_packet.headers_size();
+  ASSERT_TRUE(rtp_packet.has_header());
+  EXPECT_THAT(testing::make_tuple(expected_packet.data(), header_size),
+              testing::ElementsAreArray(rtp_packet.header().data(),
+                                        rtp_packet.header().size()));
+
+  // Check consistency of the parser.
+  PacketDirection parsed_direction;
+  uint8_t parsed_header[1500];
+  size_t parsed_header_size, parsed_total_size;
+  parsed_log.GetRtpHeader(index, &parsed_direction, parsed_header,
+                          &parsed_header_size, &parsed_total_size);
+  EXPECT_EQ(kOutgoingPacket, parsed_direction);
+  EXPECT_THAT(testing::make_tuple(expected_packet.data(), header_size),
+              testing::ElementsAreArray(parsed_header, parsed_header_size));
+  EXPECT_EQ(expected_packet.size(), parsed_total_size);
 }
 
 void RtcEventLogTestHelper::VerifyRtcpEvent(const ParsedRtcEventLog& parsed_log,
                                             size_t index,
                                             PacketDirection direction,
                                             const uint8_t* packet,
                                             size_t total_size) {
   const rtclog::Event& event = parsed_log.events_[index];
   ASSERT_TRUE(IsValidBasicEvent(event));
   ASSERT_EQ(rtclog::Event::RTCP_EVENT, event.type());
@@ skipping 172 matching lines @@
   ASSERT_TRUE(bwe_event.has_id());
   EXPECT_EQ(id, bwe_event.id());
   ASSERT_TRUE(bwe_event.has_result());
   EXPECT_EQ(GetProbeResultType(failure_reason), bwe_event.result());
   ASSERT_FALSE(bwe_event.has_bitrate_bps());
 
   // TODO(philipel): Verify the parser when parsing has been implemented.
 }
 
 }  // namespace webrtc