Removes usages of TaskQueueCongestionControl field trial.
It doesn't do anything any more, so it should be removed.
Bug: webrtc:9586
Change-Id: I0b320b6ce4f480ff8cb59451db29bcc77b882b5f
Reviewed-on: https://webrtc-review.googlesource.com/c/120813
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Stefan Holmer <stefan@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#26507}diff --git a/call/rtp_video_sender_unittest.cc b/call/rtp_video_sender_unittest.cc
index 9f98c9d..ede5b1d 100644
--- a/call/rtp_video_sender_unittest.cc
+++ b/call/rtp_video_sender_unittest.cc
@@ -132,23 +132,7 @@
};
} // namespace
-class RtpVideoSenderTest : public ::testing::Test,
- public ::testing::WithParamInterface<std::string> {
- public:
- RtpVideoSenderTest() : field_trial_(GetParam()) {}
-
- private:
- test::ScopedFieldTrials field_trial_;
-};
-
-INSTANTIATE_TEST_SUITE_P(Default, RtpVideoSenderTest, ::testing::Values(""));
-
-INSTANTIATE_TEST_SUITE_P(
- TaskQueueTrial,
- RtpVideoSenderTest,
- ::testing::Values("WebRTC-TaskQueueCongestionControl/Enabled/"));
-
-TEST_P(RtpVideoSenderTest, SendOnOneModule) {
+TEST(RtpVideoSenderTest, SendOnOneModule) {
uint8_t payload = 'a';
EncodedImage encoded_image;
encoded_image.SetTimestamp(1);
@@ -178,7 +162,7 @@
test.router()->OnEncodedImage(encoded_image, nullptr, nullptr).error);
}
-TEST_P(RtpVideoSenderTest, SendSimulcastSetActive) {
+TEST(RtpVideoSenderTest, SendSimulcastSetActive) {
uint8_t payload = 'a';
EncodedImage encoded_image_1;
encoded_image_1.SetTimestamp(1);
@@ -222,7 +206,7 @@
// behavior of the payload router. First sets one module to active and checks
// that outgoing data can be sent on this module, and checks that no data can
// be sent if both modules are inactive.
-TEST_P(RtpVideoSenderTest, SendSimulcastSetActiveModules) {
+TEST(RtpVideoSenderTest, SendSimulcastSetActiveModules) {
uint8_t payload = 'a';
EncodedImage encoded_image_1;
encoded_image_1.SetTimestamp(1);
@@ -264,7 +248,7 @@
.error);
}
-TEST_P(RtpVideoSenderTest, CreateWithNoPreviousStates) {
+TEST(RtpVideoSenderTest, CreateWithNoPreviousStates) {
RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, kPayloadType, {});
test.router()->SetActive(true);
@@ -275,7 +259,7 @@
EXPECT_NE(initial_states.find(kSsrc2), initial_states.end());
}
-TEST_P(RtpVideoSenderTest, CreateWithPreviousStates) {
+TEST(RtpVideoSenderTest, CreateWithPreviousStates) {
const int64_t kState1SharedFrameId = 123;
const int64_t kState2SharedFrameId = 234;
RtpPayloadState state1;
@@ -303,7 +287,7 @@
EXPECT_EQ(kState2SharedFrameId, initial_states[kSsrc2].shared_frame_id);
}
-TEST_P(RtpVideoSenderTest, FrameCountCallbacks) {
+TEST(RtpVideoSenderTest, FrameCountCallbacks) {
class MockFrameCountObserver : public FrameCountObserver {
public:
MOCK_METHOD2(FrameCountUpdated,
diff --git a/test/scenario/scenario_tests/bbr_performance.cc b/test/scenario/scenario_tests/bbr_performance.cc
index b6d6a44..03c00e9 100644
--- a/test/scenario/scenario_tests/bbr_performance.cc
+++ b/test/scenario/scenario_tests/bbr_performance.cc
@@ -97,7 +97,7 @@
return trial.str();
}
std::string FieldTrials() const {
- std::string trials = "WebRTC-TaskQueueCongestionControl/Enabled/";
+ std::string trials;
if (tuning.use_bbr) {
trials +=
"WebRTC-BweCongestionController/Enabled,BBR/"
diff --git a/video/end_to_end_tests/call_operation_tests.cc b/video/end_to_end_tests/call_operation_tests.cc
index af76f35..ad200d4 100644
--- a/video/end_to_end_tests/call_operation_tests.cc
+++ b/video/end_to_end_tests/call_operation_tests.cc
@@ -21,23 +21,9 @@
namespace webrtc {
-class CallOperationEndToEndTest
- : public test::CallTest,
- public testing::WithParamInterface<std::string> {
- public:
- CallOperationEndToEndTest() : field_trial_(GetParam()) {}
+class CallOperationEndToEndTest : public test::CallTest {};
- private:
- test::ScopedFieldTrials field_trial_;
-};
-
-INSTANTIATE_TEST_SUITE_P(
- FieldTrials,
- CallOperationEndToEndTest,
- ::testing::Values("WebRTC-TaskQueueCongestionControl/Enabled/",
- "WebRTC-TaskQueueCongestionControl/Disabled/"));
-
-TEST_P(CallOperationEndToEndTest, ReceiverCanBeStartedTwice) {
+TEST_F(CallOperationEndToEndTest, ReceiverCanBeStartedTwice) {
CreateCalls();
test::NullTransport transport;
@@ -52,7 +38,7 @@
DestroyStreams();
}
-TEST_P(CallOperationEndToEndTest, ReceiverCanBeStoppedTwice) {
+TEST_F(CallOperationEndToEndTest, ReceiverCanBeStoppedTwice) {
CreateCalls();
test::NullTransport transport;
@@ -67,7 +53,7 @@
DestroyStreams();
}
-TEST_P(CallOperationEndToEndTest, ReceiverCanBeStoppedAndRestarted) {
+TEST_F(CallOperationEndToEndTest, ReceiverCanBeStoppedAndRestarted) {
CreateCalls();
test::NullTransport transport;
@@ -83,7 +69,7 @@
DestroyStreams();
}
-TEST_P(CallOperationEndToEndTest, RendersSingleDelayedFrame) {
+TEST_F(CallOperationEndToEndTest, RendersSingleDelayedFrame) {
static const int kWidth = 320;
static const int kHeight = 240;
// This constant is chosen to be higher than the timeout in the video_render
@@ -157,7 +143,7 @@
});
}
-TEST_P(CallOperationEndToEndTest, TransmitsFirstFrame) {
+TEST_F(CallOperationEndToEndTest, TransmitsFirstFrame) {
class Renderer : public rtc::VideoSinkInterface<VideoFrame> {
public:
void OnFrame(const VideoFrame& video_frame) override { event_.Set(); }
diff --git a/video/end_to_end_tests/probing_tests.cc b/video/end_to_end_tests/probing_tests.cc
index 026f333..80c9ebd 100644
--- a/video/end_to_end_tests/probing_tests.cc
+++ b/video/end_to_end_tests/probing_tests.cc
@@ -17,22 +17,7 @@
#include "test/gtest.h"
namespace webrtc {
-class ProbingEndToEndTest : public test::CallTest,
- public testing::WithParamInterface<std::string> {
- public:
- ProbingEndToEndTest() : field_trial_(GetParam()) {}
-
- virtual ~ProbingEndToEndTest() {
- }
-
- private:
- test::ScopedFieldTrials field_trial_;
-};
-INSTANTIATE_TEST_SUITE_P(
- FieldTrials,
- ProbingEndToEndTest,
- ::testing::Values("WebRTC-TaskQueueCongestionControl/Enabled/",
- "WebRTC-TaskQueueCongestionControl/Disabled/"));
+class ProbingEndToEndTest : public test::CallTest {};
class ProbingTest : public test::EndToEndTest {
public:
@@ -60,11 +45,11 @@
// Flaky under MemorySanitizer: bugs.webrtc.org/7419
// Flaky on iOS bots: bugs.webrtc.org/7851
#if defined(MEMORY_SANITIZER)
-TEST_P(ProbingEndToEndTest, DISABLED_InitialProbing) {
+TEST_F(ProbingEndToEndTest, DISABLED_InitialProbing) {
#elif defined(TARGET_IPHONE_SIMULATOR) && TARGET_IPHONE_SIMULATOR
-TEST_P(ProbingEndToEndTest, DISABLED_InitialProbing) {
+TEST_F(ProbingEndToEndTest, DISABLED_InitialProbing) {
#else
-TEST_P(ProbingEndToEndTest, InitialProbing) {
+TEST_F(ProbingEndToEndTest, InitialProbing) {
#endif
class InitialProbingTest : public ProbingTest {
public:
@@ -108,12 +93,12 @@
// Fails on Linux MSan: bugs.webrtc.org/7428
#if defined(MEMORY_SANITIZER)
-TEST_P(ProbingEndToEndTest, DISABLED_TriggerMidCallProbing) {
+TEST_F(ProbingEndToEndTest, DISABLED_TriggerMidCallProbing) {
// Fails on iOS bots: bugs.webrtc.org/7851
#elif defined(TARGET_IPHONE_SIMULATOR) && TARGET_IPHONE_SIMULATOR
-TEST_P(ProbingEndToEndTest, DISABLED_TriggerMidCallProbing) {
+TEST_F(ProbingEndToEndTest, DISABLED_TriggerMidCallProbing) {
#else
-TEST_P(ProbingEndToEndTest, TriggerMidCallProbing) {
+TEST_F(ProbingEndToEndTest, TriggerMidCallProbing) {
#endif
class TriggerMidCallProbingTest : public ProbingTest {
@@ -187,11 +172,11 @@
}
#if defined(MEMORY_SANITIZER)
-TEST_P(ProbingEndToEndTest, DISABLED_ProbeOnVideoEncoderReconfiguration) {
+TEST_F(ProbingEndToEndTest, DISABLED_ProbeOnVideoEncoderReconfiguration) {
#elif defined(TARGET_IPHONE_SIMULATOR) && TARGET_IPHONE_SIMULATOR
-TEST_P(ProbingEndToEndTest, DISABLED_ProbeOnVideoEncoderReconfiguration) {
+TEST_F(ProbingEndToEndTest, DISABLED_ProbeOnVideoEncoderReconfiguration) {
#else
-TEST_P(ProbingEndToEndTest, ProbeOnVideoEncoderReconfiguration) {
+TEST_F(ProbingEndToEndTest, ProbeOnVideoEncoderReconfiguration) {
#endif
class ReconfigureTest : public ProbingTest {
diff --git a/video/end_to_end_tests/transport_feedback_tests.cc b/video/end_to_end_tests/transport_feedback_tests.cc
index 7588e02..cc0cb7b 100644
--- a/video/end_to_end_tests/transport_feedback_tests.cc
+++ b/video/end_to_end_tests/transport_feedback_tests.cc
@@ -22,26 +22,9 @@
namespace webrtc {
-class TransportFeedbackEndToEndTest
- : public test::CallTest,
- public testing::WithParamInterface<std::string> {
- public:
- TransportFeedbackEndToEndTest() : field_trial_(GetParam()) {}
+class TransportFeedbackEndToEndTest : public test::CallTest {};
- virtual ~TransportFeedbackEndToEndTest() {
- }
-
- private:
- test::ScopedFieldTrials field_trial_;
-};
-
-INSTANTIATE_TEST_SUITE_P(
- FieldTrials,
- TransportFeedbackEndToEndTest,
- ::testing::Values("WebRTC-TaskQueueCongestionControl/Enabled/",
- "WebRTC-TaskQueueCongestionControl/Disabled/"));
-
-TEST_P(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
+TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
static const int kExtensionId = 5;
class RtpExtensionHeaderObserver : public test::DirectTransport {
@@ -322,32 +305,32 @@
Call* receiver_call_;
};
-TEST_P(TransportFeedbackEndToEndTest, VideoReceivesTransportFeedback) {
+TEST_F(TransportFeedbackEndToEndTest, VideoReceivesTransportFeedback) {
TransportFeedbackTester test(true, 1, 0);
RunBaseTest(&test);
}
-TEST_P(TransportFeedbackEndToEndTest, VideoTransportFeedbackNotConfigured) {
+TEST_F(TransportFeedbackEndToEndTest, VideoTransportFeedbackNotConfigured) {
TransportFeedbackTester test(false, 1, 0);
RunBaseTest(&test);
}
-TEST_P(TransportFeedbackEndToEndTest, AudioReceivesTransportFeedback) {
+TEST_F(TransportFeedbackEndToEndTest, AudioReceivesTransportFeedback) {
TransportFeedbackTester test(true, 0, 1);
RunBaseTest(&test);
}
-TEST_P(TransportFeedbackEndToEndTest, AudioTransportFeedbackNotConfigured) {
+TEST_F(TransportFeedbackEndToEndTest, AudioTransportFeedbackNotConfigured) {
TransportFeedbackTester test(false, 0, 1);
RunBaseTest(&test);
}
-TEST_P(TransportFeedbackEndToEndTest, AudioVideoReceivesTransportFeedback) {
+TEST_F(TransportFeedbackEndToEndTest, AudioVideoReceivesTransportFeedback) {
TransportFeedbackTester test(true, 1, 1);
RunBaseTest(&test);
}
-TEST_P(TransportFeedbackEndToEndTest,
+TEST_F(TransportFeedbackEndToEndTest,
StopsAndResumesMediaWhenCongestionWindowFull) {
test::ScopedFieldTrials override_field_trials(
"WebRTC-CwndExperiment/Enabled-250/");
@@ -440,7 +423,7 @@
RunBaseTest(&test);
}
-TEST_P(TransportFeedbackEndToEndTest, TransportSeqNumOnAudioAndVideo) {
+TEST_F(TransportFeedbackEndToEndTest, TransportSeqNumOnAudioAndVideo) {
static constexpr int kExtensionId = 8;
static constexpr size_t kMinPacketsToWaitFor = 50;
class TransportSequenceNumberTest : public test::EndToEndTest {
diff --git a/video/video_send_stream_tests.cc b/video/video_send_stream_tests.cc
index 4754286..0585ef9 100644
--- a/video/video_send_stream_tests.cc
+++ b/video/video_send_stream_tests.cc
@@ -82,11 +82,7 @@
VideoFrame CreateVideoFrame(int width, int height, uint8_t data);
-class VideoSendStreamTest : public test::CallTest,
- public testing::WithParamInterface<std::string> {
- public:
- VideoSendStreamTest() : field_trial_(GetParam()) {}
-
+class VideoSendStreamTest : public test::CallTest {
protected:
void TestNackRetransmission(uint32_t retransmit_ssrc,
uint8_t retransmit_payload_type);
@@ -96,19 +92,9 @@
uint8_t num_spatial_layers);
void TestRequestSourceRotateVideo(bool support_orientation_ext);
-
- private:
- test::ScopedFieldTrials field_trial_;
};
-INSTANTIATE_TEST_SUITE_P(Default, VideoSendStreamTest, ::testing::Values(""));
-
-INSTANTIATE_TEST_SUITE_P(
- TaskQueueTrial,
- VideoSendStreamTest,
- ::testing::Values("WebRTC-TaskQueueCongestionControl/Enabled/"));
-
-TEST_P(VideoSendStreamTest, CanStartStartedStream) {
+TEST_F(VideoSendStreamTest, CanStartStartedStream) {
task_queue_.SendTask([this]() {
CreateSenderCall();
@@ -122,7 +108,7 @@
});
}
-TEST_P(VideoSendStreamTest, CanStopStoppedStream) {
+TEST_F(VideoSendStreamTest, CanStopStoppedStream) {
task_queue_.SendTask([this]() {
CreateSenderCall();
@@ -136,7 +122,7 @@
});
}
-TEST_P(VideoSendStreamTest, SupportsCName) {
+TEST_F(VideoSendStreamTest, SupportsCName) {
static std::string kCName = "PjQatC14dGfbVwGPUOA9IH7RlsFDbWl4AhXEiDsBizo=";
class CNameObserver : public test::SendTest {
public:
@@ -171,7 +157,7 @@
RunBaseTest(&test);
}
-TEST_P(VideoSendStreamTest, SupportsAbsoluteSendTime) {
+TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) {
class AbsoluteSendTimeObserver : public test::SendTest {
public:
AbsoluteSendTimeObserver() : SendTest(kDefaultTimeoutMs) {
@@ -218,7 +204,7 @@
RunBaseTest(&test);
}
-TEST_P(VideoSendStreamTest, SupportsTransmissionTimeOffset) {
+TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) {
static const int kEncodeDelayMs = 5;
class TransmissionTimeOffsetObserver : public test::SendTest {
public:
@@ -265,7 +251,7 @@
RunBaseTest(&test);
}
-TEST_P(VideoSendStreamTest, SupportsTransportWideSequenceNumbers) {
+TEST_F(VideoSendStreamTest, SupportsTransportWideSequenceNumbers) {
static const uint8_t kExtensionId = test::kTransportSequenceNumberExtensionId;
class TransportWideSequenceNumberObserver : public test::SendTest {
public:
@@ -309,7 +295,7 @@
RunBaseTest(&test);
}
-TEST_P(VideoSendStreamTest, SupportsVideoRotation) {
+TEST_F(VideoSendStreamTest, SupportsVideoRotation) {
class VideoRotationObserver : public test::SendTest {
public:
VideoRotationObserver() : SendTest(kDefaultTimeoutMs) {
@@ -351,7 +337,7 @@
RunBaseTest(&test);
}
-TEST_P(VideoSendStreamTest, SupportsVideoContentType) {
+TEST_F(VideoSendStreamTest, SupportsVideoContentType) {
class VideoContentTypeObserver : public test::SendTest {
public:
VideoContentTypeObserver()
@@ -397,7 +383,7 @@
RunBaseTest(&test);
}
-TEST_P(VideoSendStreamTest, SupportsVideoTimingFrames) {
+TEST_F(VideoSendStreamTest, SupportsVideoTimingFrames) {
class VideoTimingObserver : public test::SendTest {
public:
VideoTimingObserver()
@@ -607,14 +593,14 @@
RTPHeader prev_header_;
};
-TEST_P(VideoSendStreamTest, SupportsUlpfecWithExtensions) {
+TEST_F(VideoSendStreamTest, SupportsUlpfecWithExtensions) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
UlpfecObserver test(true, false, true, true, "VP8", &encoder_factory);
RunBaseTest(&test);
}
-TEST_P(VideoSendStreamTest, SupportsUlpfecWithoutExtensions) {
+TEST_F(VideoSendStreamTest, SupportsUlpfecWithoutExtensions) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
UlpfecObserver test(false, false, true, true, "VP8", &encoder_factory);
@@ -640,7 +626,7 @@
// since we'll still have to re-request FEC packets, effectively wasting
// bandwidth since the receiver has to wait for FEC retransmissions to determine
// that the received state is actually decodable.
-TEST_P(VideoSendStreamTest, DoesNotUtilizeUlpfecForH264WithNackEnabled) {
+TEST_F(VideoSendStreamTest, DoesNotUtilizeUlpfecForH264WithNackEnabled) {
test::FunctionVideoEncoderFactory encoder_factory([]() {
return absl::make_unique<test::FakeH264Encoder>(Clock::GetRealTimeClock());
});
@@ -649,7 +635,7 @@
}
// Without retransmissions FEC for H264 is fine.
-TEST_P(VideoSendStreamTest, DoesUtilizeUlpfecForH264WithoutNackEnabled) {
+TEST_F(VideoSendStreamTest, DoesUtilizeUlpfecForH264WithoutNackEnabled) {
test::FunctionVideoEncoderFactory encoder_factory([]() {
return absl::make_unique<test::FakeH264Encoder>(Clock::GetRealTimeClock());
});
@@ -658,7 +644,7 @@
}
// Disabled as flaky, see https://crbug.com/webrtc/7285 for details.
-TEST_P(VideoSendStreamTest, DISABLED_DoesUtilizeUlpfecForVp8WithNackEnabled) {
+TEST_F(VideoSendStreamTest, DISABLED_DoesUtilizeUlpfecForVp8WithNackEnabled) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
UlpfecObserver test(false, true, true, true, "VP8", &encoder_factory);
@@ -667,7 +653,7 @@
#if defined(RTC_ENABLE_VP9)
// Disabled as flaky, see https://crbug.com/webrtc/7285 for details.
-TEST_P(VideoSendStreamTest, DISABLED_DoesUtilizeUlpfecForVp9WithNackEnabled) {
+TEST_F(VideoSendStreamTest, DISABLED_DoesUtilizeUlpfecForVp9WithNackEnabled) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP9Encoder::Create(); });
UlpfecObserver test(false, true, true, true, "VP9", &encoder_factory);
@@ -675,7 +661,7 @@
}
#endif // defined(RTC_ENABLE_VP9)
-TEST_P(VideoSendStreamTest, SupportsUlpfecWithMultithreadedH264) {
+TEST_F(VideoSendStreamTest, SupportsUlpfecWithMultithreadedH264) {
test::FunctionVideoEncoderFactory encoder_factory([]() {
return absl::make_unique<test::MultithreadedFakeH264Encoder>(
Clock::GetRealTimeClock());
@@ -788,28 +774,28 @@
const size_t num_video_streams_;
};
-TEST_P(VideoSendStreamTest, SupportsFlexfecVp8) {
+TEST_F(VideoSendStreamTest, SupportsFlexfecVp8) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
FlexfecObserver test(false, false, "VP8", &encoder_factory, 1);
RunBaseTest(&test);
}
-TEST_P(VideoSendStreamTest, SupportsFlexfecSimulcastVp8) {
+TEST_F(VideoSendStreamTest, SupportsFlexfecSimulcastVp8) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
FlexfecObserver test(false, false, "VP8", &encoder_factory, 2);
RunBaseTest(&test);
}
-TEST_P(VideoSendStreamTest, SupportsFlexfecWithNackVp8) {
+TEST_F(VideoSendStreamTest, SupportsFlexfecWithNackVp8) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
FlexfecObserver test(false, true, "VP8", &encoder_factory, 1);
RunBaseTest(&test);
}
-TEST_P(VideoSendStreamTest, SupportsFlexfecWithRtpExtensionsVp8) {
+TEST_F(VideoSendStreamTest, SupportsFlexfecWithRtpExtensionsVp8) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
FlexfecObserver test(true, false, "VP8", &encoder_factory, 1);
@@ -817,14 +803,14 @@
}
#if defined(RTC_ENABLE_VP9)
-TEST_P(VideoSendStreamTest, SupportsFlexfecVp9) {
+TEST_F(VideoSendStreamTest, SupportsFlexfecVp9) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP9Encoder::Create(); });
FlexfecObserver test(false, false, "VP9", &encoder_factory, 1);
RunBaseTest(&test);
}
-TEST_P(VideoSendStreamTest, SupportsFlexfecWithNackVp9) {
+TEST_F(VideoSendStreamTest, SupportsFlexfecWithNackVp9) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP9Encoder::Create(); });
FlexfecObserver test(false, true, "VP9", &encoder_factory, 1);
@@ -832,7 +818,7 @@
}
#endif // defined(RTC_ENABLE_VP9)
-TEST_P(VideoSendStreamTest, SupportsFlexfecH264) {
+TEST_F(VideoSendStreamTest, SupportsFlexfecH264) {
test::FunctionVideoEncoderFactory encoder_factory([]() {
return absl::make_unique<test::FakeH264Encoder>(Clock::GetRealTimeClock());
});
@@ -840,7 +826,7 @@
RunBaseTest(&test);
}
-TEST_P(VideoSendStreamTest, SupportsFlexfecWithNackH264) {
+TEST_F(VideoSendStreamTest, SupportsFlexfecWithNackH264) {
test::FunctionVideoEncoderFactory encoder_factory([]() {
return absl::make_unique<test::FakeH264Encoder>(Clock::GetRealTimeClock());
});
@@ -848,7 +834,7 @@
RunBaseTest(&test);
}
-TEST_P(VideoSendStreamTest, SupportsFlexfecWithMultithreadedH264) {
+TEST_F(VideoSendStreamTest, SupportsFlexfecWithMultithreadedH264) {
test::FunctionVideoEncoderFactory encoder_factory([]() {
return absl::make_unique<test::MultithreadedFakeH264Encoder>(
Clock::GetRealTimeClock());
@@ -964,12 +950,12 @@
RunBaseTest(&test);
}
-TEST_P(VideoSendStreamTest, RetransmitsNack) {
+TEST_F(VideoSendStreamTest, RetransmitsNack) {
// Normal NACKs should use the send SSRC.
TestNackRetransmission(kVideoSendSsrcs[0], kFakeVideoSendPayloadType);
}
-TEST_P(VideoSendStreamTest, RetransmitsNackOverRtx) {
+TEST_F(VideoSendStreamTest, RetransmitsNackOverRtx) {
// NACKs over RTX should use a separate SSRC.
TestNackRetransmission(kSendRtxSsrcs[0], kSendRtxPayloadType);
}
@@ -1200,19 +1186,19 @@
}
// TODO(sprang): Is there any way of speeding up these tests?
-TEST_P(VideoSendStreamTest, FragmentsGenericAccordingToMaxPacketSize) {
+TEST_F(VideoSendStreamTest, FragmentsGenericAccordingToMaxPacketSize) {
TestPacketFragmentationSize(kGeneric, false);
}
-TEST_P(VideoSendStreamTest, FragmentsGenericAccordingToMaxPacketSizeWithFec) {
+TEST_F(VideoSendStreamTest, FragmentsGenericAccordingToMaxPacketSizeWithFec) {
TestPacketFragmentationSize(kGeneric, true);
}
-TEST_P(VideoSendStreamTest, FragmentsVp8AccordingToMaxPacketSize) {
+TEST_F(VideoSendStreamTest, FragmentsVp8AccordingToMaxPacketSize) {
TestPacketFragmentationSize(kVP8, false);
}
-TEST_P(VideoSendStreamTest, FragmentsVp8AccordingToMaxPacketSizeWithFec) {
+TEST_F(VideoSendStreamTest, FragmentsVp8AccordingToMaxPacketSizeWithFec) {
TestPacketFragmentationSize(kVP8, true);
}
@@ -1225,7 +1211,7 @@
// 4. Signal a high REMB and then wait for the RTP stream to start again.
// When the stream is detected again, and the stats show that the stream
// is no longer suspended, the test ends.
-TEST_P(VideoSendStreamTest, SuspendBelowMinBitrate) {
+TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
static const int kSuspendTimeFrames = 60; // Suspend for 2 seconds @ 30 fps.
class RembObserver : public test::SendTest {
@@ -1387,7 +1373,7 @@
// This test that padding stops being send after a while if the Camera stops
// producing video frames and that padding resumes if the camera restarts.
-TEST_P(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
+TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
class NoPaddingWhenVideoIsMuted : public test::SendTest {
public:
NoPaddingWhenVideoIsMuted()
@@ -1478,7 +1464,7 @@
RunBaseTest(&test);
}
-TEST_P(VideoSendStreamTest, PaddingIsPrimarilyRetransmissions) {
+TEST_F(VideoSendStreamTest, PaddingIsPrimarilyRetransmissions) {
const int kCapacityKbps = 10000; // 10 Mbps
class PaddingIsPrimarilyRetransmissions : public test::EndToEndTest {
public:
@@ -1558,7 +1544,7 @@
//
// Note that the test starts at "high" bitrate and does not ramp up to "higher"
// bitrate since no receiver block or remb is sent in the initial phase.
-TEST_P(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) {
+TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) {
static const int kMinTransmitBitrateBps = 400000;
static const int kHighBitrateBps = 150000;
static const int kRembBitrateBps = 80000;
@@ -1638,7 +1624,7 @@
RunBaseTest(&test);
}
-TEST_P(VideoSendStreamTest, ChangingNetworkRoute) {
+TEST_F(VideoSendStreamTest, ChangingNetworkRoute) {
static const int kStartBitrateBps = 300000;
static const int kNewMaxBitrateBps = 1234567;
static const uint8_t kExtensionId = test::kTransportSequenceNumberExtensionId;
@@ -1727,7 +1713,7 @@
RunBaseTest(&test);
}
-TEST_P(VideoSendStreamTest, ChangingTransportOverhead) {
+TEST_F(VideoSendStreamTest, ChangingTransportOverhead) {
class ChangingTransportOverheadTest : public test::EndToEndTest {
public:
explicit ChangingTransportOverheadTest(
@@ -1900,14 +1886,14 @@
T* const stream_resetter_;
};
-TEST_P(VideoSendStreamTest, RespectsMinTransmitBitrate) {
+TEST_F(VideoSendStreamTest, RespectsMinTransmitBitrate) {
auto reset_fun = [](const VideoSendStream::Config& send_stream_config,
const VideoEncoderConfig& encoder_config) {};
MaxPaddingSetTest<decltype(reset_fun)> test(false, &reset_fun);
RunBaseTest(&test);
}
-TEST_P(VideoSendStreamTest, RespectsMinTransmitBitrateAfterContentSwitch) {
+TEST_F(VideoSendStreamTest, RespectsMinTransmitBitrateAfterContentSwitch) {
// Function for removing and recreating the send stream with a new config.
auto reset_fun = [this](const VideoSendStream::Config& send_stream_config,
const VideoEncoderConfig& encoder_config) {
@@ -1930,7 +1916,7 @@
// possible once we start sending. Likely the frames being input are from the
// same source that will be sent later, which just means that we're ready
// earlier.
-TEST_P(VideoSendStreamTest,
+TEST_F(VideoSendStreamTest,
EncoderReconfigureOnResolutionChangeWhenNotSending) {
class EncoderObserver : public test::FakeEncoder {
public:
@@ -2013,7 +1999,7 @@
});
}
-TEST_P(VideoSendStreamTest, CanReconfigureToUseStartBitrateAbovePreviousMax) {
+TEST_F(VideoSendStreamTest, CanReconfigureToUseStartBitrateAbovePreviousMax) {
class StartBitrateObserver : public test::FakeEncoder {
public:
StartBitrateObserver()
@@ -2142,7 +2128,7 @@
// will be called with zero bitrate during initialization and that
// VideoSendStream::Stop also triggers VideoEncoder::SetRates Start to be called
// with zero bitrate.
-TEST_P(VideoSendStreamTest, VideoSendStreamStopSetEncoderRateToZero) {
+TEST_F(VideoSendStreamTest, VideoSendStreamStopSetEncoderRateToZero) {
test::NullTransport transport;
StartStopBitrateObserver encoder;
test::VideoEncoderProxyFactory encoder_factory(&encoder);
@@ -2185,7 +2171,7 @@
// be updated with a new bitrate when turning the VideoSendStream on/off with
// VideoSendStream::UpdateActiveSimulcastLayers, and when the VideoStreamEncoder
// is reconfigured with new active layers.
-TEST_P(VideoSendStreamTest, VideoSendStreamUpdateActiveSimulcastLayers) {
+TEST_F(VideoSendStreamTest, VideoSendStreamUpdateActiveSimulcastLayers) {
test::NullTransport transport;
StartStopBitrateObserver encoder;
test::VideoEncoderProxyFactory encoder_factory(&encoder);
@@ -2263,7 +2249,7 @@
return frame;
}
-TEST_P(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
+TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
class EncoderStateObserver : public test::SendTest, public VideoEncoder {
public:
explicit EncoderStateObserver(
@@ -2385,7 +2371,7 @@
EXPECT_EQ(1u, test_encoder.num_releases());
}
-TEST_P(VideoSendStreamTest, EncoderSetupPropagatesCommonEncoderConfigValues) {
+TEST_F(VideoSendStreamTest, EncoderSetupPropagatesCommonEncoderConfigValues) {
class VideoCodecConfigObserver : public test::SendTest,
public test::FakeEncoder {
public:
@@ -2626,22 +2612,22 @@
VideoEncoderConfig::Vp9EncoderSpecificSettings>(encoder_settings_);
}
-TEST_P(VideoSendStreamTest, EncoderSetupPropagatesVp8Config) {
+TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp8Config) {
VideoCodecConfigObserver<VideoCodecVP8> test(kVideoCodecVP8, "VP8");
RunBaseTest(&test);
}
-TEST_P(VideoSendStreamTest, EncoderSetupPropagatesVp9Config) {
+TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp9Config) {
VideoCodecConfigObserver<VideoCodecVP9> test(kVideoCodecVP9, "VP9");
RunBaseTest(&test);
}
-TEST_P(VideoSendStreamTest, EncoderSetupPropagatesH264Config) {
+TEST_F(VideoSendStreamTest, EncoderSetupPropagatesH264Config) {
VideoCodecConfigObserver<VideoCodecH264> test(kVideoCodecH264, "H264");
RunBaseTest(&test);
}
-TEST_P(VideoSendStreamTest, RtcpSenderReportContainsMediaBytesSent) {
+TEST_F(VideoSendStreamTest, RtcpSenderReportContainsMediaBytesSent) {
class RtcpSenderReportTest : public test::SendTest {
public:
RtcpSenderReportTest()
@@ -2692,7 +2678,7 @@
RunBaseTest(&test);
}
-TEST_P(VideoSendStreamTest, TranslatesTwoLayerScreencastToTargetBitrate) {
+TEST_F(VideoSendStreamTest, TranslatesTwoLayerScreencastToTargetBitrate) {
static const int kScreencastMaxTargetBitrateDeltaKbps = 1;
class VideoStreamFactory
@@ -2759,7 +2745,7 @@
RunBaseTest(&test);
}
-TEST_P(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
+TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
// These are chosen to be "kind of odd" to not be accidentally checked against
// default values.
static const int kMinBitrateKbps = 137;
@@ -2955,7 +2941,7 @@
RunBaseTest(&test);
}
-TEST_P(VideoSendStreamTest, ReportsSentResolution) {
+TEST_F(VideoSendStreamTest, ReportsSentResolution) {
static const size_t kNumStreams = 3;
// Unusual resolutions to make sure that they are the ones being reported.
static const struct {
@@ -3346,37 +3332,37 @@
int expected_height_;
};
-TEST_P(VideoSendStreamTest, Vp9NonFlexMode_1Tl1SLayers) {
+TEST_F(VideoSendStreamTest, Vp9NonFlexMode_1Tl1SLayers) {
const uint8_t kNumTemporalLayers = 1;
const uint8_t kNumSpatialLayers = 1;
TestVp9NonFlexMode(kNumTemporalLayers, kNumSpatialLayers);
}
-TEST_P(VideoSendStreamTest, Vp9NonFlexMode_2Tl1SLayers) {
+TEST_F(VideoSendStreamTest, Vp9NonFlexMode_2Tl1SLayers) {
const uint8_t kNumTemporalLayers = 2;
const uint8_t kNumSpatialLayers = 1;
TestVp9NonFlexMode(kNumTemporalLayers, kNumSpatialLayers);
}
-TEST_P(VideoSendStreamTest, Vp9NonFlexMode_3Tl1SLayers) {
+TEST_F(VideoSendStreamTest, Vp9NonFlexMode_3Tl1SLayers) {
const uint8_t kNumTemporalLayers = 3;
const uint8_t kNumSpatialLayers = 1;
TestVp9NonFlexMode(kNumTemporalLayers, kNumSpatialLayers);
}
-TEST_P(VideoSendStreamTest, Vp9NonFlexMode_1Tl2SLayers) {
+TEST_F(VideoSendStreamTest, Vp9NonFlexMode_1Tl2SLayers) {
const uint8_t kNumTemporalLayers = 1;
const uint8_t kNumSpatialLayers = 2;
TestVp9NonFlexMode(kNumTemporalLayers, kNumSpatialLayers);
}
-TEST_P(VideoSendStreamTest, Vp9NonFlexMode_2Tl2SLayers) {
+TEST_F(VideoSendStreamTest, Vp9NonFlexMode_2Tl2SLayers) {
const uint8_t kNumTemporalLayers = 2;
const uint8_t kNumSpatialLayers = 2;
TestVp9NonFlexMode(kNumTemporalLayers, kNumSpatialLayers);
}
-TEST_P(VideoSendStreamTest, Vp9NonFlexMode_3Tl2SLayers) {
+TEST_F(VideoSendStreamTest, Vp9NonFlexMode_3Tl2SLayers) {
const uint8_t kNumTemporalLayers = 3;
const uint8_t kNumSpatialLayers = 2;
TestVp9NonFlexMode(kNumTemporalLayers, kNumSpatialLayers);
@@ -3467,7 +3453,7 @@
RunBaseTest(&test);
}
-TEST_P(VideoSendStreamTest, Vp9NonFlexModeSmallResolution) {
+TEST_F(VideoSendStreamTest, Vp9NonFlexModeSmallResolution) {
static const size_t kNumFramesToSend = 50;
static const int kWidth = 4;
static const int kHeight = 4;
@@ -3511,7 +3497,7 @@
#define MAYBE_Vp9FlexModeRefCount DISABLED_Vp9FlexModeRefCount
// #define MAYBE_Vp9FlexModeRefCount Vp9FlexModeRefCount
#endif
-TEST_P(VideoSendStreamTest, MAYBE_Vp9FlexModeRefCount) {
+TEST_F(VideoSendStreamTest, MAYBE_Vp9FlexModeRefCount) {
class FlexibleMode : public Vp9HeaderObserver {
void ModifyVideoConfigsHook(
VideoSendStream::Config* send_config,
@@ -3561,17 +3547,17 @@
DestroyStreams();
}
-TEST_P(VideoSendStreamTest,
+TEST_F(VideoSendStreamTest,
RequestSourceRotateIfVideoOrientationExtensionNotSupported) {
TestRequestSourceRotateVideo(false);
}
-TEST_P(VideoSendStreamTest,
+TEST_F(VideoSendStreamTest,
DoNotRequestsRotationIfVideoOrientationExtensionSupported) {
TestRequestSourceRotateVideo(true);
}
-TEST_P(VideoSendStreamTest, EncoderConfigMaxFramerateReportedToSource) {
+TEST_F(VideoSendStreamTest, EncoderConfigMaxFramerateReportedToSource) {
static const int kMaxFps = 22;
class FpsObserver : public test::SendTest,
public test::FrameGeneratorCapturer::SinkWantsObserver {
@@ -3607,7 +3593,7 @@
// This test verifies that overhead is removed from the bandwidth estimate by
// testing that the maximum possible target payload rate is smaller than the
// maximum bandwidth estimate by the overhead rate.
-TEST_P(VideoSendStreamTest, RemoveOverheadFromBandwidth) {
+TEST_F(VideoSendStreamTest, RemoveOverheadFromBandwidth) {
test::ScopedFieldTrials override_field_trials(
"WebRTC-SendSideBwe-WithOverhead/Enabled/");
class RemoveOverheadFromBandwidthTest : public test::EndToEndTest,
@@ -3691,7 +3677,7 @@
RunBaseTest(&test);
}
-TEST_P(VideoSendStreamTest, SendsKeepAlive) {
+TEST_F(VideoSendStreamTest, SendsKeepAlive) {
const int kTimeoutMs = 50; // Really short timeout for testing.
class KeepaliveObserver : public test::SendTest {
@@ -3801,7 +3787,7 @@
}
const float kAlrProbingExperimentPaceMultiplier = 1.0f;
-TEST_P(VideoSendStreamTest, AlrConfiguredWhenSendSideOn) {
+TEST_F(VideoSendStreamTest, AlrConfiguredWhenSendSideOn) {
test::ScopedFieldTrials alr_experiment(GetAlrProbingExperimentString());
// Send-side bwe on, use pacing factor from |kAlrProbingExperiment| above.
PacingFactorObserver test_with_send_side(true,
@@ -3809,7 +3795,7 @@
RunBaseTest(&test_with_send_side);
}
-TEST_P(VideoSendStreamTest, AlrNotConfiguredWhenSendSideOff) {
+TEST_F(VideoSendStreamTest, AlrNotConfiguredWhenSendSideOff) {
test::ScopedFieldTrials alr_experiment(GetAlrProbingExperimentString());
// Send-side bwe off, use configuration should not be overridden.
PacingFactorObserver test_without_send_side(false, absl::nullopt);
@@ -3944,7 +3930,7 @@
T* stream_resetter_;
};
-TEST_P(VideoSendStreamTest, SwitchesToScreenshareAndBack) {
+TEST_F(VideoSendStreamTest, SwitchesToScreenshareAndBack) {
auto reset_fun = [this](const VideoSendStream::Config& send_stream_config,
const VideoEncoderConfig& encoder_config,
test::BaseTest* test) {
