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

Add version and UTC time fields to RTC event log.

Browse Source 
Bug: webrtc:8111
Change-Id: I843e1f8e50e4d4faf74819e0104aeb4fb869b834
Reviewed-on: https://webrtc-review.googlesource.com/c/110721
Reviewed-by: Elad Alon <eladalon@webrtc.org>
Commit-Queue: Björn Terelius <terelius@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#25658}
This commit is contained in:
Bjorn Terelius
2018-11-13 11:19:18 +01:00
committed by Commit Bot
parent f0db2e2ef5
commit e78b465d45
13 changed files with 283 additions and 224 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
logging/rtc_event_log/encoder/rtc_event_log_encoder.h
View File

@ -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(

3
logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.cc
View File

@ -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);

3
logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.h
View File

@ -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(

5
logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc
View File

@ -615,10 +615,13 @@ void EncodeRtpPacket(const std::vector<const EventType*>& 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();
}

3
logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.h
View File

@ -56,7 +56,8 @@ class RtcEventLogEncoderNewFormat final : public RtcEventLogEncoder {
std::deque<std::unique_ptr<RtcEvent>>::const_iterator begin,
std::deque<std::unique_ptr<RtcEvent>>::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:

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

@ -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<RtcEventLogEncoderNewFormat>();
else
@ -70,8 +72,9 @@ class RtcEventLogEncoderTest
const RtpHeaderExtensionMap& extension_map);
template <typename ParsedType>
const std::vector<ParsedType>& GetRtpPacketsBySsrc(
const ParsedRtcEventLogNew* parsed_log);
const std::vector<ParsedType>* GetRtpPacketsBySsrc(
const ParsedRtcEventLogNew* parsed_log,
uint32_t ssrc);
template <typename EventType, typename ParsedType>
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<RtcEventRtpPacketOutgoing> RtcEventLogEncoderTest::NewRtpPacket(
}
template <>
const std::vector<ParsedRtcEventLogNew::LoggedRtpStreamIncoming>&
const std::vector<LoggedRtpPacketIncoming>*
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<ParsedRtcEventLogNew::LoggedRtpStreamOutgoing>&
const std::vector<LoggedRtpPacketOutgoing>*
RtcEventLogEncoderTest::GetRtpPacketsBySsrc(
const ParsedRtcEventLogNew* parsed_log) {
return parsed_log->outgoing_rtp_packets_by_ssrc();
}
template <typename EventType, typename ParsedType>
void CompareRtpPacketSequences(
const std::vector<std::unique_ptr<EventType>>& original_events,
const ParsedType& parsed_events);
template <>
void CompareRtpPacketSequences(
const std::vector<std::unique_ptr<RtcEventRtpPacketIncoming>>& 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<std::unique_ptr<RtcEventRtpPacketOutgoing>>& 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 <typename EventType, typename ParsedType>
@ -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<ParsedType>& parsed_rtp_packets =
GetRtpPacketsBySsrc<ParsedType>(&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<ParsedType>* parsed_rtp_packets =
GetRtpPacketsBySsrc<ParsedType>(&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<EventType, ParsedType>(
*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<RtcEventRtpPacketIncoming,
ParsedRtcEventLogNew::LoggedRtpStreamIncoming>();
TestRtpPackets<RtcEventRtpPacketIncoming, LoggedRtpPacketIncoming>();
}
TEST_P(RtcEventLogEncoderTest, RtcEventRtpPacketOutgoing) {
TestRtpPackets<RtcEventRtpPacketOutgoing,
ParsedRtcEventLogNew::LoggedRtpStreamOutgoing>();
TestRtpPackets<RtcEventRtpPacketOutgoing, LoggedRtpPacketOutgoing>();
}
// 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(

6
logging/rtc_event_log/rtc_event_log2.proto
View File

@ -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 {

7
logging/rtc_event_log/rtc_event_log_impl.cc
View File

@ -173,20 +173,19 @@ bool RtcEventLogImpl::StartLogging(std::unique_ptr<RtcEventLogOutput> 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<RtcEventLogOutput> output) {
auto start = [this, timestamp_us,
utc_time_us](std::unique_ptr<RtcEventLogOutput> 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();
};

6
logging/rtc_event_log/rtc_event_log_parser_new.cc
View File

@ -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);
}

6
logging/rtc_event_log/rtc_event_log_parser_new.h
View File

@ -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 {

89
logging/rtc_event_log/rtc_event_log_unittest.cc
View File

@ -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<uint32_t>());
// Find the name of the current test, in order to use it as a temporary
// filename.
@ -168,13 +169,15 @@ class RtcEventLogSession
std::vector<std::unique_ptr<RtcEventRtcpPacketOutgoing>> 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<RtcEventLogOutputFile>(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<size_t>(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<size_t>(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<RtcEventLog::EncodingType> {
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<RtcEventLogOutputFile>(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]);
}

87
logging/rtc_event_log/rtc_event_log_unittest_helper.cc
View File

@ -501,22 +501,23 @@ EventGenerator::NewVideoSendStreamConfig(
return absl::make_unique<RtcEventVideoSendStreamConfig>(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

144
logging/rtc_event_log/rtc_event_log_unittest_helper.h
View File

@ -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 <typename EventType, typename ParsedType>
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