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

webrtc/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.
  */
 
@@ skipping 334 matching lines @@
   }
 
   // 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 rtp::Packet& 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());
+  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());
+  ASSERT_EQ(header_size, rtp_packet.header().size());
+  EXPECT_EQ(0, std::memcmp(expected_packet.data(), rtp_packet.header().data(),
+                           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(expected_packet.data(), parsed_header, header_size));

[danilchap, 2017/09/05 08:47:16]

if you want detailed (with byte arrays printed) error message should it failed,
you may use
EXPACT_THAT(testing::make_tuple(expected_packet.data(), header_size),
testing::ElementsAreArray(parsed_header, parsed_header_size));

instead of this and ASSERT_EQ just above.

[terelius, 2017/09/07 12:53:55]

Done. Also changed the similar comparison above.

+  EXPECT_EQ(expected_packet.size(), parsed_total_size);
+}
+
+void RtcEventLogTestHelper::VerifyRtpEvent(const ParsedRtcEventLog& parsed_log,
+                                           size_t index,
+                                           PacketDirection direction,
                                            const uint8_t* header,
                                            size_t header_size,
                                            size_t total_size) {
   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());
   ASSERT_TRUE(rtp_packet.has_packet_length());
@@ skipping 199 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