zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Move expectations from eventlog unittests to helper functions.

Browse Source 
Bug: webrtc:8111
Change-Id: I47fd6c1651f2630ebaf2752b471a36b1d4f98769
Reviewed-on: https://webrtc-review.googlesource.com/c/105482
Commit-Queue: Björn Terelius <terelius@webrtc.org>
Reviewed-by: Elad Alon <eladalon@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#25147}
This commit is contained in:
Bjorn Terelius
2018-10-12 13:05:22 +02:00
committed by Commit Bot
parent f7fee39547
commit 23e48fb5fd
4 changed files with 225 additions and 340 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc
View File

@ -75,7 +75,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventAlrState) {
const auto& alr_state_events = parsed_log_.alr_state_events();
ASSERT_EQ(alr_state_events.size(), 1u);
EXPECT_TRUE(test::VerifyLoggedAlrStateEvent(*event, alr_state_events[0]));
test::VerifyLoggedAlrStateEvent(*event, alr_state_events[0]);
}
void RtcEventLogEncoderTest::TestRtcEventAudioNetworkAdaptation(
@ -186,7 +186,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventAudioPlayout) {
ASSERT_TRUE(playout_stream != playout_events.end());
ASSERT_EQ(playout_stream->second.size(), 1u);
LoggedAudioPlayoutEvent playout_event = playout_stream->second[0];
EXPECT_TRUE(test::VerifyLoggedAudioPlayoutEvent(*event, playout_event));
test::VerifyLoggedAudioPlayoutEvent(*event, playout_event);
}
TEST_P(RtcEventLogEncoderTest, RtcEventAudioReceiveStreamConfig) {
@ -201,7 +201,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventAudioReceiveStreamConfig) {
const auto& audio_recv_configs = parsed_log_.audio_recv_configs();
ASSERT_EQ(audio_recv_configs.size(), 1u);
EXPECT_TRUE(test::VerifyLoggedAudioRecvConfig(*event, audio_recv_configs[0]));
test::VerifyLoggedAudioRecvConfig(*event, audio_recv_configs[0]);
}
TEST_P(RtcEventLogEncoderTest, RtcEventAudioSendStreamConfig) {
@ -216,7 +216,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventAudioSendStreamConfig) {
const auto& audio_send_configs = parsed_log_.audio_send_configs();
ASSERT_EQ(audio_send_configs.size(), 1u);
EXPECT_TRUE(test::VerifyLoggedAudioSendConfig(*event, audio_send_configs[0]));
test::VerifyLoggedAudioSendConfig(*event, audio_send_configs[0]);
}
TEST_P(RtcEventLogEncoderTest, RtcEventBweUpdateDelayBased) {
@ -229,8 +229,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventBweUpdateDelayBased) {
const auto& bwe_delay_updates = parsed_log_.bwe_delay_updates();
ASSERT_EQ(bwe_delay_updates.size(), 1u);
EXPECT_TRUE(
test::VerifyLoggedBweDelayBasedUpdate(*event, bwe_delay_updates[0]));
test::VerifyLoggedBweDelayBasedUpdate(*event, bwe_delay_updates[0]);
}
TEST_P(RtcEventLogEncoderTest, RtcEventBweUpdateLossBased) {
@ -243,8 +242,8 @@ TEST_P(RtcEventLogEncoderTest, RtcEventBweUpdateLossBased) {
const auto& bwe_loss_updates = parsed_log_.bwe_loss_updates();
ASSERT_EQ(bwe_loss_updates.size(), 1u);
EXPECT_TRUE(
test::VerifyLoggedBweLossBasedUpdate(*event, bwe_loss_updates[0]));
test::VerifyLoggedBweLossBasedUpdate(*event, bwe_loss_updates[0]);
}
TEST_P(RtcEventLogEncoderTest, RtcEventIceCandidatePairConfig) {
@ -258,8 +257,8 @@ TEST_P(RtcEventLogEncoderTest, RtcEventIceCandidatePairConfig) {
parsed_log_.ice_candidate_pair_configs();
ASSERT_EQ(ice_candidate_pair_configs.size(), 1u);
EXPECT_TRUE(test::VerifyLoggedIceCandidatePairConfig(
*event, ice_candidate_pair_configs[0]));
test::VerifyLoggedIceCandidatePairConfig(*event,
ice_candidate_pair_configs[0]);
}
TEST_P(RtcEventLogEncoderTest, RtcEventIceCandidatePair) {
@ -272,8 +271,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventIceCandidatePair) {
parsed_log_.ice_candidate_pair_events();
ASSERT_EQ(ice_candidate_pair_events.size(), 1u);
EXPECT_TRUE(test::VerifyLoggedIceCandidatePairEvent(
*event, ice_candidate_pair_events[0]));
test::VerifyLoggedIceCandidatePairEvent(*event, ice_candidate_pair_events[0]);
}
TEST_P(RtcEventLogEncoderTest, RtcEventLoggingStarted) {
@ -307,8 +305,8 @@ TEST_P(RtcEventLogEncoderTest, RtcEventProbeClusterCreated) {
parsed_log_.bwe_probe_cluster_created_events();
ASSERT_EQ(bwe_probe_cluster_created_events.size(), 1u);
EXPECT_TRUE(test::VerifyLoggedBweProbeClusterCreatedEvent(
*event, bwe_probe_cluster_created_events[0]));
test::VerifyLoggedBweProbeClusterCreatedEvent(
*event, bwe_probe_cluster_created_events[0]);
}
TEST_P(RtcEventLogEncoderTest, RtcEventProbeResultFailure) {
@ -321,8 +319,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventProbeResultFailure) {
const auto& bwe_probe_failure_events = parsed_log_.bwe_probe_failure_events();
ASSERT_EQ(bwe_probe_failure_events.size(), 1u);
EXPECT_TRUE(test::VerifyLoggedBweProbeFailureEvent(
*event, bwe_probe_failure_events[0]));
test::VerifyLoggedBweProbeFailureEvent(*event, bwe_probe_failure_events[0]);
}
TEST_P(RtcEventLogEncoderTest, RtcEventProbeResultSuccess) {
@ -335,8 +332,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventProbeResultSuccess) {
const auto& bwe_probe_success_events = parsed_log_.bwe_probe_success_events();
ASSERT_EQ(bwe_probe_success_events.size(), 1u);
EXPECT_TRUE(test::VerifyLoggedBweProbeSuccessEvent(
*event, bwe_probe_success_events[0]));
test::VerifyLoggedBweProbeSuccessEvent(*event, bwe_probe_success_events[0]);
}
TEST_P(RtcEventLogEncoderTest, RtcEventRtcpPacketIncoming) {
@ -349,8 +345,8 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtcpPacketIncoming) {
const auto& incoming_rtcp_packets = parsed_log_.incoming_rtcp_packets();
ASSERT_EQ(incoming_rtcp_packets.size(), 1u);
EXPECT_TRUE(
test::VerifyLoggedRtcpPacketIncoming(*event, incoming_rtcp_packets[0]));
test::VerifyLoggedRtcpPacketIncoming(*event, incoming_rtcp_packets[0]);
}
TEST_P(RtcEventLogEncoderTest, RtcEventRtcpPacketOutgoing) {
@ -363,8 +359,8 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtcpPacketOutgoing) {
const auto& outgoing_rtcp_packets = parsed_log_.outgoing_rtcp_packets();
ASSERT_EQ(outgoing_rtcp_packets.size(), 1u);
EXPECT_TRUE(
test::VerifyLoggedRtcpPacketOutgoing(*event, outgoing_rtcp_packets[0]));
test::VerifyLoggedRtcpPacketOutgoing(*event, outgoing_rtcp_packets[0]);
}
TEST_P(RtcEventLogEncoderTest, RtcEventRtpPacketIncoming) {
@ -383,8 +379,8 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtpPacketIncoming) {
const auto& stream = incoming_rtp_packets_by_ssrc[0];
EXPECT_EQ(stream.ssrc, ssrc);
ASSERT_EQ(stream.incoming_packets.size(), 1u);
EXPECT_TRUE(
test::VerifyLoggedRtpPacketIncoming(*event, stream.incoming_packets[0]));
test::VerifyLoggedRtpPacketIncoming(*event, stream.incoming_packets[0]);
}
TEST_P(RtcEventLogEncoderTest, RtcEventRtpPacketOutgoing) {
@ -403,8 +399,8 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtpPacketOutgoing) {
const auto& stream = outgoing_rtp_packets_by_ssrc[0];
EXPECT_EQ(stream.ssrc, ssrc);
ASSERT_EQ(stream.outgoing_packets.size(), 1u);
EXPECT_TRUE(
test::VerifyLoggedRtpPacketOutgoing(*event, stream.outgoing_packets[0]));
test::VerifyLoggedRtpPacketOutgoing(*event, stream.outgoing_packets[0]);
}
TEST_P(RtcEventLogEncoderTest, RtcEventVideoReceiveStreamConfig) {
@ -419,7 +415,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventVideoReceiveStreamConfig) {
const auto& video_recv_configs = parsed_log_.video_recv_configs();
ASSERT_EQ(video_recv_configs.size(), 1u);
EXPECT_TRUE(test::VerifyLoggedVideoRecvConfig(*event, video_recv_configs[0]));
test::VerifyLoggedVideoRecvConfig(*event, video_recv_configs[0]);
}
TEST_P(RtcEventLogEncoderTest, RtcEventVideoSendStreamConfig) {
@ -434,7 +430,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventVideoSendStreamConfig) {
const auto& video_send_configs = parsed_log_.video_send_configs();
ASSERT_EQ(video_send_configs.size(), 1u);
EXPECT_TRUE(test::VerifyLoggedVideoSendConfig(*event, video_send_configs[0]));
test::VerifyLoggedVideoSendConfig(*event, video_send_configs[0]);
}
INSTANTIATE_TEST_CASE_P(RandomSeeds,

84
logging/rtc_event_log/rtc_event_log_unittest.cc
View File

@ -465,19 +465,17 @@ void RtcEventLogSession::ReadAndVerifyLog() {
// Start and stop events.
auto& parsed_start_log_events = parsed_log.start_log_events();
ASSERT_EQ(parsed_start_log_events.size(), static_cast<size_t>(1));
EXPECT_TRUE(
test::VerifyLoggedStartEvent(start_time_us_, parsed_start_log_events[0]));
test::VerifyLoggedStartEvent(start_time_us_, parsed_start_log_events[0]);
auto& parsed_stop_log_events = parsed_log.stop_log_events();
ASSERT_EQ(parsed_stop_log_events.size(), static_cast<size_t>(1));
EXPECT_TRUE(
test::VerifyLoggedStopEvent(stop_time_us_, parsed_stop_log_events[0]));
test::VerifyLoggedStopEvent(stop_time_us_, parsed_stop_log_events[0]);
auto& parsed_alr_state_events = parsed_log.alr_state_events();
ASSERT_EQ(parsed_alr_state_events.size(), alr_state_list_.size());
for (size_t i = 0; i < parsed_alr_state_events.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedAlrStateEvent(*alr_state_list_[i],
parsed_alr_state_events[i]));
test::VerifyLoggedAlrStateEvent(*alr_state_list_[i],
parsed_alr_state_events[i]);
}
const auto& parsed_audio_playout_map = parsed_log.audio_playout_events();
@ -488,8 +486,8 @@ void RtcEventLogSession::ReadAndVerifyLog() {
const auto& audio_playout_stream = audio_playout_map_[ssrc];
ASSERT_EQ(parsed_audio_playout_stream.size(), audio_playout_stream.size());
for (size_t i = 0; i < parsed_audio_playout_map.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedAudioPlayoutEvent(
*audio_playout_stream[i], parsed_audio_playout_stream[i]));
test::VerifyLoggedAudioPlayoutEvent(*audio_playout_stream[i],
parsed_audio_playout_stream[i]);
}
}
@ -498,22 +496,22 @@ void RtcEventLogSession::ReadAndVerifyLog() {
ASSERT_EQ(parsed_audio_network_adaptation_events.size(),
ana_configs_list_.size());
for (size_t i = 0; i < parsed_audio_network_adaptation_events.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedAudioNetworkAdaptationEvent(
*ana_configs_list_[i], parsed_audio_network_adaptation_events[i]));
test::VerifyLoggedAudioNetworkAdaptationEvent(
*ana_configs_list_[i], parsed_audio_network_adaptation_events[i]);
}
auto& parsed_bwe_delay_updates = parsed_log.bwe_delay_updates();
ASSERT_EQ(parsed_bwe_delay_updates.size(), bwe_delay_list_.size());
for (size_t i = 0; i < parsed_bwe_delay_updates.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedBweDelayBasedUpdate(
*bwe_delay_list_[i], parsed_bwe_delay_updates[i]));
test::VerifyLoggedBweDelayBasedUpdate(*bwe_delay_list_[i],
parsed_bwe_delay_updates[i]);
}
auto& parsed_bwe_loss_updates = parsed_log.bwe_loss_updates();
ASSERT_EQ(parsed_bwe_loss_updates.size(), bwe_loss_list_.size());
for (size_t i = 0; i < parsed_bwe_loss_updates.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedBweLossBasedUpdate(
*bwe_loss_list_[i], parsed_bwe_loss_updates[i]));
test::VerifyLoggedBweLossBasedUpdate(*bwe_loss_list_[i],
parsed_bwe_loss_updates[i]);
}
auto& parsed_bwe_probe_cluster_created_events =
@ -521,30 +519,30 @@ void RtcEventLogSession::ReadAndVerifyLog() {
ASSERT_EQ(parsed_bwe_probe_cluster_created_events.size(),
probe_creation_list_.size());
for (size_t i = 0; i < parsed_bwe_probe_cluster_created_events.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedBweProbeClusterCreatedEvent(
*probe_creation_list_[i], parsed_bwe_probe_cluster_created_events[i]));
test::VerifyLoggedBweProbeClusterCreatedEvent(
*probe_creation_list_[i], parsed_bwe_probe_cluster_created_events[i]);
}
auto& parsed_bwe_probe_failure_events = parsed_log.bwe_probe_failure_events();
ASSERT_EQ(parsed_bwe_probe_failure_events.size(), probe_failure_list_.size());
for (size_t i = 0; i < parsed_bwe_probe_failure_events.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedBweProbeFailureEvent(
*probe_failure_list_[i], parsed_bwe_probe_failure_events[i]));
test::VerifyLoggedBweProbeFailureEvent(*probe_failure_list_[i],
parsed_bwe_probe_failure_events[i]);
}
auto& parsed_bwe_probe_success_events = parsed_log.bwe_probe_success_events();
ASSERT_EQ(parsed_bwe_probe_success_events.size(), probe_success_list_.size());
for (size_t i = 0; i < parsed_bwe_probe_success_events.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedBweProbeSuccessEvent(
*probe_success_list_[i], parsed_bwe_probe_success_events[i]));
test::VerifyLoggedBweProbeSuccessEvent(*probe_success_list_[i],
parsed_bwe_probe_success_events[i]);
}
auto& parsed_ice_candidate_pair_configs =
parsed_log.ice_candidate_pair_configs();
ASSERT_EQ(parsed_ice_candidate_pair_configs.size(), ice_config_list_.size());
for (size_t i = 0; i < parsed_ice_candidate_pair_configs.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedIceCandidatePairConfig(
*ice_config_list_[i], parsed_ice_candidate_pair_configs[i]));
test::VerifyLoggedIceCandidatePairConfig(
*ice_config_list_[i], parsed_ice_candidate_pair_configs[i]);
}
auto& parsed_ice_candidate_pair_events =
@ -552,8 +550,8 @@ void RtcEventLogSession::ReadAndVerifyLog() {
ASSERT_EQ(parsed_ice_candidate_pair_events.size(),
parsed_ice_candidate_pair_events.size());
for (size_t i = 0; i < parsed_ice_candidate_pair_events.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedIceCandidatePairEvent(
*ice_event_list_[i], parsed_ice_candidate_pair_events[i]));
test::VerifyLoggedIceCandidatePairEvent(
*ice_event_list_[i], parsed_ice_candidate_pair_events[i]);
}
auto& parsed_incoming_rtp_packets_by_ssrc =
@ -566,8 +564,7 @@ void RtcEventLogSession::ReadAndVerifyLog() {
const auto& rtp_stream = incoming_rtp_map_[ssrc];
ASSERT_EQ(parsed_rtp_stream.size(), rtp_stream.size());
for (size_t i = 0; i < parsed_rtp_stream.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedRtpPacketIncoming(*rtp_stream[i],
parsed_rtp_stream[i]));
test::VerifyLoggedRtpPacketIncoming(*rtp_stream[i], parsed_rtp_stream[i]);
}
}
@ -581,47 +578,46 @@ void RtcEventLogSession::ReadAndVerifyLog() {
const auto& rtp_stream = outgoing_rtp_map_[ssrc];
ASSERT_EQ(parsed_rtp_stream.size(), rtp_stream.size());
for (size_t i = 0; i < parsed_rtp_stream.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedRtpPacketOutgoing(*rtp_stream[i],
parsed_rtp_stream[i]));
test::VerifyLoggedRtpPacketOutgoing(*rtp_stream[i], parsed_rtp_stream[i]);
}
}
auto& parsed_incoming_rtcp_packets = parsed_log.incoming_rtcp_packets();
ASSERT_EQ(parsed_incoming_rtcp_packets.size(), incoming_rtcp_list_.size());
for (size_t i = 0; i < parsed_incoming_rtcp_packets.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedRtcpPacketIncoming(
*incoming_rtcp_list_[i], parsed_incoming_rtcp_packets[i]));
test::VerifyLoggedRtcpPacketIncoming(*incoming_rtcp_list_[i],
parsed_incoming_rtcp_packets[i]);
}
auto& parsed_outgoing_rtcp_packets = parsed_log.outgoing_rtcp_packets();
ASSERT_EQ(parsed_outgoing_rtcp_packets.size(), outgoing_rtcp_list_.size());
for (size_t i = 0; i < parsed_outgoing_rtcp_packets.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedRtcpPacketOutgoing(
*outgoing_rtcp_list_[i], parsed_outgoing_rtcp_packets[i]));
test::VerifyLoggedRtcpPacketOutgoing(*outgoing_rtcp_list_[i],
parsed_outgoing_rtcp_packets[i]);
}
auto& parsed_audio_recv_configs = parsed_log.audio_recv_configs();
ASSERT_EQ(parsed_audio_recv_configs.size(), audio_recv_config_list_.size());
for (size_t i = 0; i < parsed_audio_recv_configs.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedAudioRecvConfig(
*audio_recv_config_list_[i], parsed_audio_recv_configs[i]));
test::VerifyLoggedAudioRecvConfig(*audio_recv_config_list_[i],
parsed_audio_recv_configs[i]);
}
auto& parsed_audio_send_configs = parsed_log.audio_send_configs();
ASSERT_EQ(parsed_audio_send_configs.size(), audio_send_config_list_.size());
for (size_t i = 0; i < parsed_audio_send_configs.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedAudioSendConfig(
*audio_send_config_list_[i], parsed_audio_send_configs[i]));
test::VerifyLoggedAudioSendConfig(*audio_send_config_list_[i],
parsed_audio_send_configs[i]);
}
auto& parsed_video_recv_configs = parsed_log.video_recv_configs();
ASSERT_EQ(parsed_video_recv_configs.size(), video_recv_config_list_.size());
for (size_t i = 0; i < parsed_video_recv_configs.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedVideoRecvConfig(
*video_recv_config_list_[i], parsed_video_recv_configs[i]));
test::VerifyLoggedVideoRecvConfig(*video_recv_config_list_[i],
parsed_video_recv_configs[i]);
}
auto& parsed_video_send_configs = parsed_log.video_send_configs();
ASSERT_EQ(parsed_video_send_configs.size(), video_send_config_list_.size());
for (size_t i = 0; i < parsed_video_send_configs.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedVideoSendConfig(
*video_send_config_list_[i], parsed_video_send_configs[i]));
test::VerifyLoggedVideoSendConfig(*video_send_config_list_[i],
parsed_video_send_configs[i]);
}
// Clean up temporary file - can be pretty slow.
@ -727,11 +723,11 @@ TEST(RtcEventLogTest, CircularBufferKeepsMostRecentEvents) {
const auto& start_log_events = parsed_log.start_log_events();
ASSERT_EQ(start_log_events.size(), 1u);
EXPECT_TRUE(test::VerifyLoggedStartEvent(start_time_us, start_log_events[0]));
test::VerifyLoggedStartEvent(start_time_us, start_log_events[0]);
const auto& stop_log_events = parsed_log.stop_log_events();
ASSERT_EQ(stop_log_events.size(), 1u);
EXPECT_TRUE(test::VerifyLoggedStopEvent(stop_time_us, stop_log_events[0]));
test::VerifyLoggedStopEvent(stop_time_us, stop_log_events[0]);
const auto& probe_success_events = parsed_log.bwe_probe_success_events();
// If the following fails, it probably means that kNumEvents isn't larger
@ -752,9 +748,9 @@ TEST(RtcEventLogTest, CircularBufferKeepsMostRecentEvents) {
fake_clock->SetTimeMicros(first_timestamp_us);
for (size_t i = 1; i < probe_success_events.size(); i++) {
fake_clock->AdvanceTimeMicros(10000);
ASSERT_TRUE(test::VerifyLoggedBweProbeSuccessEvent(
test::VerifyLoggedBweProbeSuccessEvent(
RtcEventProbeResultSuccess(first_id + i, first_bitrate_bps + i * 1000),
probe_success_events[i]));
probe_success_events[i]);
}
}

389
logging/rtc_event_log/rtc_event_log_unittest_helper.cc
View File

@ -25,6 +25,7 @@
#include "modules/rtp_rtcp/source/rtp_packet_received.h"
#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
#include "rtc_base/checks.h"
#include "test/gtest.h"
namespace webrtc {
@ -469,396 +470,288 @@ EventGenerator::NewVideoSendStreamConfig(
return absl::make_unique<RtcEventVideoSendStreamConfig>(std::move(config));
}
bool VerifyLoggedAlrStateEvent(const RtcEventAlrState& original_event,
void VerifyLoggedAlrStateEvent(const RtcEventAlrState& original_event,
const LoggedAlrStateEvent& logged_event) {
if (original_event.timestamp_us_ / 1000 != logged_event.log_time_ms())
return false;
if (original_event.in_alr_ != logged_event.in_alr)
return false;
return true;
EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
EXPECT_EQ(original_event.in_alr_, logged_event.in_alr);
}
bool VerifyLoggedAudioPlayoutEvent(
void VerifyLoggedAudioPlayoutEvent(
const RtcEventAudioPlayout& original_event,
const LoggedAudioPlayoutEvent& logged_event) {
if (original_event.timestamp_us_ / 1000 != logged_event.log_time_ms())
return false;
if (original_event.ssrc_ != logged_event.ssrc)
return false;
return true;
EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
EXPECT_EQ(original_event.ssrc_, logged_event.ssrc);
}
bool VerifyLoggedAudioNetworkAdaptationEvent(
void VerifyLoggedAudioNetworkAdaptationEvent(
const RtcEventAudioNetworkAdaptation& original_event,
const LoggedAudioNetworkAdaptationEvent& logged_event) {
if (original_event.timestamp_us_ / 1000 != logged_event.log_time_ms())
return false;
EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
if (original_event.config_->bitrate_bps != logged_event.config.bitrate_bps)
return false;
if (original_event.config_->enable_dtx != logged_event.config.enable_dtx)
return false;
if (original_event.config_->enable_fec != logged_event.config.enable_fec)
return false;
if (original_event.config_->frame_length_ms !=
logged_event.config.frame_length_ms)
return false;
if (original_event.config_->num_channels != logged_event.config.num_channels)
return false;
if (original_event.config_->uplink_packet_loss_fraction !=
logged_event.config.uplink_packet_loss_fraction)
return false;
return true;
EXPECT_EQ(original_event.config_->bitrate_bps,
logged_event.config.bitrate_bps);
EXPECT_EQ(original_event.config_->enable_dtx, logged_event.config.enable_dtx);
EXPECT_EQ(original_event.config_->enable_fec, logged_event.config.enable_fec);
EXPECT_EQ(original_event.config_->frame_length_ms,
logged_event.config.frame_length_ms);
EXPECT_EQ(original_event.config_->num_channels,
logged_event.config.num_channels);
EXPECT_EQ(original_event.config_->uplink_packet_loss_fraction,
logged_event.config.uplink_packet_loss_fraction);
}
bool VerifyLoggedBweDelayBasedUpdate(
void VerifyLoggedBweDelayBasedUpdate(
const RtcEventBweUpdateDelayBased& original_event,
const LoggedBweDelayBasedUpdate& logged_event) {
if (original_event.timestamp_us_ / 1000 != logged_event.log_time_ms())
return false;
if (original_event.bitrate_bps_ != logged_event.bitrate_bps)
return false;
if (original_event.detector_state_ != logged_event.detector_state)
return false;
return true;
EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
EXPECT_EQ(original_event.bitrate_bps_, logged_event.bitrate_bps);
EXPECT_EQ(original_event.detector_state_, logged_event.detector_state);
}
bool VerifyLoggedBweLossBasedUpdate(
void VerifyLoggedBweLossBasedUpdate(
const RtcEventBweUpdateLossBased& original_event,
const LoggedBweLossBasedUpdate& logged_event) {
if (original_event.timestamp_us_ / 1000 != logged_event.log_time_ms())
return false;
if (original_event.bitrate_bps_ != logged_event.bitrate_bps)
return false;
if (original_event.fraction_loss_ != logged_event.fraction_lost)
return false;
if (original_event.total_packets_ != logged_event.expected_packets)
return false;
return true;
EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
EXPECT_EQ(original_event.bitrate_bps_, logged_event.bitrate_bps);
EXPECT_EQ(original_event.fraction_loss_, logged_event.fraction_lost);
EXPECT_EQ(original_event.total_packets_, logged_event.expected_packets);
}
bool VerifyLoggedBweProbeClusterCreatedEvent(
void VerifyLoggedBweProbeClusterCreatedEvent(
const RtcEventProbeClusterCreated& original_event,
const LoggedBweProbeClusterCreatedEvent& logged_event) {
if (original_event.timestamp_us_ / 1000 != logged_event.log_time_ms())
return false;
if (original_event.id_ != logged_event.id)
return false;
if (original_event.bitrate_bps_ != logged_event.bitrate_bps)
return false;
if (original_event.min_probes_ != logged_event.min_packets)
return false;
if (original_event.min_bytes_ != logged_event.min_bytes)
return false;
return true;
EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
EXPECT_EQ(original_event.id_, logged_event.id);
EXPECT_EQ(original_event.bitrate_bps_, logged_event.bitrate_bps);
EXPECT_EQ(original_event.min_probes_, logged_event.min_packets);
EXPECT_EQ(original_event.min_bytes_, logged_event.min_bytes);
}
bool VerifyLoggedBweProbeFailureEvent(
void VerifyLoggedBweProbeFailureEvent(
const RtcEventProbeResultFailure& original_event,
const LoggedBweProbeFailureEvent& logged_event) {
if (original_event.timestamp_us_ / 1000 != logged_event.log_time_ms())
return false;
if (original_event.id_ != logged_event.id)
return false;
if (original_event.failure_reason_ != logged_event.failure_reason)
return false;
return true;
EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
EXPECT_EQ(original_event.id_, logged_event.id);
EXPECT_EQ(original_event.failure_reason_, logged_event.failure_reason);
}
bool VerifyLoggedBweProbeSuccessEvent(
void VerifyLoggedBweProbeSuccessEvent(
const RtcEventProbeResultSuccess& original_event,
const LoggedBweProbeSuccessEvent& logged_event) {
if (original_event.timestamp_us_ / 1000 != logged_event.log_time_ms())
return false;
if (original_event.id_ != logged_event.id)
return false;
if (original_event.bitrate_bps_ != logged_event.bitrate_bps)
return false;
return true;
EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
EXPECT_EQ(original_event.id_, logged_event.id);
EXPECT_EQ(original_event.bitrate_bps_, logged_event.bitrate_bps);
}
bool VerifyLoggedIceCandidatePairConfig(
void VerifyLoggedIceCandidatePairConfig(
const RtcEventIceCandidatePairConfig& original_event,
const LoggedIceCandidatePairConfig& logged_event) {
if (original_event.timestamp_us_ / 1000 != logged_event.log_time_ms())
return false;
EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
if (original_event.type_ != logged_event.type)
return false;
if (original_event.candidate_pair_id_ != logged_event.candidate_pair_id)
return false;
if (original_event.candidate_pair_desc_.local_candidate_type !=
logged_event.local_candidate_type)
return false;
if (original_event.candidate_pair_desc_.local_relay_protocol !=
logged_event.local_relay_protocol)
return false;
if (original_event.candidate_pair_desc_.local_network_type !=
logged_event.local_network_type)
return false;
if (original_event.candidate_pair_desc_.local_address_family !=
logged_event.local_address_family)
return false;
if (original_event.candidate_pair_desc_.remote_candidate_type !=
logged_event.remote_candidate_type)
return false;
if (original_event.candidate_pair_desc_.remote_address_family !=
logged_event.remote_address_family)
return false;
if (original_event.candidate_pair_desc_.candidate_pair_protocol !=
logged_event.candidate_pair_protocol)
return false;
return true;
EXPECT_EQ(original_event.type_, logged_event.type);
EXPECT_EQ(original_event.candidate_pair_id_, logged_event.candidate_pair_id);
EXPECT_EQ(original_event.candidate_pair_desc_.local_candidate_type,
logged_event.local_candidate_type);
EXPECT_EQ(original_event.candidate_pair_desc_.local_relay_protocol,
logged_event.local_relay_protocol);
EXPECT_EQ(original_event.candidate_pair_desc_.local_network_type,
logged_event.local_network_type);
EXPECT_EQ(original_event.candidate_pair_desc_.local_address_family,
logged_event.local_address_family);
EXPECT_EQ(original_event.candidate_pair_desc_.remote_candidate_type,
logged_event.remote_candidate_type);
EXPECT_EQ(original_event.candidate_pair_desc_.remote_address_family,
logged_event.remote_address_family);
EXPECT_EQ(original_event.candidate_pair_desc_.candidate_pair_protocol,
logged_event.candidate_pair_protocol);
}
bool VerifyLoggedIceCandidatePairEvent(
void VerifyLoggedIceCandidatePairEvent(
const RtcEventIceCandidatePair& original_event,
const LoggedIceCandidatePairEvent& logged_event) {
if (original_event.timestamp_us_ / 1000 != logged_event.log_time_ms())
return false;
EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
if (original_event.type_ != logged_event.type)
return false;
if (original_event.candidate_pair_id_ != logged_event.candidate_pair_id)
return false;
return true;
EXPECT_EQ(original_event.type_, logged_event.type);
EXPECT_EQ(original_event.candidate_pair_id_, logged_event.candidate_pair_id);
}
bool VerifyLoggedRtpHeader(const RtpPacket& original_header,
void VerifyLoggedRtpHeader(const RtpPacket& original_header,
const RTPHeader& logged_header) {
// Standard RTP header.
if (original_header.Marker() != logged_header.markerBit)
return false;
if (original_header.PayloadType() != logged_header.payloadType)
return false;
if (original_header.SequenceNumber() != logged_header.sequenceNumber)
return false;
if (original_header.Timestamp() != logged_header.timestamp)
return false;
if (original_header.Ssrc() != logged_header.ssrc)
return false;
if (original_header.Csrcs().size() != logged_header.numCSRCs)
return false;
EXPECT_EQ(original_header.Marker(), logged_header.markerBit);
EXPECT_EQ(original_header.PayloadType(), logged_header.payloadType);
EXPECT_EQ(original_header.SequenceNumber(), logged_header.sequenceNumber);
EXPECT_EQ(original_header.Timestamp(), logged_header.timestamp);
EXPECT_EQ(original_header.Ssrc(), logged_header.ssrc);
ASSERT_EQ(original_header.Csrcs().size(), logged_header.numCSRCs);
for (size_t i = 0; i < logged_header.numCSRCs; i++) {
if (original_header.Csrcs()[i] != logged_header.arrOfCSRCs[i])
return false;
EXPECT_EQ(original_header.Csrcs()[i], logged_header.arrOfCSRCs[i]);
}
if (original_header.headers_size() != logged_header.headerLength)
return false;
EXPECT_EQ(original_header.headers_size(), logged_header.headerLength);
// TransmissionOffset header extension.
if (original_header.HasExtension<TransmissionOffset>() !=
logged_header.extension.hasTransmissionTimeOffset)
return false;
ASSERT_EQ(original_header.HasExtension<TransmissionOffset>(),
logged_header.extension.hasTransmissionTimeOffset);
if (logged_header.extension.hasTransmissionTimeOffset) {
int32_t offset;
original_header.GetExtension<TransmissionOffset>(&offset);
if (offset != logged_header.extension.transmissionTimeOffset)
return false;
EXPECT_EQ(offset, logged_header.extension.transmissionTimeOffset);
}
// AbsoluteSendTime header extension.
if (original_header.HasExtension<AbsoluteSendTime>() !=
logged_header.extension.hasAbsoluteSendTime)
return false;
ASSERT_EQ(original_header.HasExtension<AbsoluteSendTime>(),
logged_header.extension.hasAbsoluteSendTime);
if (logged_header.extension.hasAbsoluteSendTime) {
uint32_t sendtime;
original_header.GetExtension<AbsoluteSendTime>(&sendtime);
if (sendtime != logged_header.extension.absoluteSendTime)
return false;
EXPECT_EQ(sendtime, logged_header.extension.absoluteSendTime);
}
// TransportSequenceNumber header extension.
if (original_header.HasExtension<TransportSequenceNumber>() !=
logged_header.extension.hasTransportSequenceNumber)
return false;
ASSERT_EQ(original_header.HasExtension<TransportSequenceNumber>(),
logged_header.extension.hasTransportSequenceNumber);
if (logged_header.extension.hasTransportSequenceNumber) {
uint16_t seqnum;
original_header.GetExtension<TransportSequenceNumber>(&seqnum);
if (seqnum != logged_header.extension.transportSequenceNumber)
return false;
EXPECT_EQ(seqnum, logged_header.extension.transportSequenceNumber);
}
// AudioLevel header extension.
if (original_header.HasExtension<AudioLevel>() !=
logged_header.extension.hasAudioLevel)
return false;
ASSERT_EQ(original_header.HasExtension<AudioLevel>(),
logged_header.extension.hasAudioLevel);
if (logged_header.extension.hasAudioLevel) {
bool voice_activity;
uint8_t audio_level;
original_header.GetExtension<AudioLevel>(&voice_activity, &audio_level);
if (voice_activity != logged_header.extension.voiceActivity)
return false;
if (audio_level != logged_header.extension.audioLevel)
return false;
EXPECT_EQ(voice_activity, logged_header.extension.voiceActivity);
EXPECT_EQ(audio_level, logged_header.extension.audioLevel);
}
// VideoOrientation header extension.
if (original_header.HasExtension<VideoOrientation>() !=
logged_header.extension.hasVideoRotation)
return false;
ASSERT_EQ(original_header.HasExtension<VideoOrientation>(),
logged_header.extension.hasVideoRotation);
if (logged_header.extension.hasVideoRotation) {
uint8_t rotation;
original_header.GetExtension<VideoOrientation>(&rotation);
if (ConvertCVOByteToVideoRotation(rotation) !=
logged_header.extension.videoRotation)
return false;
EXPECT_EQ(ConvertCVOByteToVideoRotation(rotation),
logged_header.extension.videoRotation);
}
return true;
}
bool VerifyLoggedRtpPacketIncoming(
void VerifyLoggedRtpPacketIncoming(
const RtcEventRtpPacketIncoming& original_event,
const LoggedRtpPacketIncoming& logged_event) {
if (original_event.timestamp_us_ / 1000 != logged_event.log_time_ms())
return false;
EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
if (original_event.header_.headers_size() != logged_event.rtp.header_length)
return false;
EXPECT_EQ(original_event.header_.headers_size(),
logged_event.rtp.header_length);
if (original_event.packet_length_ != logged_event.rtp.total_length)
return false;
EXPECT_EQ(original_event.packet_length_, logged_event.rtp.total_length);
if ((original_event.header_.data()[0] & 0x20) != 0 && // has padding
original_event.packet_length_ - original_event.header_.headers_size() !=
logged_event.rtp.header.paddingLength) {
if ((original_event.header_.data()[0] & 0x20) != 0) { // has padding
// Currently, RTC eventlog encoder-parser can only maintain padding length
// if packet is full padding.
// TODO(webrtc:9730): Change the condition to something like
// original_event.padding_length_ != logged_event.rtp.header.paddingLength.
return false;
EXPECT_EQ(
original_event.packet_length_ - original_event.header_.headers_size(),
logged_event.rtp.header.paddingLength);
}
if (!VerifyLoggedRtpHeader(original_event.header_, logged_event.rtp.header))
return false;
return true;
VerifyLoggedRtpHeader(original_event.header_, logged_event.rtp.header);
}
bool VerifyLoggedRtpPacketOutgoing(
void VerifyLoggedRtpPacketOutgoing(
const RtcEventRtpPacketOutgoing& original_event,
const LoggedRtpPacketOutgoing& logged_event) {
if (original_event.timestamp_us_ / 1000 != logged_event.log_time_ms())
return false;
EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
if (original_event.header_.headers_size() != logged_event.rtp.header_length)
return false;
EXPECT_EQ(original_event.header_.headers_size(),
logged_event.rtp.header_length);
if (original_event.packet_length_ != logged_event.rtp.total_length)
return false;
EXPECT_EQ(original_event.packet_length_, logged_event.rtp.total_length);
if ((original_event.header_.data()[0] & 0x20) != 0 && // has padding
original_event.packet_length_ - original_event.header_.headers_size() !=
logged_event.rtp.header.paddingLength) {
if ((original_event.header_.data()[0] & 0x20) != 0) { // has padding
// Currently, RTC eventlog encoder-parser can only maintain padding length
// if packet is full padding.
// TODO(webrtc:9730): Change the condition to something like
// original_event.padding_length_ != logged_event.rtp.header.paddingLength.
return false;
EXPECT_EQ(
original_event.packet_length_ - original_event.header_.headers_size(),
logged_event.rtp.header.paddingLength);
}
// TODO(terelius): Probe cluster ID isn't parsed, used or tested. Unless
// someone has a strong reason to keep it, it'll be removed.
if (!VerifyLoggedRtpHeader(original_event.header_, logged_event.rtp.header))
return false;
return true;
VerifyLoggedRtpHeader(original_event.header_, logged_event.rtp.header);
}
bool VerifyLoggedRtcpPacketIncoming(
void VerifyLoggedRtcpPacketIncoming(
const RtcEventRtcpPacketIncoming& original_event,
const LoggedRtcpPacketIncoming& logged_event) {
if (original_event.timestamp_us_ / 1000 != logged_event.log_time_ms())
return false;
EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
if (original_event.packet_.size() != logged_event.rtcp.raw_data.size())
return false;
if (memcmp(original_event.packet_.data(), logged_event.rtcp.raw_data.data(),
original_event.packet_.size()) != 0) {
return false;
}
return true;
ASSERT_EQ(original_event.packet_.size(), logged_event.rtcp.raw_data.size());
EXPECT_EQ(
memcmp(original_event.packet_.data(), logged_event.rtcp.raw_data.data(),
original_event.packet_.size()),
0);
}
bool VerifyLoggedRtcpPacketOutgoing(
void VerifyLoggedRtcpPacketOutgoing(
const RtcEventRtcpPacketOutgoing& original_event,
const LoggedRtcpPacketOutgoing& logged_event) {
if (original_event.timestamp_us_ / 1000 != logged_event.log_time_ms())
return false;
EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
if (original_event.packet_.size() != logged_event.rtcp.raw_data.size())
return false;
if (memcmp(original_event.packet_.data(), logged_event.rtcp.raw_data.data(),
original_event.packet_.size()) != 0) {
return false;
}
return true;
ASSERT_EQ(original_event.packet_.size(), logged_event.rtcp.raw_data.size());
EXPECT_EQ(
memcmp(original_event.packet_.data(), logged_event.rtcp.raw_data.data(),
original_event.packet_.size()),
0);
}
bool VerifyLoggedStartEvent(int64_t start_time_us,
void VerifyLoggedStartEvent(int64_t start_time_us,
const LoggedStartEvent& logged_event) {
if (start_time_us / 1000 != logged_event.log_time_ms())
return false;
return true;
EXPECT_EQ(start_time_us / 1000, logged_event.log_time_ms());
}
bool VerifyLoggedStopEvent(int64_t stop_time_us,
void VerifyLoggedStopEvent(int64_t stop_time_us,
const LoggedStopEvent& logged_event) {
if (stop_time_us / 1000 != logged_event.log_time_ms())
return false;
return true;
EXPECT_EQ(stop_time_us / 1000, logged_event.log_time_ms());
}
bool VerifyLoggedAudioRecvConfig(
void VerifyLoggedAudioRecvConfig(
const RtcEventAudioReceiveStreamConfig& original_event,
const LoggedAudioRecvConfig& logged_event) {
if (original_event.timestamp_us_ / 1000 != logged_event.log_time_ms())
return false;
if (*original_event.config_ != logged_event.config)
return false;
return true;
EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
EXPECT_EQ(*original_event.config_, logged_event.config);
}
bool VerifyLoggedAudioSendConfig(
void VerifyLoggedAudioSendConfig(
const RtcEventAudioSendStreamConfig& original_event,
const LoggedAudioSendConfig& logged_event) {
if (original_event.timestamp_us_ / 1000 != logged_event.log_time_ms())
return false;
if (*original_event.config_ != logged_event.config)
return false;
return true;
EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
EXPECT_EQ(*original_event.config_, logged_event.config);
}
bool VerifyLoggedVideoRecvConfig(
void VerifyLoggedVideoRecvConfig(
const RtcEventVideoReceiveStreamConfig& original_event,
const LoggedVideoRecvConfig& logged_event) {
if (original_event.timestamp_us_ / 1000 != logged_event.log_time_ms())
return false;
if (*original_event.config_ != logged_event.config)
return false;
return true;
EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
EXPECT_EQ(*original_event.config_, logged_event.config);
}
bool VerifyLoggedVideoSendConfig(
void VerifyLoggedVideoSendConfig(
const RtcEventVideoSendStreamConfig& original_event,
const LoggedVideoSendConfig& logged_event) {
if (original_event.timestamp_us_ / 1000 != logged_event.log_time_ms())
return false;
EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
// TODO(terelius): In the past, we allowed storing multiple RtcStreamConfigs
// in the same RtcEventVideoSendStreamConfig. Look into whether we should drop
// backwards compatibility in the parser.
if (logged_event.configs.size() != 1)
return false;
if (*original_event.config_ != logged_event.configs[0])
return false;
return true;
EXPECT_EQ(logged_event.configs.size(), 1u);
EXPECT_EQ(*original_event.config_, logged_event.configs[0]);
}
} // namespace test

40
logging/rtc_event_log/rtc_event_log_unittest_helper.h
View File

@ -110,78 +110,78 @@ class EventGenerator {
Random prng_;
};
bool VerifyLoggedAlrStateEvent(const RtcEventAlrState& original_event,
void VerifyLoggedAlrStateEvent(const RtcEventAlrState& original_event,
const LoggedAlrStateEvent& logged_event);
bool VerifyLoggedAudioPlayoutEvent(const RtcEventAudioPlayout& original_event,
void VerifyLoggedAudioPlayoutEvent(const RtcEventAudioPlayout& original_event,
const LoggedAudioPlayoutEvent& logged_event);
bool VerifyLoggedAudioNetworkAdaptationEvent(
void VerifyLoggedAudioNetworkAdaptationEvent(
const RtcEventAudioNetworkAdaptation& original_event,
const LoggedAudioNetworkAdaptationEvent& logged_event);
bool VerifyLoggedBweDelayBasedUpdate(
void VerifyLoggedBweDelayBasedUpdate(
const RtcEventBweUpdateDelayBased& original_event,
const LoggedBweDelayBasedUpdate& logged_event);
bool VerifyLoggedBweLossBasedUpdate(
void VerifyLoggedBweLossBasedUpdate(
const RtcEventBweUpdateLossBased& original_event,
const LoggedBweLossBasedUpdate& logged_event);
bool VerifyLoggedBweProbeClusterCreatedEvent(
void VerifyLoggedBweProbeClusterCreatedEvent(
const RtcEventProbeClusterCreated& original_event,
const LoggedBweProbeClusterCreatedEvent& logged_event);
bool VerifyLoggedBweProbeFailureEvent(
void VerifyLoggedBweProbeFailureEvent(
const RtcEventProbeResultFailure& original_event,
const LoggedBweProbeFailureEvent& logged_event);
bool VerifyLoggedBweProbeSuccessEvent(
void VerifyLoggedBweProbeSuccessEvent(
const RtcEventProbeResultSuccess& original_event,
const LoggedBweProbeSuccessEvent& logged_event);
bool VerifyLoggedIceCandidatePairConfig(
void VerifyLoggedIceCandidatePairConfig(
const RtcEventIceCandidatePairConfig& original_event,
const LoggedIceCandidatePairConfig& logged_event);
bool VerifyLoggedIceCandidatePairEvent(
void VerifyLoggedIceCandidatePairEvent(
const RtcEventIceCandidatePair& original_event,
const LoggedIceCandidatePairEvent& logged_event);
bool VerifyLoggedRtpPacketIncoming(
void VerifyLoggedRtpPacketIncoming(
const RtcEventRtpPacketIncoming& original_event,
const LoggedRtpPacketIncoming& logged_event);
bool VerifyLoggedRtpPacketOutgoing(
void VerifyLoggedRtpPacketOutgoing(
const RtcEventRtpPacketOutgoing& original_event,
const LoggedRtpPacketOutgoing& logged_event);
bool VerifyLoggedRtcpPacketIncoming(
void VerifyLoggedRtcpPacketIncoming(
const RtcEventRtcpPacketIncoming& original_event,
const LoggedRtcpPacketIncoming& logged_event);
bool VerifyLoggedRtcpPacketOutgoing(
void VerifyLoggedRtcpPacketOutgoing(
const RtcEventRtcpPacketOutgoing& original_event,
const LoggedRtcpPacketOutgoing& logged_event);
bool VerifyLoggedStartEvent(int64_t start_time_us,
void VerifyLoggedStartEvent(int64_t start_time_us,
const LoggedStartEvent& logged_event);
bool VerifyLoggedStopEvent(int64_t stop_time_us,
void VerifyLoggedStopEvent(int64_t stop_time_us,
const LoggedStopEvent& logged_event);
bool VerifyLoggedAudioRecvConfig(
void VerifyLoggedAudioRecvConfig(
const RtcEventAudioReceiveStreamConfig& original_event,
const LoggedAudioRecvConfig& logged_event);
bool VerifyLoggedAudioSendConfig(
void VerifyLoggedAudioSendConfig(
const RtcEventAudioSendStreamConfig& original_event,
const LoggedAudioSendConfig& logged_event);
bool VerifyLoggedVideoRecvConfig(
void VerifyLoggedVideoRecvConfig(
const RtcEventVideoReceiveStreamConfig& original_event,
const LoggedVideoRecvConfig& logged_event);
bool VerifyLoggedVideoSendConfig(
void VerifyLoggedVideoSendConfig(
const RtcEventVideoSendStreamConfig& original_event,
const LoggedVideoSendConfig& logged_event);