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(); const auto& alr_state_events = parsed_log_.alr_state_events();
ASSERT_EQ(alr_state_events.size(), 1u); 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( void RtcEventLogEncoderTest::TestRtcEventAudioNetworkAdaptation(
@ -186,7 +186,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventAudioPlayout) {
ASSERT_TRUE(playout_stream != playout_events.end()); ASSERT_TRUE(playout_stream != playout_events.end());
ASSERT_EQ(playout_stream->second.size(), 1u); ASSERT_EQ(playout_stream->second.size(), 1u);
LoggedAudioPlayoutEvent playout_event = playout_stream->second[0]; LoggedAudioPlayoutEvent playout_event = playout_stream->second[0];
EXPECT_TRUE(test::VerifyLoggedAudioPlayoutEvent(*event, playout_event)); test::VerifyLoggedAudioPlayoutEvent(*event, playout_event);
} }
TEST_P(RtcEventLogEncoderTest, RtcEventAudioReceiveStreamConfig) { TEST_P(RtcEventLogEncoderTest, RtcEventAudioReceiveStreamConfig) {
@ -201,7 +201,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventAudioReceiveStreamConfig) {
const auto& audio_recv_configs = parsed_log_.audio_recv_configs(); const auto& audio_recv_configs = parsed_log_.audio_recv_configs();
ASSERT_EQ(audio_recv_configs.size(), 1u); 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) { TEST_P(RtcEventLogEncoderTest, RtcEventAudioSendStreamConfig) {
@ -216,7 +216,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventAudioSendStreamConfig) {
const auto& audio_send_configs = parsed_log_.audio_send_configs(); const auto& audio_send_configs = parsed_log_.audio_send_configs();
ASSERT_EQ(audio_send_configs.size(), 1u); 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) { TEST_P(RtcEventLogEncoderTest, RtcEventBweUpdateDelayBased) {
@ -229,8 +229,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventBweUpdateDelayBased) {
const auto& bwe_delay_updates = parsed_log_.bwe_delay_updates(); const auto& bwe_delay_updates = parsed_log_.bwe_delay_updates();
ASSERT_EQ(bwe_delay_updates.size(), 1u); 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) { TEST_P(RtcEventLogEncoderTest, RtcEventBweUpdateLossBased) {
@ -243,8 +242,8 @@ TEST_P(RtcEventLogEncoderTest, RtcEventBweUpdateLossBased) {
const auto& bwe_loss_updates = parsed_log_.bwe_loss_updates(); const auto& bwe_loss_updates = parsed_log_.bwe_loss_updates();
ASSERT_EQ(bwe_loss_updates.size(), 1u); 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) { TEST_P(RtcEventLogEncoderTest, RtcEventIceCandidatePairConfig) {
@ -258,8 +257,8 @@ TEST_P(RtcEventLogEncoderTest, RtcEventIceCandidatePairConfig) {
parsed_log_.ice_candidate_pair_configs(); parsed_log_.ice_candidate_pair_configs();
ASSERT_EQ(ice_candidate_pair_configs.size(), 1u); ASSERT_EQ(ice_candidate_pair_configs.size(), 1u);
EXPECT_TRUE(test::VerifyLoggedIceCandidatePairConfig( test::VerifyLoggedIceCandidatePairConfig(*event,
*event, ice_candidate_pair_configs[0])); ice_candidate_pair_configs[0]);
} }
TEST_P(RtcEventLogEncoderTest, RtcEventIceCandidatePair) { TEST_P(RtcEventLogEncoderTest, RtcEventIceCandidatePair) {
@ -272,8 +271,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventIceCandidatePair) {
parsed_log_.ice_candidate_pair_events(); parsed_log_.ice_candidate_pair_events();
ASSERT_EQ(ice_candidate_pair_events.size(), 1u); ASSERT_EQ(ice_candidate_pair_events.size(), 1u);
EXPECT_TRUE(test::VerifyLoggedIceCandidatePairEvent( test::VerifyLoggedIceCandidatePairEvent(*event, ice_candidate_pair_events[0]);
*event, ice_candidate_pair_events[0]));
} }
TEST_P(RtcEventLogEncoderTest, RtcEventLoggingStarted) { TEST_P(RtcEventLogEncoderTest, RtcEventLoggingStarted) {
@ -307,8 +305,8 @@ TEST_P(RtcEventLogEncoderTest, RtcEventProbeClusterCreated) {
parsed_log_.bwe_probe_cluster_created_events(); parsed_log_.bwe_probe_cluster_created_events();
ASSERT_EQ(bwe_probe_cluster_created_events.size(), 1u); ASSERT_EQ(bwe_probe_cluster_created_events.size(), 1u);
EXPECT_TRUE(test::VerifyLoggedBweProbeClusterCreatedEvent( test::VerifyLoggedBweProbeClusterCreatedEvent(
*event, bwe_probe_cluster_created_events[0])); *event, bwe_probe_cluster_created_events[0]);
} }
TEST_P(RtcEventLogEncoderTest, RtcEventProbeResultFailure) { TEST_P(RtcEventLogEncoderTest, RtcEventProbeResultFailure) {
@ -321,8 +319,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventProbeResultFailure) {
const auto& bwe_probe_failure_events = parsed_log_.bwe_probe_failure_events(); const auto& bwe_probe_failure_events = parsed_log_.bwe_probe_failure_events();
ASSERT_EQ(bwe_probe_failure_events.size(), 1u); ASSERT_EQ(bwe_probe_failure_events.size(), 1u);
EXPECT_TRUE(test::VerifyLoggedBweProbeFailureEvent( test::VerifyLoggedBweProbeFailureEvent(*event, bwe_probe_failure_events[0]);
*event, bwe_probe_failure_events[0]));
} }
TEST_P(RtcEventLogEncoderTest, RtcEventProbeResultSuccess) { TEST_P(RtcEventLogEncoderTest, RtcEventProbeResultSuccess) {
@ -335,8 +332,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventProbeResultSuccess) {
const auto& bwe_probe_success_events = parsed_log_.bwe_probe_success_events(); const auto& bwe_probe_success_events = parsed_log_.bwe_probe_success_events();
ASSERT_EQ(bwe_probe_success_events.size(), 1u); ASSERT_EQ(bwe_probe_success_events.size(), 1u);
EXPECT_TRUE(test::VerifyLoggedBweProbeSuccessEvent( test::VerifyLoggedBweProbeSuccessEvent(*event, bwe_probe_success_events[0]);
*event, bwe_probe_success_events[0]));
} }
TEST_P(RtcEventLogEncoderTest, RtcEventRtcpPacketIncoming) { TEST_P(RtcEventLogEncoderTest, RtcEventRtcpPacketIncoming) {
@ -349,8 +345,8 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtcpPacketIncoming) {
const auto& incoming_rtcp_packets = parsed_log_.incoming_rtcp_packets(); const auto& incoming_rtcp_packets = parsed_log_.incoming_rtcp_packets();
ASSERT_EQ(incoming_rtcp_packets.size(), 1u); 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) { TEST_P(RtcEventLogEncoderTest, RtcEventRtcpPacketOutgoing) {
@ -363,8 +359,8 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtcpPacketOutgoing) {
const auto& outgoing_rtcp_packets = parsed_log_.outgoing_rtcp_packets(); const auto& outgoing_rtcp_packets = parsed_log_.outgoing_rtcp_packets();
ASSERT_EQ(outgoing_rtcp_packets.size(), 1u); 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) { TEST_P(RtcEventLogEncoderTest, RtcEventRtpPacketIncoming) {
@ -383,8 +379,8 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtpPacketIncoming) {
const auto& stream = incoming_rtp_packets_by_ssrc[0]; const auto& stream = incoming_rtp_packets_by_ssrc[0];
EXPECT_EQ(stream.ssrc, ssrc); EXPECT_EQ(stream.ssrc, ssrc);
ASSERT_EQ(stream.incoming_packets.size(), 1u); 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) { TEST_P(RtcEventLogEncoderTest, RtcEventRtpPacketOutgoing) {
@ -403,8 +399,8 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtpPacketOutgoing) {
const auto& stream = outgoing_rtp_packets_by_ssrc[0]; const auto& stream = outgoing_rtp_packets_by_ssrc[0];
EXPECT_EQ(stream.ssrc, ssrc); EXPECT_EQ(stream.ssrc, ssrc);
ASSERT_EQ(stream.outgoing_packets.size(), 1u); 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) { TEST_P(RtcEventLogEncoderTest, RtcEventVideoReceiveStreamConfig) {
@ -419,7 +415,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventVideoReceiveStreamConfig) {
const auto& video_recv_configs = parsed_log_.video_recv_configs(); const auto& video_recv_configs = parsed_log_.video_recv_configs();
ASSERT_EQ(video_recv_configs.size(), 1u); 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) { TEST_P(RtcEventLogEncoderTest, RtcEventVideoSendStreamConfig) {
@ -434,7 +430,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventVideoSendStreamConfig) {
const auto& video_send_configs = parsed_log_.video_send_configs(); const auto& video_send_configs = parsed_log_.video_send_configs();
ASSERT_EQ(video_send_configs.size(), 1u); 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, 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. // Start and stop events.
auto& parsed_start_log_events = parsed_log.start_log_events(); auto& parsed_start_log_events = parsed_log.start_log_events();
ASSERT_EQ(parsed_start_log_events.size(), static_cast<size_t>(1)); 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(); auto& parsed_stop_log_events = parsed_log.stop_log_events();
ASSERT_EQ(parsed_stop_log_events.size(), static_cast<size_t>(1)); 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(); auto& parsed_alr_state_events = parsed_log.alr_state_events();
ASSERT_EQ(parsed_alr_state_events.size(), alr_state_list_.size()); ASSERT_EQ(parsed_alr_state_events.size(), alr_state_list_.size());
for (size_t i = 0; i < parsed_alr_state_events.size(); i++) { for (size_t i = 0; i < parsed_alr_state_events.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedAlrStateEvent(*alr_state_list_[i], test::VerifyLoggedAlrStateEvent(*alr_state_list_[i],
parsed_alr_state_events[i])); parsed_alr_state_events[i]);
} }
const auto& parsed_audio_playout_map = parsed_log.audio_playout_events(); 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]; const auto& audio_playout_stream = audio_playout_map_[ssrc];
ASSERT_EQ(parsed_audio_playout_stream.size(), audio_playout_stream.size()); ASSERT_EQ(parsed_audio_playout_stream.size(), audio_playout_stream.size());
for (size_t i = 0; i < parsed_audio_playout_map.size(); i++) { for (size_t i = 0; i < parsed_audio_playout_map.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedAudioPlayoutEvent( test::VerifyLoggedAudioPlayoutEvent(*audio_playout_stream[i],
*audio_playout_stream[i], parsed_audio_playout_stream[i])); parsed_audio_playout_stream[i]);
} }
} }
@ -498,22 +496,22 @@ void RtcEventLogSession::ReadAndVerifyLog() {
ASSERT_EQ(parsed_audio_network_adaptation_events.size(), ASSERT_EQ(parsed_audio_network_adaptation_events.size(),
ana_configs_list_.size()); ana_configs_list_.size());
for (size_t i = 0; i < parsed_audio_network_adaptation_events.size(); i++) { for (size_t i = 0; i < parsed_audio_network_adaptation_events.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedAudioNetworkAdaptationEvent( test::VerifyLoggedAudioNetworkAdaptationEvent(
*ana_configs_list_[i], parsed_audio_network_adaptation_events[i])); *ana_configs_list_[i], parsed_audio_network_adaptation_events[i]);
} }
auto& parsed_bwe_delay_updates = parsed_log.bwe_delay_updates(); auto& parsed_bwe_delay_updates = parsed_log.bwe_delay_updates();
ASSERT_EQ(parsed_bwe_delay_updates.size(), bwe_delay_list_.size()); ASSERT_EQ(parsed_bwe_delay_updates.size(), bwe_delay_list_.size());
for (size_t i = 0; i < parsed_bwe_delay_updates.size(); i++) { for (size_t i = 0; i < parsed_bwe_delay_updates.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedBweDelayBasedUpdate( test::VerifyLoggedBweDelayBasedUpdate(*bwe_delay_list_[i],
*bwe_delay_list_[i], parsed_bwe_delay_updates[i])); parsed_bwe_delay_updates[i]);
} }
auto& parsed_bwe_loss_updates = parsed_log.bwe_loss_updates(); auto& parsed_bwe_loss_updates = parsed_log.bwe_loss_updates();
ASSERT_EQ(parsed_bwe_loss_updates.size(), bwe_loss_list_.size()); ASSERT_EQ(parsed_bwe_loss_updates.size(), bwe_loss_list_.size());
for (size_t i = 0; i < parsed_bwe_loss_updates.size(); i++) { for (size_t i = 0; i < parsed_bwe_loss_updates.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedBweLossBasedUpdate( test::VerifyLoggedBweLossBasedUpdate(*bwe_loss_list_[i],
*bwe_loss_list_[i], parsed_bwe_loss_updates[i])); parsed_bwe_loss_updates[i]);
} }
auto& parsed_bwe_probe_cluster_created_events = auto& parsed_bwe_probe_cluster_created_events =
@ -521,30 +519,30 @@ void RtcEventLogSession::ReadAndVerifyLog() {
ASSERT_EQ(parsed_bwe_probe_cluster_created_events.size(), ASSERT_EQ(parsed_bwe_probe_cluster_created_events.size(),
probe_creation_list_.size()); probe_creation_list_.size());
for (size_t i = 0; i < parsed_bwe_probe_cluster_created_events.size(); i++) { for (size_t i = 0; i < parsed_bwe_probe_cluster_created_events.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedBweProbeClusterCreatedEvent( test::VerifyLoggedBweProbeClusterCreatedEvent(
*probe_creation_list_[i], parsed_bwe_probe_cluster_created_events[i])); *probe_creation_list_[i], parsed_bwe_probe_cluster_created_events[i]);
} }
auto& parsed_bwe_probe_failure_events = parsed_log.bwe_probe_failure_events(); auto& parsed_bwe_probe_failure_events = parsed_log.bwe_probe_failure_events();
ASSERT_EQ(parsed_bwe_probe_failure_events.size(), probe_failure_list_.size()); 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++) { for (size_t i = 0; i < parsed_bwe_probe_failure_events.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedBweProbeFailureEvent( test::VerifyLoggedBweProbeFailureEvent(*probe_failure_list_[i],
*probe_failure_list_[i], parsed_bwe_probe_failure_events[i])); parsed_bwe_probe_failure_events[i]);
} }
auto& parsed_bwe_probe_success_events = parsed_log.bwe_probe_success_events(); auto& parsed_bwe_probe_success_events = parsed_log.bwe_probe_success_events();
ASSERT_EQ(parsed_bwe_probe_success_events.size(), probe_success_list_.size()); 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++) { for (size_t i = 0; i < parsed_bwe_probe_success_events.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedBweProbeSuccessEvent( test::VerifyLoggedBweProbeSuccessEvent(*probe_success_list_[i],
*probe_success_list_[i], parsed_bwe_probe_success_events[i])); parsed_bwe_probe_success_events[i]);
} }
auto& parsed_ice_candidate_pair_configs = auto& parsed_ice_candidate_pair_configs =
parsed_log.ice_candidate_pair_configs(); parsed_log.ice_candidate_pair_configs();
ASSERT_EQ(parsed_ice_candidate_pair_configs.size(), ice_config_list_.size()); 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++) { for (size_t i = 0; i < parsed_ice_candidate_pair_configs.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedIceCandidatePairConfig( test::VerifyLoggedIceCandidatePairConfig(
*ice_config_list_[i], parsed_ice_candidate_pair_configs[i])); *ice_config_list_[i], parsed_ice_candidate_pair_configs[i]);
} }
auto& parsed_ice_candidate_pair_events = auto& parsed_ice_candidate_pair_events =
@ -552,8 +550,8 @@ void RtcEventLogSession::ReadAndVerifyLog() {
ASSERT_EQ(parsed_ice_candidate_pair_events.size(), ASSERT_EQ(parsed_ice_candidate_pair_events.size(),
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++) { for (size_t i = 0; i < parsed_ice_candidate_pair_events.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedIceCandidatePairEvent( test::VerifyLoggedIceCandidatePairEvent(
*ice_event_list_[i], parsed_ice_candidate_pair_events[i])); *ice_event_list_[i], parsed_ice_candidate_pair_events[i]);
} }
auto& parsed_incoming_rtp_packets_by_ssrc = auto& parsed_incoming_rtp_packets_by_ssrc =
@ -566,8 +564,7 @@ void RtcEventLogSession::ReadAndVerifyLog() {
const auto& rtp_stream = incoming_rtp_map_[ssrc]; const auto& rtp_stream = incoming_rtp_map_[ssrc];
ASSERT_EQ(parsed_rtp_stream.size(), rtp_stream.size()); ASSERT_EQ(parsed_rtp_stream.size(), rtp_stream.size());
for (size_t i = 0; i < parsed_rtp_stream.size(); i++) { for (size_t i = 0; i < parsed_rtp_stream.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedRtpPacketIncoming(*rtp_stream[i], test::VerifyLoggedRtpPacketIncoming(*rtp_stream[i], parsed_rtp_stream[i]);
parsed_rtp_stream[i]));
} }
} }
@ -581,47 +578,46 @@ void RtcEventLogSession::ReadAndVerifyLog() {
const auto& rtp_stream = outgoing_rtp_map_[ssrc]; const auto& rtp_stream = outgoing_rtp_map_[ssrc];
ASSERT_EQ(parsed_rtp_stream.size(), rtp_stream.size()); ASSERT_EQ(parsed_rtp_stream.size(), rtp_stream.size());
for (size_t i = 0; i < parsed_rtp_stream.size(); i++) { for (size_t i = 0; i < parsed_rtp_stream.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedRtpPacketOutgoing(*rtp_stream[i], test::VerifyLoggedRtpPacketOutgoing(*rtp_stream[i], parsed_rtp_stream[i]);
parsed_rtp_stream[i]));
} }
} }
auto& parsed_incoming_rtcp_packets = parsed_log.incoming_rtcp_packets(); auto& parsed_incoming_rtcp_packets = parsed_log.incoming_rtcp_packets();
ASSERT_EQ(parsed_incoming_rtcp_packets.size(), incoming_rtcp_list_.size()); ASSERT_EQ(parsed_incoming_rtcp_packets.size(), incoming_rtcp_list_.size());
for (size_t i = 0; i < parsed_incoming_rtcp_packets.size(); i++) { for (size_t i = 0; i < parsed_incoming_rtcp_packets.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedRtcpPacketIncoming( test::VerifyLoggedRtcpPacketIncoming(*incoming_rtcp_list_[i],
*incoming_rtcp_list_[i], parsed_incoming_rtcp_packets[i])); parsed_incoming_rtcp_packets[i]);
} }
auto& parsed_outgoing_rtcp_packets = parsed_log.outgoing_rtcp_packets(); auto& parsed_outgoing_rtcp_packets = parsed_log.outgoing_rtcp_packets();
ASSERT_EQ(parsed_outgoing_rtcp_packets.size(), outgoing_rtcp_list_.size()); ASSERT_EQ(parsed_outgoing_rtcp_packets.size(), outgoing_rtcp_list_.size());
for (size_t i = 0; i < parsed_outgoing_rtcp_packets.size(); i++) { for (size_t i = 0; i < parsed_outgoing_rtcp_packets.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedRtcpPacketOutgoing( test::VerifyLoggedRtcpPacketOutgoing(*outgoing_rtcp_list_[i],
*outgoing_rtcp_list_[i], parsed_outgoing_rtcp_packets[i])); parsed_outgoing_rtcp_packets[i]);
} }
auto& parsed_audio_recv_configs = parsed_log.audio_recv_configs(); auto& parsed_audio_recv_configs = parsed_log.audio_recv_configs();
ASSERT_EQ(parsed_audio_recv_configs.size(), audio_recv_config_list_.size()); ASSERT_EQ(parsed_audio_recv_configs.size(), audio_recv_config_list_.size());
for (size_t i = 0; i < parsed_audio_recv_configs.size(); i++) { for (size_t i = 0; i < parsed_audio_recv_configs.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedAudioRecvConfig( test::VerifyLoggedAudioRecvConfig(*audio_recv_config_list_[i],
*audio_recv_config_list_[i], parsed_audio_recv_configs[i])); parsed_audio_recv_configs[i]);
} }
auto& parsed_audio_send_configs = parsed_log.audio_send_configs(); auto& parsed_audio_send_configs = parsed_log.audio_send_configs();
ASSERT_EQ(parsed_audio_send_configs.size(), audio_send_config_list_.size()); ASSERT_EQ(parsed_audio_send_configs.size(), audio_send_config_list_.size());
for (size_t i = 0; i < parsed_audio_send_configs.size(); i++) { for (size_t i = 0; i < parsed_audio_send_configs.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedAudioSendConfig( test::VerifyLoggedAudioSendConfig(*audio_send_config_list_[i],
*audio_send_config_list_[i], parsed_audio_send_configs[i])); parsed_audio_send_configs[i]);
} }
auto& parsed_video_recv_configs = parsed_log.video_recv_configs(); auto& parsed_video_recv_configs = parsed_log.video_recv_configs();
ASSERT_EQ(parsed_video_recv_configs.size(), video_recv_config_list_.size()); ASSERT_EQ(parsed_video_recv_configs.size(), video_recv_config_list_.size());
for (size_t i = 0; i < parsed_video_recv_configs.size(); i++) { for (size_t i = 0; i < parsed_video_recv_configs.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedVideoRecvConfig( test::VerifyLoggedVideoRecvConfig(*video_recv_config_list_[i],
*video_recv_config_list_[i], parsed_video_recv_configs[i])); parsed_video_recv_configs[i]);
} }
auto& parsed_video_send_configs = parsed_log.video_send_configs(); auto& parsed_video_send_configs = parsed_log.video_send_configs();
ASSERT_EQ(parsed_video_send_configs.size(), video_send_config_list_.size()); ASSERT_EQ(parsed_video_send_configs.size(), video_send_config_list_.size());
for (size_t i = 0; i < parsed_video_send_configs.size(); i++) { for (size_t i = 0; i < parsed_video_send_configs.size(); i++) {
EXPECT_TRUE(test::VerifyLoggedVideoSendConfig( test::VerifyLoggedVideoSendConfig(*video_send_config_list_[i],
*video_send_config_list_[i], parsed_video_send_configs[i])); parsed_video_send_configs[i]);
} }
// Clean up temporary file - can be pretty slow. // 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(); const auto& start_log_events = parsed_log.start_log_events();
ASSERT_EQ(start_log_events.size(), 1u); 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(); const auto& stop_log_events = parsed_log.stop_log_events();
ASSERT_EQ(stop_log_events.size(), 1u); 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(); const auto& probe_success_events = parsed_log.bwe_probe_success_events();
// If the following fails, it probably means that kNumEvents isn't larger // 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); fake_clock->SetTimeMicros(first_timestamp_us);
for (size_t i = 1; i < probe_success_events.size(); i++) { for (size_t i = 1; i < probe_success_events.size(); i++) {
fake_clock->AdvanceTimeMicros(10000); fake_clock->AdvanceTimeMicros(10000);
ASSERT_TRUE(test::VerifyLoggedBweProbeSuccessEvent( test::VerifyLoggedBweProbeSuccessEvent(
RtcEventProbeResultSuccess(first_id + i, first_bitrate_bps + i * 1000), RtcEventProbeResultSuccess(first_id + i, first_bitrate_bps + i * 1000),
probe_success_events[i])); probe_success_events[i]);
} }
} }

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

40
logging/rtc_event_log/rtc_event_log_unittest_helper.h
View File

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