From fd5770df4e265cae3650d9dc885900ff0200f28d Mon Sep 17 00:00:00 2001 From: Ilya Nikolaevskiy Date: Mon, 3 Sep 2018 13:47:24 +0200 Subject: [PATCH] Remove obsolete field trial from the tests MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bug: webrtc:8968 Change-Id: I78f5cca98a469dcfbbecba7a16d31e5aac500fc9 Reviewed-on: https://webrtc-review.googlesource.com/97332 Reviewed-by: Erik Språng Commit-Queue: Ilya Nikolaevskiy Cr-Commit-Position: refs/heads/master@{#24534} --- video/end_to_end_tests/bandwidth_tests.cc | 23 +++------ .../end_to_end_tests/call_operation_tests.cc | 5 +- video/end_to_end_tests/codec_tests.cc | 47 +++++++++---------- video/end_to_end_tests/fec_tests.cc | 23 +++------ video/end_to_end_tests/multi_stream_tests.cc | 16 ++----- video/end_to_end_tests/probing_tests.cc | 5 +- .../end_to_end_tests/retransmission_tests.cc | 33 +++++-------- .../transport_feedback_tests.cc | 5 +- video/full_stack_tests.cc | 8 +--- 9 files changed, 57 insertions(+), 108 deletions(-) diff --git a/video/end_to_end_tests/bandwidth_tests.cc b/video/end_to_end_tests/bandwidth_tests.cc index 839fcf30ec..5ab24fa853 100644 --- a/video/end_to_end_tests/bandwidth_tests.cc +++ b/video/end_to_end_tests/bandwidth_tests.cc @@ -24,21 +24,12 @@ namespace webrtc { -class BandwidthEndToEndTest : public test::CallTest, - public testing::WithParamInterface { +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: diff --git a/video/end_to_end_tests/call_operation_tests.cc b/video/end_to_end_tests/call_operation_tests.cc index 87f0ba3ee9..2acd1b9fe8 100644 --- a/video/end_to_end_tests/call_operation_tests.cc +++ b/video/end_to_end_tests/call_operation_tests.cc @@ -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(); diff --git a/video/end_to_end_tests/codec_tests.cc b/video/end_to_end_tests/codec_tests.cc index 58af0a7c1d..f97483a2d2 100644 --- a/video/end_to_end_tests/codec_tests.cc +++ b/video/end_to_end_tests/codec_tests.cc @@ -23,20 +23,11 @@ namespace webrtc { -class CodecEndToEndTest : public test::CallTest, - public testing::WithParamInterface { +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 { 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 { + 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( diff --git a/video/end_to_end_tests/fec_tests.cc b/video/end_to_end_tests/fec_tests.cc index 7fef99bdc2..048376e926 100644 --- a/video/end_to_end_tests/fec_tests.cc +++ b/video/end_to_end_tests/fec_tests.cc @@ -21,21 +21,12 @@ namespace webrtc { -class FecEndToEndTest : public test::CallTest, - public testing::WithParamInterface { +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 { 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() diff --git a/video/end_to_end_tests/multi_stream_tests.cc b/video/end_to_end_tests/multi_stream_tests.cc index 0c925b36e5..dbead24564 100644 --- a/video/end_to_end_tests/multi_stream_tests.cc +++ b/video/end_to_end_tests/multi_stream_tests.cc @@ -17,24 +17,14 @@ #include "video/end_to_end_tests/multi_stream_tester.h" namespace webrtc { -class MultiStreamEndToEndTest - : public test::CallTest, - public testing::WithParamInterface { +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 { public: VideoOutputObserver(const MultiStreamTester::CodecSettings& settings, diff --git a/video/end_to_end_tests/probing_tests.cc b/video/end_to_end_tests/probing_tests.cc index 985d917a99..7dff657ad0 100644 --- a/video/end_to_end_tests/probing_tests.cc +++ b/video/end_to_end_tests/probing_tests.cc @@ -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: diff --git a/video/end_to_end_tests/retransmission_tests.cc b/video/end_to_end_tests/retransmission_tests.cc index 7f1c832fd9..a8c1c4e48f 100644 --- a/video/end_to_end_tests/retransmission_tests.cc +++ b/video/end_to_end_tests/retransmission_tests.cc @@ -20,27 +20,16 @@ #include "test/rtcp_packet_parser.h" namespace webrtc { -class RetransmissionEndToEndTest - : public test::CallTest, - public testing::WithParamInterface { +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); } diff --git a/video/end_to_end_tests/transport_feedback_tests.cc b/video/end_to_end_tests/transport_feedback_tests.cc index d7a53e0192..1437cd46e4 100644 --- a/video/end_to_end_tests/transport_feedback_tests.cc +++ b/video/end_to_end_tests/transport_feedback_tests.cc @@ -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; diff --git a/video/full_stack_tests.cc b/video/full_stack_tests.cc index bed77f4161..a27f0f6f5e 100644 --- a/video/full_stack_tests.cc +++ b/video/full_stack_tests.cc @@ -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 {}; 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;