Simple tests for Call::SetBitrateConfig.

webrtc/call/call_unittest.cc

 /*
  *  Copyright (c) 2015 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.
  */
 
@@ skipping 291 matching lines @@
   config.remote_ssrc = 5548;
   stream = call->CreateFlexfecReceiveStream(config);
   EXPECT_NE(stream, nullptr);
   streams.push_back(stream);
 
   for (auto s : streams) {
     call->DestroyFlexfecReceiveStream(s);
   }
 }
 
-// TODO(zstein): This is just a motivating example for
-// MockSendSideCongestionController. It should be deleted once we have more
-// meaningful tests.
-TEST(CallTest, MockSendSideCongestionControllerExample) {
-  RtcEventLogNullImpl event_log;
-  Call::Config config(&event_log);
+class CallBitrateTest : public testing::Test {

[the sun, 2017/05/16 21:30:11]

I don't really see the point of using a fixture here since you nevertheless need
to call CreateCall() from each test case. IMO the fixture and inheritance only
muddles configuration of the test.

You could instead create a little utility class/struct, without SetUp() - do
everything in the ctor, and just put that on the stack in each test case:

class BitrateTestHelper {
  BitrateTestHelper() {
    Clock* clock = Clock::GetRealTimeClock();
    ...
    call_.reset(Call::Create(config, std::move(fake_controller)));
  }

...

TEST_F(CallBitrateTest, SetBitrateConfigWithValidConfigCallsSetBweBitrates) {
  BitrateTestHelper helper;
  ...
  helper.call()->SetBitrateConfig(bitrate_config);
}

etc

[Zach Stein, 2017/05/17 18:00:12]

The utility struct looks cleaner to me too - thanks for the suggestion!

+ public:
+  void SetUp() {
+    Clock* clock = Clock::GetRealTimeClock();
+    mock_cc_ = rtc::MakeUnique<
+        testing::NiceMock<test::MockSendSideCongestionController>>(
+        clock, &event_log_, &packet_router_);
+  }
 
-  SimulatedClock clock(123456);
-  PacketRouter packet_router;
-  testing::NiceMock<test::MockSendSideCongestionController> mock_cc(
-      &clock, &event_log, &packet_router);
-  auto transport_send =
-      rtc::MakeUnique<FakeRtpTransportControllerSend>(&mock_cc);
-  std::unique_ptr<Call> call(Call::Create(config, std::move(transport_send)));
+  void CreateCall() {
+    Call::Config config(&event_log_);
+    CreateCall(config);
+  }
+
+  void CreateCall(const Call::Config& config) {
+    std::unique_ptr<RtpTransportControllerSendInterface> fake_controller =
+        rtc::MakeUnique<FakeRtpTransportControllerSend>(&packet_router_,
+                                                        mock_cc_.get());
+    call_.reset(Call::Create(config, std::move(fake_controller)));
+  }
+
+  std::unique_ptr<testing::NiceMock<test::MockSendSideCongestionController>>
+      mock_cc_;
+  std::unique_ptr<Call> call_;
+  webrtc::RtcEventLogNullImpl event_log_;
+
+ private:
+  PacketRouter packet_router_;
+};
+
+TEST_F(CallBitrateTest, SetBitrateConfigWithValidConfigCallsSetBweBitrates) {
+  CreateCall();
 
   Call::Config::BitrateConfig bitrate_config;
   bitrate_config.min_bitrate_bps = 1;
   bitrate_config.start_bitrate_bps = 2;
   bitrate_config.max_bitrate_bps = 3;
 
-  EXPECT_CALL(mock_cc, SetBweBitrates(1, 2, 3));
-  call->SetBitrateConfig(bitrate_config);
+  EXPECT_CALL(*mock_cc_, SetBweBitrates(1, 2, 3));
+  call_->SetBitrateConfig(bitrate_config);
+}
+
+TEST_F(CallBitrateTest, SetBitrateConfigWithDifferentMinCallsSetBweBitrates) {
+  CreateCall();
+
+  Call::Config::BitrateConfig bitrate_config;
+  bitrate_config.min_bitrate_bps = 10;
+  bitrate_config.start_bitrate_bps = 20;
+  bitrate_config.max_bitrate_bps = 30;
+  call_->SetBitrateConfig(bitrate_config);
+
+  bitrate_config.min_bitrate_bps = 11;
+  EXPECT_CALL(*mock_cc_, SetBweBitrates(11, 20, 30));
+  call_->SetBitrateConfig(bitrate_config);
+}
+
+TEST_F(CallBitrateTest, SetBitrateConfigWithDifferentStartCallsSetBweBitrates) {
+  CreateCall();
+
+  Call::Config::BitrateConfig bitrate_config;
+  bitrate_config.min_bitrate_bps = 10;
+  bitrate_config.start_bitrate_bps = 20;
+  bitrate_config.max_bitrate_bps = 30;
+  call_->SetBitrateConfig(bitrate_config);
+
+  bitrate_config.start_bitrate_bps = 21;
+  EXPECT_CALL(*mock_cc_, SetBweBitrates(10, 21, 30));
+  call_->SetBitrateConfig(bitrate_config);
+}
+
+TEST_F(CallBitrateTest, SetBitrateConfigWithDifferentMaxCallsSetBweBitrates) {
+  CreateCall();
+
+  Call::Config::BitrateConfig bitrate_config;
+  bitrate_config.min_bitrate_bps = 10;
+  bitrate_config.start_bitrate_bps = 20;
+  bitrate_config.max_bitrate_bps = 30;
+  call_->SetBitrateConfig(bitrate_config);
+
+  bitrate_config.max_bitrate_bps = 31;
+  EXPECT_CALL(*mock_cc_, SetBweBitrates(10, 20, 31));
+  call_->SetBitrateConfig(bitrate_config);
+}
+
+TEST_F(CallBitrateTest, SetBitrateConfigWithSameConfigElidesSecondCall) {
+  CreateCall();
+
+  Call::Config::BitrateConfig bitrate_config;
+  bitrate_config.min_bitrate_bps = 1;
+  bitrate_config.start_bitrate_bps = 2;
+  bitrate_config.max_bitrate_bps = 3;
+
+  EXPECT_CALL(*mock_cc_, SetBweBitrates(1, 2, 3)).Times(1);
+  call_->SetBitrateConfig(bitrate_config);
+  call_->SetBitrateConfig(bitrate_config);
+}
+
+TEST_F(CallBitrateTest,
+       SetBitrateConfigWithSameMinMaxAndNegativeStartElidesSecondCall) {
+  CreateCall();
+
+  Call::Config::BitrateConfig bitrate_config;
+  bitrate_config.min_bitrate_bps = 1;
+  bitrate_config.start_bitrate_bps = 2;
+  bitrate_config.max_bitrate_bps = 3;
+
+  EXPECT_CALL(*mock_cc_, SetBweBitrates(1, 2, 3)).Times(1);
+  call_->SetBitrateConfig(bitrate_config);
+
+  bitrate_config.start_bitrate_bps = -1;
+  call_->SetBitrateConfig(bitrate_config);
 }
 
 }  // namespace webrtc