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

Revert "Remove obsolete field trial from the tests"

Browse Source 
This reverts commit fd5770df4e265cae3650d9dc885900ff0200f28d.

Reason for revert: Speculative revert

Original change's description:
> Remove obsolete field trial from the tests
> 
> 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}

TBR=ilnik@webrtc.org,sprang@webrtc.org

Change-Id: I8b806c04174ffc70b66beca664f239dbf5f0363a
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: webrtc:8968
Reviewed-on: https://webrtc-review.googlesource.com/97601
Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
Commit-Queue: Ilya Nikolaevskiy <ilnik@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#24544}
This commit is contained in:
Ilya Nikolaevskiy 2018-09-04 09:02:26 +00:00 committed by Commit Bot
parent 22c7d69d41
commit 504edc0913
9 changed files with 108 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
video/end_to_end_tests/bandwidth_tests.cc
View File

@ -24,12 +24,21 @@
namespace webrtc {
class BandwidthEndToEndTest : public test::CallTest {
class BandwidthEndToEndTest : public test::CallTest,
public testing::WithParamInterface<std::string> {
public:
BandwidthEndToEndTest() = default;
BandwidthEndToEndTest() : field_trial_(GetParam()) {}
private:
test::ScopedFieldTrials field_trial_;
};
TEST_F(BandwidthEndToEndTest, ReceiveStreamSendsRemb) {
INSTANTIATE_TEST_CASE_P(RoundRobin,
BandwidthEndToEndTest,
::testing::Values("WebRTC-RoundRobinPacing/Disabled/",
"WebRTC-RoundRobinPacing/Enabled/"));
TEST_P(BandwidthEndToEndTest, ReceiveStreamSendsRemb) {
class RembObserver : public test::EndToEndTest {
public:
RembObserver() : EndToEndTest(kDefaultTimeoutMs) {}
@ -120,12 +129,12 @@ class BandwidthStatsTest : public test::EndToEndTest {
const bool send_side_bwe_;
};
TEST_F(BandwidthEndToEndTest, VerifySendSideBweStats) {
TEST_P(BandwidthEndToEndTest, VerifySendSideBweStats) {
BandwidthStatsTest test(true);
RunBaseTest(&test);
}
TEST_F(BandwidthEndToEndTest, VerifyRecvSideBweStats) {
TEST_P(BandwidthEndToEndTest, VerifyRecvSideBweStats) {
BandwidthStatsTest test(false);
RunBaseTest(&test);
}
@ -135,7 +144,7 @@ TEST_F(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_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
TEST_P(BandwidthEndToEndTest, RembWithSendSideBwe) {
class BweObserver : public test::EndToEndTest {
public:
BweObserver()
@ -263,7 +272,7 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
RunBaseTest(&test);
}
TEST_F(BandwidthEndToEndTest, ReportsSetEncoderRates) {
TEST_P(BandwidthEndToEndTest, ReportsSetEncoderRates) {
class EncoderRateStatsTest : public test::EndToEndTest,
public test::FakeEncoder {
public:

5
video/end_to_end_tests/call_operation_tests.cc
View File

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

47
video/end_to_end_tests/codec_tests.cc
View File

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

23
video/end_to_end_tests/fec_tests.cc
View File

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

16
video/end_to_end_tests/multi_stream_tests.cc
View File

@ -17,14 +17,24 @@
#include "video/end_to_end_tests/multi_stream_tester.h"
namespace webrtc {
class MultiStreamEndToEndTest : public test::CallTest {
class MultiStreamEndToEndTest
: public test::CallTest,
public testing::WithParamInterface<std::string> {
public:
MultiStreamEndToEndTest() = default;
MultiStreamEndToEndTest() : field_trial_(GetParam()) {}
private:
test::ScopedFieldTrials field_trial_;
};
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_F(MultiStreamEndToEndTest, SendsAndReceivesMultipleStreams) {
TEST_P(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,8 +30,9 @@ class ProbingEndToEndTest : public test::CallTest,
INSTANTIATE_TEST_CASE_P(
FieldTrials,
ProbingEndToEndTest,
::testing::Values("WebRTC-TaskQueueCongestionControl/Enabled/",
"WebRTC-TaskQueueCongestionControl/Disabled/"));
::testing::Values("WebRTC-RoundRobinPacing/Disabled/",
"WebRTC-RoundRobinPacing/Enabled/",
"WebRTC-TaskQueueCongestionControl/Enabled/"));
class ProbingTest : public test::EndToEndTest {
public:

33
video/end_to_end_tests/retransmission_tests.cc
View File

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

5
video/end_to_end_tests/transport_feedback_tests.cc
View File

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

8
video/full_stack_tests.cc
View File

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