admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replaces call config create in tests with modify.

Browse Source 
This ensures the event logs in CallTest will be used by default.

Bug: webrtc:9510
Change-Id: I9df82b5ef39e1b2cba2789f8c5c7a9fed3c4c2f6
Reviewed-on: https://webrtc-review.googlesource.com/88562
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Erik Språng <sprang@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23970}
This commit is contained in:
Sebastian Jansson 2018-07-13 13:19:42 +02:00 committed by Commit Bot
parent 3bd2c7976b
commit 7258224c3b
12 changed files with 48 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
call/call_perf_tests.cc
View File

@ -724,11 +724,8 @@ TEST_F(CallPerfTest, MAYBE_KeepsHighBitrateWhenReconfiguringSender) {
return FakeEncoder::SetRateAllocation(rate_allocation, framerate);
}
Call::Config GetSenderCallConfig() override {
Call::Config config = EndToEndTest::GetSenderCallConfig();
config.event_log = event_log_.get();
config.bitrate_config.start_bitrate_bps = kInitialBitrateKbps * 1000;
return config;
void ModifySenderCallConfig(Call::Config* config) override {
config->bitrate_config.start_bitrate_bps = kInitialBitrateKbps * 1000;
}
void ModifyVideoConfigs(

14
call/rampup_tests.cc
View File

@ -77,13 +77,11 @@ RampUpTester::RampUpTester(size_t num_video_streams,
RampUpTester::~RampUpTester() {}
Call::Config RampUpTester::GetSenderCallConfig() {
Call::Config call_config(&event_log_);
void RampUpTester::ModifySenderCallConfig(Call::Config* config) {
if (start_bitrate_bps_ != 0) {
call_config.bitrate_config.start_bitrate_bps = start_bitrate_bps_;
config->bitrate_config.start_bitrate_bps = start_bitrate_bps_;
}
call_config.bitrate_config.min_bitrate_bps = 10000;
return call_config;
config->bitrate_config.min_bitrate_bps = 10000;
}
void RampUpTester::OnVideoStreamsCreated(
@ -438,10 +436,8 @@ void RampUpDownUpTester::PollStats() {
} while (!stop_event_.Wait(kPollIntervalMs));
}
Call::Config RampUpDownUpTester::GetReceiverCallConfig() {
Call::Config config(&event_log_);
config.bitrate_config.min_bitrate_bps = 10000;
return config;
void RampUpDownUpTester::ModifyReceiverCallConfig(Call::Config* config) {
config->bitrate_config.min_bitrate_bps = 10000;
}
std::string RampUpDownUpTester::GetModifierString() const {

5
call/rampup_tests.h
View File

@ -62,7 +62,6 @@ class RampUpTester : public test::EndToEndTest {
const std::string& units) const;
void TriggerTestDone();
webrtc::RtcEventLogNullImpl event_log_;
rtc::Event stop_event_;
Clock* const clock_;
FakeNetworkPipe::Config forward_transport_config_;
@ -80,7 +79,7 @@ class RampUpTester : public test::EndToEndTest {
typedef std::map<uint32_t, uint32_t> SsrcMap;
class VideoStreamFactory;
Call::Config GetSenderCallConfig() override;
void ModifySenderCallConfig(Call::Config* config) override;
void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override;
@ -139,7 +138,7 @@ class RampUpDownUpTester : public RampUpTester {
kTransitionToNextState,
};
Call::Config GetReceiverCallConfig() override;
void ModifyReceiverCallConfig(Call::Config* config);
std::string GetModifierString() const;
int GetExpectedHighBitrate() const;

23
test/call_test.cc
View File

@ -63,7 +63,8 @@ void CallTest::RunBaseTest(BaseTest* test) {
num_audio_streams_ = test->GetNumAudioStreams();
num_flexfec_streams_ = test->GetNumFlexfecStreams();
RTC_DCHECK(num_video_streams_ > 0 || num_audio_streams_ > 0);
Call::Config send_config(test->GetSenderCallConfig());
Call::Config send_config(send_event_log_.get());
test->ModifySenderCallConfig(&send_config);
if (num_audio_streams_ > 0) {
CreateFakeAudioDevices(test->CreateCapturer(), test->CreateRenderer());
test->OnFakeAudioDevicesCreated(fake_send_audio_device_.get(),
@ -86,7 +87,8 @@ void CallTest::RunBaseTest(BaseTest* test) {
sender_call_transport_controller_);
}
if (test->ShouldCreateReceivers()) {
Call::Config recv_config(test->GetReceiverCallConfig());
Call::Config recv_config(recv_event_log_.get());
test->ModifyReceiverCallConfig(&recv_config);
if (num_audio_streams_ > 0) {
AudioState::Config audio_state_config;
audio_state_config.audio_mixer = AudioMixerImpl::Create();
@ -683,10 +685,9 @@ const std::map<uint8_t, MediaType> CallTest::payload_type_map_ = {
{CallTest::kAudioSendPayloadType, MediaType::AUDIO},
{CallTest::kDefaultKeepalivePayloadType, MediaType::ANY}};
BaseTest::BaseTest() : event_log_(RtcEventLog::CreateNull()) {}
BaseTest::BaseTest() {}
BaseTest::BaseTest(unsigned int timeout_ms)
: RtpRtcpObserver(timeout_ms), event_log_(RtcEventLog::CreateNull()) {}
BaseTest::BaseTest(int timeout_ms) : RtpRtcpObserver(timeout_ms) {}
BaseTest::~BaseTest() {}
@ -702,13 +703,9 @@ void BaseTest::OnFakeAudioDevicesCreated(
TestAudioDeviceModule* send_audio_device,
TestAudioDeviceModule* recv_audio_device) {}
Call::Config BaseTest::GetSenderCallConfig() {
return Call::Config(event_log_.get());
}
void BaseTest::ModifySenderCallConfig(Call::Config* config) {}
Call::Config BaseTest::GetReceiverCallConfig() {
return Call::Config(event_log_.get());
}
void BaseTest::ModifyReceiverCallConfig(Call::Config* config) {}
void BaseTest::OnRtpTransportControllerSendCreated(
RtpTransportControllerSend* controller) {}
@ -774,7 +771,7 @@ void BaseTest::OnFrameGeneratorCapturerCreated(
void BaseTest::OnStreamsStopped() {}
SendTest::SendTest(unsigned int timeout_ms) : BaseTest(timeout_ms) {}
SendTest::SendTest(int timeout_ms) : BaseTest(timeout_ms) {}
bool SendTest::ShouldCreateReceivers() const {
return false;
@ -782,7 +779,7 @@ bool SendTest::ShouldCreateReceivers() const {
EndToEndTest::EndToEndTest() {}
EndToEndTest::EndToEndTest(unsigned int timeout_ms) : BaseTest(timeout_ms) {}
EndToEndTest::EndToEndTest(int timeout_ms) : BaseTest(timeout_ms) {}
bool EndToEndTest::ShouldCreateReceivers() const {
return true;

13
test/call_test.h
View File

@ -219,7 +219,7 @@ class CallTest : public ::testing::Test {
class BaseTest : public RtpRtcpObserver {
public:
BaseTest();
explicit BaseTest(unsigned int timeout_ms);
explicit BaseTest(int timeout_ms);
virtual ~BaseTest();
virtual void PerformTest() = 0;
@ -235,8 +235,9 @@ class BaseTest : public RtpRtcpObserver {
TestAudioDeviceModule* send_audio_device,
TestAudioDeviceModule* recv_audio_device);
virtual Call::Config GetSenderCallConfig();
virtual Call::Config GetReceiverCallConfig();
virtual void ModifySenderCallConfig(Call::Config* config);
virtual void ModifyReceiverCallConfig(Call::Config* config);
virtual void OnRtpTransportControllerSendCreated(
RtpTransportControllerSend* controller);
virtual void OnCallsCreated(Call* sender_call, Call* receiver_call);
@ -274,13 +275,11 @@ class BaseTest : public RtpRtcpObserver {
FrameGeneratorCapturer* frame_generator_capturer);
virtual void OnStreamsStopped();
std::unique_ptr<webrtc::RtcEventLog> event_log_;
};
class SendTest : public BaseTest {
public:
explicit SendTest(unsigned int timeout_ms);
explicit SendTest(int timeout_ms);
bool ShouldCreateReceivers() const override;
};
@ -288,7 +287,7 @@ class SendTest : public BaseTest {
class EndToEndTest : public BaseTest {
public:
EndToEndTest();
explicit EndToEndTest(unsigned int timeout_ms);
explicit EndToEndTest(int timeout_ms);
bool ShouldCreateReceivers() const override;
};

6
video/end_to_end_tests/bandwidth_tests.cc
View File

@ -168,11 +168,9 @@ TEST_P(BandwidthEndToEndTest, RembWithSendSideBwe) {
return receive_transport_;
}
Call::Config GetSenderCallConfig() override {
Call::Config config(event_log_.get());
void ModifySenderCallConfig(Call::Config* config) override {
// Set a high start bitrate to reduce the test completion time.
config.bitrate_config.start_bitrate_bps = remb_bitrate_bps_;
return config;
config->bitrate_config.start_bitrate_bps = remb_bitrate_bps_;
}
void ModifyVideoConfigs(

6
video/end_to_end_tests/fec_tests.cc
View File

@ -433,11 +433,9 @@ TEST_P(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
// TODO(holmer): Investigate why we don't send FEC packets when the bitrate
// is 10 kbps.
Call::Config GetSenderCallConfig() override {
Call::Config config(event_log_.get());
void ModifySenderCallConfig(Call::Config* config) override {
const int kMinBitrateBps = 30000;
config.bitrate_config.min_bitrate_bps = kMinBitrateBps;
return config;
config->bitrate_config.min_bitrate_bps = kMinBitrateBps;
}
void ModifyVideoConfigs(

6
video/end_to_end_tests/probing_tests.cc
View File

@ -39,10 +39,8 @@ class ProbingTest : public test::EndToEndTest {
state_(0),
sender_call_(nullptr) {}
Call::Config GetSenderCallConfig() override {
Call::Config config(event_log_.get());
config.bitrate_config.start_bitrate_bps = start_bitrate_bps_;
return config;
void ModifySenderCallConfig(Call::Config* config) override {
config->bitrate_config.start_bitrate_bps = start_bitrate_bps_;
}
void OnCallsCreated(Call* sender_call, Call* receiver_call) override {

14
video/end_to_end_tests/stats_tests.cc
View File

@ -234,11 +234,8 @@ TEST_F(StatsEndToEndTest, GetStats) {
test::PacketTransport::kSender,
payload_type_map_, network_config);
}
Call::Config GetSenderCallConfig() override {
Call::Config config = EndToEndTest::GetSenderCallConfig();
config.bitrate_config.start_bitrate_bps = kStartBitrateBps;
return config;
void ModifySenderCallConfig(Call::Config* config) override {
config->bitrate_config.start_bitrate_bps = kStartBitrateBps;
}
// This test use other VideoStream settings than the the default settings
@ -511,8 +508,11 @@ TEST_F(StatsEndToEndTest, MAYBE_ContentTypeSwitches) {
metrics::Reset();
Call::Config send_config(test.GetSenderCallConfig());
Call::Config recv_config(test.GetReceiverCallConfig());
Call::Config send_config(send_event_log_.get());
test.ModifySenderCallConfig(&send_config);
Call::Config recv_config(recv_event_log_.get());
test.ModifyReceiverCallConfig(&recv_config);
VideoEncoderConfig encoder_config_with_screenshare;
task_queue_.SendTask([this, &test, &send_config, &recv_config,

7
video/end_to_end_tests/transport_feedback_tests.cc
View File

@ -407,11 +407,8 @@ TEST_P(TransportFeedbackEndToEndTest,
EXPECT_TRUE(parser.Parse(data, length));
return parser.transport_feedback()->num_packets() > 0;
}
Call::Config GetSenderCallConfig() override {
Call::Config config = EndToEndTest::GetSenderCallConfig();
config.bitrate_config.max_bitrate_bps = 300000;
return config;
void ModifySenderCallConfig(Call::Config* config) override {
config->bitrate_config.max_bitrate_bps = 300000;
}
void PerformTest() override {

7
video/quality_scaling_tests.cc
View File

@ -103,11 +103,8 @@ void QualityScalingTest::RunTest(VideoEncoderFactory* encoder_factory,
EXPECT_LT(wants.max_pixel_count, kWidth * kHeight) << "Not a downscale.";
observation_complete_.Set();
}
Call::Config GetSenderCallConfig() override {
Call::Config config(event_log_.get());
config.bitrate_config.start_bitrate_bps = start_bps_;
return config;
void ModifySenderCallConfig(Call::Config* config) override {
config->bitrate_config.start_bitrate_bps = start_bps_;
}
void ModifyVideoConfigs(

17
video/video_send_stream_tests.cc
View File

@ -1085,12 +1085,9 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
}
encoder_.SetFrameSize(static_cast<size_t>(current_size_frame_));
}
Call::Config GetSenderCallConfig() override {
Call::Config config(event_log_.get());
void ModifySenderCallConfig(Call::Config* config) override {
const int kMinBitrateBps = 30000;
config.bitrate_config.min_bitrate_bps = kMinBitrateBps;
return config;
config->bitrate_config.min_bitrate_bps = kMinBitrateBps;
}
void ModifyVideoConfigs(
@ -2900,12 +2897,10 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
EXPECT_EQ(expected_bitrate, target_bitrate_);
}
Call::Config GetSenderCallConfig() override {
Call::Config config(event_log_.get());
config.bitrate_config.min_bitrate_bps = kMinBitrateKbps * 1000;
config.bitrate_config.start_bitrate_bps = kStartBitrateKbps * 1000;
config.bitrate_config.max_bitrate_bps = kMaxBitrateKbps * 1000;
return config;
void ModifySenderCallConfig(Call::Config* config) override {
config->bitrate_config.min_bitrate_bps = kMinBitrateKbps * 1000;
config->bitrate_config.start_bitrate_bps = kStartBitrateKbps * 1000;
config->bitrate_config.max_bitrate_bps = kMaxBitrateKbps * 1000;
}
class VideoStreamFactory