From 23e48fb5fd518845c34dfa8344bc7b7153392fdc Mon Sep 17 00:00:00 2001 From: Bjorn Terelius Date: Fri, 12 Oct 2018 13:05:22 +0200 Subject: [PATCH] Move expectations from eventlog unittests to helper functions. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bug: webrtc:8111 Change-Id: I47fd6c1651f2630ebaf2752b471a36b1d4f98769 Reviewed-on: https://webrtc-review.googlesource.com/c/105482 Commit-Queue: Björn Terelius Reviewed-by: Elad Alon Cr-Commit-Position: refs/heads/master@{#25147} --- .../encoder/rtc_event_log_encoder_unittest.cc | 52 ++- .../rtc_event_log/rtc_event_log_unittest.cc | 84 ++-- .../rtc_event_log_unittest_helper.cc | 389 +++++++----------- .../rtc_event_log_unittest_helper.h | 40 +- 4 files changed, 225 insertions(+), 340 deletions(-) diff --git a/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc b/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc index 990fa6080b..4c36684c8e 100644 --- a/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc +++ b/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc @@ -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, diff --git a/logging/rtc_event_log/rtc_event_log_unittest.cc b/logging/rtc_event_log/rtc_event_log_unittest.cc index e238f84884..1b7fbce489 100644 --- a/logging/rtc_event_log/rtc_event_log_unittest.cc +++ b/logging/rtc_event_log/rtc_event_log_unittest.cc @@ -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(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(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]); } } diff --git a/logging/rtc_event_log/rtc_event_log_unittest_helper.cc b/logging/rtc_event_log/rtc_event_log_unittest_helper.cc index 6532f9a406..5af8dfae60 100644 --- a/logging/rtc_event_log/rtc_event_log_unittest_helper.cc +++ b/logging/rtc_event_log/rtc_event_log_unittest_helper.cc @@ -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(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() != - logged_header.extension.hasTransmissionTimeOffset) - return false; + ASSERT_EQ(original_header.HasExtension(), + logged_header.extension.hasTransmissionTimeOffset); if (logged_header.extension.hasTransmissionTimeOffset) { int32_t offset; original_header.GetExtension(&offset); - if (offset != logged_header.extension.transmissionTimeOffset) - return false; + EXPECT_EQ(offset, logged_header.extension.transmissionTimeOffset); } // AbsoluteSendTime header extension. - if (original_header.HasExtension() != - logged_header.extension.hasAbsoluteSendTime) - return false; + ASSERT_EQ(original_header.HasExtension(), + logged_header.extension.hasAbsoluteSendTime); if (logged_header.extension.hasAbsoluteSendTime) { uint32_t sendtime; original_header.GetExtension(&sendtime); - if (sendtime != logged_header.extension.absoluteSendTime) - return false; + EXPECT_EQ(sendtime, logged_header.extension.absoluteSendTime); } // TransportSequenceNumber header extension. - if (original_header.HasExtension() != - logged_header.extension.hasTransportSequenceNumber) - return false; + ASSERT_EQ(original_header.HasExtension(), + logged_header.extension.hasTransportSequenceNumber); if (logged_header.extension.hasTransportSequenceNumber) { uint16_t seqnum; original_header.GetExtension(&seqnum); - if (seqnum != logged_header.extension.transportSequenceNumber) - return false; + EXPECT_EQ(seqnum, logged_header.extension.transportSequenceNumber); } // AudioLevel header extension. - if (original_header.HasExtension() != - logged_header.extension.hasAudioLevel) - return false; + ASSERT_EQ(original_header.HasExtension(), + logged_header.extension.hasAudioLevel); if (logged_header.extension.hasAudioLevel) { bool voice_activity; uint8_t audio_level; original_header.GetExtension(&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() != - logged_header.extension.hasVideoRotation) - return false; + ASSERT_EQ(original_header.HasExtension(), + logged_header.extension.hasVideoRotation); if (logged_header.extension.hasVideoRotation) { uint8_t rotation; original_header.GetExtension(&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 diff --git a/logging/rtc_event_log/rtc_event_log_unittest_helper.h b/logging/rtc_event_log/rtc_event_log_unittest_helper.h index f4d1876528..9c2457d9bd 100644 --- a/logging/rtc_event_log/rtc_event_log_unittest_helper.h +++ b/logging/rtc_event_log/rtc_event_log_unittest_helper.h @@ -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);