Remove redundant unit tests for RtcEventLog.
Bug: webrtc:8111 Change-Id: I53c8729ec9d207bbf64d771469a9b0749c7588bf Reviewed-on: https://webrtc-review.googlesource.com/17363 Commit-Queue: Björn Terelius <terelius@webrtc.org> Reviewed-by: Elad Alon <eladalon@webrtc.org> Cr-Commit-Position: refs/heads/master@{#20536}
This commit is contained in:
Bjorn Terelius
Commit Bot
parent
4184bbbdfa
commit
449d295d1a
@ -36,8 +36,10 @@
|
||||
#include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor_config.h"
|
||||
#include "modules/remote_bitrate_estimator/include/bwe_defines.h"
|
||||
#include "modules/rtp_rtcp/source/rtcp_packet/bye.h" // Arbitrary RTCP message.
|
||||
#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
|
||||
#include "modules/rtp_rtcp/source/rtp_packet_received.h"
|
||||
#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
|
||||
#include "rtc_base/arraysize.h"
|
||||
#include "rtc_base/ptr_util.h"
|
||||
#include "rtc_base/random.h"
|
||||
#include "rtc_base/safe_conversions.h"
|
||||
@ -46,8 +48,29 @@
|
||||
namespace webrtc {
|
||||
|
||||
namespace {
|
||||
const char* const arbitrary_uri = // Just a recognized URI.
|
||||
"urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id";
|
||||
struct ExtensionInfo {
|
||||
RTPExtensionType type;
|
||||
const char* uri;
|
||||
};
|
||||
|
||||
template <typename Extension>
|
||||
constexpr ExtensionInfo CreateExtensionInfo() {
|
||||
return {Extension::kId, Extension::kUri};
|
||||
}
|
||||
|
||||
constexpr ExtensionInfo kExtensions[] = {
|
||||
CreateExtensionInfo<TransmissionOffset>(),
|
||||
CreateExtensionInfo<AudioLevel>(),
|
||||
CreateExtensionInfo<AbsoluteSendTime>(),
|
||||
CreateExtensionInfo<VideoOrientation>(),
|
||||
CreateExtensionInfo<TransportSequenceNumber>(),
|
||||
CreateExtensionInfo<PlayoutDelayLimits>(),
|
||||
CreateExtensionInfo<VideoContentTypeExtension>(),
|
||||
CreateExtensionInfo<VideoTimingExtension>(),
|
||||
CreateExtensionInfo<RtpStreamId>(),
|
||||
CreateExtensionInfo<RepairedRtpStreamId>(),
|
||||
CreateExtensionInfo<RtpMid>(),
|
||||
};
|
||||
} // namespace
|
||||
|
||||
class RtcEventLogEncoderTest : public testing::TestWithParam<int> {
|
||||
@ -82,9 +105,15 @@ class RtcEventLogEncoderTest : public testing::TestWithParam<int> {
|
||||
return prng_.Rand(std::numeric_limits<uint32_t>::max());
|
||||
}
|
||||
|
||||
int RandomRtpExtensionId() {
|
||||
return static_cast<int>(
|
||||
prng_.Rand(RtpExtension::kMinId, RtpExtension::kMaxId));
|
||||
std::vector<RtpExtension> RandomRtpExtensions() {
|
||||
RTC_DCHECK(arraysize(kExtensions) >= 2);
|
||||
size_t id_1 = prng_.Rand(0u, arraysize(kExtensions) - 1);
|
||||
size_t id_2 = prng_.Rand(0u, arraysize(kExtensions) - 2);
|
||||
if (id_2 == id_1)
|
||||
id_2 = arraysize(kExtensions) - 1;
|
||||
return std::vector<RtpExtension>{
|
||||
RtpExtension(kExtensions[id_1].uri, kExtensions[id_1].type),
|
||||
RtpExtension(kExtensions[id_2].uri, kExtensions[id_2].type)};
|
||||
}
|
||||
|
||||
int RandomBitrate() { return RandomInt(); }
|
||||
@ -209,9 +238,11 @@ TEST_P(RtcEventLogEncoderTest, RtcEventAudioReceiveStreamConfig) {
|
||||
auto stream_config = rtc::MakeUnique<rtclog::StreamConfig>();
|
||||
stream_config->local_ssrc = RandomSsrc();
|
||||
stream_config->remote_ssrc = RandomSsrc();
|
||||
// TODO(eladalon): !!! Validate this, here and elsewhere.
|
||||
stream_config->rtp_extensions.push_back(
|
||||
RtpExtension(arbitrary_uri, RandomRtpExtensionId()));
|
||||
// TODO(eladalon): Verify that the extensions are used correctly when
|
||||
// parsing RTP packets headers. Here and elsewhere.
|
||||
std::vector<RtpExtension> extensions = RandomRtpExtensions();
|
||||
for (const auto& extension : extensions)
|
||||
stream_config->rtp_extensions.push_back(extension);
|
||||
|
||||
auto original_stream_config = *stream_config;
|
||||
|
||||
@ -232,8 +263,9 @@ TEST_P(RtcEventLogEncoderTest, RtcEventAudioReceiveStreamConfig) {
|
||||
TEST_P(RtcEventLogEncoderTest, RtcEventAudioSendStreamConfig) {
|
||||
auto stream_config = rtc::MakeUnique<rtclog::StreamConfig>();
|
||||
stream_config->local_ssrc = RandomSsrc();
|
||||
stream_config->rtp_extensions.push_back(
|
||||
RtpExtension(arbitrary_uri, RandomRtpExtensionId()));
|
||||
std::vector<RtpExtension> extensions = RandomRtpExtensions();
|
||||
for (const auto& extension : extensions)
|
||||
stream_config->rtp_extensions.push_back(extension);
|
||||
|
||||
auto original_stream_config = *stream_config;
|
||||
|
||||
@ -440,6 +472,8 @@ void RtcEventLogEncoderTest::TestRtcEventRtpPacket(PacketDirection direction) {
|
||||
packet->SetSsrc(RandomSsrc());
|
||||
packet->SetSequenceNumber(static_cast<uint16_t>(RandomInt()));
|
||||
packet->SetPayloadSize(prng_.Rand(0u, 1000u));
|
||||
// TODO(terelius): Add marker bit, capture timestamp, CSRCs, and header
|
||||
// extensions.
|
||||
|
||||
std::unique_ptr<RtcEvent> event;
|
||||
if (direction == PacketDirection::kIncomingPacket) {
|
||||
@ -487,8 +521,9 @@ TEST_P(RtcEventLogEncoderTest, RtcEventVideoReceiveStreamConfig) {
|
||||
stream_config->remote_ssrc = RandomSsrc();
|
||||
stream_config->rtcp_mode = RtcpMode::kCompound;
|
||||
stream_config->remb = prng_.Rand<bool>();
|
||||
stream_config->rtp_extensions.push_back(
|
||||
RtpExtension(arbitrary_uri, RandomRtpExtensionId()));
|
||||
std::vector<RtpExtension> extensions = RandomRtpExtensions();
|
||||
for (const auto& extension : extensions)
|
||||
stream_config->rtp_extensions.push_back(extension);
|
||||
stream_config->codecs.emplace_back("CODEC", 122, 7);
|
||||
|
||||
auto original_stream_config = *stream_config;
|
||||
@ -510,8 +545,9 @@ TEST_P(RtcEventLogEncoderTest, RtcEventVideoReceiveStreamConfig) {
|
||||
TEST_P(RtcEventLogEncoderTest, RtcEventVideoSendStreamConfig) {
|
||||
auto stream_config = rtc::MakeUnique<rtclog::StreamConfig>();
|
||||
stream_config->local_ssrc = RandomSsrc();
|
||||
stream_config->rtp_extensions.push_back(
|
||||
RtpExtension(arbitrary_uri, RandomRtpExtensionId()));
|
||||
std::vector<RtpExtension> extensions = RandomRtpExtensions();
|
||||
for (const auto& extension : extensions)
|
||||
stream_config->rtp_extensions.push_back(extension);
|
||||
stream_config->codecs.emplace_back("CODEC", 120, 3);
|
||||
|
||||
auto original_stream_config = *stream_config;
|
||||
|
||||
@ -717,473 +717,4 @@ TEST(RtcEventLogTest, LogSessionAndReadBackAllCombinations) {
|
||||
}
|
||||
}
|
||||
|
||||
TEST(RtcEventLogTest, LogEventAndReadBack) {
|
||||
Random prng(987654321);
|
||||
|
||||
// Create one RTP and one RTCP packet containing random data.
|
||||
size_t packet_size = prng.Rand(1000, 1100);
|
||||
RtpPacketReceived rtp_packet =
|
||||
GenerateIncomingRtpPacket(nullptr, 0, packet_size, &prng);
|
||||
rtc::Buffer rtcp_packet = GenerateRtcpPacket(&prng);
|
||||
|
||||
// Find the name of the current test, in order to use it as a temporary
|
||||
// filename.
|
||||
auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
|
||||
const std::string temp_filename =
|
||||
test::OutputPath() + test_info->test_case_name() + test_info->name();
|
||||
|
||||
// Add RTP, start logging, add RTCP and then stop logging
|
||||
rtc::ScopedFakeClock fake_clock;
|
||||
fake_clock.SetTimeMicros(prng.Rand<uint32_t>());
|
||||
std::unique_ptr<RtcEventLog> log_dumper(
|
||||
RtcEventLog::Create(RtcEventLog::EncodingType::Legacy));
|
||||
|
||||
log_dumper->Log(rtc::MakeUnique<RtcEventRtpPacketIncoming>(rtp_packet));
|
||||
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
|
||||
|
||||
log_dumper->StartLogging(
|
||||
rtc::MakeUnique<RtcEventLogOutputFile>(temp_filename, 10000000));
|
||||
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
|
||||
|
||||
log_dumper->Log(rtc::MakeUnique<RtcEventRtcpPacketOutgoing>(rtcp_packet));
|
||||
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
|
||||
|
||||
log_dumper->StopLogging();
|
||||
|
||||
// Read the generated file from disk.
|
||||
ParsedRtcEventLog parsed_log;
|
||||
ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
|
||||
|
||||
// Verify that what we read back from the event log is the same as
|
||||
// what we wrote down.
|
||||
EXPECT_EQ(4u, parsed_log.GetNumberOfEvents());
|
||||
|
||||
RtcEventLogTestHelper::VerifyLogStartEvent(parsed_log, 0);
|
||||
|
||||
RtcEventLogTestHelper::VerifyIncomingRtpEvent(parsed_log, 1, rtp_packet);
|
||||
|
||||
RtcEventLogTestHelper::VerifyRtcpEvent(
|
||||
parsed_log, 2, kOutgoingPacket, rtcp_packet.data(), rtcp_packet.size());
|
||||
|
||||
RtcEventLogTestHelper::VerifyLogEndEvent(parsed_log, 3);
|
||||
|
||||
// Clean up temporary file - can be pretty slow.
|
||||
remove(temp_filename.c_str());
|
||||
}
|
||||
|
||||
TEST(RtcEventLogTest, LogLossBasedBweUpdateAndReadBack) {
|
||||
Random prng(1234);
|
||||
|
||||
// Generate a random packet loss event.
|
||||
int32_t bitrate = prng.Rand(0, 10000000);
|
||||
uint8_t fraction_lost = prng.Rand<uint8_t>();
|
||||
int32_t total_packets = prng.Rand(1, 1000);
|
||||
|
||||
// Find the name of the current test, in order to use it as a temporary
|
||||
// filename.
|
||||
auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
|
||||
const std::string temp_filename =
|
||||
test::OutputPath() + test_info->test_case_name() + test_info->name();
|
||||
|
||||
// Start logging, add the packet loss event and then stop logging.
|
||||
rtc::ScopedFakeClock fake_clock;
|
||||
fake_clock.SetTimeMicros(prng.Rand<uint32_t>());
|
||||
std::unique_ptr<RtcEventLog> log_dumper(
|
||||
RtcEventLog::Create(RtcEventLog::EncodingType::Legacy));
|
||||
log_dumper->StartLogging(
|
||||
rtc::MakeUnique<RtcEventLogOutputFile>(temp_filename, 10000000));
|
||||
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
|
||||
log_dumper->Log(rtc::MakeUnique<RtcEventBweUpdateLossBased>(
|
||||
bitrate, fraction_lost, total_packets));
|
||||
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
|
||||
log_dumper->StopLogging();
|
||||
|
||||
// Read the generated file from disk.
|
||||
ParsedRtcEventLog parsed_log;
|
||||
ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
|
||||
|
||||
// Verify that what we read back from the event log is the same as
|
||||
// what we wrote down.
|
||||
EXPECT_EQ(3u, parsed_log.GetNumberOfEvents());
|
||||
RtcEventLogTestHelper::VerifyLogStartEvent(parsed_log, 0);
|
||||
RtcEventLogTestHelper::VerifyBweLossEvent(parsed_log, 1, bitrate,
|
||||
fraction_lost, total_packets);
|
||||
RtcEventLogTestHelper::VerifyLogEndEvent(parsed_log, 2);
|
||||
|
||||
// Clean up temporary file - can be pretty slow.
|
||||
remove(temp_filename.c_str());
|
||||
}
|
||||
|
||||
TEST(RtcEventLogTest, LogDelayBasedBweUpdateAndReadBack) {
|
||||
Random prng(1234);
|
||||
|
||||
// Generate 3 random packet delay event.
|
||||
int32_t bitrate1 = prng.Rand(0, 10000000);
|
||||
int32_t bitrate2 = prng.Rand(0, 10000000);
|
||||
int32_t bitrate3 = prng.Rand(0, 10000000);
|
||||
|
||||
// Find the name of the current test, in order to use it as a temporary
|
||||
// filename.
|
||||
auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
|
||||
const std::string temp_filename =
|
||||
test::OutputPath() + test_info->test_case_name() + test_info->name();
|
||||
|
||||
// Start logging, add the packet delay events and then stop logging.
|
||||
rtc::ScopedFakeClock fake_clock;
|
||||
fake_clock.SetTimeMicros(prng.Rand<uint32_t>());
|
||||
std::unique_ptr<RtcEventLog> log_dumper(
|
||||
RtcEventLog::Create(RtcEventLog::EncodingType::Legacy));
|
||||
log_dumper->StartLogging(
|
||||
rtc::MakeUnique<RtcEventLogOutputFile>(temp_filename, 10000000));
|
||||
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
|
||||
log_dumper->Log(rtc::MakeUnique<RtcEventBweUpdateDelayBased>(
|
||||
bitrate1, BandwidthUsage::kBwNormal));
|
||||
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
|
||||
log_dumper->Log(rtc::MakeUnique<RtcEventBweUpdateDelayBased>(
|
||||
bitrate2, BandwidthUsage::kBwOverusing));
|
||||
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
|
||||
log_dumper->Log(rtc::MakeUnique<RtcEventBweUpdateDelayBased>(
|
||||
bitrate3, BandwidthUsage::kBwUnderusing));
|
||||
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
|
||||
log_dumper->StopLogging();
|
||||
|
||||
// Read the generated file from disk.
|
||||
ParsedRtcEventLog parsed_log;
|
||||
ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
|
||||
|
||||
// Verify that what we read back from the event log is the same as
|
||||
// what we wrote down.
|
||||
EXPECT_EQ(5u, parsed_log.GetNumberOfEvents());
|
||||
RtcEventLogTestHelper::VerifyLogStartEvent(parsed_log, 0);
|
||||
RtcEventLogTestHelper::VerifyBweDelayEvent(parsed_log, 1, bitrate1,
|
||||
BandwidthUsage::kBwNormal);
|
||||
RtcEventLogTestHelper::VerifyBweDelayEvent(parsed_log, 2, bitrate2,
|
||||
BandwidthUsage::kBwOverusing);
|
||||
RtcEventLogTestHelper::VerifyBweDelayEvent(parsed_log, 3, bitrate3,
|
||||
BandwidthUsage::kBwUnderusing);
|
||||
RtcEventLogTestHelper::VerifyLogEndEvent(parsed_log, 4);
|
||||
|
||||
// Clean up temporary file - can be pretty slow.
|
||||
remove(temp_filename.c_str());
|
||||
}
|
||||
|
||||
TEST(RtcEventLogTest, LogProbeClusterCreatedAndReadBack) {
|
||||
Random prng(794613);
|
||||
|
||||
int bitrate_bps0 = prng.Rand(0, 10000000);
|
||||
int bitrate_bps1 = prng.Rand(0, 10000000);
|
||||
int bitrate_bps2 = prng.Rand(0, 10000000);
|
||||
int min_probes0 = prng.Rand(0, 100);
|
||||
int min_probes1 = prng.Rand(0, 100);
|
||||
int min_probes2 = prng.Rand(0, 100);
|
||||
int min_bytes0 = prng.Rand(0, 10000);
|
||||
int min_bytes1 = prng.Rand(0, 10000);
|
||||
int min_bytes2 = prng.Rand(0, 10000);
|
||||
|
||||
// Find the name of the current test, in order to use it as a temporary
|
||||
// filename.
|
||||
auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
|
||||
const std::string temp_filename =
|
||||
test::OutputPath() + test_info->test_case_name() + test_info->name();
|
||||
|
||||
rtc::ScopedFakeClock fake_clock;
|
||||
fake_clock.SetTimeMicros(prng.Rand<uint32_t>());
|
||||
std::unique_ptr<RtcEventLog> log_dumper(
|
||||
RtcEventLog::Create(RtcEventLog::EncodingType::Legacy));
|
||||
|
||||
log_dumper->StartLogging(
|
||||
rtc::MakeUnique<RtcEventLogOutputFile>(temp_filename, 10000000));
|
||||
log_dumper->Log(rtc::MakeUnique<RtcEventProbeClusterCreated>(
|
||||
0, bitrate_bps0, min_probes0, min_bytes0));
|
||||
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
|
||||
log_dumper->Log(rtc::MakeUnique<RtcEventProbeClusterCreated>(
|
||||
1, bitrate_bps1, min_probes1, min_bytes1));
|
||||
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
|
||||
log_dumper->Log(rtc::MakeUnique<RtcEventProbeClusterCreated>(
|
||||
2, bitrate_bps2, min_probes2, min_bytes2));
|
||||
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
|
||||
log_dumper->StopLogging();
|
||||
|
||||
// Read the generated file from disk.
|
||||
ParsedRtcEventLog parsed_log;
|
||||
ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
|
||||
|
||||
// Verify that what we read back from the event log is the same as
|
||||
// what we wrote down.
|
||||
EXPECT_EQ(5u, parsed_log.GetNumberOfEvents());
|
||||
RtcEventLogTestHelper::VerifyLogStartEvent(parsed_log, 0);
|
||||
RtcEventLogTestHelper::VerifyBweProbeCluster(parsed_log, 1, 0, bitrate_bps0,
|
||||
min_probes0, min_bytes0);
|
||||
RtcEventLogTestHelper::VerifyBweProbeCluster(parsed_log, 2, 1, bitrate_bps1,
|
||||
min_probes1, min_bytes1);
|
||||
RtcEventLogTestHelper::VerifyBweProbeCluster(parsed_log, 3, 2, bitrate_bps2,
|
||||
min_probes2, min_bytes2);
|
||||
RtcEventLogTestHelper::VerifyLogEndEvent(parsed_log, 4);
|
||||
|
||||
// Clean up temporary file - can be pretty slow.
|
||||
remove(temp_filename.c_str());
|
||||
}
|
||||
|
||||
TEST(RtcEventLogTest, LogProbeResultSuccessAndReadBack) {
|
||||
Random prng(192837);
|
||||
|
||||
int bitrate_bps0 = prng.Rand(0, 10000000);
|
||||
int bitrate_bps1 = prng.Rand(0, 10000000);
|
||||
int bitrate_bps2 = prng.Rand(0, 10000000);
|
||||
|
||||
// Find the name of the current test, in order to use it as a temporary
|
||||
// filename.
|
||||
auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
|
||||
const std::string temp_filename =
|
||||
test::OutputPath() + test_info->test_case_name() + test_info->name();
|
||||
|
||||
rtc::ScopedFakeClock fake_clock;
|
||||
fake_clock.SetTimeMicros(prng.Rand<uint32_t>());
|
||||
std::unique_ptr<RtcEventLog> log_dumper(
|
||||
RtcEventLog::Create(RtcEventLog::EncodingType::Legacy));
|
||||
|
||||
log_dumper->StartLogging(
|
||||
rtc::MakeUnique<RtcEventLogOutputFile>(temp_filename, 10000000));
|
||||
log_dumper->Log(rtc::MakeUnique<RtcEventProbeResultSuccess>(0, bitrate_bps0));
|
||||
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
|
||||
log_dumper->Log(rtc::MakeUnique<RtcEventProbeResultSuccess>(1, bitrate_bps1));
|
||||
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
|
||||
log_dumper->Log(rtc::MakeUnique<RtcEventProbeResultSuccess>(2, bitrate_bps2));
|
||||
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
|
||||
log_dumper->StopLogging();
|
||||
|
||||
// Read the generated file from disk.
|
||||
ParsedRtcEventLog parsed_log;
|
||||
ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
|
||||
|
||||
// Verify that what we read back from the event log is the same as
|
||||
// what we wrote down.
|
||||
EXPECT_EQ(5u, parsed_log.GetNumberOfEvents());
|
||||
RtcEventLogTestHelper::VerifyLogStartEvent(parsed_log, 0);
|
||||
RtcEventLogTestHelper::VerifyProbeResultSuccess(parsed_log, 1, 0,
|
||||
bitrate_bps0);
|
||||
RtcEventLogTestHelper::VerifyProbeResultSuccess(parsed_log, 2, 1,
|
||||
bitrate_bps1);
|
||||
RtcEventLogTestHelper::VerifyProbeResultSuccess(parsed_log, 3, 2,
|
||||
bitrate_bps2);
|
||||
RtcEventLogTestHelper::VerifyLogEndEvent(parsed_log, 4);
|
||||
|
||||
// Clean up temporary file - can be pretty slow.
|
||||
remove(temp_filename.c_str());
|
||||
}
|
||||
|
||||
TEST(RtcEventLogTest, LogProbeResultFailureAndReadBack) {
|
||||
Random prng(192837);
|
||||
|
||||
// Find the name of the current test, in order to use it as a temporary
|
||||
// filename.
|
||||
auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
|
||||
const std::string temp_filename =
|
||||
test::OutputPath() + test_info->test_case_name() + test_info->name();
|
||||
|
||||
rtc::ScopedFakeClock fake_clock;
|
||||
fake_clock.SetTimeMicros(prng.Rand<uint32_t>());
|
||||
std::unique_ptr<RtcEventLog> log_dumper(
|
||||
RtcEventLog::Create(RtcEventLog::EncodingType::Legacy));
|
||||
|
||||
log_dumper->StartLogging(
|
||||
rtc::MakeUnique<RtcEventLogOutputFile>(temp_filename, 10000000));
|
||||
log_dumper->Log(rtc::MakeUnique<RtcEventProbeResultFailure>(
|
||||
0, ProbeFailureReason::kInvalidSendReceiveInterval));
|
||||
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
|
||||
log_dumper->Log(rtc::MakeUnique<RtcEventProbeResultFailure>(
|
||||
1, ProbeFailureReason::kInvalidSendReceiveRatio));
|
||||
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
|
||||
log_dumper->Log(rtc::MakeUnique<RtcEventProbeResultFailure>(
|
||||
2, ProbeFailureReason::kTimeout));
|
||||
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
|
||||
log_dumper->StopLogging();
|
||||
|
||||
// Read the generated file from disk.
|
||||
ParsedRtcEventLog parsed_log;
|
||||
ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
|
||||
|
||||
// Verify that what we read back from the event log is the same as
|
||||
// what we wrote down.
|
||||
EXPECT_EQ(5u, parsed_log.GetNumberOfEvents());
|
||||
RtcEventLogTestHelper::VerifyLogStartEvent(parsed_log, 0);
|
||||
RtcEventLogTestHelper::VerifyProbeResultFailure(
|
||||
parsed_log, 1, 0, ProbeFailureReason::kInvalidSendReceiveInterval);
|
||||
RtcEventLogTestHelper::VerifyProbeResultFailure(
|
||||
parsed_log, 2, 1, ProbeFailureReason::kInvalidSendReceiveRatio);
|
||||
RtcEventLogTestHelper::VerifyProbeResultFailure(parsed_log, 3, 2,
|
||||
ProbeFailureReason::kTimeout);
|
||||
RtcEventLogTestHelper::VerifyLogEndEvent(parsed_log, 4);
|
||||
|
||||
// Clean up temporary file - can be pretty slow.
|
||||
remove(temp_filename.c_str());
|
||||
}
|
||||
|
||||
class ConfigReadWriteTest {
|
||||
public:
|
||||
ConfigReadWriteTest() : prng(987654321) {}
|
||||
virtual ~ConfigReadWriteTest() {}
|
||||
virtual void GenerateConfig(const RtpHeaderExtensionMap& extensions) = 0;
|
||||
virtual void VerifyConfig(const ParsedRtcEventLog& parsed_log,
|
||||
size_t index) = 0;
|
||||
virtual void LogConfig(RtcEventLog* event_log) = 0;
|
||||
|
||||
void DoTest() {
|
||||
// Find the name of the current test, in order to use it as a temporary
|
||||
// filename.
|
||||
auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
|
||||
const std::string temp_filename =
|
||||
test::OutputPath() + test_info->test_case_name() + test_info->name();
|
||||
|
||||
// Use all extensions.
|
||||
RtpHeaderExtensionMap extensions;
|
||||
for (uint32_t i = 0; i < kNumExtensions; i++) {
|
||||
extensions.Register(kExtensionTypes[i], kExtensionIds[i]);
|
||||
}
|
||||
GenerateConfig(extensions);
|
||||
|
||||
// Log a single config event and stop logging.
|
||||
rtc::ScopedFakeClock fake_clock;
|
||||
fake_clock.SetTimeMicros(prng.Rand<uint32_t>());
|
||||
std::unique_ptr<RtcEventLog> log_dumper(
|
||||
RtcEventLog::Create(RtcEventLog::EncodingType::Legacy));
|
||||
|
||||
log_dumper->StartLogging(
|
||||
rtc::MakeUnique<RtcEventLogOutputFile>(temp_filename, 10000000));
|
||||
LogConfig(log_dumper.get());
|
||||
log_dumper->StopLogging();
|
||||
|
||||
// Read the generated file from disk.
|
||||
ParsedRtcEventLog parsed_log;
|
||||
ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
|
||||
|
||||
// Check the generated number of events.
|
||||
EXPECT_EQ(3u, parsed_log.GetNumberOfEvents());
|
||||
|
||||
RtcEventLogTestHelper::VerifyLogStartEvent(parsed_log, 0);
|
||||
|
||||
// Verify that the parsed config struct matches the one that was logged.
|
||||
VerifyConfig(parsed_log, 1);
|
||||
|
||||
RtcEventLogTestHelper::VerifyLogEndEvent(parsed_log, 2);
|
||||
|
||||
// Clean up temporary file - can be pretty slow.
|
||||
remove(temp_filename.c_str());
|
||||
}
|
||||
Random prng;
|
||||
};
|
||||
|
||||
class AudioReceiveConfigReadWriteTest : public ConfigReadWriteTest {
|
||||
public:
|
||||
void GenerateConfig(const RtpHeaderExtensionMap& extensions) override {
|
||||
GenerateAudioReceiveConfig(extensions, &config, &prng);
|
||||
}
|
||||
void LogConfig(RtcEventLog* event_log) override {
|
||||
event_log->Log(rtc::MakeUnique<RtcEventAudioReceiveStreamConfig>(
|
||||
rtc::MakeUnique<rtclog::StreamConfig>(config)));
|
||||
}
|
||||
void VerifyConfig(const ParsedRtcEventLog& parsed_log,
|
||||
size_t index) override {
|
||||
RtcEventLogTestHelper::VerifyAudioReceiveStreamConfig(parsed_log, index,
|
||||
config);
|
||||
}
|
||||
rtclog::StreamConfig config;
|
||||
};
|
||||
|
||||
class AudioSendConfigReadWriteTest : public ConfigReadWriteTest {
|
||||
public:
|
||||
AudioSendConfigReadWriteTest() {}
|
||||
void GenerateConfig(const RtpHeaderExtensionMap& extensions) override {
|
||||
GenerateAudioSendConfig(extensions, &config, &prng);
|
||||
}
|
||||
void LogConfig(RtcEventLog* event_log) override {
|
||||
event_log->Log(rtc::MakeUnique<RtcEventAudioSendStreamConfig>(
|
||||
rtc::MakeUnique<rtclog::StreamConfig>(config)));
|
||||
}
|
||||
void VerifyConfig(const ParsedRtcEventLog& parsed_log,
|
||||
size_t index) override {
|
||||
RtcEventLogTestHelper::VerifyAudioSendStreamConfig(parsed_log, index,
|
||||
config);
|
||||
}
|
||||
rtclog::StreamConfig config;
|
||||
};
|
||||
|
||||
class VideoReceiveConfigReadWriteTest : public ConfigReadWriteTest {
|
||||
public:
|
||||
VideoReceiveConfigReadWriteTest() {}
|
||||
void GenerateConfig(const RtpHeaderExtensionMap& extensions) override {
|
||||
GenerateVideoReceiveConfig(extensions, &config, &prng);
|
||||
}
|
||||
void LogConfig(RtcEventLog* event_log) override {
|
||||
event_log->Log(rtc::MakeUnique<RtcEventVideoReceiveStreamConfig>(
|
||||
rtc::MakeUnique<rtclog::StreamConfig>(config)));
|
||||
}
|
||||
void VerifyConfig(const ParsedRtcEventLog& parsed_log,
|
||||
size_t index) override {
|
||||
RtcEventLogTestHelper::VerifyVideoReceiveStreamConfig(parsed_log, index,
|
||||
config);
|
||||
}
|
||||
rtclog::StreamConfig config;
|
||||
};
|
||||
|
||||
class VideoSendConfigReadWriteTest : public ConfigReadWriteTest {
|
||||
public:
|
||||
VideoSendConfigReadWriteTest() {}
|
||||
void GenerateConfig(const RtpHeaderExtensionMap& extensions) override {
|
||||
GenerateVideoSendConfig(extensions, &config, &prng);
|
||||
}
|
||||
void LogConfig(RtcEventLog* event_log) override {
|
||||
event_log->Log(rtc::MakeUnique<RtcEventVideoSendStreamConfig>(
|
||||
rtc::MakeUnique<rtclog::StreamConfig>(config)));
|
||||
}
|
||||
void VerifyConfig(const ParsedRtcEventLog& parsed_log,
|
||||
size_t index) override {
|
||||
RtcEventLogTestHelper::VerifyVideoSendStreamConfig(parsed_log, index,
|
||||
config);
|
||||
}
|
||||
rtclog::StreamConfig config;
|
||||
};
|
||||
|
||||
class AudioNetworkAdaptationReadWriteTest : public ConfigReadWriteTest {
|
||||
public:
|
||||
void GenerateConfig(const RtpHeaderExtensionMap& extensions) override {
|
||||
GenerateAudioNetworkAdaptation(extensions, &config, &prng);
|
||||
}
|
||||
void LogConfig(RtcEventLog* event_log) override {
|
||||
event_log->Log(rtc::MakeUnique<RtcEventAudioNetworkAdaptation>(
|
||||
rtc::MakeUnique<AudioEncoderRuntimeConfig>(config)));
|
||||
}
|
||||
void VerifyConfig(const ParsedRtcEventLog& parsed_log,
|
||||
size_t index) override {
|
||||
RtcEventLogTestHelper::VerifyAudioNetworkAdaptation(parsed_log, index,
|
||||
config);
|
||||
}
|
||||
AudioEncoderRuntimeConfig config;
|
||||
};
|
||||
|
||||
TEST(RtcEventLogTest, LogAudioReceiveConfig) {
|
||||
AudioReceiveConfigReadWriteTest test;
|
||||
test.DoTest();
|
||||
}
|
||||
|
||||
TEST(RtcEventLogTest, LogAudioSendConfig) {
|
||||
AudioSendConfigReadWriteTest test;
|
||||
test.DoTest();
|
||||
}
|
||||
|
||||
TEST(RtcEventLogTest, LogVideoReceiveConfig) {
|
||||
VideoReceiveConfigReadWriteTest test;
|
||||
test.DoTest();
|
||||
}
|
||||
|
||||
TEST(RtcEventLogTest, LogVideoSendConfig) {
|
||||
VideoSendConfigReadWriteTest test;
|
||||
test.DoTest();
|
||||
}
|
||||
|
||||
TEST(RtcEventLogTest, LogAudioNetworkAdaptation) {
|
||||
AudioNetworkAdaptationReadWriteTest test;
|
||||
test.DoTest();
|
||||
}
|
||||
|
||||
} // namespace webrtc
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user