1 /*
2 * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "logging/rtc_event_log/rtc_event_log_unittest_helper.h"
12
13 #include <string.h>
14
15 #include <string>
16 #include <vector>
17
18 #include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
19 #include "modules/remote_bitrate_estimator/include/bwe_defines.h"
20 #include "rtc_base/checks.h"
21 #include "test/gmock.h"
22 #include "test/gtest.h"
23 #include "test/testsupport/fileutils.h"
24
25 // Files generated at build-time by the protobuf compiler.
26 #ifdef WEBRTC_ANDROID_PLATFORM_BUILD
27 #include "external/webrtc/webrtc/logging/rtc_event_log/rtc_event_log.pb.h"
28 #else
29 #include "logging/rtc_event_log/rtc_event_log.pb.h"
30 #endif
31
32 namespace webrtc {
33
34 namespace {
35
GetRuntimeDetectorState(rtclog::DelayBasedBweUpdate::DetectorState detector_state)36 BandwidthUsage GetRuntimeDetectorState(
37 rtclog::DelayBasedBweUpdate::DetectorState detector_state) {
38 switch (detector_state) {
39 case rtclog::DelayBasedBweUpdate::BWE_NORMAL:
40 return BandwidthUsage::kBwNormal;
41 case rtclog::DelayBasedBweUpdate::BWE_UNDERUSING:
42 return BandwidthUsage::kBwUnderusing;
43 case rtclog::DelayBasedBweUpdate::BWE_OVERUSING:
44 return BandwidthUsage::kBwOverusing;
45 }
46 RTC_NOTREACHED();
47 return BandwidthUsage::kBwNormal;
48 }
49
GetProbeResultType(ProbeFailureReason failure_reason)50 rtclog::BweProbeResult::ResultType GetProbeResultType(
51 ProbeFailureReason failure_reason) {
52 switch (failure_reason) {
53 case ProbeFailureReason::kInvalidSendReceiveInterval:
54 return rtclog::BweProbeResult::INVALID_SEND_RECEIVE_INTERVAL;
55 case ProbeFailureReason::kInvalidSendReceiveRatio:
56 return rtclog::BweProbeResult::INVALID_SEND_RECEIVE_RATIO;
57 case ProbeFailureReason::kTimeout:
58 return rtclog::BweProbeResult::TIMEOUT;
59 case ProbeFailureReason::kLast:
60 RTC_NOTREACHED();
61 }
62 RTC_NOTREACHED();
63 return rtclog::BweProbeResult::SUCCESS;
64 }
65 } // namespace
66
67 // Checks that the event has a timestamp, a type and exactly the data field
68 // corresponding to the type.
IsValidBasicEvent(const rtclog::Event & event)69 ::testing::AssertionResult IsValidBasicEvent(const rtclog::Event& event) {
70 if (!event.has_timestamp_us()) {
71 return ::testing::AssertionFailure() << "Event has no timestamp";
72 }
73 if (!event.has_type()) {
74 return ::testing::AssertionFailure() << "Event has no event type";
75 }
76 rtclog::Event_EventType type = event.type();
77 if ((type == rtclog::Event::RTP_EVENT) != event.has_rtp_packet()) {
78 return ::testing::AssertionFailure()
79 << "Event of type " << type << " has "
80 << (event.has_rtp_packet() ? "" : "no ") << "RTP packet";
81 }
82 if ((type == rtclog::Event::RTCP_EVENT) != event.has_rtcp_packet()) {
83 return ::testing::AssertionFailure()
84 << "Event of type " << type << " has "
85 << (event.has_rtcp_packet() ? "" : "no ") << "RTCP packet";
86 }
87 if ((type == rtclog::Event::LOSS_BASED_BWE_UPDATE) !=
88 event.has_loss_based_bwe_update()) {
89 return ::testing::AssertionFailure()
90 << "Event of type " << type << " has "
91 << (event.has_loss_based_bwe_update() ? "" : "no ") << "loss update";
92 }
93 if ((type == rtclog::Event::DELAY_BASED_BWE_UPDATE) !=
94 event.has_delay_based_bwe_update()) {
95 return ::testing::AssertionFailure()
96 << "Event of type " << type << " has "
97 << (event.has_delay_based_bwe_update() ? "" : "no ")
98 << "delay update";
99 }
100 if ((type == rtclog::Event::AUDIO_PLAYOUT_EVENT) !=
101 event.has_audio_playout_event()) {
102 return ::testing::AssertionFailure()
103 << "Event of type " << type << " has "
104 << (event.has_audio_playout_event() ? "" : "no ")
105 << "audio_playout event";
106 }
107 if ((type == rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT) !=
108 event.has_video_receiver_config()) {
109 return ::testing::AssertionFailure()
110 << "Event of type " << type << " has "
111 << (event.has_video_receiver_config() ? "" : "no ")
112 << "receiver config";
113 }
114 if ((type == rtclog::Event::VIDEO_SENDER_CONFIG_EVENT) !=
115 event.has_video_sender_config()) {
116 return ::testing::AssertionFailure()
117 << "Event of type " << type << " has "
118 << (event.has_video_sender_config() ? "" : "no ") << "sender config";
119 }
120 if ((type == rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT) !=
121 event.has_audio_receiver_config()) {
122 return ::testing::AssertionFailure()
123 << "Event of type " << type << " has "
124 << (event.has_audio_receiver_config() ? "" : "no ")
125 << "audio receiver config";
126 }
127 if ((type == rtclog::Event::AUDIO_SENDER_CONFIG_EVENT) !=
128 event.has_audio_sender_config()) {
129 return ::testing::AssertionFailure()
130 << "Event of type " << type << " has "
131 << (event.has_audio_sender_config() ? "" : "no ")
132 << "audio sender config";
133 }
134 if ((type == rtclog::Event::AUDIO_NETWORK_ADAPTATION_EVENT) !=
135 event.has_audio_network_adaptation()) {
136 return ::testing::AssertionFailure()
137 << "Event of type " << type << " has "
138 << (event.has_audio_network_adaptation() ? "" : "no ")
139 << "audio network adaptation";
140 }
141 if ((type == rtclog::Event::BWE_PROBE_CLUSTER_CREATED_EVENT) !=
142 event.has_probe_cluster()) {
143 return ::testing::AssertionFailure()
144 << "Event of type " << type << " has "
145 << (event.has_probe_cluster() ? "" : "no ") << "bwe probe cluster";
146 }
147 if ((type == rtclog::Event::BWE_PROBE_RESULT_EVENT) !=
148 event.has_probe_result()) {
149 return ::testing::AssertionFailure()
150 << "Event of type " << type << " has "
151 << (event.has_probe_result() ? "" : "no ") << "bwe probe result";
152 }
153 return ::testing::AssertionSuccess();
154 }
155
VerifyStreamConfigsAreEqual(const rtclog::StreamConfig & config_1,const rtclog::StreamConfig & config_2)156 void VerifyStreamConfigsAreEqual(const rtclog::StreamConfig& config_1,
157 const rtclog::StreamConfig& config_2) {
158 EXPECT_EQ(config_1.remote_ssrc, config_2.remote_ssrc);
159 EXPECT_EQ(config_1.local_ssrc, config_2.local_ssrc);
160 EXPECT_EQ(config_1.rtx_ssrc, config_2.rtx_ssrc);
161 EXPECT_EQ(config_1.rtcp_mode, config_2.rtcp_mode);
162 EXPECT_EQ(config_1.remb, config_2.remb);
163
164 ASSERT_EQ(config_1.rtp_extensions.size(), config_2.rtp_extensions.size());
165 for (size_t i = 0; i < config_2.rtp_extensions.size(); i++) {
166 EXPECT_EQ(config_1.rtp_extensions[i].uri, config_2.rtp_extensions[i].uri);
167 EXPECT_EQ(config_1.rtp_extensions[i].id, config_2.rtp_extensions[i].id);
168 }
169 ASSERT_EQ(config_1.codecs.size(), config_2.codecs.size());
170 for (size_t i = 0; i < config_2.codecs.size(); i++) {
171 EXPECT_EQ(config_1.codecs[i].payload_name, config_2.codecs[i].payload_name);
172 EXPECT_EQ(config_1.codecs[i].payload_type, config_2.codecs[i].payload_type);
173 EXPECT_EQ(config_1.codecs[i].rtx_payload_type,
174 config_2.codecs[i].rtx_payload_type);
175 }
176 }
177
VerifyVideoReceiveStreamConfig(const ParsedRtcEventLog & parsed_log,size_t index,const rtclog::StreamConfig & config)178 void RtcEventLogTestHelper::VerifyVideoReceiveStreamConfig(
179 const ParsedRtcEventLog& parsed_log,
180 size_t index,
181 const rtclog::StreamConfig& config) {
182 ASSERT_LT(index, parsed_log.events_.size());
183 const rtclog::Event& event = parsed_log.events_[index];
184 ASSERT_TRUE(IsValidBasicEvent(event));
185 ASSERT_EQ(rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT, event.type());
186 const rtclog::VideoReceiveConfig& receiver_config =
187 event.video_receiver_config();
188 // Check SSRCs.
189 ASSERT_TRUE(receiver_config.has_remote_ssrc());
190 EXPECT_EQ(config.remote_ssrc, receiver_config.remote_ssrc());
191 ASSERT_TRUE(receiver_config.has_local_ssrc());
192 EXPECT_EQ(config.local_ssrc, receiver_config.local_ssrc());
193 // Check RTCP settings.
194 ASSERT_TRUE(receiver_config.has_rtcp_mode());
195 if (config.rtcp_mode == RtcpMode::kCompound) {
196 EXPECT_EQ(rtclog::VideoReceiveConfig::RTCP_COMPOUND,
197 receiver_config.rtcp_mode());
198 } else {
199 EXPECT_EQ(rtclog::VideoReceiveConfig::RTCP_REDUCEDSIZE,
200 receiver_config.rtcp_mode());
201 }
202 ASSERT_TRUE(receiver_config.has_remb());
203 EXPECT_EQ(config.remb, receiver_config.remb());
204 // Check RTX map.
205 for (const rtclog::RtxMap& rtx_map : receiver_config.rtx_map()) {
206 ASSERT_TRUE(rtx_map.has_payload_type());
207 ASSERT_TRUE(rtx_map.has_config());
208 const rtclog::RtxConfig& rtx_config = rtx_map.config();
209 ASSERT_TRUE(rtx_config.has_rtx_ssrc());
210 ASSERT_TRUE(rtx_config.has_rtx_payload_type());
211
212 EXPECT_EQ(config.rtx_ssrc, rtx_config.rtx_ssrc());
213 auto codec_found =
214 std::find_if(config.codecs.begin(), config.codecs.end(),
215 [&rtx_map](const rtclog::StreamConfig::Codec& codec) {
216 return rtx_map.payload_type() == codec.payload_type;
217 });
218 ASSERT_TRUE(codec_found != config.codecs.end());
219 EXPECT_EQ(rtx_config.rtx_payload_type(), codec_found->rtx_payload_type);
220 }
221 // Check header extensions.
222 ASSERT_EQ(static_cast<int>(config.rtp_extensions.size()),
223 receiver_config.header_extensions_size());
224 for (int i = 0; i < receiver_config.header_extensions_size(); i++) {
225 ASSERT_TRUE(receiver_config.header_extensions(i).has_name());
226 ASSERT_TRUE(receiver_config.header_extensions(i).has_id());
227 const std::string& name = receiver_config.header_extensions(i).name();
228 int id = receiver_config.header_extensions(i).id();
229 EXPECT_EQ(config.rtp_extensions[i].id, id);
230 EXPECT_EQ(config.rtp_extensions[i].uri, name);
231 }
232 // Check decoders.
233 ASSERT_EQ(static_cast<int>(config.codecs.size()),
234 receiver_config.decoders_size());
235 for (int i = 0; i < receiver_config.decoders_size(); i++) {
236 ASSERT_TRUE(receiver_config.decoders(i).has_name());
237 ASSERT_TRUE(receiver_config.decoders(i).has_payload_type());
238 const std::string& decoder_name = receiver_config.decoders(i).name();
239 int decoder_type = receiver_config.decoders(i).payload_type();
240 EXPECT_EQ(config.codecs[i].payload_name, decoder_name);
241 EXPECT_EQ(config.codecs[i].payload_type, decoder_type);
242 }
243
244 // Check consistency of the parser.
245 rtclog::StreamConfig parsed_config = parsed_log.GetVideoReceiveConfig(index);
246 VerifyStreamConfigsAreEqual(config, parsed_config);
247 }
248
VerifyVideoSendStreamConfig(const ParsedRtcEventLog & parsed_log,size_t index,const rtclog::StreamConfig & config)249 void RtcEventLogTestHelper::VerifyVideoSendStreamConfig(
250 const ParsedRtcEventLog& parsed_log,
251 size_t index,
252 const rtclog::StreamConfig& config) {
253 ASSERT_LT(index, parsed_log.events_.size());
254 const rtclog::Event& event = parsed_log.events_[index];
255 ASSERT_TRUE(IsValidBasicEvent(event));
256 ASSERT_EQ(rtclog::Event::VIDEO_SENDER_CONFIG_EVENT, event.type());
257 const rtclog::VideoSendConfig& sender_config = event.video_sender_config();
258
259 EXPECT_EQ(config.local_ssrc, sender_config.ssrcs(0));
260 EXPECT_EQ(config.rtx_ssrc, sender_config.rtx_ssrcs(0));
261
262 // Check header extensions.
263 ASSERT_EQ(static_cast<int>(config.rtp_extensions.size()),
264 sender_config.header_extensions_size());
265 for (int i = 0; i < sender_config.header_extensions_size(); i++) {
266 ASSERT_TRUE(sender_config.header_extensions(i).has_name());
267 ASSERT_TRUE(sender_config.header_extensions(i).has_id());
268 const std::string& name = sender_config.header_extensions(i).name();
269 int id = sender_config.header_extensions(i).id();
270 EXPECT_EQ(config.rtp_extensions[i].id, id);
271 EXPECT_EQ(config.rtp_extensions[i].uri, name);
272 }
273 // Check encoder.
274 ASSERT_TRUE(sender_config.has_encoder());
275 ASSERT_TRUE(sender_config.encoder().has_name());
276 ASSERT_TRUE(sender_config.encoder().has_payload_type());
277 EXPECT_EQ(config.codecs[0].payload_name, sender_config.encoder().name());
278 EXPECT_EQ(config.codecs[0].payload_type,
279 sender_config.encoder().payload_type());
280
281 EXPECT_EQ(config.codecs[0].rtx_payload_type,
282 sender_config.rtx_payload_type());
283
284 // Check consistency of the parser.
285 std::vector<rtclog::StreamConfig> parsed_configs =
286 parsed_log.GetVideoSendConfig(index);
287 ASSERT_EQ(1u, parsed_configs.size());
288 VerifyStreamConfigsAreEqual(config, parsed_configs[0]);
289 }
290
VerifyAudioReceiveStreamConfig(const ParsedRtcEventLog & parsed_log,size_t index,const rtclog::StreamConfig & config)291 void RtcEventLogTestHelper::VerifyAudioReceiveStreamConfig(
292 const ParsedRtcEventLog& parsed_log,
293 size_t index,
294 const rtclog::StreamConfig& config) {
295 ASSERT_LT(index, parsed_log.events_.size());
296 const rtclog::Event& event = parsed_log.events_[index];
297 ASSERT_TRUE(IsValidBasicEvent(event));
298 ASSERT_EQ(rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT, event.type());
299 const rtclog::AudioReceiveConfig& receiver_config =
300 event.audio_receiver_config();
301 // Check SSRCs.
302 ASSERT_TRUE(receiver_config.has_remote_ssrc());
303 EXPECT_EQ(config.remote_ssrc, receiver_config.remote_ssrc());
304 ASSERT_TRUE(receiver_config.has_local_ssrc());
305 EXPECT_EQ(config.local_ssrc, receiver_config.local_ssrc());
306 // Check header extensions.
307 ASSERT_EQ(static_cast<int>(config.rtp_extensions.size()),
308 receiver_config.header_extensions_size());
309 for (int i = 0; i < receiver_config.header_extensions_size(); i++) {
310 ASSERT_TRUE(receiver_config.header_extensions(i).has_name());
311 ASSERT_TRUE(receiver_config.header_extensions(i).has_id());
312 const std::string& name = receiver_config.header_extensions(i).name();
313 int id = receiver_config.header_extensions(i).id();
314 EXPECT_EQ(config.rtp_extensions[i].id, id);
315 EXPECT_EQ(config.rtp_extensions[i].uri, name);
316 }
317
318 // Check consistency of the parser.
319 rtclog::StreamConfig parsed_config = parsed_log.GetAudioReceiveConfig(index);
320 EXPECT_EQ(config.remote_ssrc, parsed_config.remote_ssrc);
321 EXPECT_EQ(config.local_ssrc, parsed_config.local_ssrc);
322 // Check header extensions.
323 EXPECT_EQ(config.rtp_extensions.size(), parsed_config.rtp_extensions.size());
324 for (size_t i = 0; i < parsed_config.rtp_extensions.size(); i++) {
325 EXPECT_EQ(config.rtp_extensions[i].uri,
326 parsed_config.rtp_extensions[i].uri);
327 EXPECT_EQ(config.rtp_extensions[i].id, parsed_config.rtp_extensions[i].id);
328 }
329 }
330
VerifyAudioSendStreamConfig(const ParsedRtcEventLog & parsed_log,size_t index,const rtclog::StreamConfig & config)331 void RtcEventLogTestHelper::VerifyAudioSendStreamConfig(
332 const ParsedRtcEventLog& parsed_log,
333 size_t index,
334 const rtclog::StreamConfig& config) {
335 ASSERT_LT(index, parsed_log.events_.size());
336 const rtclog::Event& event = parsed_log.events_[index];
337 ASSERT_TRUE(IsValidBasicEvent(event));
338 ASSERT_EQ(rtclog::Event::AUDIO_SENDER_CONFIG_EVENT, event.type());
339 const rtclog::AudioSendConfig& sender_config = event.audio_sender_config();
340 // Check SSRCs.
341 EXPECT_EQ(config.local_ssrc, sender_config.ssrc());
342 // Check header extensions.
343 ASSERT_EQ(static_cast<int>(config.rtp_extensions.size()),
344 sender_config.header_extensions_size());
345 for (int i = 0; i < sender_config.header_extensions_size(); i++) {
346 ASSERT_TRUE(sender_config.header_extensions(i).has_name());
347 ASSERT_TRUE(sender_config.header_extensions(i).has_id());
348 const std::string& name = sender_config.header_extensions(i).name();
349 int id = sender_config.header_extensions(i).id();
350 EXPECT_EQ(config.rtp_extensions[i].id, id);
351 EXPECT_EQ(config.rtp_extensions[i].uri, name);
352 }
353
354 // Check consistency of the parser.
355 rtclog::StreamConfig parsed_config = parsed_log.GetAudioSendConfig(index);
356 VerifyStreamConfigsAreEqual(config, parsed_config);
357 }
358
VerifyIncomingRtpEvent(const ParsedRtcEventLog & parsed_log,size_t index,const RtpPacketReceived & expected_packet)359 void RtcEventLogTestHelper::VerifyIncomingRtpEvent(
360 const ParsedRtcEventLog& parsed_log,
361 size_t index,
362 const RtpPacketReceived& expected_packet) {
363 ASSERT_LT(index, parsed_log.events_.size());
364 const rtclog::Event& event = parsed_log.events_[index];
365 ASSERT_TRUE(IsValidBasicEvent(event));
366 ASSERT_EQ(rtclog::Event::RTP_EVENT, event.type());
367 const rtclog::RtpPacket& rtp_packet = event.rtp_packet();
368 ASSERT_TRUE(rtp_packet.has_incoming());
369 EXPECT_TRUE(rtp_packet.incoming());
370 ASSERT_TRUE(rtp_packet.has_packet_length());
371 EXPECT_EQ(expected_packet.size(), rtp_packet.packet_length());
372 size_t header_size = expected_packet.headers_size();
373 ASSERT_TRUE(rtp_packet.has_header());
374 EXPECT_THAT(testing::make_tuple(expected_packet.data(), header_size),
375 testing::ElementsAreArray(rtp_packet.header().data(),
376 rtp_packet.header().size()));
377
378 // Check consistency of the parser.
379 PacketDirection parsed_direction;
380 uint8_t parsed_header[1500];
381 size_t parsed_header_size, parsed_total_size;
382 parsed_log.GetRtpHeader(index, &parsed_direction, parsed_header,
383 &parsed_header_size, &parsed_total_size, nullptr);
384 EXPECT_EQ(kIncomingPacket, parsed_direction);
385 EXPECT_THAT(testing::make_tuple(expected_packet.data(), header_size),
386 testing::ElementsAreArray(parsed_header, parsed_header_size));
387 EXPECT_EQ(expected_packet.size(), parsed_total_size);
388 }
389
VerifyOutgoingRtpEvent(const ParsedRtcEventLog & parsed_log,size_t index,const RtpPacketToSend & expected_packet)390 void RtcEventLogTestHelper::VerifyOutgoingRtpEvent(
391 const ParsedRtcEventLog& parsed_log,
392 size_t index,
393 const RtpPacketToSend& expected_packet) {
394 ASSERT_LT(index, parsed_log.events_.size());
395 const rtclog::Event& event = parsed_log.events_[index];
396 ASSERT_TRUE(IsValidBasicEvent(event));
397 ASSERT_EQ(rtclog::Event::RTP_EVENT, event.type());
398 const rtclog::RtpPacket& rtp_packet = event.rtp_packet();
399 ASSERT_TRUE(rtp_packet.has_incoming());
400 EXPECT_FALSE(rtp_packet.incoming());
401 ASSERT_TRUE(rtp_packet.has_packet_length());
402 EXPECT_EQ(expected_packet.size(), rtp_packet.packet_length());
403 size_t header_size = expected_packet.headers_size();
404 ASSERT_TRUE(rtp_packet.has_header());
405 EXPECT_THAT(testing::make_tuple(expected_packet.data(), header_size),
406 testing::ElementsAreArray(rtp_packet.header().data(),
407 rtp_packet.header().size()));
408
409 // Check consistency of the parser.
410 PacketDirection parsed_direction;
411 uint8_t parsed_header[1500];
412 size_t parsed_header_size, parsed_total_size;
413 parsed_log.GetRtpHeader(index, &parsed_direction, parsed_header,
414 &parsed_header_size, &parsed_total_size, nullptr);
415 EXPECT_EQ(kOutgoingPacket, parsed_direction);
416 EXPECT_THAT(testing::make_tuple(expected_packet.data(), header_size),
417 testing::ElementsAreArray(parsed_header, parsed_header_size));
418 EXPECT_EQ(expected_packet.size(), parsed_total_size);
419 }
420
VerifyRtcpEvent(const ParsedRtcEventLog & parsed_log,size_t index,PacketDirection direction,const uint8_t * packet,size_t total_size)421 void RtcEventLogTestHelper::VerifyRtcpEvent(const ParsedRtcEventLog& parsed_log,
422 size_t index,
423 PacketDirection direction,
424 const uint8_t* packet,
425 size_t total_size) {
426 ASSERT_LT(index, parsed_log.events_.size());
427 const rtclog::Event& event = parsed_log.events_[index];
428 ASSERT_TRUE(IsValidBasicEvent(event));
429 ASSERT_EQ(rtclog::Event::RTCP_EVENT, event.type());
430 const rtclog::RtcpPacket& rtcp_packet = event.rtcp_packet();
431 ASSERT_TRUE(rtcp_packet.has_incoming());
432 EXPECT_EQ(direction == kIncomingPacket, rtcp_packet.incoming());
433 ASSERT_TRUE(rtcp_packet.has_packet_data());
434 ASSERT_EQ(total_size, rtcp_packet.packet_data().size());
435 for (size_t i = 0; i < total_size; i++) {
436 EXPECT_EQ(packet[i], static_cast<uint8_t>(rtcp_packet.packet_data()[i]));
437 }
438
439 // Check consistency of the parser.
440 PacketDirection parsed_direction;
441 uint8_t parsed_packet[1500];
442 size_t parsed_total_size;
443 parsed_log.GetRtcpPacket(index, &parsed_direction, parsed_packet,
444 &parsed_total_size);
445 EXPECT_EQ(direction, parsed_direction);
446 ASSERT_EQ(total_size, parsed_total_size);
447 EXPECT_EQ(0, std::memcmp(packet, parsed_packet, total_size));
448 }
449
VerifyPlayoutEvent(const ParsedRtcEventLog & parsed_log,size_t index,uint32_t ssrc)450 void RtcEventLogTestHelper::VerifyPlayoutEvent(
451 const ParsedRtcEventLog& parsed_log,
452 size_t index,
453 uint32_t ssrc) {
454 ASSERT_LT(index, parsed_log.events_.size());
455 const rtclog::Event& event = parsed_log.events_[index];
456 ASSERT_TRUE(IsValidBasicEvent(event));
457 ASSERT_EQ(rtclog::Event::AUDIO_PLAYOUT_EVENT, event.type());
458 const rtclog::AudioPlayoutEvent& playout_event = event.audio_playout_event();
459 ASSERT_TRUE(playout_event.has_local_ssrc());
460 EXPECT_EQ(ssrc, playout_event.local_ssrc());
461
462 // Check consistency of the parser.
463 uint32_t parsed_ssrc;
464 parsed_log.GetAudioPlayout(index, &parsed_ssrc);
465 EXPECT_EQ(ssrc, parsed_ssrc);
466 }
467
VerifyBweLossEvent(const ParsedRtcEventLog & parsed_log,size_t index,int32_t bitrate,uint8_t fraction_loss,int32_t total_packets)468 void RtcEventLogTestHelper::VerifyBweLossEvent(
469 const ParsedRtcEventLog& parsed_log,
470 size_t index,
471 int32_t bitrate,
472 uint8_t fraction_loss,
473 int32_t total_packets) {
474 ASSERT_LT(index, parsed_log.events_.size());
475 const rtclog::Event& event = parsed_log.events_[index];
476 ASSERT_TRUE(IsValidBasicEvent(event));
477 ASSERT_EQ(rtclog::Event::LOSS_BASED_BWE_UPDATE, event.type());
478 const rtclog::LossBasedBweUpdate& bwe_event = event.loss_based_bwe_update();
479 ASSERT_TRUE(bwe_event.has_bitrate_bps());
480 EXPECT_EQ(bitrate, bwe_event.bitrate_bps());
481 ASSERT_TRUE(bwe_event.has_fraction_loss());
482 EXPECT_EQ(fraction_loss, bwe_event.fraction_loss());
483 ASSERT_TRUE(bwe_event.has_total_packets());
484 EXPECT_EQ(total_packets, bwe_event.total_packets());
485
486 // Check consistency of the parser.
487 int32_t parsed_bitrate;
488 uint8_t parsed_fraction_loss;
489 int32_t parsed_total_packets;
490 parsed_log.GetLossBasedBweUpdate(
491 index, &parsed_bitrate, &parsed_fraction_loss, &parsed_total_packets);
492 EXPECT_EQ(bitrate, parsed_bitrate);
493 EXPECT_EQ(fraction_loss, parsed_fraction_loss);
494 EXPECT_EQ(total_packets, parsed_total_packets);
495 }
496
VerifyBweDelayEvent(const ParsedRtcEventLog & parsed_log,size_t index,int32_t bitrate,BandwidthUsage detector_state)497 void RtcEventLogTestHelper::VerifyBweDelayEvent(
498 const ParsedRtcEventLog& parsed_log,
499 size_t index,
500 int32_t bitrate,
501 BandwidthUsage detector_state) {
502 ASSERT_LT(index, parsed_log.events_.size());
503 const rtclog::Event& event = parsed_log.events_[index];
504 ASSERT_TRUE(IsValidBasicEvent(event));
505 ASSERT_EQ(rtclog::Event::DELAY_BASED_BWE_UPDATE, event.type());
506 const rtclog::DelayBasedBweUpdate& bwe_event = event.delay_based_bwe_update();
507 ASSERT_TRUE(bwe_event.has_bitrate_bps());
508 EXPECT_EQ(bitrate, bwe_event.bitrate_bps());
509 ASSERT_TRUE(bwe_event.has_detector_state());
510 EXPECT_EQ(detector_state,
511 GetRuntimeDetectorState(bwe_event.detector_state()));
512
513 // Check consistency of the parser.
514 ParsedRtcEventLog::BweDelayBasedUpdate res =
515 parsed_log.GetDelayBasedBweUpdate(index);
516 EXPECT_EQ(res.bitrate_bps, bitrate);
517 EXPECT_EQ(res.detector_state, detector_state);
518 }
519
VerifyAudioNetworkAdaptation(const ParsedRtcEventLog & parsed_log,size_t index,const AudioEncoderRuntimeConfig & config)520 void RtcEventLogTestHelper::VerifyAudioNetworkAdaptation(
521 const ParsedRtcEventLog& parsed_log,
522 size_t index,
523 const AudioEncoderRuntimeConfig& config) {
524 AudioEncoderRuntimeConfig parsed_config;
525 parsed_log.GetAudioNetworkAdaptation(index, &parsed_config);
526 EXPECT_EQ(config.bitrate_bps, parsed_config.bitrate_bps);
527 EXPECT_EQ(config.enable_dtx, parsed_config.enable_dtx);
528 EXPECT_EQ(config.enable_fec, parsed_config.enable_fec);
529 EXPECT_EQ(config.frame_length_ms, parsed_config.frame_length_ms);
530 EXPECT_EQ(config.num_channels, parsed_config.num_channels);
531 EXPECT_EQ(config.uplink_packet_loss_fraction,
532 parsed_config.uplink_packet_loss_fraction);
533 }
534
VerifyLogStartEvent(const ParsedRtcEventLog & parsed_log,size_t index)535 void RtcEventLogTestHelper::VerifyLogStartEvent(
536 const ParsedRtcEventLog& parsed_log,
537 size_t index) {
538 ASSERT_LT(index, parsed_log.events_.size());
539 const rtclog::Event& event = parsed_log.events_[index];
540 ASSERT_TRUE(IsValidBasicEvent(event));
541 EXPECT_EQ(rtclog::Event::LOG_START, event.type());
542 }
543
VerifyLogEndEvent(const ParsedRtcEventLog & parsed_log,size_t index)544 void RtcEventLogTestHelper::VerifyLogEndEvent(
545 const ParsedRtcEventLog& parsed_log,
546 size_t index) {
547 ASSERT_LT(index, parsed_log.events_.size());
548 const rtclog::Event& event = parsed_log.events_[index];
549 ASSERT_TRUE(IsValidBasicEvent(event));
550 EXPECT_EQ(rtclog::Event::LOG_END, event.type());
551 }
552
VerifyBweProbeCluster(const ParsedRtcEventLog & parsed_log,size_t index,uint32_t id,uint32_t bitrate_bps,uint32_t min_probes,uint32_t min_bytes)553 void RtcEventLogTestHelper::VerifyBweProbeCluster(
554 const ParsedRtcEventLog& parsed_log,
555 size_t index,
556 uint32_t id,
557 uint32_t bitrate_bps,
558 uint32_t min_probes,
559 uint32_t min_bytes) {
560 ASSERT_LT(index, parsed_log.events_.size());
561 const rtclog::Event& event = parsed_log.events_[index];
562 ASSERT_TRUE(IsValidBasicEvent(event));
563 EXPECT_EQ(rtclog::Event::BWE_PROBE_CLUSTER_CREATED_EVENT, event.type());
564
565 const rtclog::BweProbeCluster& bwe_event = event.probe_cluster();
566 ASSERT_TRUE(bwe_event.has_id());
567 EXPECT_EQ(id, bwe_event.id());
568 ASSERT_TRUE(bwe_event.has_bitrate_bps());
569 EXPECT_EQ(bitrate_bps, bwe_event.bitrate_bps());
570 ASSERT_TRUE(bwe_event.has_min_packets());
571 EXPECT_EQ(min_probes, bwe_event.min_packets());
572 ASSERT_TRUE(bwe_event.has_min_bytes());
573 EXPECT_EQ(min_bytes, bwe_event.min_bytes());
574
575 // TODO(philipel): Verify the parser when parsing has been implemented.
576 }
577
VerifyProbeResultSuccess(const ParsedRtcEventLog & parsed_log,size_t index,uint32_t id,uint32_t bitrate_bps)578 void RtcEventLogTestHelper::VerifyProbeResultSuccess(
579 const ParsedRtcEventLog& parsed_log,
580 size_t index,
581 uint32_t id,
582 uint32_t bitrate_bps) {
583 ASSERT_LT(index, parsed_log.events_.size());
584 const rtclog::Event& event = parsed_log.events_[index];
585 ASSERT_TRUE(IsValidBasicEvent(event));
586 EXPECT_EQ(rtclog::Event::BWE_PROBE_RESULT_EVENT, event.type());
587
588 const rtclog::BweProbeResult& bwe_event = event.probe_result();
589 ASSERT_TRUE(bwe_event.has_id());
590 EXPECT_EQ(id, bwe_event.id());
591 ASSERT_TRUE(bwe_event.has_bitrate_bps());
592 EXPECT_EQ(bitrate_bps, bwe_event.bitrate_bps());
593 ASSERT_TRUE(bwe_event.has_result());
594 EXPECT_EQ(rtclog::BweProbeResult::SUCCESS, bwe_event.result());
595
596 // TODO(philipel): Verify the parser when parsing has been implemented.
597 }
598
VerifyProbeResultFailure(const ParsedRtcEventLog & parsed_log,size_t index,uint32_t id,ProbeFailureReason failure_reason)599 void RtcEventLogTestHelper::VerifyProbeResultFailure(
600 const ParsedRtcEventLog& parsed_log,
601 size_t index,
602 uint32_t id,
603 ProbeFailureReason failure_reason) {
604 ASSERT_LT(index, parsed_log.events_.size());
605 const rtclog::Event& event = parsed_log.events_[index];
606 ASSERT_TRUE(IsValidBasicEvent(event));
607 EXPECT_EQ(rtclog::Event::BWE_PROBE_RESULT_EVENT, event.type());
608
609 const rtclog::BweProbeResult& bwe_event = event.probe_result();
610 ASSERT_TRUE(bwe_event.has_id());
611 EXPECT_EQ(id, bwe_event.id());
612 ASSERT_TRUE(bwe_event.has_result());
613 EXPECT_EQ(GetProbeResultType(failure_reason), bwe_event.result());
614 ASSERT_FALSE(bwe_event.has_bitrate_bps());
615
616 // TODO(philipel): Verify the parser when parsing has been implemented.
617 }
618
619 } // namespace webrtc
620