webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimators_test.cc - platform/external/webrtc - Git at Google

 /*
  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */

 #include <sstream>

 #include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
 #include "webrtc/modules/remote_bitrate_estimator/test/bwe_test.h"
 #include "webrtc/test/testsupport/fileutils.h"
 #include "webrtc/test/testsupport/perf_test.h"

 using std::string;

 namespace webrtc {
 namespace testing {
 namespace bwe {
 enum Estimator { kAbsSendTime, kTransmissionOffset };

 BweTestConfig::EstimatorConfig EstimatorConfigs(Estimator estimator,
                                                 int flow_id) {
   static const RemoteBitrateEstimatorFactory factories[] = {
     RemoteBitrateEstimatorFactory(),
     AbsoluteSendTimeRemoteBitrateEstimatorFactory()
   };
   switch (estimator) {
     case kTransmissionOffset:
       return BweTestConfig::EstimatorConfig("TOF", flow_id, &factories[0],
                                             kMimdControl, false, false);
     case kAbsSendTime:
       return BweTestConfig::EstimatorConfig("AST", flow_id, &factories[1],
                                             kMimdControl, false, false);
   }
   assert(false);
   return BweTestConfig::EstimatorConfig();
 }

 struct DefaultBweTestConfig {
   BweTestConfig bwe_test_config;
   size_t number_of_senders;
 };

 DefaultBweTestConfig MakeBweTestConfig(uint32_t sender_count,
                                        Estimator estimator) {
   DefaultBweTestConfig result;
   result.bwe_test_config.estimator_configs.push_back(
       EstimatorConfigs(estimator, 0));
   result.number_of_senders = sender_count;
   return result;
 }

 class DefaultBweTest : public BweTest,
                        public ::testing::TestWithParam<DefaultBweTestConfig> {
  public:
   DefaultBweTest() : packet_senders_() {}
   virtual ~DefaultBweTest() {}

   virtual void SetUp() {
     const DefaultBweTestConfig& config = GetParam();
     SetupTestFromConfig(config.bwe_test_config);
     for (size_t i = 0; i < config.number_of_senders; ++i) {
       packet_senders_.push_back(new VideoSender(0, this, 30, 300, 0, 0));
     }
   }

   virtual void TearDown() {
     while (!packet_senders_.empty()) {
       delete packet_senders_.front();
       packet_senders_.pop_front();
     }
   }

  protected:
   std::list<PacketSender*> packet_senders_;
 };

 INSTANTIATE_TEST_CASE_P(VideoSendersTest, DefaultBweTest,
     ::testing::Values(MakeBweTestConfig(1, kAbsSendTime),
                       MakeBweTestConfig(3, kAbsSendTime),
                       MakeBweTestConfig(1, kTransmissionOffset),
                       MakeBweTestConfig(3, kTransmissionOffset)));

 TEST_P(DefaultBweTest, UnlimitedSpeed) {
   VerboseLogging(false);
   RunFor(10 * 60 * 1000);
 }

 TEST_P(DefaultBweTest, DISABLED_SteadyLoss) {
   LossFilter loss(this);
   loss.SetLoss(20.0);
   RunFor(10 * 60 * 1000);
 }

 TEST_P(DefaultBweTest, IncreasingLoss1) {
   LossFilter loss(this);
   for (int i = 0; i < 76; ++i) {
     loss.SetLoss(i);
     RunFor(5000);
   }
 }

 TEST_P(DefaultBweTest, SteadyDelay) {
   DelayFilter delay(this);
   delay.SetDelay(1000);
   RunFor(10 * 60 * 1000);
 }

 TEST_P(DefaultBweTest, DISABLED_IncreasingDelay1) {
   DelayFilter delay(this);
   RunFor(10 * 60 * 1000);
   for (int i = 0; i < 30 * 2; ++i) {
     delay.SetDelay(i);
     RunFor(10 * 1000);
   }
   RunFor(10 * 60 * 1000);
 }

 TEST_P(DefaultBweTest, IncreasingDelay2) {
   DelayFilter delay(this);
   RateCounterFilter counter(this);
   RunFor(1 * 60 * 1000);
   for (int i = 1; i < 51; ++i) {
     delay.SetDelay(10.0f * i);
     RunFor(10 * 1000);
   }
   delay.SetDelay(0.0f);
   RunFor(10 * 60 * 1000);
 }

 TEST_P(DefaultBweTest, JumpyDelay1) {
   DelayFilter delay(this);
   RunFor(10 * 60 * 1000);
   for (int i = 1; i < 200; ++i) {
     delay.SetDelay((10 * i) % 500);
     RunFor(1000);
     delay.SetDelay(1.0f);
     RunFor(1000);
   }
   delay.SetDelay(0.0f);
   RunFor(10 * 60 * 1000);
 }

 TEST_P(DefaultBweTest, SteadyJitter) {
   JitterFilter jitter(this);
   RateCounterFilter counter(this);
   jitter.SetJitter(20);
   RunFor(2 * 60 * 1000);
 }

 TEST_P(DefaultBweTest, IncreasingJitter1) {
   JitterFilter jitter(this);
   for (int i = 0; i < 2 * 60 * 2; ++i) {
     jitter.SetJitter(i);
     RunFor(10 * 1000);
   }
   RunFor(10 * 60 * 1000);
 }

 TEST_P(DefaultBweTest, IncreasingJitter2) {
   JitterFilter jitter(this);
   RunFor(30 * 1000);
   for (int i = 1; i < 51; ++i) {
     jitter.SetJitter(10.0f * i);
     RunFor(10 * 1000);
   }
   jitter.SetJitter(0.0f);
   RunFor(10 * 60 * 1000);
 }

 TEST_P(DefaultBweTest, SteadyReorder) {
   ReorderFilter reorder(this);
   reorder.SetReorder(20.0);
   RunFor(10 * 60 * 1000);
 }

 TEST_P(DefaultBweTest, IncreasingReorder1) {
   ReorderFilter reorder(this);
   for (int i = 0; i < 76; ++i) {
     reorder.SetReorder(i);
     RunFor(5000);
   }
 }

 TEST_P(DefaultBweTest, DISABLED_SteadyChoke) {
   ChokeFilter choke(this);
   choke.SetCapacity(140);
   RunFor(10 * 60 * 1000);
 }

 TEST_P(DefaultBweTest, DISABLED_IncreasingChoke1) {
   ChokeFilter choke(this);
   for (int i = 1200; i >= 100; i -= 100) {
     choke.SetCapacity(i);
     RunFor(5000);
   }
 }

 TEST_P(DefaultBweTest, DISABLED_IncreasingChoke2) {
   ChokeFilter choke(this);
   RunFor(60 * 1000);
   for (int i = 1200; i >= 100; i -= 20) {
     choke.SetCapacity(i);
     RunFor(1000);
   }
 }

 TEST_P(DefaultBweTest, DISABLED_Multi1) {
   DelayFilter delay(this);
   ChokeFilter choke(this);
   RateCounterFilter counter(this);
   choke.SetCapacity(1000);
   RunFor(1 * 60 * 1000);
   for (int i = 1; i < 51; ++i) {
     delay.SetDelay(100.0f * i);
     RunFor(10 * 1000);
   }
   RunFor(500 * 1000);
   delay.SetDelay(0.0f);
   RunFor(5 * 60 * 1000);
 }

 TEST_P(DefaultBweTest, Multi2) {
   ChokeFilter choke(this);
   JitterFilter jitter(this);
   RateCounterFilter counter(this);
   choke.SetCapacity(2000);
   jitter.SetJitter(120);
   RunFor(5 * 60 * 1000);
 }

 // This test fixture is used to instantiate tests running with adaptive video
 // senders.
 class BweFeedbackTest : public BweTest,
                         public ::testing::TestWithParam<BweTestConfig> {
  public:
   BweFeedbackTest() : BweTest() {}
   virtual ~BweFeedbackTest() {}

   virtual void SetUp() {
     BweTestConfig config;
     config.estimator_configs.push_back(EstimatorConfigs(kAbsSendTime, 0));
     SetupTestFromConfig(config);
   }

   void PrintResults(double max_throughput_kbps, Stats<double> throughput_kbps,
                     Stats<double> delay_ms) {
     double utilization = throughput_kbps.GetMean() / max_throughput_kbps;
     webrtc::test::PrintResult("BwePerformance",
                               GetTestName(),
                               "Utilization",
                               utilization * 100.0,
                               "%",
                               false);
     std::stringstream ss;
     ss << throughput_kbps.GetStdDev() / throughput_kbps.GetMean();
     webrtc::test::PrintResult("BwePerformance",
                               GetTestName(),
                               "Utilization var coeff",
                               ss.str(),
                               "",
                               false);
     webrtc::test::PrintResult("BwePerformance",
                               GetTestName(),
                               "Average delay",
                               delay_ms.AsString(),
                               "ms",
                               false);
   }

  private:
   DISALLOW_COPY_AND_ASSIGN(BweFeedbackTest);
 };

 TEST_F(BweFeedbackTest, Choke1000kbps500kbps1000kbps) {
   AdaptiveVideoSender sender(0, this, 30, 300, 0, 0);
   ChokeFilter filter(this);
   RateCounterFilter counter(this, "receiver_input");
   const int kHighCapacityKbps = 1000;
   const int kLowCapacityKbps = 500;
   filter.SetCapacity(kHighCapacityKbps);
   filter.SetMaxDelay(500);
   RunFor(60 * 1000);
   filter.SetCapacity(kLowCapacityKbps);
   RunFor(60 * 1000);
   filter.SetCapacity(kHighCapacityKbps);
   RunFor(60 * 1000);
   PrintResults((2 * kHighCapacityKbps + kLowCapacityKbps) / 3.0,
                counter.GetBitrateStats(), filter.GetDelayStats());
 }

 TEST_F(BweFeedbackTest, Choke200kbps30kbps200kbps) {
   AdaptiveVideoSender sender(0, this, 30, 300, 0, 0);
   ChokeFilter filter(this);
   RateCounterFilter counter(this, "receiver_input");
   const int kHighCapacityKbps = 200;
   const int kLowCapacityKbps = 30;
   filter.SetCapacity(kHighCapacityKbps);
   filter.SetMaxDelay(500);
   RunFor(60 * 1000);
   filter.SetCapacity(kLowCapacityKbps);
   RunFor(60 * 1000);
   filter.SetCapacity(kHighCapacityKbps);
   RunFor(60 * 1000);

   PrintResults((2 * kHighCapacityKbps + kLowCapacityKbps) / 3.0,
                counter.GetBitrateStats(), filter.GetDelayStats());
 }

 TEST_F(BweFeedbackTest, Verizon4gDownlinkTest) {
   AdaptiveVideoSender sender(0, this, 30, 300, 0, 0);
   RateCounterFilter counter1(this, "sender_output");
   TraceBasedDeliveryFilter filter(this, "link_capacity");
   RateCounterFilter counter2(this, "receiver_input");
   ASSERT_TRUE(filter.Init(test::ResourcePath("verizon4g-downlink", "rx")));
   RunFor(22 * 60 * 1000);
   PrintResults(filter.GetBitrateStats().GetMean(), counter2.GetBitrateStats(),
                filter.GetDelayStats());
 }

 // webrtc:3277
 TEST_F(BweFeedbackTest, DISABLED_GoogleWifiTrace3Mbps) {
   AdaptiveVideoSender sender(0, this, 30, 300, 0, 0);
   RateCounterFilter counter1(this, "sender_output");
   TraceBasedDeliveryFilter filter(this, "link_capacity");
   filter.SetMaxDelay(500);
   RateCounterFilter counter2(this, "receiver_input");
   ASSERT_TRUE(filter.Init(test::ResourcePath("google-wifi-3mbps", "rx")));
   RunFor(300 * 1000);
   PrintResults(filter.GetBitrateStats().GetMean(), counter2.GetBitrateStats(),
                filter.GetDelayStats());
 }
 }  // namespace bwe
 }  // namespace testing
 }  // namespace webrtc
	/*
	* Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
	*
	* Use of this source code is governed by a BSD-style license
	* that can be found in the LICENSE file in the root of the source
	* tree. An additional intellectual property rights grant can be found
	* in the file PATENTS. All contributing project authors may
	* be found in the AUTHORS file in the root of the source tree.
	*/

	#include <sstream>

	#include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
	#include "webrtc/modules/remote_bitrate_estimator/test/bwe_test.h"
	#include "webrtc/test/testsupport/fileutils.h"
	#include "webrtc/test/testsupport/perf_test.h"

	using std::string;

	namespace webrtc {
	namespace testing {
	namespace bwe {
	enum Estimator { kAbsSendTime, kTransmissionOffset };

	BweTestConfig::EstimatorConfig EstimatorConfigs(Estimator estimator,
	int flow_id) {
	static const RemoteBitrateEstimatorFactory factories[] = {
	RemoteBitrateEstimatorFactory(),
	AbsoluteSendTimeRemoteBitrateEstimatorFactory()
	};
	switch (estimator) {
	case kTransmissionOffset:
	return BweTestConfig::EstimatorConfig("TOF", flow_id, &factories[0],
	kMimdControl, false, false);
	case kAbsSendTime:
	return BweTestConfig::EstimatorConfig("AST", flow_id, &factories[1],
	kMimdControl, false, false);
	}
	assert(false);
	return BweTestConfig::EstimatorConfig();
	}

	struct DefaultBweTestConfig {
	BweTestConfig bwe_test_config;
	size_t number_of_senders;
	};

	DefaultBweTestConfig MakeBweTestConfig(uint32_t sender_count,
	Estimator estimator) {
	DefaultBweTestConfig result;
	result.bwe_test_config.estimator_configs.push_back(
	EstimatorConfigs(estimator, 0));
	result.number_of_senders = sender_count;
	return result;
	}

	class DefaultBweTest : public BweTest,
	public ::testing::TestWithParam<DefaultBweTestConfig> {
	public:
	DefaultBweTest() : packet_senders_() {}
	virtual ~DefaultBweTest() {}

	virtual void SetUp() {
	const DefaultBweTestConfig& config = GetParam();
	SetupTestFromConfig(config.bwe_test_config);
	for (size_t i = 0; i < config.number_of_senders; ++i) {
	packet_senders_.push_back(new VideoSender(0, this, 30, 300, 0, 0));
	}
	}

	virtual void TearDown() {
	while (!packet_senders_.empty()) {
	delete packet_senders_.front();
	packet_senders_.pop_front();
	}
	}

	protected:
	std::list<PacketSender*> packet_senders_;
	};

	INSTANTIATE_TEST_CASE_P(VideoSendersTest, DefaultBweTest,
	::testing::Values(MakeBweTestConfig(1, kAbsSendTime),
	MakeBweTestConfig(3, kAbsSendTime),
	MakeBweTestConfig(1, kTransmissionOffset),
	MakeBweTestConfig(3, kTransmissionOffset)));

	TEST_P(DefaultBweTest, UnlimitedSpeed) {
	VerboseLogging(false);
	RunFor(10 * 60 * 1000);
	}

	TEST_P(DefaultBweTest, DISABLED_SteadyLoss) {
	LossFilter loss(this);
	loss.SetLoss(20.0);
	RunFor(10 * 60 * 1000);
	}

	TEST_P(DefaultBweTest, IncreasingLoss1) {
	LossFilter loss(this);
	for (int i = 0; i < 76; ++i) {
	loss.SetLoss(i);
	RunFor(5000);
	}
	}

	TEST_P(DefaultBweTest, SteadyDelay) {
	DelayFilter delay(this);
	delay.SetDelay(1000);
	RunFor(10 * 60 * 1000);
	}

	TEST_P(DefaultBweTest, DISABLED_IncreasingDelay1) {
	DelayFilter delay(this);
	RunFor(10 * 60 * 1000);
	for (int i = 0; i < 30 * 2; ++i) {
	delay.SetDelay(i);
	RunFor(10 * 1000);
	}
	RunFor(10 * 60 * 1000);
	}

	TEST_P(DefaultBweTest, IncreasingDelay2) {
	DelayFilter delay(this);
	RateCounterFilter counter(this);
	RunFor(1 * 60 * 1000);
	for (int i = 1; i < 51; ++i) {
	delay.SetDelay(10.0f * i);
	RunFor(10 * 1000);
	}
	delay.SetDelay(0.0f);
	RunFor(10 * 60 * 1000);
	}

	TEST_P(DefaultBweTest, JumpyDelay1) {
	DelayFilter delay(this);
	RunFor(10 * 60 * 1000);
	for (int i = 1; i < 200; ++i) {
	delay.SetDelay((10 * i) % 500);
	RunFor(1000);
	delay.SetDelay(1.0f);
	RunFor(1000);
	}
	delay.SetDelay(0.0f);
	RunFor(10 * 60 * 1000);
	}

	TEST_P(DefaultBweTest, SteadyJitter) {
	JitterFilter jitter(this);
	RateCounterFilter counter(this);
	jitter.SetJitter(20);
	RunFor(2 * 60 * 1000);
	}

	TEST_P(DefaultBweTest, IncreasingJitter1) {
	JitterFilter jitter(this);
	for (int i = 0; i < 2 * 60 * 2; ++i) {
	jitter.SetJitter(i);
	RunFor(10 * 1000);
	}
	RunFor(10 * 60 * 1000);
	}

	TEST_P(DefaultBweTest, IncreasingJitter2) {
	JitterFilter jitter(this);
	RunFor(30 * 1000);
	for (int i = 1; i < 51; ++i) {
	jitter.SetJitter(10.0f * i);
	RunFor(10 * 1000);
	}
	jitter.SetJitter(0.0f);
	RunFor(10 * 60 * 1000);
	}

	TEST_P(DefaultBweTest, SteadyReorder) {
	ReorderFilter reorder(this);
	reorder.SetReorder(20.0);
	RunFor(10 * 60 * 1000);
	}

	TEST_P(DefaultBweTest, IncreasingReorder1) {
	ReorderFilter reorder(this);
	for (int i = 0; i < 76; ++i) {
	reorder.SetReorder(i);
	RunFor(5000);
	}
	}

	TEST_P(DefaultBweTest, DISABLED_SteadyChoke) {
	ChokeFilter choke(this);
	choke.SetCapacity(140);
	RunFor(10 * 60 * 1000);
	}

	TEST_P(DefaultBweTest, DISABLED_IncreasingChoke1) {
	ChokeFilter choke(this);
	for (int i = 1200; i >= 100; i -= 100) {
	choke.SetCapacity(i);
	RunFor(5000);
	}
	}

	TEST_P(DefaultBweTest, DISABLED_IncreasingChoke2) {
	ChokeFilter choke(this);
	RunFor(60 * 1000);
	for (int i = 1200; i >= 100; i -= 20) {
	choke.SetCapacity(i);
	RunFor(1000);
	}
	}

	TEST_P(DefaultBweTest, DISABLED_Multi1) {
	DelayFilter delay(this);
	ChokeFilter choke(this);
	RateCounterFilter counter(this);
	choke.SetCapacity(1000);
	RunFor(1 * 60 * 1000);
	for (int i = 1; i < 51; ++i) {
	delay.SetDelay(100.0f * i);
	RunFor(10 * 1000);
	}
	RunFor(500 * 1000);
	delay.SetDelay(0.0f);
	RunFor(5 * 60 * 1000);
	}

	TEST_P(DefaultBweTest, Multi2) {
	ChokeFilter choke(this);
	JitterFilter jitter(this);
	RateCounterFilter counter(this);
	choke.SetCapacity(2000);
	jitter.SetJitter(120);
	RunFor(5 * 60 * 1000);
	}

	// This test fixture is used to instantiate tests running with adaptive video
	// senders.
	class BweFeedbackTest : public BweTest,
	public ::testing::TestWithParam<BweTestConfig> {
	public:
	BweFeedbackTest() : BweTest() {}
	virtual ~BweFeedbackTest() {}

	virtual void SetUp() {
	BweTestConfig config;
	config.estimator_configs.push_back(EstimatorConfigs(kAbsSendTime, 0));
	SetupTestFromConfig(config);
	}

	void PrintResults(double max_throughput_kbps, Stats<double> throughput_kbps,
	Stats<double> delay_ms) {
	double utilization = throughput_kbps.GetMean() / max_throughput_kbps;
	webrtc::test::PrintResult("BwePerformance",
	GetTestName(),
	"Utilization",
	utilization * 100.0,
	"%",
	false);
	std::stringstream ss;
	ss << throughput_kbps.GetStdDev() / throughput_kbps.GetMean();
	webrtc::test::PrintResult("BwePerformance",
	GetTestName(),
	"Utilization var coeff",
	ss.str(),
	"",
	false);
	webrtc::test::PrintResult("BwePerformance",
	GetTestName(),
	"Average delay",
	delay_ms.AsString(),
	"ms",
	false);
	}

	private:
	DISALLOW_COPY_AND_ASSIGN(BweFeedbackTest);
	};

	TEST_F(BweFeedbackTest, Choke1000kbps500kbps1000kbps) {
	AdaptiveVideoSender sender(0, this, 30, 300, 0, 0);
	ChokeFilter filter(this);
	RateCounterFilter counter(this, "receiver_input");
	const int kHighCapacityKbps = 1000;
	const int kLowCapacityKbps = 500;
	filter.SetCapacity(kHighCapacityKbps);
	filter.SetMaxDelay(500);
	RunFor(60 * 1000);
	filter.SetCapacity(kLowCapacityKbps);
	RunFor(60 * 1000);
	filter.SetCapacity(kHighCapacityKbps);
	RunFor(60 * 1000);
	PrintResults((2 * kHighCapacityKbps + kLowCapacityKbps) / 3.0,
	counter.GetBitrateStats(), filter.GetDelayStats());
	}

	TEST_F(BweFeedbackTest, Choke200kbps30kbps200kbps) {
	AdaptiveVideoSender sender(0, this, 30, 300, 0, 0);
	ChokeFilter filter(this);
	RateCounterFilter counter(this, "receiver_input");
	const int kHighCapacityKbps = 200;
	const int kLowCapacityKbps = 30;
	filter.SetCapacity(kHighCapacityKbps);
	filter.SetMaxDelay(500);
	RunFor(60 * 1000);
	filter.SetCapacity(kLowCapacityKbps);
	RunFor(60 * 1000);
	filter.SetCapacity(kHighCapacityKbps);
	RunFor(60 * 1000);

	PrintResults((2 * kHighCapacityKbps + kLowCapacityKbps) / 3.0,
	counter.GetBitrateStats(), filter.GetDelayStats());
	}

	TEST_F(BweFeedbackTest, Verizon4gDownlinkTest) {
	AdaptiveVideoSender sender(0, this, 30, 300, 0, 0);
	RateCounterFilter counter1(this, "sender_output");
	TraceBasedDeliveryFilter filter(this, "link_capacity");
	RateCounterFilter counter2(this, "receiver_input");
	ASSERT_TRUE(filter.Init(test::ResourcePath("verizon4g-downlink", "rx")));
	RunFor(22 * 60 * 1000);
	PrintResults(filter.GetBitrateStats().GetMean(), counter2.GetBitrateStats(),
	filter.GetDelayStats());
	}

	// webrtc:3277
	TEST_F(BweFeedbackTest, DISABLED_GoogleWifiTrace3Mbps) {
	AdaptiveVideoSender sender(0, this, 30, 300, 0, 0);
	RateCounterFilter counter1(this, "sender_output");
	TraceBasedDeliveryFilter filter(this, "link_capacity");
	filter.SetMaxDelay(500);
	RateCounterFilter counter2(this, "receiver_input");
	ASSERT_TRUE(filter.Init(test::ResourcePath("google-wifi-3mbps", "rx")));
	RunFor(300 * 1000);
	PrintResults(filter.GetBitrateStats().GetMean(), counter2.GetBitrateStats(),
	filter.GetDelayStats());
	}
	} // namespace bwe
	} // namespace testing
	} // namespace webrtc