/*
 *  Copyright (c) 2012 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/remote_bitrate_estimator/overuse_detector.h"

#include <stdio.h>
#include <string.h>

#include <algorithm>
#include <cstdlib>
#include <memory>

#include "api/transport/field_trial_based_config.h"
#include "modules/remote_bitrate_estimator/inter_arrival.h"
#include "modules/remote_bitrate_estimator/overuse_estimator.h"
#include "rtc_base/random.h"
#include "test/gtest.h"

namespace webrtc {
namespace testing {

const double kRtpTimestampToMs = 1.0 / 90.0;

class OveruseDetectorTest : public ::testing::Test {
 public:
  OveruseDetectorTest()
      : now_ms_(0),
        receive_time_ms_(0),
        rtp_timestamp_(10 * 90),
        overuse_detector_(),
        inter_arrival_(5 * 90, kRtpTimestampToMs),
        random_(123456789) {}

 protected:
  void SetUp() override {
    overuse_detector_.reset(new OveruseDetector(&field_trials_));
  }

  int Run100000Samples(int packets_per_frame,
                       size_t packet_size,
                       int mean_ms,
                       int standard_deviation_ms) {
    int unique_overuse = 0;
    int last_overuse = -1;
    for (int i = 0; i < 100000; ++i) {
      for (int j = 0; j < packets_per_frame; ++j) {
        UpdateDetector(rtp_timestamp_, receive_time_ms_, packet_size);
      }
      rtp_timestamp_ += mean_ms * 90;
      now_ms_ += mean_ms;
      receive_time_ms_ = std::max<int64_t>(
          receive_time_ms_,
          now_ms_ + static_cast<int64_t>(
                        random_.Gaussian(0, standard_deviation_ms) + 0.5));
      if (BandwidthUsage::kBwOverusing == overuse_detector_->State()) {
        if (last_overuse + 1 != i) {
          unique_overuse++;
        }
        last_overuse = i;
      }
    }
    return unique_overuse;
  }

  int RunUntilOveruse(int packets_per_frame,
                      size_t packet_size,
                      int mean_ms,
                      int standard_deviation_ms,
                      int drift_per_frame_ms) {
    // Simulate a higher send pace, that is too high.
    for (int i = 0; i < 1000; ++i) {
      for (int j = 0; j < packets_per_frame; ++j) {
        UpdateDetector(rtp_timestamp_, receive_time_ms_, packet_size);
      }
      rtp_timestamp_ += mean_ms * 90;
      now_ms_ += mean_ms + drift_per_frame_ms;
      receive_time_ms_ = std::max<int64_t>(
          receive_time_ms_,
          now_ms_ + static_cast<int64_t>(
                        random_.Gaussian(0, standard_deviation_ms) + 0.5));
      if (BandwidthUsage::kBwOverusing == overuse_detector_->State()) {
        return i + 1;
      }
    }
    return -1;
  }

  void UpdateDetector(uint32_t rtp_timestamp,
                      int64_t receive_time_ms,
                      size_t packet_size) {
    uint32_t timestamp_delta;
    int64_t time_delta;
    int size_delta;
    if (inter_arrival_.ComputeDeltas(
            rtp_timestamp, receive_time_ms, receive_time_ms, packet_size,
            &timestamp_delta, &time_delta, &size_delta)) {
      double timestamp_delta_ms = timestamp_delta / 90.0;
      overuse_estimator_.Update(time_delta, timestamp_delta_ms, size_delta,
                                overuse_detector_->State(), receive_time_ms);
      overuse_detector_->Detect(overuse_estimator_.offset(), timestamp_delta_ms,
                                overuse_estimator_.num_of_deltas(),
                                receive_time_ms);
    }
  }

  const FieldTrialBasedConfig field_trials_;
  int64_t now_ms_;
  int64_t receive_time_ms_;
  uint32_t rtp_timestamp_;
  std::unique_ptr<OveruseDetector> overuse_detector_;
  OveruseEstimator overuse_estimator_;
  InterArrival inter_arrival_;
  Random random_;
};

TEST_F(OveruseDetectorTest, GaussianRandom) {
  int buckets[100];
  memset(buckets, 0, sizeof(buckets));
  for (int i = 0; i < 100000; ++i) {
    int index = random_.Gaussian(49, 10);
    if (index >= 0 && index < 100)
      buckets[index]++;
  }
  for (int n = 0; n < 100; ++n) {
    printf("Bucket n:%d, %d\n", n, buckets[n]);
  }
}

TEST_F(OveruseDetectorTest, SimpleNonOveruse30fps) {
  size_t packet_size = 1200;
  uint32_t frame_duration_ms = 33;
  uint32_t rtp_timestamp = 10 * 90;

  // No variance.
  for (int i = 0; i < 1000; ++i) {
    UpdateDetector(rtp_timestamp, now_ms_, packet_size);
    now_ms_ += frame_duration_ms;
    rtp_timestamp += frame_duration_ms * 90;
    EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_->State());
  }
}

// Roughly 1 Mbit/s
TEST_F(OveruseDetectorTest, SimpleNonOveruseWithReceiveVariance) {
  uint32_t frame_duration_ms = 10;
  uint32_t rtp_timestamp = 10 * 90;
  size_t packet_size = 1200;

  for (int i = 0; i < 1000; ++i) {
    UpdateDetector(rtp_timestamp, now_ms_, packet_size);
    rtp_timestamp += frame_duration_ms * 90;
    if (i % 2) {
      now_ms_ += frame_duration_ms - 5;
    } else {
      now_ms_ += frame_duration_ms + 5;
    }
    EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_->State());
  }
}

TEST_F(OveruseDetectorTest, SimpleNonOveruseWithRtpTimestampVariance) {
  // Roughly 1 Mbit/s.
  uint32_t frame_duration_ms = 10;
  uint32_t rtp_timestamp = 10 * 90;
  size_t packet_size = 1200;

  for (int i = 0; i < 1000; ++i) {
    UpdateDetector(rtp_timestamp, now_ms_, packet_size);
    now_ms_ += frame_duration_ms;
    if (i % 2) {
      rtp_timestamp += (frame_duration_ms - 5) * 90;
    } else {
      rtp_timestamp += (frame_duration_ms + 5) * 90;
    }
    EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_->State());
  }
}

TEST_F(OveruseDetectorTest, SimpleOveruse2000Kbit30fps) {
  size_t packet_size = 1200;
  int packets_per_frame = 6;
  int frame_duration_ms = 33;
  int drift_per_frame_ms = 1;
  int sigma_ms = 0;  // No variance.
  int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                        frame_duration_ms, sigma_ms);

  EXPECT_EQ(0, unique_overuse);
  int frames_until_overuse =
      RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
                      sigma_ms, drift_per_frame_ms);
  EXPECT_EQ(7, frames_until_overuse);
}

TEST_F(OveruseDetectorTest, SimpleOveruse100kbit10fps) {
  size_t packet_size = 1200;
  int packets_per_frame = 1;
  int frame_duration_ms = 100;
  int drift_per_frame_ms = 1;
  int sigma_ms = 0;  // No variance.
  int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                        frame_duration_ms, sigma_ms);

  EXPECT_EQ(0, unique_overuse);
  int frames_until_overuse =
      RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
                      sigma_ms, drift_per_frame_ms);
  EXPECT_EQ(7, frames_until_overuse);
}

TEST_F(OveruseDetectorTest, OveruseWithLowVariance2000Kbit30fps) {
  uint32_t frame_duration_ms = 33;
  uint32_t drift_per_frame_ms = 1;
  uint32_t rtp_timestamp = frame_duration_ms * 90;
  size_t packet_size = 1200;
  int offset = 0;

  // Run 1000 samples to reach steady state.
  for (int i = 0; i < 1000; ++i) {
    UpdateDetector(rtp_timestamp, now_ms_, packet_size);
    UpdateDetector(rtp_timestamp, now_ms_, packet_size);
    UpdateDetector(rtp_timestamp, now_ms_, packet_size);
    UpdateDetector(rtp_timestamp, now_ms_, packet_size);
    UpdateDetector(rtp_timestamp, now_ms_, packet_size);
    UpdateDetector(rtp_timestamp, now_ms_, packet_size);
    rtp_timestamp += frame_duration_ms * 90;
    if (i % 2) {
      offset = random_.Rand(0, 1);
      now_ms_ += frame_duration_ms - offset;
    } else {
      now_ms_ += frame_duration_ms + offset;
    }
    EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_->State());
  }
  // Simulate a higher send pace, that is too high.
  // Total build up of 30 ms.
  for (int j = 0; j < 3; ++j) {
    UpdateDetector(rtp_timestamp, now_ms_, packet_size);
    UpdateDetector(rtp_timestamp, now_ms_, packet_size);
    UpdateDetector(rtp_timestamp, now_ms_, packet_size);
    UpdateDetector(rtp_timestamp, now_ms_, packet_size);
    UpdateDetector(rtp_timestamp, now_ms_, packet_size);
    UpdateDetector(rtp_timestamp, now_ms_, packet_size);
    now_ms_ += frame_duration_ms + drift_per_frame_ms * 6;
    rtp_timestamp += frame_duration_ms * 90;
    EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_->State());
  }
  UpdateDetector(rtp_timestamp, now_ms_, packet_size);
  EXPECT_EQ(BandwidthUsage::kBwOverusing, overuse_detector_->State());
}

TEST_F(OveruseDetectorTest, LowGaussianVariance30Kbit3fps) {
  size_t packet_size = 1200;
  int packets_per_frame = 1;
  int frame_duration_ms = 333;
  int drift_per_frame_ms = 1;
  int sigma_ms = 3;
  int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                        frame_duration_ms, sigma_ms);
  EXPECT_EQ(0, unique_overuse);
  int frames_until_overuse =
      RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
                      sigma_ms, drift_per_frame_ms);
  EXPECT_EQ(20, frames_until_overuse);
}

TEST_F(OveruseDetectorTest, LowGaussianVarianceFastDrift30Kbit3fps) {
  size_t packet_size = 1200;
  int packets_per_frame = 1;
  int frame_duration_ms = 333;
  int drift_per_frame_ms = 100;
  int sigma_ms = 3;
  int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                        frame_duration_ms, sigma_ms);
  EXPECT_EQ(0, unique_overuse);
  int frames_until_overuse =
      RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
                      sigma_ms, drift_per_frame_ms);
  EXPECT_EQ(4, frames_until_overuse);
}

TEST_F(OveruseDetectorTest, HighGaussianVariance30Kbit3fps) {
  size_t packet_size = 1200;
  int packets_per_frame = 1;
  int frame_duration_ms = 333;
  int drift_per_frame_ms = 1;
  int sigma_ms = 10;
  int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                        frame_duration_ms, sigma_ms);
  EXPECT_EQ(0, unique_overuse);
  int frames_until_overuse =
      RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
                      sigma_ms, drift_per_frame_ms);
  EXPECT_EQ(44, frames_until_overuse);
}

TEST_F(OveruseDetectorTest, HighGaussianVarianceFastDrift30Kbit3fps) {
  size_t packet_size = 1200;
  int packets_per_frame = 1;
  int frame_duration_ms = 333;
  int drift_per_frame_ms = 100;
  int sigma_ms = 10;
  int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                        frame_duration_ms, sigma_ms);
  EXPECT_EQ(0, unique_overuse);
  int frames_until_overuse =
      RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
                      sigma_ms, drift_per_frame_ms);
  EXPECT_EQ(4, frames_until_overuse);
}

TEST_F(OveruseDetectorTest, LowGaussianVariance100Kbit5fps) {
  size_t packet_size = 1200;
  int packets_per_frame = 2;
  int frame_duration_ms = 200;
  int drift_per_frame_ms = 1;
  int sigma_ms = 3;
  int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                        frame_duration_ms, sigma_ms);
  EXPECT_EQ(0, unique_overuse);
  int frames_until_overuse =
      RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
                      sigma_ms, drift_per_frame_ms);
  EXPECT_EQ(20, frames_until_overuse);
}

TEST_F(OveruseDetectorTest, HighGaussianVariance100Kbit5fps) {
  size_t packet_size = 1200;
  int packets_per_frame = 2;
  int frame_duration_ms = 200;
  int drift_per_frame_ms = 1;
  int sigma_ms = 10;
  int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                        frame_duration_ms, sigma_ms);
  EXPECT_EQ(0, unique_overuse);
  int frames_until_overuse =
      RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
                      sigma_ms, drift_per_frame_ms);
  EXPECT_EQ(44, frames_until_overuse);
}

TEST_F(OveruseDetectorTest, LowGaussianVariance100Kbit10fps) {
  size_t packet_size = 1200;
  int packets_per_frame = 1;
  int frame_duration_ms = 100;
  int drift_per_frame_ms = 1;
  int sigma_ms = 3;
  int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                        frame_duration_ms, sigma_ms);
  EXPECT_EQ(0, unique_overuse);
  int frames_until_overuse =
      RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
                      sigma_ms, drift_per_frame_ms);
  EXPECT_EQ(20, frames_until_overuse);
}

TEST_F(OveruseDetectorTest, HighGaussianVariance100Kbit10fps) {
  size_t packet_size = 1200;
  int packets_per_frame = 1;
  int frame_duration_ms = 100;
  int drift_per_frame_ms = 1;
  int sigma_ms = 10;
  int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                        frame_duration_ms, sigma_ms);
  EXPECT_EQ(0, unique_overuse);
  int frames_until_overuse =
      RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
                      sigma_ms, drift_per_frame_ms);
  EXPECT_EQ(44, frames_until_overuse);
}

TEST_F(OveruseDetectorTest, LowGaussianVariance300Kbit30fps) {
  size_t packet_size = 1200;
  int packets_per_frame = 1;
  int frame_duration_ms = 33;
  int drift_per_frame_ms = 1;
  int sigma_ms = 3;
  int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                        frame_duration_ms, sigma_ms);
  EXPECT_EQ(0, unique_overuse);
  int frames_until_overuse =
      RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
                      sigma_ms, drift_per_frame_ms);
  EXPECT_EQ(19, frames_until_overuse);
}

TEST_F(OveruseDetectorTest, LowGaussianVarianceFastDrift300Kbit30fps) {
  size_t packet_size = 1200;
  int packets_per_frame = 1;
  int frame_duration_ms = 33;
  int drift_per_frame_ms = 10;
  int sigma_ms = 3;
  int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                        frame_duration_ms, sigma_ms);
  EXPECT_EQ(0, unique_overuse);
  int frames_until_overuse =
      RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
                      sigma_ms, drift_per_frame_ms);
  EXPECT_EQ(5, frames_until_overuse);
}

TEST_F(OveruseDetectorTest, HighGaussianVariance300Kbit30fps) {
  size_t packet_size = 1200;
  int packets_per_frame = 1;
  int frame_duration_ms = 33;
  int drift_per_frame_ms = 1;
  int sigma_ms = 10;
  int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                        frame_duration_ms, sigma_ms);
  EXPECT_EQ(0, unique_overuse);
  int frames_until_overuse =
      RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
                      sigma_ms, drift_per_frame_ms);
  EXPECT_EQ(44, frames_until_overuse);
}

TEST_F(OveruseDetectorTest, HighGaussianVarianceFastDrift300Kbit30fps) {
  size_t packet_size = 1200;
  int packets_per_frame = 1;
  int frame_duration_ms = 33;
  int drift_per_frame_ms = 10;
  int sigma_ms = 10;
  int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                        frame_duration_ms, sigma_ms);
  EXPECT_EQ(0, unique_overuse);
  int frames_until_overuse =
      RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
                      sigma_ms, drift_per_frame_ms);
  EXPECT_EQ(10, frames_until_overuse);
}

TEST_F(OveruseDetectorTest, LowGaussianVariance1000Kbit30fps) {
  size_t packet_size = 1200;
  int packets_per_frame = 3;
  int frame_duration_ms = 33;
  int drift_per_frame_ms = 1;
  int sigma_ms = 3;
  int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                        frame_duration_ms, sigma_ms);
  EXPECT_EQ(0, unique_overuse);
  int frames_until_overuse =
      RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
                      sigma_ms, drift_per_frame_ms);
  EXPECT_EQ(19, frames_until_overuse);
}

TEST_F(OveruseDetectorTest, LowGaussianVarianceFastDrift1000Kbit30fps) {
  size_t packet_size = 1200;
  int packets_per_frame = 3;
  int frame_duration_ms = 33;
  int drift_per_frame_ms = 10;
  int sigma_ms = 3;
  int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                        frame_duration_ms, sigma_ms);
  EXPECT_EQ(0, unique_overuse);
  int frames_until_overuse =
      RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
                      sigma_ms, drift_per_frame_ms);
  EXPECT_EQ(5, frames_until_overuse);
}

TEST_F(OveruseDetectorTest, HighGaussianVariance1000Kbit30fps) {
  size_t packet_size = 1200;
  int packets_per_frame = 3;
  int frame_duration_ms = 33;
  int drift_per_frame_ms = 1;
  int sigma_ms = 10;
  int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                        frame_duration_ms, sigma_ms);
  EXPECT_EQ(0, unique_overuse);
  int frames_until_overuse =
      RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
                      sigma_ms, drift_per_frame_ms);
  EXPECT_EQ(44, frames_until_overuse);
}

TEST_F(OveruseDetectorTest, HighGaussianVarianceFastDrift1000Kbit30fps) {
  size_t packet_size = 1200;
  int packets_per_frame = 3;
  int frame_duration_ms = 33;
  int drift_per_frame_ms = 10;
  int sigma_ms = 10;
  int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                        frame_duration_ms, sigma_ms);
  EXPECT_EQ(0, unique_overuse);
  int frames_until_overuse =
      RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
                      sigma_ms, drift_per_frame_ms);
  EXPECT_EQ(10, frames_until_overuse);
}

TEST_F(OveruseDetectorTest, LowGaussianVariance2000Kbit30fps) {
  size_t packet_size = 1200;
  int packets_per_frame = 6;
  int frame_duration_ms = 33;
  int drift_per_frame_ms = 1;
  int sigma_ms = 3;
  int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                        frame_duration_ms, sigma_ms);
  EXPECT_EQ(0, unique_overuse);
  int frames_until_overuse =
      RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
                      sigma_ms, drift_per_frame_ms);
  EXPECT_EQ(19, frames_until_overuse);
}

TEST_F(OveruseDetectorTest, LowGaussianVarianceFastDrift2000Kbit30fps) {
  size_t packet_size = 1200;
  int packets_per_frame = 6;
  int frame_duration_ms = 33;
  int drift_per_frame_ms = 10;
  int sigma_ms = 3;
  int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                        frame_duration_ms, sigma_ms);
  EXPECT_EQ(0, unique_overuse);
  int frames_until_overuse =
      RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
                      sigma_ms, drift_per_frame_ms);
  EXPECT_EQ(5, frames_until_overuse);
}

TEST_F(OveruseDetectorTest, HighGaussianVariance2000Kbit30fps) {
  size_t packet_size = 1200;
  int packets_per_frame = 6;
  int frame_duration_ms = 33;
  int drift_per_frame_ms = 1;
  int sigma_ms = 10;
  int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                        frame_duration_ms, sigma_ms);
  EXPECT_EQ(0, unique_overuse);
  int frames_until_overuse =
      RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
                      sigma_ms, drift_per_frame_ms);
  EXPECT_EQ(44, frames_until_overuse);
}

TEST_F(OveruseDetectorTest, HighGaussianVarianceFastDrift2000Kbit30fps) {
  size_t packet_size = 1200;
  int packets_per_frame = 6;
  int frame_duration_ms = 33;
  int drift_per_frame_ms = 10;
  int sigma_ms = 10;
  int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                        frame_duration_ms, sigma_ms);
  EXPECT_EQ(0, unique_overuse);
  int frames_until_overuse =
      RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
                      sigma_ms, drift_per_frame_ms);
  EXPECT_EQ(10, frames_until_overuse);
}

TEST_F(OveruseDetectorTest, ThresholdAdapts) {
  const double kOffset = 0.21;
  double kTsDelta = 3000.0;
  int64_t now_ms = 0;
  int num_deltas = 60;
  const int kBatchLength = 10;

  // Pass in a positive offset and verify it triggers overuse.
  bool overuse_detected = false;
  for (int i = 0; i < kBatchLength; ++i) {
    BandwidthUsage overuse_state =
        overuse_detector_->Detect(kOffset, kTsDelta, num_deltas, now_ms);
    if (overuse_state == BandwidthUsage::kBwOverusing) {
      overuse_detected = true;
    }
    ++num_deltas;
    now_ms += 5;
  }
  EXPECT_TRUE(overuse_detected);

  // Force the threshold to increase by passing in a higher offset.
  overuse_detected = false;
  for (int i = 0; i < kBatchLength; ++i) {
    BandwidthUsage overuse_state =
        overuse_detector_->Detect(1.1 * kOffset, kTsDelta, num_deltas, now_ms);
    if (overuse_state == BandwidthUsage::kBwOverusing) {
      overuse_detected = true;
    }
    ++num_deltas;
    now_ms += 5;
  }
  EXPECT_TRUE(overuse_detected);

  // Verify that the same offset as before no longer triggers overuse.
  overuse_detected = false;
  for (int i = 0; i < kBatchLength; ++i) {
    BandwidthUsage overuse_state =
        overuse_detector_->Detect(kOffset, kTsDelta, num_deltas, now_ms);
    if (overuse_state == BandwidthUsage::kBwOverusing) {
      overuse_detected = true;
    }
    ++num_deltas;
    now_ms += 5;
  }
  EXPECT_FALSE(overuse_detected);

  // Pass in a low offset to make the threshold adapt down.
  for (int i = 0; i < 15 * kBatchLength; ++i) {
    BandwidthUsage overuse_state =
        overuse_detector_->Detect(0.7 * kOffset, kTsDelta, num_deltas, now_ms);
    if (overuse_state == BandwidthUsage::kBwOverusing) {
      overuse_detected = true;
    }
    ++num_deltas;
    now_ms += 5;
  }
  EXPECT_FALSE(overuse_detected);

  // Make sure the original offset now again triggers overuse.
  for (int i = 0; i < kBatchLength; ++i) {
    BandwidthUsage overuse_state =
        overuse_detector_->Detect(kOffset, kTsDelta, num_deltas, now_ms);
    if (overuse_state == BandwidthUsage::kBwOverusing) {
      overuse_detected = true;
    }
    ++num_deltas;
    now_ms += 5;
  }
  EXPECT_TRUE(overuse_detected);
}

TEST_F(OveruseDetectorTest, DoesntAdaptToSpikes) {
  const double kOffset = 1.0;
  const double kLargeOffset = 20.0;
  double kTsDelta = 3000.0;
  int64_t now_ms = 0;
  int num_deltas = 60;
  const int kBatchLength = 10;
  const int kShortBatchLength = 3;

  // Pass in a positive offset and verify it triggers overuse.
  bool overuse_detected = false;
  for (int i = 0; i < kBatchLength; ++i) {
    BandwidthUsage overuse_state =
        overuse_detector_->Detect(kOffset, kTsDelta, num_deltas, now_ms);
    if (overuse_state == BandwidthUsage::kBwOverusing) {
      overuse_detected = true;
    }
    ++num_deltas;
    now_ms += 5;
  }

  // Pass in a large offset. This shouldn't have a too big impact on the
  // threshold, but still trigger an overuse.
  now_ms += 100;
  overuse_detected = false;
  for (int i = 0; i < kShortBatchLength; ++i) {
    BandwidthUsage overuse_state =
        overuse_detector_->Detect(kLargeOffset, kTsDelta, num_deltas, now_ms);
    if (overuse_state == BandwidthUsage::kBwOverusing) {
      overuse_detected = true;
    }
    ++num_deltas;
    now_ms += 5;
  }
  EXPECT_TRUE(overuse_detected);

  // Pass in a positive normal offset and verify it still triggers.
  overuse_detected = false;
  for (int i = 0; i < kBatchLength; ++i) {
    BandwidthUsage overuse_state =
        overuse_detector_->Detect(kOffset, kTsDelta, num_deltas, now_ms);
    if (overuse_state == BandwidthUsage::kBwOverusing) {
      overuse_detected = true;
    }
    ++num_deltas;
    now_ms += 5;
  }
  EXPECT_TRUE(overuse_detected);
}
}  // namespace testing
}  // namespace webrtc
