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

Remove obsolete field trial from the tests

Browse Source 
Bug: webrtc:8968
Change-Id: I78f5cca98a469dcfbbecba7a16d31e5aac500fc9
Reviewed-on: https://webrtc-review.googlesource.com/97332
Reviewed-by: Erik Språng <sprang@webrtc.org>
Commit-Queue: Ilya Nikolaevskiy <ilnik@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#24534}
This commit is contained in:
Ilya Nikolaevskiy
2018-09-03 13:47:24 +02:00
committed by Commit Bot
parent 1beef1a97a
commit fd5770df4e
9 changed files with 57 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
video/end_to_end_tests/bandwidth_tests.cc
View File

@ -24,21 +24,12 @@
namespace webrtc {
class BandwidthEndToEndTest : public test::CallTest,
public testing::WithParamInterface<std::string> {
class BandwidthEndToEndTest : public test::CallTest {
public:
BandwidthEndToEndTest() : field_trial_(GetParam()) {}
private:
test::ScopedFieldTrials field_trial_;
BandwidthEndToEndTest() = default;
};
INSTANTIATE_TEST_CASE_P(RoundRobin,
BandwidthEndToEndTest,
::testing::Values("WebRTC-RoundRobinPacing/Disabled/",
"WebRTC-RoundRobinPacing/Enabled/"));
TEST_P(BandwidthEndToEndTest, ReceiveStreamSendsRemb) {
TEST_F(BandwidthEndToEndTest, ReceiveStreamSendsRemb) {
class RembObserver : public test::EndToEndTest {
public:
RembObserver() : EndToEndTest(kDefaultTimeoutMs) {}
@ -129,12 +120,12 @@ class BandwidthStatsTest : public test::EndToEndTest {
const bool send_side_bwe_;
};
TEST_P(BandwidthEndToEndTest, VerifySendSideBweStats) {
TEST_F(BandwidthEndToEndTest, VerifySendSideBweStats) {
BandwidthStatsTest test(true);
RunBaseTest(&test);
}
TEST_P(BandwidthEndToEndTest, VerifyRecvSideBweStats) {
TEST_F(BandwidthEndToEndTest, VerifyRecvSideBweStats) {
BandwidthStatsTest test(false);
RunBaseTest(&test);
}
@ -144,7 +135,7 @@ TEST_P(BandwidthEndToEndTest, VerifyRecvSideBweStats) {
// then have the test generate a REMB of 500 kbps and verify that the send BWE
// is reduced to exactly 500 kbps. Then a REMB of 1000 kbps is generated and the
// test verifies that the send BWE ramps back up to exactly 1000 kbps.
TEST_P(BandwidthEndToEndTest, RembWithSendSideBwe) {
TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
class BweObserver : public test::EndToEndTest {
public:
BweObserver()
@ -272,7 +263,7 @@ TEST_P(BandwidthEndToEndTest, RembWithSendSideBwe) {
RunBaseTest(&test);
}
TEST_P(BandwidthEndToEndTest, ReportsSetEncoderRates) {
TEST_F(BandwidthEndToEndTest, ReportsSetEncoderRates) {
class EncoderRateStatsTest : public test::EndToEndTest,
public test::FakeEncoder {
public:

5
video/end_to_end_tests/call_operation_tests.cc
View File

@ -33,9 +33,8 @@ class CallOperationEndToEndTest
INSTANTIATE_TEST_CASE_P(
FieldTrials,
CallOperationEndToEndTest,
::testing::Values("WebRTC-RoundRobinPacing/Disabled/",
"WebRTC-RoundRobinPacing/Enabled/",
"WebRTC-TaskQueueCongestionControl/Enabled/"));
::testing::Values("WebRTC-TaskQueueCongestionControl/Enabled/",
"WebRTC-TaskQueueCongestionControl/Disabled/"));
TEST_P(CallOperationEndToEndTest, ReceiverCanBeStartedTwice) {
CreateCalls();

47
video/end_to_end_tests/codec_tests.cc
View File

@ -23,20 +23,11 @@
namespace webrtc {
class CodecEndToEndTest : public test::CallTest,
public testing::WithParamInterface<std::string> {
class CodecEndToEndTest : public test::CallTest {
public:
CodecEndToEndTest() : field_trial_(GetParam()) {}
private:
test::ScopedFieldTrials field_trial_;
CodecEndToEndTest() = default;
};
INSTANTIATE_TEST_CASE_P(RoundRobin,
CodecEndToEndTest,
::testing::Values("WebRTC-RoundRobinPacing/Disabled/",
"WebRTC-RoundRobinPacing/Enabled/"));
class CodecObserver : public test::EndToEndTest,
public rtc::VideoSinkInterface<VideoFrame> {
public:
@ -98,7 +89,7 @@ class CodecObserver : public test::EndToEndTest,
int frame_counter_;
};
TEST_P(CodecEndToEndTest, SendsAndReceivesVP8) {
TEST_F(CodecEndToEndTest, SendsAndReceivesVP8) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
CodecObserver test(5, kVideoRotation_0, "VP8", &encoder_factory,
@ -106,7 +97,7 @@ TEST_P(CodecEndToEndTest, SendsAndReceivesVP8) {
RunBaseTest(&test);
}
TEST_P(CodecEndToEndTest, SendsAndReceivesVP8Rotation90) {
TEST_F(CodecEndToEndTest, SendsAndReceivesVP8Rotation90) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
CodecObserver test(5, kVideoRotation_90, "VP8", &encoder_factory,
@ -115,7 +106,7 @@ TEST_P(CodecEndToEndTest, SendsAndReceivesVP8Rotation90) {
}
#if !defined(RTC_DISABLE_VP9)
TEST_P(CodecEndToEndTest, SendsAndReceivesVP9) {
TEST_F(CodecEndToEndTest, SendsAndReceivesVP9) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP9Encoder::Create(); });
CodecObserver test(500, kVideoRotation_0, "VP9", &encoder_factory,
@ -123,7 +114,7 @@ TEST_P(CodecEndToEndTest, SendsAndReceivesVP9) {
RunBaseTest(&test);
}
TEST_P(CodecEndToEndTest, SendsAndReceivesVP9VideoRotation90) {
TEST_F(CodecEndToEndTest, SendsAndReceivesVP9VideoRotation90) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP9Encoder::Create(); });
CodecObserver test(5, kVideoRotation_90, "VP9", &encoder_factory,
@ -132,7 +123,7 @@ TEST_P(CodecEndToEndTest, SendsAndReceivesVP9VideoRotation90) {
}
// Mutiplex tests are using VP9 as the underlying implementation.
TEST_P(CodecEndToEndTest, SendsAndReceivesMultiplex) {
TEST_F(CodecEndToEndTest, SendsAndReceivesMultiplex) {
InternalEncoderFactory internal_encoder_factory;
InternalDecoderFactory decoder_factory;
test::FunctionVideoEncoderFactory encoder_factory(
@ -147,7 +138,7 @@ TEST_P(CodecEndToEndTest, SendsAndReceivesMultiplex) {
RunBaseTest(&test);
}
TEST_P(CodecEndToEndTest, SendsAndReceivesMultiplexVideoRotation90) {
TEST_F(CodecEndToEndTest, SendsAndReceivesMultiplexVideoRotation90) {
InternalEncoderFactory internal_encoder_factory;
InternalDecoderFactory decoder_factory;
test::FunctionVideoEncoderFactory encoder_factory(
@ -165,16 +156,20 @@ TEST_P(CodecEndToEndTest, SendsAndReceivesMultiplexVideoRotation90) {
#endif // !defined(RTC_DISABLE_VP9)
#if defined(WEBRTC_USE_H264)
class EndToEndTestH264 : public CodecEndToEndTest {};
class EndToEndTestH264 : public test::CallTest,
public testing::WithParamInterface<std::string> {
public:
EndToEndTestH264() : field_trial_(GetParam()) {}
const auto h264_field_trial_combinations = ::testing::Values(
"WebRTC-SpsPpsIdrIsH264Keyframe/Disabled/WebRTC-RoundRobinPacing/Disabled/",
"WebRTC-SpsPpsIdrIsH264Keyframe/Enabled/WebRTC-RoundRobinPacing/Disabled/",
"WebRTC-SpsPpsIdrIsH264Keyframe/Disabled/WebRTC-RoundRobinPacing/Enabled/",
"WebRTC-SpsPpsIdrIsH264Keyframe/Enabled/WebRTC-RoundRobinPacing/Enabled/");
INSTANTIATE_TEST_CASE_P(SpsPpsIdrIsKeyframe,
EndToEndTestH264,
h264_field_trial_combinations);
private:
test::ScopedFieldTrials field_trial_;
};
INSTANTIATE_TEST_CASE_P(
SpsPpsIdrIsKeyframe,
EndToEndTestH264,
::testing::Values("WebRTC-SpsPpsIdrIsH264Keyframe/Disabled/",
"WebRTC-SpsPpsIdrIsH264Keyframe/Enabled/"));
TEST_P(EndToEndTestH264, SendsAndReceivesH264) {
test::FunctionVideoEncoderFactory encoder_factory(

23
video/end_to_end_tests/fec_tests.cc
View File

@ -21,21 +21,12 @@
namespace webrtc {
class FecEndToEndTest : public test::CallTest,
public testing::WithParamInterface<std::string> {
class FecEndToEndTest : public test::CallTest {
public:
FecEndToEndTest() : field_trial_(GetParam()) {}
private:
test::ScopedFieldTrials field_trial_;
FecEndToEndTest() = default;
};
INSTANTIATE_TEST_CASE_P(RoundRobin,
FecEndToEndTest,
::testing::Values("WebRTC-RoundRobinPacing/Disabled/",
"WebRTC-RoundRobinPacing/Enabled/"));
TEST_P(FecEndToEndTest, ReceivesUlpfec) {
TEST_F(FecEndToEndTest, ReceivesUlpfec) {
class UlpfecRenderObserver : public test::EndToEndTest,
public rtc::VideoSinkInterface<VideoFrame> {
public:
@ -314,22 +305,22 @@ class FlexfecRenderObserver : public test::EndToEndTest,
int num_packets_sent_;
};
TEST_P(FecEndToEndTest, RecoversWithFlexfec) {
TEST_F(FecEndToEndTest, RecoversWithFlexfec) {
FlexfecRenderObserver test(false, false);
RunBaseTest(&test);
}
TEST_P(FecEndToEndTest, RecoversWithFlexfecAndNack) {
TEST_F(FecEndToEndTest, RecoversWithFlexfecAndNack) {
FlexfecRenderObserver test(true, false);
RunBaseTest(&test);
}
TEST_P(FecEndToEndTest, RecoversWithFlexfecAndSendsCorrespondingRtcp) {
TEST_F(FecEndToEndTest, RecoversWithFlexfecAndSendsCorrespondingRtcp) {
FlexfecRenderObserver test(false, true);
RunBaseTest(&test);
}
TEST_P(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
TEST_F(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
class UlpfecNackObserver : public test::EndToEndTest {
public:
UlpfecNackObserver()

16
video/end_to_end_tests/multi_stream_tests.cc
View File

@ -17,24 +17,14 @@
#include "video/end_to_end_tests/multi_stream_tester.h"
namespace webrtc {
class MultiStreamEndToEndTest
: public test::CallTest,
public testing::WithParamInterface<std::string> {
class MultiStreamEndToEndTest : public test::CallTest {
public:
MultiStreamEndToEndTest() : field_trial_(GetParam()) {}
private:
test::ScopedFieldTrials field_trial_;
MultiStreamEndToEndTest() = default;
};
INSTANTIATE_TEST_CASE_P(RoundRobin,
MultiStreamEndToEndTest,
::testing::Values("WebRTC-RoundRobinPacing/Disabled/",
"WebRTC-RoundRobinPacing/Enabled/"));
// Each renderer verifies that it receives the expected resolution, and as soon
// as every renderer has received a frame, the test finishes.
TEST_P(MultiStreamEndToEndTest, SendsAndReceivesMultipleStreams) {
TEST_F(MultiStreamEndToEndTest, SendsAndReceivesMultipleStreams) {
class VideoOutputObserver : public rtc::VideoSinkInterface<VideoFrame> {
public:
VideoOutputObserver(const MultiStreamTester::CodecSettings& settings,

5
video/end_to_end_tests/probing_tests.cc
View File

@ -30,9 +30,8 @@ class ProbingEndToEndTest : public test::CallTest,
INSTANTIATE_TEST_CASE_P(
FieldTrials,
ProbingEndToEndTest,
::testing::Values("WebRTC-RoundRobinPacing/Disabled/",
"WebRTC-RoundRobinPacing/Enabled/",
"WebRTC-TaskQueueCongestionControl/Enabled/"));
::testing::Values("WebRTC-TaskQueueCongestionControl/Enabled/",
"WebRTC-TaskQueueCongestionControl/Disabled/"));
class ProbingTest : public test::EndToEndTest {
public:

33
video/end_to_end_tests/retransmission_tests.cc
View File

@ -20,27 +20,16 @@
#include "test/rtcp_packet_parser.h"
namespace webrtc {
class RetransmissionEndToEndTest
: public test::CallTest,
public testing::WithParamInterface<std::string> {
class RetransmissionEndToEndTest : public test::CallTest {
public:
RetransmissionEndToEndTest() : field_trial_(GetParam()) {}
RetransmissionEndToEndTest() = default;
protected:
void DecodesRetransmittedFrame(bool enable_rtx, bool enable_red);
void ReceivesPliAndRecovers(int rtp_history_ms);
private:
private:
test::ScopedFieldTrials field_trial_;
};
INSTANTIATE_TEST_CASE_P(RoundRobin,
RetransmissionEndToEndTest,
::testing::Values("WebRTC-RoundRobinPacing/Disabled/",
"WebRTC-RoundRobinPacing/Enabled/"));
TEST_P(RetransmissionEndToEndTest, ReceivesAndRetransmitsNack) {
TEST_F(RetransmissionEndToEndTest, ReceivesAndRetransmitsNack) {
static const int kNumberOfNacksToObserve = 2;
static const int kLossBurstSize = 2;
static const int kPacketsBetweenLossBursts = 9;
@ -123,7 +112,7 @@ TEST_P(RetransmissionEndToEndTest, ReceivesAndRetransmitsNack) {
RunBaseTest(&test);
}
TEST_P(RetransmissionEndToEndTest, ReceivesNackAndRetransmitsAudio) {
TEST_F(RetransmissionEndToEndTest, ReceivesNackAndRetransmitsAudio) {
class NackObserver : public test::EndToEndTest {
public:
NackObserver()
@ -198,7 +187,7 @@ TEST_P(RetransmissionEndToEndTest, ReceivesNackAndRetransmitsAudio) {
RunBaseTest(&test);
}
TEST_P(RetransmissionEndToEndTest,
TEST_F(RetransmissionEndToEndTest,
StopSendingKeyframeRequestsForInactiveStream) {
class KeyframeRequestObserver : public test::EndToEndTest {
public:
@ -321,11 +310,11 @@ void RetransmissionEndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) {
RunBaseTest(&test);
}
TEST_P(RetransmissionEndToEndTest, ReceivesPliAndRecoversWithNack) {
TEST_F(RetransmissionEndToEndTest, ReceivesPliAndRecoversWithNack) {
ReceivesPliAndRecovers(1000);
}
TEST_P(RetransmissionEndToEndTest, ReceivesPliAndRecoversWithoutNack) {
TEST_F(RetransmissionEndToEndTest, ReceivesPliAndRecoversWithoutNack) {
ReceivesPliAndRecovers(0);
}
// This test drops second RTP packet with a marker bit set, makes sure it's
@ -482,19 +471,19 @@ void RetransmissionEndToEndTest::DecodesRetransmittedFrame(bool enable_rtx,
RunBaseTest(&test);
}
TEST_P(RetransmissionEndToEndTest, DecodesRetransmittedFrame) {
TEST_F(RetransmissionEndToEndTest, DecodesRetransmittedFrame) {
DecodesRetransmittedFrame(false, false);
}
TEST_P(RetransmissionEndToEndTest, DecodesRetransmittedFrameOverRtx) {
TEST_F(RetransmissionEndToEndTest, DecodesRetransmittedFrameOverRtx) {
DecodesRetransmittedFrame(true, false);
}
TEST_P(RetransmissionEndToEndTest, DecodesRetransmittedFrameByRed) {
TEST_F(RetransmissionEndToEndTest, DecodesRetransmittedFrameByRed) {
DecodesRetransmittedFrame(false, true);
}
TEST_P(RetransmissionEndToEndTest, DecodesRetransmittedFrameByRedOverRtx) {
TEST_F(RetransmissionEndToEndTest, DecodesRetransmittedFrameByRedOverRtx) {
DecodesRetransmittedFrame(true, true);
}

5
video/end_to_end_tests/transport_feedback_tests.cc
View File

@ -37,9 +37,8 @@ class TransportFeedbackEndToEndTest
INSTANTIATE_TEST_CASE_P(
FieldTrials,
TransportFeedbackEndToEndTest,
::testing::Values("WebRTC-RoundRobinPacing/Disabled/",
"WebRTC-RoundRobinPacing/Enabled/",
"WebRTC-TaskQueueCongestionControl/Enabled/"));
::testing::Values("WebRTC-TaskQueueCongestionControl/Enabled/",
"WebRTC-TaskQueueCongestionControl/Disabled/"));
TEST_P(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
static const int kExtensionId = 5;

8
video/full_stack_tests.cc
View File

@ -48,8 +48,6 @@ namespace {
static const int kFullStackTestDurationSecs = 45;
const char kNotScreenshareSimulcastExperiment[] =
"WebRTC-SimulcastScreenshare/Disabled/";
const char kRoundRobinPacingQueueExperiment[] =
"WebRTC-RoundRobinPacing/Enabled/";
const char kPacerPushBackExperiment[] =
"WebRTC-PacerPushbackExperiment/Enabled/";
@ -1072,8 +1070,7 @@ class DualStreamsTest : public ::testing::TestWithParam<int> {};
TEST_P(DualStreamsTest,
ModeratelyRestricted_SlidesVp8_3TL_Simulcast_Video_Simulcast_High) {
test::ScopedFieldTrials field_trial(
AppendFieldTrials(std::string(kRoundRobinPacingQueueExperiment) +
std::string(kPacerPushBackExperiment)));
AppendFieldTrials(std::string(kPacerPushBackExperiment)));
const int first_stream = GetParam();
ParamsWithLogging dual_streams;
@ -1136,8 +1133,7 @@ TEST_P(DualStreamsTest,
TEST_P(DualStreamsTest, Conference_Restricted) {
test::ScopedFieldTrials field_trial(
AppendFieldTrials(std::string(kRoundRobinPacingQueueExperiment) +
std::string(kPacerPushBackExperiment)));
AppendFieldTrials(std::string(kPacerPushBackExperiment)));
const int first_stream = GetParam();
ParamsWithLogging dual_streams;