tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

interval_budget_unittest.cc (4798B)

      1 /*
      2 *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
      3 *
      4 *  Use of this source code is governed by a BSD-style license
      5 *  that can be found in the LICENSE file in the root of the source
      6 *  tree. An additional intellectual property rights grant can be found
      7 *  in the file PATENTS.  All contributing project authors may
      8 *  be found in the AUTHORS file in the root of the source tree.
      9 */
     10 
     11 #include "modules/pacing/interval_budget.h"
     12 
     13 #include <cstddef>
     14 
     15 #include "test/gtest.h"
     16 
     17 namespace webrtc {
     18 
     19 namespace {
     20 constexpr int kWindowMs = 500;
     21 constexpr int kBitrateKbps = 100;
     22 constexpr bool kCanBuildUpUnderuse = true;
     23 constexpr bool kCanNotBuildUpUnderuse = false;
     24 size_t TimeToBytes(int bitrate_kbps, int time_ms) {
     25  return static_cast<size_t>(bitrate_kbps * time_ms / 8);
     26 }
     27 }  // namespace
     28 
     29 TEST(IntervalBudgetTest, InitailState) {
     30  IntervalBudget interval_budget(kBitrateKbps);
     31  EXPECT_DOUBLE_EQ(interval_budget.budget_ratio(), 0.0);
     32  EXPECT_EQ(interval_budget.bytes_remaining(), 0u);
     33 }
     34 
     35 TEST(IntervalBudgetTest, Underuse) {
     36  IntervalBudget interval_budget(kBitrateKbps);
     37  int delta_time_ms = 50;
     38  interval_budget.IncreaseBudget(delta_time_ms);
     39  EXPECT_DOUBLE_EQ(interval_budget.budget_ratio(),
     40                   kWindowMs / static_cast<double>(100 * delta_time_ms));
     41  EXPECT_EQ(interval_budget.bytes_remaining(),
     42            TimeToBytes(kBitrateKbps, delta_time_ms));
     43 }
     44 
     45 TEST(IntervalBudgetTest, DontUnderuseMoreThanMaxWindow) {
     46  IntervalBudget interval_budget(kBitrateKbps);
     47  int delta_time_ms = 1000;
     48  interval_budget.IncreaseBudget(delta_time_ms);
     49  EXPECT_DOUBLE_EQ(interval_budget.budget_ratio(), 1.0);
     50  EXPECT_EQ(interval_budget.bytes_remaining(),
     51            TimeToBytes(kBitrateKbps, kWindowMs));
     52 }
     53 
     54 TEST(IntervalBudgetTest, DontUnderuseMoreThanMaxWindowWhenChangeBitrate) {
     55  IntervalBudget interval_budget(kBitrateKbps);
     56  int delta_time_ms = kWindowMs / 2;
     57  interval_budget.IncreaseBudget(delta_time_ms);
     58  interval_budget.set_target_rate_kbps(kBitrateKbps / 10);
     59  EXPECT_DOUBLE_EQ(interval_budget.budget_ratio(), 1.0);
     60  EXPECT_EQ(interval_budget.bytes_remaining(),
     61            TimeToBytes(kBitrateKbps / 10, kWindowMs));
     62 }
     63 
     64 TEST(IntervalBudgetTest, BalanceChangeOnBitrateChange) {
     65  IntervalBudget interval_budget(kBitrateKbps);
     66  int delta_time_ms = kWindowMs;
     67  interval_budget.IncreaseBudget(delta_time_ms);
     68  interval_budget.set_target_rate_kbps(kBitrateKbps * 2);
     69  EXPECT_DOUBLE_EQ(interval_budget.budget_ratio(), 0.5);
     70  EXPECT_EQ(interval_budget.bytes_remaining(),
     71            TimeToBytes(kBitrateKbps, kWindowMs));
     72 }
     73 
     74 TEST(IntervalBudgetTest, Overuse) {
     75  IntervalBudget interval_budget(kBitrateKbps);
     76  int overuse_time_ms = 50;
     77  int used_bytes = TimeToBytes(kBitrateKbps, overuse_time_ms);
     78  interval_budget.UseBudget(used_bytes);
     79  EXPECT_DOUBLE_EQ(interval_budget.budget_ratio(),
     80                   -kWindowMs / static_cast<double>(100 * overuse_time_ms));
     81  EXPECT_EQ(interval_budget.bytes_remaining(), 0u);
     82 }
     83 
     84 TEST(IntervalBudgetTest, DontOveruseMoreThanMaxWindow) {
     85  IntervalBudget interval_budget(kBitrateKbps);
     86  int overuse_time_ms = 1000;
     87  int used_bytes = TimeToBytes(kBitrateKbps, overuse_time_ms);
     88  interval_budget.UseBudget(used_bytes);
     89  EXPECT_DOUBLE_EQ(interval_budget.budget_ratio(), -1.0);
     90  EXPECT_EQ(interval_budget.bytes_remaining(), 0u);
     91 }
     92 
     93 TEST(IntervalBudgetTest, CanBuildUpUnderuseWhenConfigured) {
     94  IntervalBudget interval_budget(kBitrateKbps, kCanBuildUpUnderuse);
     95  int delta_time_ms = 50;
     96  interval_budget.IncreaseBudget(delta_time_ms);
     97  EXPECT_DOUBLE_EQ(interval_budget.budget_ratio(),
     98                   kWindowMs / static_cast<double>(100 * delta_time_ms));
     99  EXPECT_EQ(interval_budget.bytes_remaining(),
    100            TimeToBytes(kBitrateKbps, delta_time_ms));
    101 
    102  interval_budget.IncreaseBudget(delta_time_ms);
    103  EXPECT_DOUBLE_EQ(interval_budget.budget_ratio(),
    104                   2 * kWindowMs / static_cast<double>(100 * delta_time_ms));
    105  EXPECT_EQ(interval_budget.bytes_remaining(),
    106            TimeToBytes(kBitrateKbps, 2 * delta_time_ms));
    107 }
    108 
    109 TEST(IntervalBudgetTest, CanNotBuildUpUnderuseWhenConfigured) {
    110  IntervalBudget interval_budget(kBitrateKbps, kCanNotBuildUpUnderuse);
    111  int delta_time_ms = 50;
    112  interval_budget.IncreaseBudget(delta_time_ms);
    113  EXPECT_DOUBLE_EQ(interval_budget.budget_ratio(),
    114                   kWindowMs / static_cast<double>(100 * delta_time_ms));
    115  EXPECT_EQ(interval_budget.bytes_remaining(),
    116            TimeToBytes(kBitrateKbps, delta_time_ms));
    117 
    118  interval_budget.IncreaseBudget(delta_time_ms);
    119  EXPECT_DOUBLE_EQ(interval_budget.budget_ratio(),
    120                   kWindowMs / static_cast<double>(100 * delta_time_ms));
    121  EXPECT_EQ(interval_budget.bytes_remaining(),
    122            TimeToBytes(kBitrateKbps, delta_time_ms));
    123 }
    124 
    125 }  // namespace webrtc