blob: e5b733b119621b31b9869f1245b4893f5c9c419b [file] [log] [blame]
/*
* Copyright (c) 2017 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 "modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator.h"
#include <memory>
#include <utility>
#include "api/transport/field_trial_based_config.h"
#include "rtc_base/fake_clock.h"
#include "test/gmock.h"
#include "test/gtest.h"
using ::testing::_;
using ::testing::InSequence;
using ::testing::NiceMock;
using ::testing::Return;
namespace webrtc {
namespace {
constexpr int64_t kFirstArrivalTimeMs = 10;
constexpr int64_t kFirstSendTimeMs = 10;
constexpr uint16_t kSequenceNumber = 1;
constexpr size_t kPayloadSize = 10;
class MockBitrateEstimator : public BitrateEstimator {
public:
using BitrateEstimator::BitrateEstimator;
MOCK_METHOD(void,
Update,
(Timestamp at_time, DataSize data_size, bool in_alr),
(override));
MOCK_METHOD(absl::optional<DataRate>, bitrate, (), (const, override));
MOCK_METHOD(void, ExpectFastRateChange, (), (override));
};
struct AcknowledgedBitrateEstimatorTestStates {
FieldTrialBasedConfig field_trial_config;
std::unique_ptr<AcknowledgedBitrateEstimator> acknowledged_bitrate_estimator;
MockBitrateEstimator* mock_bitrate_estimator;
};
AcknowledgedBitrateEstimatorTestStates CreateTestStates() {
AcknowledgedBitrateEstimatorTestStates states;
auto mock_bitrate_estimator =
std::make_unique<MockBitrateEstimator>(&states.field_trial_config);
states.mock_bitrate_estimator = mock_bitrate_estimator.get();
states.acknowledged_bitrate_estimator =
std::make_unique<AcknowledgedBitrateEstimator>(
&states.field_trial_config, std::move(mock_bitrate_estimator));
return states;
}
std::vector<PacketResult> CreateFeedbackVector() {
std::vector<PacketResult> packet_feedback_vector(2);
packet_feedback_vector[0].receive_time =
Timestamp::Millis(kFirstArrivalTimeMs);
packet_feedback_vector[0].sent_packet.send_time =
Timestamp::Millis(kFirstSendTimeMs);
packet_feedback_vector[0].sent_packet.sequence_number = kSequenceNumber;
packet_feedback_vector[0].sent_packet.size = DataSize::Bytes(kPayloadSize);
packet_feedback_vector[1].receive_time =
Timestamp::Millis(kFirstArrivalTimeMs + 10);
packet_feedback_vector[1].sent_packet.send_time =
Timestamp::Millis(kFirstSendTimeMs + 10);
packet_feedback_vector[1].sent_packet.sequence_number = kSequenceNumber;
packet_feedback_vector[1].sent_packet.size =
DataSize::Bytes(kPayloadSize + 10);
return packet_feedback_vector;
}
} // anonymous namespace
TEST(TestAcknowledgedBitrateEstimator, UpdateBandwidth) {
auto states = CreateTestStates();
auto packet_feedback_vector = CreateFeedbackVector();
{
InSequence dummy;
EXPECT_CALL(*states.mock_bitrate_estimator,
Update(packet_feedback_vector[0].receive_time,
packet_feedback_vector[0].sent_packet.size,
/*in_alr*/ false))
.Times(1);
EXPECT_CALL(*states.mock_bitrate_estimator,
Update(packet_feedback_vector[1].receive_time,
packet_feedback_vector[1].sent_packet.size,
/*in_alr*/ false))
.Times(1);
}
states.acknowledged_bitrate_estimator->IncomingPacketFeedbackVector(
packet_feedback_vector);
}
TEST(TestAcknowledgedBitrateEstimator, ExpectFastRateChangeWhenLeftAlr) {
auto states = CreateTestStates();
auto packet_feedback_vector = CreateFeedbackVector();
{
InSequence dummy;
EXPECT_CALL(*states.mock_bitrate_estimator,
Update(packet_feedback_vector[0].receive_time,
packet_feedback_vector[0].sent_packet.size,
/*in_alr*/ false))
.Times(1);
EXPECT_CALL(*states.mock_bitrate_estimator, ExpectFastRateChange())
.Times(1);
EXPECT_CALL(*states.mock_bitrate_estimator,
Update(packet_feedback_vector[1].receive_time,
packet_feedback_vector[1].sent_packet.size,
/*in_alr*/ false))
.Times(1);
}
states.acknowledged_bitrate_estimator->SetAlrEndedTime(
Timestamp::Millis(kFirstArrivalTimeMs + 1));
states.acknowledged_bitrate_estimator->IncomingPacketFeedbackVector(
packet_feedback_vector);
}
TEST(TestAcknowledgedBitrateEstimator, ReturnBitrate) {
auto states = CreateTestStates();
absl::optional<DataRate> return_value = DataRate::KilobitsPerSec(42);
EXPECT_CALL(*states.mock_bitrate_estimator, bitrate())
.Times(1)
.WillOnce(Return(return_value));
EXPECT_EQ(return_value, states.acknowledged_bitrate_estimator->bitrate());
}
} // namespace webrtc*/