From e78b465d458a329f360e1022ef4b5aa221cc4557 Mon Sep 17 00:00:00 2001 From: Bjorn Terelius Date: Tue, 13 Nov 2018 11:19:18 +0100 Subject: [PATCH] Add version and UTC time fields to RTC event log. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bug: webrtc:8111 Change-Id: I843e1f8e50e4d4faf74819e0104aeb4fb869b834 Reviewed-on: https://webrtc-review.googlesource.com/c/110721 Reviewed-by: Elad Alon Commit-Queue: Björn Terelius Cr-Commit-Position: refs/heads/master@{#25658} --- .../encoder/rtc_event_log_encoder.h | 3 +- .../encoder/rtc_event_log_encoder_legacy.cc | 3 +- .../encoder/rtc_event_log_encoder_legacy.h | 3 +- .../rtc_event_log_encoder_new_format.cc | 5 +- .../rtc_event_log_encoder_new_format.h | 3 +- .../encoder/rtc_event_log_encoder_unittest.cc | 145 +++++++++--------- logging/rtc_event_log/rtc_event_log2.proto | 6 + logging/rtc_event_log/rtc_event_log_impl.cc | 7 +- .../rtc_event_log/rtc_event_log_parser_new.cc | 6 +- .../rtc_event_log/rtc_event_log_parser_new.h | 6 +- .../rtc_event_log/rtc_event_log_unittest.cc | 89 ++++++----- .../rtc_event_log_unittest_helper.cc | 87 ++++++----- .../rtc_event_log_unittest_helper.h | 144 ++++++++++------- 13 files changed, 283 insertions(+), 224 deletions(-) diff --git a/logging/rtc_event_log/encoder/rtc_event_log_encoder.h b/logging/rtc_event_log/encoder/rtc_event_log_encoder.h index beb711c9dd..6ce750f67e 100644 --- a/logging/rtc_event_log/encoder/rtc_event_log_encoder.h +++ b/logging/rtc_event_log/encoder/rtc_event_log_encoder.h @@ -22,7 +22,8 @@ class RtcEventLogEncoder { public: virtual ~RtcEventLogEncoder() = default; - virtual std::string EncodeLogStart(int64_t timestamp_us) = 0; + virtual std::string EncodeLogStart(int64_t timestamp_us, + int64_t utc_time_us) = 0; virtual std::string EncodeLogEnd(int64_t timestamp_us) = 0; virtual std::string EncodeBatch( diff --git a/logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.cc b/logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.cc index c60b2111ce..29636ede92 100644 --- a/logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.cc +++ b/logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.cc @@ -222,7 +222,8 @@ ConvertIceCandidatePairEventType(IceCandidatePairEventType type) { } // namespace -std::string RtcEventLogEncoderLegacy::EncodeLogStart(int64_t timestamp_us) { +std::string RtcEventLogEncoderLegacy::EncodeLogStart(int64_t timestamp_us, + int64_t utc_time_us) { rtclog::Event rtclog_event; rtclog_event.set_timestamp_us(timestamp_us); rtclog_event.set_type(rtclog::Event::LOG_START); diff --git a/logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.h b/logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.h index fd109f41e0..3105dc1e68 100644 --- a/logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.h +++ b/logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.h @@ -50,7 +50,8 @@ class RtcEventLogEncoderLegacy final : public RtcEventLogEncoder { public: ~RtcEventLogEncoderLegacy() override = default; - std::string EncodeLogStart(int64_t timestamp_us) override; + std::string EncodeLogStart(int64_t timestamp_us, + int64_t utc_time_us) override; std::string EncodeLogEnd(int64_t timestamp_us) override; std::string EncodeBatch( diff --git a/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc b/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc index b8cb747607..a5cd177fb6 100644 --- a/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc +++ b/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc @@ -615,10 +615,13 @@ void EncodeRtpPacket(const std::vector& batch, } } // namespace -std::string RtcEventLogEncoderNewFormat::EncodeLogStart(int64_t timestamp_us) { +std::string RtcEventLogEncoderNewFormat::EncodeLogStart(int64_t timestamp_us, + int64_t utc_time_us) { rtclog2::EventStream event_stream; rtclog2::BeginLogEvent* proto_batch = event_stream.add_begin_log_events(); proto_batch->set_timestamp_ms(timestamp_us / 1000); + proto_batch->set_version(2); + proto_batch->set_utc_time_ms(utc_time_us / 1000); return event_stream.SerializeAsString(); } diff --git a/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.h b/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.h index d9a3f0a337..7dfa490114 100644 --- a/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.h +++ b/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.h @@ -56,7 +56,8 @@ class RtcEventLogEncoderNewFormat final : public RtcEventLogEncoder { std::deque>::const_iterator begin, std::deque>::const_iterator end) override; - std::string EncodeLogStart(int64_t timestamp_us) override; + std::string EncodeLogStart(int64_t timestamp_us, + int64_t utc_time_us) override; std::string EncodeLogEnd(int64_t timestamp_us) override; private: 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 b29237e850..856bec66e7 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 @@ -47,10 +47,12 @@ class RtcEventLogEncoderTest RtcEventLogEncoderTest() : seed_(std::get<0>(GetParam())), prng_(seed_), - gen_(seed_ * 880001UL), new_encoding_(std::get<1>(GetParam())), event_count_(std::get<2>(GetParam())), - force_repeated_fields_(std::get<3>(GetParam())) { + force_repeated_fields_(std::get<3>(GetParam())), + gen_(seed_ * 880001UL), + verifier_(new_encoding_ ? RtcEventLog::EncodingType::NewFormat + : RtcEventLog::EncodingType::Legacy) { if (new_encoding_) encoder_ = absl::make_unique(); else @@ -70,8 +72,9 @@ class RtcEventLogEncoderTest const RtpHeaderExtensionMap& extension_map); template - const std::vector& GetRtpPacketsBySsrc( - const ParsedRtcEventLogNew* parsed_log); + const std::vector* GetRtpPacketsBySsrc( + const ParsedRtcEventLogNew* parsed_log, + uint32_t ssrc); template void TestRtpPackets(); @@ -81,10 +84,11 @@ class RtcEventLogEncoderTest ParsedRtcEventLogNew parsed_log_; const uint64_t seed_; Random prng_; - test::EventGenerator gen_; const bool new_encoding_; const size_t event_count_; const bool force_repeated_fields_; + test::EventGenerator gen_; + test::EventVerifier verifier_; }; void RtcEventLogEncoderTest::TestRtcEventAudioNetworkAdaptation( @@ -102,7 +106,8 @@ void RtcEventLogEncoderTest::TestRtcEventAudioNetworkAdaptation( ASSERT_EQ(ana_configs.size(), events.size()); for (size_t i = 0; i < events.size(); ++i) { - test::VerifyLoggedAudioNetworkAdaptationEvent(*events[i], ana_configs[i]); + verifier_.VerifyLoggedAudioNetworkAdaptationEvent(*events[i], + ana_configs[i]); } } @@ -121,44 +126,31 @@ std::unique_ptr RtcEventLogEncoderTest::NewRtpPacket( } template <> -const std::vector& +const std::vector* RtcEventLogEncoderTest::GetRtpPacketsBySsrc( - const ParsedRtcEventLogNew* parsed_log) { - return parsed_log->incoming_rtp_packets_by_ssrc(); + const ParsedRtcEventLogNew* parsed_log, + uint32_t ssrc) { + const auto& incoming_streams = parsed_log->incoming_rtp_packets_by_ssrc(); + for (const auto& stream : incoming_streams) { + if (stream.ssrc == ssrc) { + return &stream.incoming_packets; + } + } + return nullptr; } template <> -const std::vector& +const std::vector* RtcEventLogEncoderTest::GetRtpPacketsBySsrc( - const ParsedRtcEventLogNew* parsed_log) { - return parsed_log->outgoing_rtp_packets_by_ssrc(); -} - -template -void CompareRtpPacketSequences( - const std::vector>& original_events, - const ParsedType& parsed_events); - -template <> -void CompareRtpPacketSequences( - const std::vector>& original, - const ParsedRtcEventLogNew::LoggedRtpStreamIncoming& parsed) { - ASSERT_EQ(parsed.incoming_packets.size(), original.size()); - for (size_t i = 0; i < original.size(); ++i) { - test::VerifyLoggedRtpPacketIncoming(*original[i], - parsed.incoming_packets[i]); - } -} - -template <> -void CompareRtpPacketSequences( - const std::vector>& original, - const ParsedRtcEventLogNew::LoggedRtpStreamOutgoing& parsed) { - ASSERT_EQ(parsed.outgoing_packets.size(), original.size()); - for (size_t i = 0; i < original.size(); ++i) { - test::VerifyLoggedRtpPacketOutgoing(*original[i], - parsed.outgoing_packets[i]); + const ParsedRtcEventLogNew* parsed_log, + uint32_t ssrc) { + const auto& outgoing_streams = parsed_log->outgoing_rtp_packets_by_ssrc(); + for (const auto& stream : outgoing_streams) { + if (stream.ssrc == ssrc) { + return &stream.outgoing_packets; + } } + return nullptr; } template @@ -193,20 +185,19 @@ void RtcEventLogEncoderTest::TestRtpPackets() { std::string encoded = encoder_->EncodeBatch(history_.begin(), history_.end()); ASSERT_TRUE(parsed_log_.ParseString(encoded)); - // Expect as many distinct SSRCs to be parsed, as were simulated. - const std::vector& parsed_rtp_packets = - GetRtpPacketsBySsrc(&parsed_log_); - ASSERT_EQ(parsed_rtp_packets.size(), events_by_ssrc.size()); - // For each SSRC, make sure the RTP packets associated with it to have been // correctly encoded and parsed. for (auto it = events_by_ssrc.begin(); it != events_by_ssrc.end(); ++it) { const uint32_t ssrc = it->first; - auto parsed = std::find_if( - parsed_rtp_packets.begin(), parsed_rtp_packets.end(), - [ssrc](const ParsedType& packet) { return packet.ssrc == ssrc; }); - ASSERT_NE(parsed, parsed_rtp_packets.end()); - CompareRtpPacketSequences(it->second, *parsed); + const auto& original_packets = it->second; + const std::vector* parsed_rtp_packets = + GetRtpPacketsBySsrc(&parsed_log_, ssrc); + ASSERT_NE(parsed_rtp_packets, nullptr); + ASSERT_EQ(original_packets.size(), parsed_rtp_packets->size()); + for (size_t i = 0; i < original_packets.size(); ++i) { + verifier_.VerifyLoggedRtpPacket( + *original_packets[i], (*parsed_rtp_packets)[i]); + } } } @@ -224,7 +215,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventAlrState) { ASSERT_EQ(alr_state_events.size(), event_count_); for (size_t i = 0; i < event_count_; ++i) { - test::VerifyLoggedAlrStateEvent(*events[i], alr_state_events[i]); + verifier_.VerifyLoggedAlrStateEvent(*events[i], alr_state_events[i]); } } @@ -394,8 +385,8 @@ TEST_P(RtcEventLogEncoderTest, RtcEventAudioPlayout) { ASSERT_EQ(original_playout_events.size(), parsed_playout_events.size()); for (size_t i = 0; i < original_playout_events.size(); ++i) { - test::VerifyLoggedAudioPlayoutEvent(*original_playout_events[i], - parsed_playout_events[i]); + verifier_.VerifyLoggedAudioPlayoutEvent(*original_playout_events[i], + parsed_playout_events[i]); } } } @@ -413,7 +404,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventAudioReceiveStreamConfig) { const auto& audio_recv_configs = parsed_log_.audio_recv_configs(); ASSERT_EQ(audio_recv_configs.size(), 1u); - test::VerifyLoggedAudioRecvConfig(*event, audio_recv_configs[0]); + verifier_.VerifyLoggedAudioRecvConfig(*event, audio_recv_configs[0]); } // TODO(eladalon/terelius): Test with multiple events in the batch. @@ -429,7 +420,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventAudioSendStreamConfig) { const auto& audio_send_configs = parsed_log_.audio_send_configs(); ASSERT_EQ(audio_send_configs.size(), 1u); - test::VerifyLoggedAudioSendConfig(*event, audio_send_configs[0]); + verifier_.VerifyLoggedAudioSendConfig(*event, audio_send_configs[0]); } TEST_P(RtcEventLogEncoderTest, RtcEventBweUpdateDelayBased) { @@ -449,7 +440,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventBweUpdateDelayBased) { ASSERT_EQ(bwe_delay_updates.size(), event_count_); for (size_t i = 0; i < event_count_; ++i) { - test::VerifyLoggedBweDelayBasedUpdate(*events[i], bwe_delay_updates[i]); + verifier_.VerifyLoggedBweDelayBasedUpdate(*events[i], bwe_delay_updates[i]); } } @@ -469,7 +460,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventBweUpdateLossBased) { ASSERT_EQ(bwe_loss_updates.size(), event_count_); for (size_t i = 0; i < event_count_; ++i) { - test::VerifyLoggedBweLossBasedUpdate(*events[i], bwe_loss_updates[i]); + verifier_.VerifyLoggedBweLossBasedUpdate(*events[i], bwe_loss_updates[i]); } } @@ -485,8 +476,8 @@ TEST_P(RtcEventLogEncoderTest, RtcEventIceCandidatePairConfig) { parsed_log_.ice_candidate_pair_configs(); ASSERT_EQ(ice_candidate_pair_configs.size(), 1u); - test::VerifyLoggedIceCandidatePairConfig(*event, - ice_candidate_pair_configs[0]); + verifier_.VerifyLoggedIceCandidatePairConfig(*event, + ice_candidate_pair_configs[0]); } // TODO(eladalon/terelius): Test with multiple events in the batch. @@ -500,23 +491,23 @@ TEST_P(RtcEventLogEncoderTest, RtcEventIceCandidatePair) { parsed_log_.ice_candidate_pair_events(); ASSERT_EQ(ice_candidate_pair_events.size(), 1u); - test::VerifyLoggedIceCandidatePairEvent(*event, ice_candidate_pair_events[0]); + verifier_.VerifyLoggedIceCandidatePairEvent(*event, + ice_candidate_pair_events[0]); } -// TODO(eladalon/terelius): Test with multiple events in the batch, or prevent -// it from happening. TEST_P(RtcEventLogEncoderTest, RtcEventLoggingStarted) { const int64_t timestamp_us = rtc::TimeMicros(); + const int64_t utc_time_us = rtc::TimeUTCMicros(); - ASSERT_TRUE(parsed_log_.ParseString(encoder_->EncodeLogStart(timestamp_us))); + ASSERT_TRUE(parsed_log_.ParseString( + encoder_->EncodeLogStart(timestamp_us, utc_time_us))); const auto& start_log_events = parsed_log_.start_log_events(); ASSERT_EQ(start_log_events.size(), 1u); - test::VerifyLoggedStartEvent(timestamp_us, start_log_events[0]); + verifier_.VerifyLoggedStartEvent(timestamp_us, utc_time_us, + start_log_events[0]); } -// TODO(eladalon/terelius): Test with multiple events in the batch, or prevent -// it from happening. TEST_P(RtcEventLogEncoderTest, RtcEventLoggingStopped) { const int64_t timestamp_us = rtc::TimeMicros(); @@ -524,7 +515,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventLoggingStopped) { const auto& stop_log_events = parsed_log_.stop_log_events(); ASSERT_EQ(stop_log_events.size(), 1u); - test::VerifyLoggedStopEvent(timestamp_us, stop_log_events[0]); + verifier_.VerifyLoggedStopEvent(timestamp_us, stop_log_events[0]); } // TODO(eladalon/terelius): Test with multiple events in the batch. @@ -539,7 +530,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventProbeClusterCreated) { parsed_log_.bwe_probe_cluster_created_events(); ASSERT_EQ(bwe_probe_cluster_created_events.size(), 1u); - test::VerifyLoggedBweProbeClusterCreatedEvent( + verifier_.VerifyLoggedBweProbeClusterCreatedEvent( *event, bwe_probe_cluster_created_events[0]); } @@ -554,7 +545,8 @@ TEST_P(RtcEventLogEncoderTest, RtcEventProbeResultFailure) { const auto& bwe_probe_failure_events = parsed_log_.bwe_probe_failure_events(); ASSERT_EQ(bwe_probe_failure_events.size(), 1u); - test::VerifyLoggedBweProbeFailureEvent(*event, bwe_probe_failure_events[0]); + verifier_.VerifyLoggedBweProbeFailureEvent(*event, + bwe_probe_failure_events[0]); } // TODO(eladalon/terelius): Test with multiple events in the batch. @@ -568,7 +560,8 @@ TEST_P(RtcEventLogEncoderTest, RtcEventProbeResultSuccess) { const auto& bwe_probe_success_events = parsed_log_.bwe_probe_success_events(); ASSERT_EQ(bwe_probe_success_events.size(), 1u); - test::VerifyLoggedBweProbeSuccessEvent(*event, bwe_probe_success_events[0]); + verifier_.VerifyLoggedBweProbeSuccessEvent(*event, + bwe_probe_success_events[0]); } TEST_P(RtcEventLogEncoderTest, RtcEventRtcpPacketIncoming) { @@ -593,7 +586,8 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtcpPacketIncoming) { ASSERT_EQ(incoming_rtcp_packets.size(), event_count_); for (size_t i = 0; i < event_count_; ++i) { - test::VerifyLoggedRtcpPacketIncoming(*events[i], incoming_rtcp_packets[i]); + verifier_.VerifyLoggedRtcpPacketIncoming(*events[i], + incoming_rtcp_packets[i]); } } @@ -613,18 +607,17 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtcpPacketOutgoing) { ASSERT_EQ(outgoing_rtcp_packets.size(), event_count_); for (size_t i = 0; i < event_count_; ++i) { - test::VerifyLoggedRtcpPacketOutgoing(*events[i], outgoing_rtcp_packets[i]); + verifier_.VerifyLoggedRtcpPacketOutgoing(*events[i], + outgoing_rtcp_packets[i]); } } TEST_P(RtcEventLogEncoderTest, RtcEventRtpPacketIncoming) { - TestRtpPackets(); + TestRtpPackets(); } TEST_P(RtcEventLogEncoderTest, RtcEventRtpPacketOutgoing) { - TestRtpPackets(); + TestRtpPackets(); } // TODO(eladalon/terelius): Test with multiple events in the batch. @@ -640,7 +633,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventVideoReceiveStreamConfig) { const auto& video_recv_configs = parsed_log_.video_recv_configs(); ASSERT_EQ(video_recv_configs.size(), 1u); - test::VerifyLoggedVideoRecvConfig(*event, video_recv_configs[0]); + verifier_.VerifyLoggedVideoRecvConfig(*event, video_recv_configs[0]); } // TODO(eladalon/terelius): Test with multiple events in the batch. @@ -656,7 +649,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventVideoSendStreamConfig) { const auto& video_send_configs = parsed_log_.video_send_configs(); ASSERT_EQ(video_send_configs.size(), 1u); - test::VerifyLoggedVideoSendConfig(*event, video_send_configs[0]); + verifier_.VerifyLoggedVideoSendConfig(*event, video_send_configs[0]); } INSTANTIATE_TEST_CASE_P( diff --git a/logging/rtc_event_log/rtc_event_log2.proto b/logging/rtc_event_log/rtc_event_log2.proto index 4e0e104280..adaefd64cf 100644 --- a/logging/rtc_event_log/rtc_event_log2.proto +++ b/logging/rtc_event_log/rtc_event_log2.proto @@ -230,6 +230,12 @@ message AudioPlayoutEvents { message BeginLogEvent { // required optional int64 timestamp_ms = 1; + + // required + optional uint32 version = 2; + + // required + optional int64 utc_time_ms = 3; } message EndLogEvent { diff --git a/logging/rtc_event_log/rtc_event_log_impl.cc b/logging/rtc_event_log/rtc_event_log_impl.cc index 2954467713..c022a3d418 100644 --- a/logging/rtc_event_log/rtc_event_log_impl.cc +++ b/logging/rtc_event_log/rtc_event_log_impl.cc @@ -173,20 +173,19 @@ bool RtcEventLogImpl::StartLogging(std::unique_ptr output, return false; } - // TODO(terelius): The mapping between log timestamps and UTC should be stored - // in the event_log START event. const int64_t timestamp_us = rtc::TimeMicros(); const int64_t utc_time_us = rtc::TimeUTCMicros(); RTC_LOG(LS_INFO) << "Starting WebRTC event log. (Timestamp, UTC) = " << "(" << timestamp_us << ", " << utc_time_us << ")."; // Binding to |this| is safe because |this| outlives the |task_queue_|. - auto start = [this, timestamp_us](std::unique_ptr output) { + auto start = [this, timestamp_us, + utc_time_us](std::unique_ptr output) { RTC_DCHECK_RUN_ON(task_queue_.get()); RTC_DCHECK(output->IsActive()); event_output_ = std::move(output); num_config_events_written_ = 0; - WriteToOutput(event_encoder_->EncodeLogStart(timestamp_us)); + WriteToOutput(event_encoder_->EncodeLogStart(timestamp_us, utc_time_us)); LogEventsFromMemoryToOutput(); }; diff --git a/logging/rtc_event_log/rtc_event_log_parser_new.cc b/logging/rtc_event_log/rtc_event_log_parser_new.cc index 9fce8401cf..0107722baa 100644 --- a/logging/rtc_event_log/rtc_event_log_parser_new.cc +++ b/logging/rtc_event_log/rtc_event_log_parser_new.cc @@ -1943,7 +1943,11 @@ void ParsedRtcEventLogNew::StoreOutgoingRtcpPackets( void ParsedRtcEventLogNew::StoreStartEvent( const rtclog2::BeginLogEvent& proto) { RTC_CHECK(proto.has_timestamp_ms()); - LoggedStartEvent start_event(proto.timestamp_ms() * 1000); + RTC_CHECK(proto.has_version()); + RTC_CHECK(proto.has_utc_time_ms()); + RTC_CHECK_EQ(proto.version(), 2); + LoggedStartEvent start_event(proto.timestamp_ms() * 1000, + proto.utc_time_ms()); start_log_events_.push_back(start_event); } diff --git a/logging/rtc_event_log/rtc_event_log_parser_new.h b/logging/rtc_event_log/rtc_event_log_parser_new.h index 7eb2237af2..50e3b9922d 100644 --- a/logging/rtc_event_log/rtc_event_log_parser_new.h +++ b/logging/rtc_event_log/rtc_event_log_parser_new.h @@ -369,12 +369,16 @@ struct LoggedRtcpPacketTransportFeedback { struct LoggedStartEvent { explicit LoggedStartEvent(int64_t timestamp_us) - : timestamp_us(timestamp_us) {} + : LoggedStartEvent(timestamp_us, timestamp_us / 1000) {} + + LoggedStartEvent(int64_t timestamp_us, int64_t utc_start_time_ms) + : timestamp_us(timestamp_us), utc_start_time_ms(utc_start_time_ms) {} int64_t log_time_us() const { return timestamp_us; } int64_t log_time_ms() const { return timestamp_us / 1000; } int64_t timestamp_us; + int64_t utc_start_time_ms; }; struct LoggedStopEvent { diff --git a/logging/rtc_event_log/rtc_event_log_unittest.cc b/logging/rtc_event_log/rtc_event_log_unittest.cc index bd136bb77b..f7b7898993 100644 --- a/logging/rtc_event_log/rtc_event_log_unittest.cc +++ b/logging/rtc_event_log/rtc_event_log_unittest.cc @@ -107,9 +107,10 @@ class RtcEventLogSession RtcEventLogSession() : seed_(std::get<0>(GetParam())), prng_(seed_), - gen_(seed_ * 880001UL), output_period_ms_(std::get<1>(GetParam())), - encoding_type_(std::get<2>(GetParam())) { + encoding_type_(std::get<2>(GetParam())), + gen_(seed_ * 880001UL), + verifier_(encoding_type_) { clock_.SetTimeMicros(prng_.Rand()); // Find the name of the current test, in order to use it as a temporary // filename. @@ -168,13 +169,15 @@ class RtcEventLogSession std::vector> outgoing_rtcp_list_; int64_t start_time_us_; + int64_t utc_start_time_us_; int64_t stop_time_us_; const uint64_t seed_; Random prng_; - test::EventGenerator gen_; const int64_t output_period_ms_; const RtcEventLog::EncodingType encoding_type_; + test::EventGenerator gen_; + test::EventVerifier verifier_; rtc::ScopedFakeClock clock_; std::string temp_filename_; }; @@ -308,6 +311,7 @@ void RtcEventLogSession::WriteLog(EventCounts count, absl::make_unique(temp_filename_, 10000000), output_period_ms_); start_time_us_ = rtc::TimeMicros(); + utc_start_time_us_ = rtc::TimeUTCMicros(); } clock_.AdvanceTimeMicros(prng_.Rand(20) * 1000); @@ -467,17 +471,18 @@ 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)); - test::VerifyLoggedStartEvent(start_time_us_, parsed_start_log_events[0]); + verifier_.VerifyLoggedStartEvent(start_time_us_, utc_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)); - test::VerifyLoggedStopEvent(stop_time_us_, parsed_stop_log_events[0]); + verifier_.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++) { - test::VerifyLoggedAlrStateEvent(*alr_state_list_[i], - parsed_alr_state_events[i]); + verifier_.VerifyLoggedAlrStateEvent(*alr_state_list_[i], + parsed_alr_state_events[i]); } const auto& parsed_audio_playout_map = parsed_log.audio_playout_events(); @@ -488,8 +493,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++) { - test::VerifyLoggedAudioPlayoutEvent(*audio_playout_stream[i], - parsed_audio_playout_stream[i]); + verifier_.VerifyLoggedAudioPlayoutEvent(*audio_playout_stream[i], + parsed_audio_playout_stream[i]); } } @@ -498,22 +503,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++) { - test::VerifyLoggedAudioNetworkAdaptationEvent( + verifier_.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++) { - test::VerifyLoggedBweDelayBasedUpdate(*bwe_delay_list_[i], - parsed_bwe_delay_updates[i]); + verifier_.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++) { - test::VerifyLoggedBweLossBasedUpdate(*bwe_loss_list_[i], - parsed_bwe_loss_updates[i]); + verifier_.VerifyLoggedBweLossBasedUpdate(*bwe_loss_list_[i], + parsed_bwe_loss_updates[i]); } auto& parsed_bwe_probe_cluster_created_events = @@ -521,29 +526,29 @@ 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++) { - test::VerifyLoggedBweProbeClusterCreatedEvent( + verifier_.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++) { - test::VerifyLoggedBweProbeFailureEvent(*probe_failure_list_[i], - parsed_bwe_probe_failure_events[i]); + verifier_.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++) { - test::VerifyLoggedBweProbeSuccessEvent(*probe_success_list_[i], - parsed_bwe_probe_success_events[i]); + verifier_.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++) { - test::VerifyLoggedIceCandidatePairConfig( + verifier_.VerifyLoggedIceCandidatePairConfig( *ice_config_list_[i], parsed_ice_candidate_pair_configs[i]); } @@ -552,7 +557,7 @@ 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++) { - test::VerifyLoggedIceCandidatePairEvent( + verifier_.VerifyLoggedIceCandidatePairEvent( *ice_event_list_[i], parsed_ice_candidate_pair_events[i]); } @@ -566,7 +571,8 @@ 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++) { - test::VerifyLoggedRtpPacketIncoming(*rtp_stream[i], parsed_rtp_stream[i]); + verifier_.VerifyLoggedRtpPacketIncoming(*rtp_stream[i], + parsed_rtp_stream[i]); } } @@ -580,46 +586,47 @@ 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++) { - test::VerifyLoggedRtpPacketOutgoing(*rtp_stream[i], parsed_rtp_stream[i]); + verifier_.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++) { - test::VerifyLoggedRtcpPacketIncoming(*incoming_rtcp_list_[i], - parsed_incoming_rtcp_packets[i]); + verifier_.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++) { - test::VerifyLoggedRtcpPacketOutgoing(*outgoing_rtcp_list_[i], - parsed_outgoing_rtcp_packets[i]); + verifier_.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++) { - test::VerifyLoggedAudioRecvConfig(*audio_recv_config_list_[i], - parsed_audio_recv_configs[i]); + verifier_.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++) { - test::VerifyLoggedAudioSendConfig(*audio_send_config_list_[i], - parsed_audio_send_configs[i]); + verifier_.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++) { - test::VerifyLoggedVideoRecvConfig(*video_recv_config_list_[i], - parsed_video_recv_configs[i]); + verifier_.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++) { - test::VerifyLoggedVideoSendConfig(*video_send_config_list_[i], - parsed_video_send_configs[i]); + verifier_.VerifyLoggedVideoSendConfig(*video_send_config_list_[i], + parsed_video_send_configs[i]); } // Clean up temporary file - can be pretty slow. @@ -690,8 +697,10 @@ INSTANTIATE_TEST_CASE_P( class RtcEventLogCircularBufferTest : public ::testing::TestWithParam { public: - RtcEventLogCircularBufferTest() : encoding_type_(GetParam()) {} + RtcEventLogCircularBufferTest() + : encoding_type_(GetParam()), verifier_(encoding_type_) {} const RtcEventLog::EncodingType encoding_type_; + const test::EventVerifier verifier_; }; TEST_P(RtcEventLogCircularBufferTest, KeepsMostRecentEvents) { @@ -727,6 +736,7 @@ TEST_P(RtcEventLogCircularBufferTest, KeepsMostRecentEvents) { fake_clock->AdvanceTimeMicros(10000); } int64_t start_time_us = rtc::TimeMicros(); + int64_t utc_start_time_us = rtc::TimeUTCMicros(); log_dumper->StartLogging( absl::make_unique(temp_filename, 10000000), RtcEventLog::kImmediateOutput); @@ -740,11 +750,12 @@ TEST_P(RtcEventLogCircularBufferTest, KeepsMostRecentEvents) { const auto& start_log_events = parsed_log.start_log_events(); ASSERT_EQ(start_log_events.size(), 1u); - test::VerifyLoggedStartEvent(start_time_us, start_log_events[0]); + verifier_.VerifyLoggedStartEvent(start_time_us, utc_start_time_us, + start_log_events[0]); const auto& stop_log_events = parsed_log.stop_log_events(); ASSERT_EQ(stop_log_events.size(), 1u); - test::VerifyLoggedStopEvent(stop_time_us, stop_log_events[0]); + verifier_.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 @@ -765,7 +776,7 @@ TEST_P(RtcEventLogCircularBufferTest, KeepsMostRecentEvents) { fake_clock->SetTimeMicros(first_timestamp_us); for (size_t i = 1; i < probe_success_events.size(); i++) { fake_clock->AdvanceTimeMicros(10000); - test::VerifyLoggedBweProbeSuccessEvent( + verifier_.VerifyLoggedBweProbeSuccessEvent( RtcEventProbeResultSuccess(first_id + i, first_bitrate_bps + i * 1000), 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 215c986287..a0c5d3205c 100644 --- a/logging/rtc_event_log/rtc_event_log_unittest_helper.cc +++ b/logging/rtc_event_log/rtc_event_log_unittest_helper.cc @@ -501,22 +501,23 @@ EventGenerator::NewVideoSendStreamConfig( return absl::make_unique(std::move(config)); } -void VerifyLoggedAlrStateEvent(const RtcEventAlrState& original_event, - const LoggedAlrStateEvent& logged_event) { +void EventVerifier::VerifyLoggedAlrStateEvent( + const RtcEventAlrState& original_event, + const LoggedAlrStateEvent& logged_event) const { EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms()); EXPECT_EQ(original_event.in_alr(), logged_event.in_alr); } -void VerifyLoggedAudioPlayoutEvent( +void EventVerifier::VerifyLoggedAudioPlayoutEvent( const RtcEventAudioPlayout& original_event, - const LoggedAudioPlayoutEvent& logged_event) { + const LoggedAudioPlayoutEvent& logged_event) const { EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms()); EXPECT_EQ(original_event.ssrc(), logged_event.ssrc); } -void VerifyLoggedAudioNetworkAdaptationEvent( +void EventVerifier::VerifyLoggedAudioNetworkAdaptationEvent( const RtcEventAudioNetworkAdaptation& original_event, - const LoggedAudioNetworkAdaptationEvent& logged_event) { + const LoggedAudioNetworkAdaptationEvent& logged_event) const { EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms()); EXPECT_EQ(original_event.config().bitrate_bps, @@ -541,26 +542,26 @@ void VerifyLoggedAudioNetworkAdaptationEvent( } } -void VerifyLoggedBweDelayBasedUpdate( +void EventVerifier::VerifyLoggedBweDelayBasedUpdate( const RtcEventBweUpdateDelayBased& original_event, - const LoggedBweDelayBasedUpdate& logged_event) { + const LoggedBweDelayBasedUpdate& logged_event) const { EXPECT_EQ(original_event.timestamp_ms(), 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); } -void VerifyLoggedBweLossBasedUpdate( +void EventVerifier::VerifyLoggedBweLossBasedUpdate( const RtcEventBweUpdateLossBased& original_event, - const LoggedBweLossBasedUpdate& logged_event) { + const LoggedBweLossBasedUpdate& logged_event) const { EXPECT_EQ(original_event.timestamp_ms(), 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); } -void VerifyLoggedBweProbeClusterCreatedEvent( +void EventVerifier::VerifyLoggedBweProbeClusterCreatedEvent( const RtcEventProbeClusterCreated& original_event, - const LoggedBweProbeClusterCreatedEvent& logged_event) { + const LoggedBweProbeClusterCreatedEvent& logged_event) const { EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms()); EXPECT_EQ(original_event.id(), logged_event.id); EXPECT_EQ(original_event.bitrate_bps(), logged_event.bitrate_bps); @@ -568,25 +569,25 @@ void VerifyLoggedBweProbeClusterCreatedEvent( EXPECT_EQ(original_event.min_bytes(), logged_event.min_bytes); } -void VerifyLoggedBweProbeFailureEvent( +void EventVerifier::VerifyLoggedBweProbeFailureEvent( const RtcEventProbeResultFailure& original_event, - const LoggedBweProbeFailureEvent& logged_event) { + const LoggedBweProbeFailureEvent& logged_event) const { EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms()); EXPECT_EQ(original_event.id(), logged_event.id); EXPECT_EQ(original_event.failure_reason(), logged_event.failure_reason); } -void VerifyLoggedBweProbeSuccessEvent( +void EventVerifier::VerifyLoggedBweProbeSuccessEvent( const RtcEventProbeResultSuccess& original_event, - const LoggedBweProbeSuccessEvent& logged_event) { + const LoggedBweProbeSuccessEvent& logged_event) const { EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms()); EXPECT_EQ(original_event.id(), logged_event.id); EXPECT_EQ(original_event.bitrate_bps(), logged_event.bitrate_bps); } -void VerifyLoggedIceCandidatePairConfig( +void EventVerifier::VerifyLoggedIceCandidatePairConfig( const RtcEventIceCandidatePairConfig& original_event, - const LoggedIceCandidatePairConfig& logged_event) { + const LoggedIceCandidatePairConfig& logged_event) const { EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms()); EXPECT_EQ(original_event.type(), logged_event.type); @@ -607,9 +608,9 @@ void VerifyLoggedIceCandidatePairConfig( logged_event.candidate_pair_protocol); } -void VerifyLoggedIceCandidatePairEvent( +void EventVerifier::VerifyLoggedIceCandidatePairEvent( const RtcEventIceCandidatePair& original_event, - const LoggedIceCandidatePairEvent& logged_event) { + const LoggedIceCandidatePairEvent& logged_event) const { EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms()); EXPECT_EQ(original_event.type(), logged_event.type); @@ -677,9 +678,9 @@ void VerifyLoggedRtpHeader(const RtpPacket& original_header, } } -void VerifyLoggedRtpPacketIncoming( +void EventVerifier::VerifyLoggedRtpPacketIncoming( const RtcEventRtpPacketIncoming& original_event, - const LoggedRtpPacketIncoming& logged_event) { + const LoggedRtpPacketIncoming& logged_event) const { EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms()); EXPECT_EQ(original_event.header().headers_size(), @@ -695,9 +696,9 @@ void VerifyLoggedRtpPacketIncoming( VerifyLoggedRtpHeader(original_event.header(), logged_event.rtp.header); } -void VerifyLoggedRtpPacketOutgoing( +void EventVerifier::VerifyLoggedRtpPacketOutgoing( const RtcEventRtpPacketOutgoing& original_event, - const LoggedRtpPacketOutgoing& logged_event) { + const LoggedRtpPacketOutgoing& logged_event) const { EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms()); EXPECT_EQ(original_event.header().headers_size(), @@ -716,9 +717,9 @@ void VerifyLoggedRtpPacketOutgoing( VerifyLoggedRtpHeader(original_event.header(), logged_event.rtp.header); } -void VerifyLoggedRtcpPacketIncoming( +void EventVerifier::VerifyLoggedRtcpPacketIncoming( const RtcEventRtcpPacketIncoming& original_event, - const LoggedRtcpPacketIncoming& logged_event) { + const LoggedRtcpPacketIncoming& logged_event) const { EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms()); ASSERT_EQ(original_event.packet().size(), logged_event.rtcp.raw_data.size()); @@ -728,9 +729,9 @@ void VerifyLoggedRtcpPacketIncoming( 0); } -void VerifyLoggedRtcpPacketOutgoing( +void EventVerifier::VerifyLoggedRtcpPacketOutgoing( const RtcEventRtcpPacketOutgoing& original_event, - const LoggedRtcpPacketOutgoing& logged_event) { + const LoggedRtcpPacketOutgoing& logged_event) const { EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms()); ASSERT_EQ(original_event.packet().size(), logged_event.rtcp.raw_data.size()); @@ -740,13 +741,19 @@ void VerifyLoggedRtcpPacketOutgoing( 0); } -void VerifyLoggedStartEvent(int64_t start_time_us, - const LoggedStartEvent& logged_event) { +void EventVerifier::VerifyLoggedStartEvent( + int64_t start_time_us, + int64_t utc_start_time_us, + const LoggedStartEvent& logged_event) const { EXPECT_EQ(start_time_us / 1000, logged_event.log_time_ms()); + if (encoding_type_ == RtcEventLog::EncodingType::NewFormat) { + EXPECT_EQ(utc_start_time_us / 1000, logged_event.utc_start_time_ms); + } } -void VerifyLoggedStopEvent(int64_t stop_time_us, - const LoggedStopEvent& logged_event) { +void EventVerifier::VerifyLoggedStopEvent( + int64_t stop_time_us, + const LoggedStopEvent& logged_event) const { EXPECT_EQ(stop_time_us / 1000, logged_event.log_time_ms()); } @@ -776,30 +783,30 @@ void VerifyLoggedStreamConfig(const rtclog::StreamConfig& original_config, EXPECT_EQ(recognized_extensions, original_config.rtp_extensions.size()); } -void VerifyLoggedAudioRecvConfig( +void EventVerifier::VerifyLoggedAudioRecvConfig( const RtcEventAudioReceiveStreamConfig& original_event, - const LoggedAudioRecvConfig& logged_event) { + const LoggedAudioRecvConfig& logged_event) const { EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms()); VerifyLoggedStreamConfig(original_event.config(), logged_event.config); } -void VerifyLoggedAudioSendConfig( +void EventVerifier::VerifyLoggedAudioSendConfig( const RtcEventAudioSendStreamConfig& original_event, - const LoggedAudioSendConfig& logged_event) { + const LoggedAudioSendConfig& logged_event) const { EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms()); VerifyLoggedStreamConfig(original_event.config(), logged_event.config); } -void VerifyLoggedVideoRecvConfig( +void EventVerifier::VerifyLoggedVideoRecvConfig( const RtcEventVideoReceiveStreamConfig& original_event, - const LoggedVideoRecvConfig& logged_event) { + const LoggedVideoRecvConfig& logged_event) const { EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms()); VerifyLoggedStreamConfig(original_event.config(), logged_event.config); } -void VerifyLoggedVideoSendConfig( +void EventVerifier::VerifyLoggedVideoSendConfig( const RtcEventVideoSendStreamConfig& original_event, - const LoggedVideoSendConfig& logged_event) { + const LoggedVideoSendConfig& logged_event) const { EXPECT_EQ(original_event.timestamp_ms(), 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 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 d25970cf01..81760b7555 100644 --- a/logging/rtc_event_log/rtc_event_log_unittest_helper.h +++ b/logging/rtc_event_log/rtc_event_log_unittest_helper.h @@ -122,83 +122,111 @@ class EventGenerator { Random prng_; }; -void VerifyLoggedAlrStateEvent(const RtcEventAlrState& original_event, - const LoggedAlrStateEvent& logged_event); +class EventVerifier { + public: + explicit EventVerifier(RtcEventLog::EncodingType encoding_type) + : encoding_type_(encoding_type) {} -void VerifyLoggedAudioPlayoutEvent(const RtcEventAudioPlayout& original_event, - const LoggedAudioPlayoutEvent& logged_event); + void VerifyLoggedAlrStateEvent(const RtcEventAlrState& original_event, + const LoggedAlrStateEvent& logged_event) const; -void VerifyLoggedAudioNetworkAdaptationEvent( - const RtcEventAudioNetworkAdaptation& original_event, - const LoggedAudioNetworkAdaptationEvent& logged_event); + void VerifyLoggedAudioPlayoutEvent( + const RtcEventAudioPlayout& original_event, + const LoggedAudioPlayoutEvent& logged_event) const; -void VerifyLoggedBweDelayBasedUpdate( - const RtcEventBweUpdateDelayBased& original_event, - const LoggedBweDelayBasedUpdate& logged_event); + void VerifyLoggedAudioNetworkAdaptationEvent( + const RtcEventAudioNetworkAdaptation& original_event, + const LoggedAudioNetworkAdaptationEvent& logged_event) const; -void VerifyLoggedBweLossBasedUpdate( - const RtcEventBweUpdateLossBased& original_event, - const LoggedBweLossBasedUpdate& logged_event); + void VerifyLoggedBweDelayBasedUpdate( + const RtcEventBweUpdateDelayBased& original_event, + const LoggedBweDelayBasedUpdate& logged_event) const; -void VerifyLoggedBweProbeClusterCreatedEvent( - const RtcEventProbeClusterCreated& original_event, - const LoggedBweProbeClusterCreatedEvent& logged_event); + void VerifyLoggedBweLossBasedUpdate( + const RtcEventBweUpdateLossBased& original_event, + const LoggedBweLossBasedUpdate& logged_event) const; -void VerifyLoggedBweProbeFailureEvent( - const RtcEventProbeResultFailure& original_event, - const LoggedBweProbeFailureEvent& logged_event); + void VerifyLoggedBweProbeClusterCreatedEvent( + const RtcEventProbeClusterCreated& original_event, + const LoggedBweProbeClusterCreatedEvent& logged_event) const; -void VerifyLoggedBweProbeSuccessEvent( - const RtcEventProbeResultSuccess& original_event, - const LoggedBweProbeSuccessEvent& logged_event); + void VerifyLoggedBweProbeFailureEvent( + const RtcEventProbeResultFailure& original_event, + const LoggedBweProbeFailureEvent& logged_event) const; -void VerifyLoggedIceCandidatePairConfig( - const RtcEventIceCandidatePairConfig& original_event, - const LoggedIceCandidatePairConfig& logged_event); + void VerifyLoggedBweProbeSuccessEvent( + const RtcEventProbeResultSuccess& original_event, + const LoggedBweProbeSuccessEvent& logged_event) const; -void VerifyLoggedIceCandidatePairEvent( - const RtcEventIceCandidatePair& original_event, - const LoggedIceCandidatePairEvent& logged_event); + void VerifyLoggedIceCandidatePairConfig( + const RtcEventIceCandidatePairConfig& original_event, + const LoggedIceCandidatePairConfig& logged_event) const; -void VerifyLoggedRtpPacketIncoming( - const RtcEventRtpPacketIncoming& original_event, - const LoggedRtpPacketIncoming& logged_event); + void VerifyLoggedIceCandidatePairEvent( + const RtcEventIceCandidatePair& original_event, + const LoggedIceCandidatePairEvent& logged_event) const; -void VerifyLoggedRtpPacketOutgoing( - const RtcEventRtpPacketOutgoing& original_event, - const LoggedRtpPacketOutgoing& logged_event); + void VerifyLoggedRtpPacketIncoming( + const RtcEventRtpPacketIncoming& original_event, + const LoggedRtpPacketIncoming& logged_event) const; -void VerifyLoggedRtcpPacketIncoming( - const RtcEventRtcpPacketIncoming& original_event, - const LoggedRtcpPacketIncoming& logged_event); + void VerifyLoggedRtpPacketOutgoing( + const RtcEventRtpPacketOutgoing& original_event, + const LoggedRtpPacketOutgoing& logged_event) const; -void VerifyLoggedRtcpPacketOutgoing( - const RtcEventRtcpPacketOutgoing& original_event, - const LoggedRtcpPacketOutgoing& logged_event); + template + void VerifyLoggedRtpPacket(const EventType& original_event, + const ParsedType& logged_event) { + static_assert(sizeof(ParsedType) == 0, + "You have to use one of the two defined template " + "specializations of VerifyLoggedRtpPacket"); + } -void VerifyLoggedStartEvent(int64_t start_time_us, - const LoggedStartEvent& logged_event); -void VerifyLoggedStopEvent(int64_t stop_time_us, - const LoggedStopEvent& logged_event); + template <> + void VerifyLoggedRtpPacket(const RtcEventRtpPacketIncoming& original_event, + const LoggedRtpPacketIncoming& logged_event) { + VerifyLoggedRtpPacketIncoming(original_event, logged_event); + } -void VerifyLoggedStreamConfig(const rtclog::StreamConfig& original_config, - const rtclog::StreamConfig& logged_config); + template <> + void VerifyLoggedRtpPacket(const RtcEventRtpPacketOutgoing& original_event, + const LoggedRtpPacketOutgoing& logged_event) { + VerifyLoggedRtpPacketOutgoing(original_event, logged_event); + } -void VerifyLoggedAudioRecvConfig( - const RtcEventAudioReceiveStreamConfig& original_event, - const LoggedAudioRecvConfig& logged_event); + void VerifyLoggedRtcpPacketIncoming( + const RtcEventRtcpPacketIncoming& original_event, + const LoggedRtcpPacketIncoming& logged_event) const; -void VerifyLoggedAudioSendConfig( - const RtcEventAudioSendStreamConfig& original_event, - const LoggedAudioSendConfig& logged_event); + void VerifyLoggedRtcpPacketOutgoing( + const RtcEventRtcpPacketOutgoing& original_event, + const LoggedRtcpPacketOutgoing& logged_event) const; -void VerifyLoggedVideoRecvConfig( - const RtcEventVideoReceiveStreamConfig& original_event, - const LoggedVideoRecvConfig& logged_event); + void VerifyLoggedStartEvent(int64_t start_time_us, + int64_t utc_start_time_us, + const LoggedStartEvent& logged_event) const; + void VerifyLoggedStopEvent(int64_t stop_time_us, + const LoggedStopEvent& logged_event) const; -void VerifyLoggedVideoSendConfig( - const RtcEventVideoSendStreamConfig& original_event, - const LoggedVideoSendConfig& logged_event); + void VerifyLoggedAudioRecvConfig( + const RtcEventAudioReceiveStreamConfig& original_event, + const LoggedAudioRecvConfig& logged_event) const; + + void VerifyLoggedAudioSendConfig( + const RtcEventAudioSendStreamConfig& original_event, + const LoggedAudioSendConfig& logged_event) const; + + void VerifyLoggedVideoRecvConfig( + const RtcEventVideoReceiveStreamConfig& original_event, + const LoggedVideoRecvConfig& logged_event) const; + + void VerifyLoggedVideoSendConfig( + const RtcEventVideoSendStreamConfig& original_event, + const LoggedVideoSendConfig& logged_event) const; + + private: + RtcEventLog::EncodingType encoding_type_; +}; } // namespace test } // namespace webrtc