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 { namespace webrtc {
class BandwidthEndToEndTest : public test::CallTest { class BandwidthEndToEndTest : public test::CallTest,
public testing::WithParamInterface<std::string> {
public: 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 { class RembObserver : public test::EndToEndTest {
public: public:
RembObserver() : EndToEndTest(kDefaultTimeoutMs) {} RembObserver() : EndToEndTest(kDefaultTimeoutMs) {}
@ -120,12 +129,12 @@ class BandwidthStatsTest : public test::EndToEndTest {
const bool send_side_bwe_; const bool send_side_bwe_;
}; };
TEST_F(BandwidthEndToEndTest, VerifySendSideBweStats) { TEST_P(BandwidthEndToEndTest, VerifySendSideBweStats) {
BandwidthStatsTest test(true); BandwidthStatsTest test(true);
RunBaseTest(&test); RunBaseTest(&test);
} }
TEST_F(BandwidthEndToEndTest, VerifyRecvSideBweStats) { TEST_P(BandwidthEndToEndTest, VerifyRecvSideBweStats) {
BandwidthStatsTest test(false); BandwidthStatsTest test(false);
RunBaseTest(&test); 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 // 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 // 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 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 { class BweObserver : public test::EndToEndTest {
public: public:
BweObserver() BweObserver()
@ -263,7 +272,7 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
RunBaseTest(&test); RunBaseTest(&test);
} }
TEST_F(BandwidthEndToEndTest, ReportsSetEncoderRates) { TEST_P(BandwidthEndToEndTest, ReportsSetEncoderRates) {
class EncoderRateStatsTest : public test::EndToEndTest, class EncoderRateStatsTest : public test::EndToEndTest,
public test::FakeEncoder { public test::FakeEncoder {
public: public:

5
video/end_to_end_tests/call_operation_tests.cc
View File

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

47
video/end_to_end_tests/codec_tests.cc
View File

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

23
video/end_to_end_tests/fec_tests.cc
View File

@ -21,12 +21,21 @@
namespace webrtc { namespace webrtc {
class FecEndToEndTest : public test::CallTest { class FecEndToEndTest : public test::CallTest,
public testing::WithParamInterface<std::string> {
public: 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, class UlpfecRenderObserver : public test::EndToEndTest,
public rtc::VideoSinkInterface<VideoFrame> { public rtc::VideoSinkInterface<VideoFrame> {
public: public:
@ -305,22 +314,22 @@ class FlexfecRenderObserver : public test::EndToEndTest,
int num_packets_sent_; int num_packets_sent_;
}; };
TEST_F(FecEndToEndTest, RecoversWithFlexfec) { TEST_P(FecEndToEndTest, RecoversWithFlexfec) {
FlexfecRenderObserver test(false, false); FlexfecRenderObserver test(false, false);
RunBaseTest(&test); RunBaseTest(&test);
} }
TEST_F(FecEndToEndTest, RecoversWithFlexfecAndNack) { TEST_P(FecEndToEndTest, RecoversWithFlexfecAndNack) {
FlexfecRenderObserver test(true, false); FlexfecRenderObserver test(true, false);
RunBaseTest(&test); RunBaseTest(&test);
} }
TEST_F(FecEndToEndTest, RecoversWithFlexfecAndSendsCorrespondingRtcp) { TEST_P(FecEndToEndTest, RecoversWithFlexfecAndSendsCorrespondingRtcp) {
FlexfecRenderObserver test(false, true); FlexfecRenderObserver test(false, true);
RunBaseTest(&test); RunBaseTest(&test);
} }
TEST_F(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) { TEST_P(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
class UlpfecNackObserver : public test::EndToEndTest { class UlpfecNackObserver : public test::EndToEndTest {
public: public:
UlpfecNackObserver() 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" #include "video/end_to_end_tests/multi_stream_tester.h"
namespace webrtc { namespace webrtc {
class MultiStreamEndToEndTest : public test::CallTest { class MultiStreamEndToEndTest
: public test::CallTest,
public testing::WithParamInterface<std::string> {
public: 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 // Each renderer verifies that it receives the expected resolution, and as soon
// as every renderer has received a frame, the test finishes. // as every renderer has received a frame, the test finishes.
TEST_F(MultiStreamEndToEndTest, SendsAndReceivesMultipleStreams) { TEST_P(MultiStreamEndToEndTest, SendsAndReceivesMultipleStreams) {
class VideoOutputObserver : public rtc::VideoSinkInterface<VideoFrame> { class VideoOutputObserver : public rtc::VideoSinkInterface<VideoFrame> {
public: public:
VideoOutputObserver(const MultiStreamTester::CodecSettings& settings, 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( INSTANTIATE_TEST_CASE_P(
FieldTrials, FieldTrials,
ProbingEndToEndTest, ProbingEndToEndTest,
::testing::Values("WebRTC-TaskQueueCongestionControl/Enabled/", ::testing::Values("WebRTC-RoundRobinPacing/Disabled/",
"WebRTC-TaskQueueCongestionControl/Disabled/")); "WebRTC-RoundRobinPacing/Enabled/",
"WebRTC-TaskQueueCongestionControl/Enabled/"));
class ProbingTest : public test::EndToEndTest { class ProbingTest : public test::EndToEndTest {
public: public:

33
video/end_to_end_tests/retransmission_tests.cc
View File

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

8
video/full_stack_tests.cc
View File

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