//
// Copyright (C) 2014 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

#include "shill/wifi/mac80211_monitor.h"

#include <vector>

#include <base/files/file_util.h>
#include <base/files/scoped_temp_dir.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>

#include "shill/mock_event_dispatcher.h"
#include "shill/mock_log.h"
#include "shill/mock_metrics.h"
#include "shill/net/mock_time.h"

using std::string;
using std::vector;
using ::testing::_;
using ::testing::AnyNumber;
using ::testing::DoAll;
using ::testing::ElementsAre;
using ::testing::HasSubstr;
using ::testing::Return;
using ::testing::SetArgumentPointee;
using ::testing::StrictMock;

namespace shill {

namespace {

const char kTestDeviceName[] = "test-dev";
const char kJunkData[] = "junk data";

}  // namespace

typedef Mac80211Monitor::QueueState QState;

class Mac80211MonitorTest : public testing::Test {
 public:
  Mac80211MonitorTest()
      : metrics_(nullptr),
        mac80211_monitor_(
            &event_dispatcher_,
            kTestDeviceName,
            kQueueLengthLimit,
            base::Bind(&Mac80211MonitorTest::OnRepairHandler,
                       base::Unretained(this)),
            &metrics_) {
    mac80211_monitor_.time_ = &time_;
  }
  virtual ~Mac80211MonitorTest() {}

 protected:
  static const size_t kQueueLengthLimit = 5;
  base::FilePath fake_queue_state_file_path_;  // Call FakeUpSysfs() first.
  base::FilePath fake_wake_queues_file_path_;  // Call FakeUpSysfs() first.

  // Getters for fixture fields.
  MockTime& time() { return time_; }
  MockEventDispatcher& event_dispatcher() { return event_dispatcher_; }
  MockMetrics& metrics() { return metrics_; }

  // Complex fixture methods.
  void AllowWakeQueuesIfNeededCommonCalls() {
    // Allow any number of these calls, as these aspects of
    // WakeQueuesIfNeeded interaction are tested elsewhere.
    EXPECT_CALL(event_dispatcher(), PostDelayedTask(_, _))
        .Times(AnyNumber());
    EXPECT_CALL(metrics(), SendEnumToUMA(_, _, _))
        .Times(AnyNumber());
    EXPECT_CALL(metrics(), SendToUMA(_, _, _, _, _))
        .Times(AnyNumber());
  }
  void FakeUpNotStuckState() {
    FakeUpQueueFiles("00: 0x00000000/10\n");
  }
  void FakeUpStuckByDriverState() {
    FakeUpQueueFiles("00: 0x00000001/10\n");
  }
  void FakeUpStuckByPowerSaveState() {
    FakeUpQueueFiles("00: 0x00000002/10\n");
  }
  void FakeUpSysfs() {
    CHECK(fake_sysfs_tree_.CreateUniqueTempDir());
    CHECK(base::CreateTemporaryFileInDir(
        fake_sysfs_tree_.path(), &fake_queue_state_file_path_));
    CHECK(base::CreateTemporaryFileInDir(
        fake_sysfs_tree_.path(), &fake_wake_queues_file_path_));
    PlumbFakeSysfs();
  }
  void DeleteQueueStateFile() {
    fake_queue_state_file_path_.clear();
    PlumbFakeSysfs();
  }
  bool IsRunning() const {
    return mac80211_monitor_.is_running_ &&
        !mac80211_monitor_.check_queues_callback_.IsCancelled();
  }
  bool IsStopped() const {
    return !mac80211_monitor_.is_running_ &&
        mac80211_monitor_.check_queues_callback_.IsCancelled();
  }
  bool IsWakeQueuesFileModified() const {
    CHECK(fake_sysfs_tree_.IsValid());  // Keep tests hermetic.
    string wake_file_contents;
    base::ReadFileToString(fake_wake_queues_file_path_, &wake_file_contents);
    return wake_file_contents != kJunkData;
  }
  MOCK_METHOD0(OnRepairHandler, void());

  // Getters for Mac80211Monitor state.
  bool GetIsDeviceConnected() const {
    return mac80211_monitor_.is_device_connected_;
  }
  time_t GetLastWokeQueuesMonotonicSeconds() const {
    return mac80211_monitor_.last_woke_queues_monotonic_seconds_;
  }
  const string& GetLinkName() const {
    return mac80211_monitor_.link_name_;
  }
  time_t GetMinimumTimeBetweenWakesSeconds() const {
    return Mac80211Monitor::kMinimumTimeBetweenWakesSeconds;
  }
  const string& GetPhyName() const {
    return mac80211_monitor_.phy_name_;
  }
  const base::FilePath& GetQueueStateFilePath() const {
    return mac80211_monitor_.queue_state_file_path_;
  }
  const base::FilePath& GetWakeQueuesFilePath() const {
    return mac80211_monitor_.wake_queues_file_path_;
  }

  // Pass-through methods to Mac80211Monitor methods.
  void StartMonitor(const string& phy_name) {
    EXPECT_CALL(
        event_dispatcher_,
        PostDelayedTask(
            _, Mac80211Monitor::kQueueStatePollIntervalSeconds * 1000));
    mac80211_monitor_.Start(phy_name);
    if (fake_sysfs_tree_.IsValid()) {
      PlumbFakeSysfs();  // Re-plumb, since un-plumbed by Start().
    }
  }
  void StopMonitor() {
    mac80211_monitor_.Stop();
  }
  uint32_t CheckAreQueuesStuck(const vector<QState>& queue_states) {
    return mac80211_monitor_.CheckAreQueuesStuck(queue_states);
  }
  void UpdateConnectedState(bool new_state) {
    mac80211_monitor_.UpdateConnectedState(new_state);
  }
  void WakeQueuesIfNeeded() {
    CHECK(fake_sysfs_tree_.IsValid());  // Keep tests hermetic.
    mac80211_monitor_.WakeQueuesIfNeeded();
  }

 private:
  base::ScopedTempDir fake_sysfs_tree_;  // Call FakeUpSysfs() first.
  StrictMock<MockEventDispatcher> event_dispatcher_;
  StrictMock<MockMetrics> metrics_;
  StrictMock<MockTime> time_;
  Mac80211Monitor mac80211_monitor_;

  void FakeUpQueueFiles(const string& queue_state_string) {
    CHECK(fake_sysfs_tree_.IsValid());  // Keep tests hermetic.
    base::WriteFile(fake_queue_state_file_path_,
                    queue_state_string.c_str(),
                    queue_state_string.length());
    ASSERT_TRUE(base::WriteFile(fake_wake_queues_file_path_,
                                kJunkData, strlen(kJunkData)));
  }
  void PlumbFakeSysfs() {
    mac80211_monitor_.queue_state_file_path_ = fake_queue_state_file_path_;
    mac80211_monitor_.wake_queues_file_path_ = fake_wake_queues_file_path_;
  }
};

// Can't be in an anonymous namespace, due to ADL.
// Instead, we use static to constain visibility to this unit.
static bool operator==(const QState& a, const QState& b) {
  return a.queue_number == b.queue_number &&
      a.stop_flags == b.stop_flags &&
      a.queue_length == b.queue_length;
}

TEST_F(Mac80211MonitorTest, Ctor) {
  EXPECT_TRUE(IsStopped());
  EXPECT_EQ(kTestDeviceName, GetLinkName());
}

TEST_F(Mac80211MonitorTest, Start) {
  StartMonitor("test-phy");
  EXPECT_TRUE(IsRunning());
  EXPECT_EQ("test-phy", GetPhyName());
  EXPECT_EQ("/sys/kernel/debug/ieee80211/test-phy/queues",
            GetQueueStateFilePath().value());
  EXPECT_EQ("/sys/kernel/debug/ieee80211/test-phy/wake_queues",
            GetWakeQueuesFilePath().value());
  EXPECT_EQ(0, GetLastWokeQueuesMonotonicSeconds());
}

TEST_F(Mac80211MonitorTest, Stop) {
  StartMonitor("dont-care-phy");
  EXPECT_TRUE(IsRunning());
  StopMonitor();
  EXPECT_TRUE(IsStopped());
}

TEST_F(Mac80211MonitorTest, UpdateConnectedState) {
  UpdateConnectedState(false);
  EXPECT_FALSE(GetIsDeviceConnected());

  UpdateConnectedState(true);
  EXPECT_TRUE(GetIsDeviceConnected());

  // Initial state was unknown. Ensure that we can move from true to false.
  UpdateConnectedState(false);
  EXPECT_FALSE(GetIsDeviceConnected());
}

TEST_F(Mac80211MonitorTest, WakeQueuesIfNeededFullMacDevice) {
  FakeUpSysfs();
  StartMonitor("dont-care-phy");
  UpdateConnectedState(false);
  EXPECT_CALL(event_dispatcher(), PostDelayedTask(_, _));
  ScopedMockLog log;
  EXPECT_CALL(log, Log(_, _, HasSubstr(": incomplete read on "))).Times(0);

  // In case of using device with Full-Mac support,
  // there is no queue state file in debugfs.
  DeleteQueueStateFile();
  WakeQueuesIfNeeded();
}

TEST_F(Mac80211MonitorTest, WakeQueuesIfNeededRearmsTimerWhenDisconnected) {
  FakeUpSysfs();
  StartMonitor("dont-care-phy");
  UpdateConnectedState(false);
  EXPECT_CALL(event_dispatcher(), PostDelayedTask(_, _));
  WakeQueuesIfNeeded();
}

TEST_F(Mac80211MonitorTest, WakeQueuesIfNeededFailToReadQueueState) {
  FakeUpSysfs();
  StartMonitor("dont-care-phy");
  UpdateConnectedState(false);
  AllowWakeQueuesIfNeededCommonCalls();
  WakeQueuesIfNeeded();

  // In case we succeeded reading queue state before, but fail this time.
  ScopedMockLog log;
  EXPECT_CALL(log, Log(_, _, HasSubstr(": incomplete read on "))).Times(1);
  DeleteQueueStateFile();
  WakeQueuesIfNeeded();
}

TEST_F(Mac80211MonitorTest, WakeQueuesIfNeededRearmsTimerWhenConnected) {
  FakeUpSysfs();
  StartMonitor("dont-care-phy");
  UpdateConnectedState(true);
  EXPECT_CALL(event_dispatcher(), PostDelayedTask(_, _));
  WakeQueuesIfNeeded();
}

TEST_F(Mac80211MonitorTest, WakeQueuesIfNeededWakeNeeded) {
  FakeUpSysfs();
  FakeUpStuckByPowerSaveState();
  StartMonitor("dont-care-phy");
  EXPECT_EQ(0, GetLastWokeQueuesMonotonicSeconds());

  const time_t kNowMonotonicSeconds = GetMinimumTimeBetweenWakesSeconds();
  EXPECT_CALL(time(), GetSecondsMonotonic(_))
      .WillOnce(DoAll(SetArgumentPointee<0>(kNowMonotonicSeconds),
                      Return(true)));
  EXPECT_CALL(*this, OnRepairHandler());
  AllowWakeQueuesIfNeededCommonCalls();
  WakeQueuesIfNeeded();

  EXPECT_EQ(kNowMonotonicSeconds, GetLastWokeQueuesMonotonicSeconds());
  EXPECT_TRUE(IsWakeQueuesFileModified());
}

TEST_F(Mac80211MonitorTest, WakeQueuesIfNeededRateLimiting) {
  FakeUpSysfs();
  FakeUpStuckByPowerSaveState();
  StartMonitor("dont-care-phy");
  EXPECT_EQ(0, GetLastWokeQueuesMonotonicSeconds());

  EXPECT_CALL(time(), GetSecondsMonotonic(_))
      .WillOnce(DoAll(
          SetArgumentPointee<0>(GetMinimumTimeBetweenWakesSeconds() - 1),
          Return(true)));
  EXPECT_CALL(*this, OnRepairHandler()).Times(0);
  AllowWakeQueuesIfNeededCommonCalls();
  WakeQueuesIfNeeded();

  EXPECT_EQ(0, GetLastWokeQueuesMonotonicSeconds());
  EXPECT_FALSE(IsWakeQueuesFileModified());
}

TEST_F(Mac80211MonitorTest, WakeQueuesIfNeededNotStuck) {
  FakeUpSysfs();
  FakeUpNotStuckState();
  StartMonitor("dont-care-phy");
  EXPECT_EQ(0, GetLastWokeQueuesMonotonicSeconds());

  EXPECT_CALL(*this, OnRepairHandler()).Times(0);
  AllowWakeQueuesIfNeededCommonCalls();
  WakeQueuesIfNeeded();

  EXPECT_EQ(0, GetLastWokeQueuesMonotonicSeconds());
  EXPECT_FALSE(IsWakeQueuesFileModified());
}

TEST_F(Mac80211MonitorTest, WakeQueuesIfNeededStuckByDriver) {
  FakeUpSysfs();
  FakeUpStuckByDriverState();
  StartMonitor("dont-care-phy");
  EXPECT_EQ(0, GetLastWokeQueuesMonotonicSeconds());

  EXPECT_CALL(*this, OnRepairHandler()).Times(0);
  AllowWakeQueuesIfNeededCommonCalls();
  WakeQueuesIfNeeded();

  EXPECT_EQ(0, GetLastWokeQueuesMonotonicSeconds());
  EXPECT_FALSE(IsWakeQueuesFileModified());
}

TEST_F(Mac80211MonitorTest, ParseQueueStateSimple) {
  // Single queue.
  EXPECT_THAT(Mac80211Monitor::ParseQueueState("00: 0x00000000/0\n"),
              ElementsAre(QState(0, 0, 0)));

  // Multiple queues, non-empty.
  EXPECT_THAT(
      Mac80211Monitor::ParseQueueState(
          "00: 0x00000000/10\n"
          "01: 0x00000000/20\n"),
      ElementsAre(QState(0, 0, 10), QState(1, 0, 20)));
}

TEST_F(Mac80211MonitorTest, ParseQueueStateStopped) {
  // Single queue, stopped for various reasons.
  EXPECT_THAT(
      Mac80211Monitor::ParseQueueState("00: 0x00000001/10\n"),
      ElementsAre(QState(0, Mac80211Monitor::kStopFlagDriver, 10)));
  EXPECT_THAT(
      Mac80211Monitor::ParseQueueState("00: 0x00000003/10\n"),
      ElementsAre(QState(0,
                         Mac80211Monitor::kStopFlagDriver |
                         Mac80211Monitor::kStopFlagPowerSave,
                         10)));
  EXPECT_THAT(
      Mac80211Monitor::ParseQueueState("00: 0x00000007/10\n"),
      ElementsAre(QState(0,
                         Mac80211Monitor::kStopFlagDriver |
                         Mac80211Monitor::kStopFlagPowerSave |
                         Mac80211Monitor::kStopFlagChannelSwitch,
                         10)));
  EXPECT_THAT(
      Mac80211Monitor::ParseQueueState("00: 0x0000000f/10\n"),
      ElementsAre(QState(0,
                         Mac80211Monitor::kStopFlagDriver |
                         Mac80211Monitor::kStopFlagPowerSave |
                         Mac80211Monitor::kStopFlagChannelSwitch |
                         Mac80211Monitor::kStopFlagAggregation,
                         10)));
  EXPECT_THAT(
      Mac80211Monitor::ParseQueueState("00: 0x0000001f/10\n"),
      ElementsAre(QState(0,
                         Mac80211Monitor::kStopFlagDriver |
                         Mac80211Monitor::kStopFlagPowerSave |
                         Mac80211Monitor::kStopFlagChannelSwitch |
                         Mac80211Monitor::kStopFlagAggregation |
                         Mac80211Monitor::kStopFlagSuspend,
                         10)));
  EXPECT_THAT(
      Mac80211Monitor::ParseQueueState("00: 0x0000003f/10\n"),
      ElementsAre(QState(0,
                         Mac80211Monitor::kStopFlagDriver |
                         Mac80211Monitor::kStopFlagPowerSave |
                         Mac80211Monitor::kStopFlagChannelSwitch |
                         Mac80211Monitor::kStopFlagAggregation |
                         Mac80211Monitor::kStopFlagSuspend |
                         Mac80211Monitor::kStopFlagBufferAdd,
                         10)));
  EXPECT_THAT(
      Mac80211Monitor::ParseQueueState("00: 0x0000007f/10\n"),
      ElementsAre(QState(0,
                         Mac80211Monitor::kStopFlagDriver |
                         Mac80211Monitor::kStopFlagPowerSave |
                         Mac80211Monitor::kStopFlagChannelSwitch |
                         Mac80211Monitor::kStopFlagAggregation |
                         Mac80211Monitor::kStopFlagSuspend |
                         Mac80211Monitor::kStopFlagBufferAdd |
                         Mac80211Monitor::kStopFlagChannelTypeChange,
                         10)));
}

TEST_F(Mac80211MonitorTest, ParseQueueStateBadInput) {
  // Empty input -> Empty output.
  EXPECT_TRUE(Mac80211Monitor::ParseQueueState("").empty());

  // Missing queue length for queue 0.
  EXPECT_THAT(
      Mac80211Monitor::ParseQueueState(
          "00: 0x00000000\n"
          "01: 0xffffffff/10\n"),
      ElementsAre(QState(1, 0xffffffff, 10)));

  // Missing flags for queue 0.
  EXPECT_THAT(
      Mac80211Monitor::ParseQueueState(
          "00: 0\n"
          "01: 0xffffffff/10\n"),
      ElementsAre(QState(1, 0xffffffff, 10)));

  // Bad number for queue 0.
  EXPECT_THAT(
      Mac80211Monitor::ParseQueueState(
          "aa: 0xabcdefgh/0\n"
          "01: 0xffffffff/10\n"),
      ElementsAre(QState(1, 0xffffffff, 10)));

  // Bad flags for queue 0.
  EXPECT_THAT(
      Mac80211Monitor::ParseQueueState(
          "00: 0xabcdefgh/0\n"
          "01: 0xffffffff/10\n"),
      ElementsAre(QState(1, 0xffffffff, 10)));

  // Bad length for queue 0.
  EXPECT_THAT(
      Mac80211Monitor::ParseQueueState(
          "00: 0x00000000/-1\n"
          "01: 0xffffffff/10\n"),
      ElementsAre(QState(1, 0xffffffff, 10)));
}

TEST_F(Mac80211MonitorTest, CheckAreQueuesStuckNotStuck) {
  EXPECT_FALSE(CheckAreQueuesStuck({}));
  EXPECT_FALSE(CheckAreQueuesStuck({QState(0, 0, 0)}));
  // Not stuck when queue length is below limit.
  EXPECT_FALSE(CheckAreQueuesStuck({
        QState(0, Mac80211Monitor::kStopFlagPowerSave, kQueueLengthLimit-1)}));
}

TEST_F(Mac80211MonitorTest, CheckAreQueuesStuckSingleReason) {
  EXPECT_CALL(metrics(), SendEnumToUMA(
      Metrics::kMetricWifiStoppedTxQueueReason,
      Mac80211Monitor::kStopReasonDriver,
      Mac80211Monitor::kStopReasonMax));
  EXPECT_CALL(metrics(), SendEnumToUMA(
      Metrics::kMetricWifiStoppedTxQueueReason,
      Mac80211Monitor::kStopReasonPowerSave,
      Mac80211Monitor::kStopReasonMax));
  EXPECT_CALL(metrics(), SendToUMA(
      Metrics::kMetricWifiStoppedTxQueueLength,
      kQueueLengthLimit,
      Metrics::kMetricWifiStoppedTxQueueLengthMin,
      Metrics::kMetricWifiStoppedTxQueueLengthMax,
      Metrics::kMetricWifiStoppedTxQueueLengthNumBuckets)).Times(2);
  EXPECT_EQ(Mac80211Monitor::kStopFlagDriver,
            CheckAreQueuesStuck({
                QState(0,
                       Mac80211Monitor::kStopFlagDriver,
                       kQueueLengthLimit)}));
  EXPECT_EQ(Mac80211Monitor::kStopFlagPowerSave,
            CheckAreQueuesStuck({
                QState(0,
                       Mac80211Monitor::kStopFlagPowerSave,
                       kQueueLengthLimit)}));
}

TEST_F(Mac80211MonitorTest, CheckAreQueuesStuckMultipleReasons) {
  EXPECT_CALL(metrics(), SendEnumToUMA(
      Metrics::kMetricWifiStoppedTxQueueReason,
      Mac80211Monitor::kStopReasonPowerSave,
      Mac80211Monitor::kStopReasonMax)).Times(2);
  EXPECT_CALL(metrics(), SendEnumToUMA(
      Metrics::kMetricWifiStoppedTxQueueReason,
      Mac80211Monitor::kStopReasonDriver,
      Mac80211Monitor::kStopReasonMax)).Times(2);
  EXPECT_CALL(metrics(), SendEnumToUMA(
      Metrics::kMetricWifiStoppedTxQueueReason,
      Mac80211Monitor::kStopReasonChannelSwitch,
      Mac80211Monitor::kStopReasonMax)).Times(2);
  EXPECT_CALL(metrics(), SendToUMA(
      Metrics::kMetricWifiStoppedTxQueueLength,
      kQueueLengthLimit,
      Metrics::kMetricWifiStoppedTxQueueLengthMin,
      Metrics::kMetricWifiStoppedTxQueueLengthMax,
      Metrics::kMetricWifiStoppedTxQueueLengthNumBuckets)).Times(3);
  EXPECT_EQ(Mac80211Monitor::kStopFlagDriver |
            Mac80211Monitor::kStopFlagPowerSave,
            CheckAreQueuesStuck({
                QState(0,
                       Mac80211Monitor::kStopFlagDriver |
                       Mac80211Monitor::kStopFlagPowerSave,
                       kQueueLengthLimit)}));
  EXPECT_EQ(Mac80211Monitor::kStopFlagPowerSave |
            Mac80211Monitor::kStopFlagChannelSwitch,
            CheckAreQueuesStuck({
                QState(0,
                       Mac80211Monitor::kStopFlagPowerSave |
                       Mac80211Monitor::kStopFlagChannelSwitch,
                       kQueueLengthLimit)}));
  EXPECT_EQ(Mac80211Monitor::kStopFlagDriver |
            Mac80211Monitor::kStopFlagChannelSwitch,
            CheckAreQueuesStuck({
                QState(0,
                       Mac80211Monitor::kStopFlagDriver |
                       Mac80211Monitor::kStopFlagChannelSwitch,
                       kQueueLengthLimit)}));
}

TEST_F(Mac80211MonitorTest, CheckAreQueuesStuckMultipleQueues) {
  EXPECT_CALL(metrics(), SendEnumToUMA(
      Metrics::kMetricWifiStoppedTxQueueReason,
      Mac80211Monitor::kStopReasonPowerSave,
      Mac80211Monitor::kStopReasonMax)).Times(5);
  EXPECT_CALL(metrics(), SendEnumToUMA(
      Metrics::kMetricWifiStoppedTxQueueReason,
      Mac80211Monitor::kStopReasonDriver,
      Mac80211Monitor::kStopReasonMax)).Times(2);
  EXPECT_CALL(metrics(), SendToUMA(
      Metrics::kMetricWifiStoppedTxQueueLength,
      kQueueLengthLimit,
      Metrics::kMetricWifiStoppedTxQueueLengthMin,
      Metrics::kMetricWifiStoppedTxQueueLengthMax,
      Metrics::kMetricWifiStoppedTxQueueLengthNumBuckets)).Times(5);
  EXPECT_EQ(Mac80211Monitor::kStopFlagPowerSave,
            CheckAreQueuesStuck({
                QState(0, 0, 0),
                QState(0,
                       Mac80211Monitor::kStopFlagPowerSave,
                       kQueueLengthLimit)}));
  EXPECT_EQ(Mac80211Monitor::kStopFlagPowerSave,
            CheckAreQueuesStuck({
                QState(0,
                       Mac80211Monitor::kStopFlagPowerSave,
                       kQueueLengthLimit),
                QState(0, 0, 0)}));
  EXPECT_EQ(Mac80211Monitor::kStopFlagPowerSave,
            CheckAreQueuesStuck({
                QState(0,
                       Mac80211Monitor::kStopFlagPowerSave,
                       kQueueLengthLimit),
                QState(0,
                       Mac80211Monitor::kStopFlagPowerSave,
                       kQueueLengthLimit)}));
  EXPECT_EQ(Mac80211Monitor::kStopFlagDriver |
            Mac80211Monitor::kStopFlagPowerSave,
            CheckAreQueuesStuck({
                QState(0,
                       Mac80211Monitor::kStopFlagPowerSave,
                       kQueueLengthLimit),
                QState(0,
                       Mac80211Monitor::kStopFlagDriver,
                       kQueueLengthLimit)}));
  EXPECT_EQ(Mac80211Monitor::kStopFlagDriver |
            Mac80211Monitor::kStopFlagPowerSave,
            CheckAreQueuesStuck({
                QState(0, Mac80211Monitor::kStopFlagDriver, kQueueLengthLimit),
                QState(0,
                       Mac80211Monitor::kStopFlagPowerSave,
                       kQueueLengthLimit)}));
}

TEST_F(Mac80211MonitorTest, CheckAreQueuesStuckQueueLength) {
  EXPECT_CALL(metrics(), SendEnumToUMA(
      Metrics::kMetricWifiStoppedTxQueueReason,
      Mac80211Monitor::kStopReasonPowerSave,
      Mac80211Monitor::kStopReasonMax)).Times(4);
  EXPECT_CALL(metrics(), SendToUMA(
      Metrics::kMetricWifiStoppedTxQueueLength,
      kQueueLengthLimit,
      Metrics::kMetricWifiStoppedTxQueueLengthMin,
      Metrics::kMetricWifiStoppedTxQueueLengthMax,
      Metrics::kMetricWifiStoppedTxQueueLengthNumBuckets)).Times(4);
  EXPECT_TRUE(CheckAreQueuesStuck({
        QState(0, Mac80211Monitor::kStopFlagPowerSave, kQueueLengthLimit)}));
  EXPECT_TRUE(CheckAreQueuesStuck({
        QState(0, Mac80211Monitor::kStopFlagPowerSave, kQueueLengthLimit-2),
        QState(0, Mac80211Monitor::kStopFlagPowerSave, kQueueLengthLimit-1),
        QState(0, Mac80211Monitor::kStopFlagPowerSave, kQueueLengthLimit)}));
  EXPECT_TRUE(CheckAreQueuesStuck({
        QState(0, Mac80211Monitor::kStopFlagPowerSave, kQueueLengthLimit),
        QState(0, Mac80211Monitor::kStopFlagPowerSave, kQueueLengthLimit-1),
        QState(0, Mac80211Monitor::kStopFlagPowerSave, kQueueLengthLimit-2)}));
  EXPECT_TRUE(CheckAreQueuesStuck({
        QState(0, Mac80211Monitor::kStopFlagPowerSave, kQueueLengthLimit-1),
        QState(0, Mac80211Monitor::kStopFlagPowerSave, kQueueLengthLimit),
        QState(0, Mac80211Monitor::kStopFlagPowerSave, kQueueLengthLimit-2)}));
}

TEST_F(Mac80211MonitorTest, CheckAreQueuesStuckQueueLengthIgnoresUnstopped) {
  EXPECT_CALL(metrics(), SendEnumToUMA(
      Metrics::kMetricWifiStoppedTxQueueReason,
      Mac80211Monitor::kStopReasonPowerSave,
      Mac80211Monitor::kStopReasonMax));
  EXPECT_CALL(metrics(), SendToUMA(
      Metrics::kMetricWifiStoppedTxQueueLength,
      kQueueLengthLimit,
      Metrics::kMetricWifiStoppedTxQueueLengthMin,
      Metrics::kMetricWifiStoppedTxQueueLengthMax,
      Metrics::kMetricWifiStoppedTxQueueLengthNumBuckets));
  EXPECT_TRUE(CheckAreQueuesStuck({
        QState(0, 0, kQueueLengthLimit * 10),
        QState(0, Mac80211Monitor::kStopFlagPowerSave, kQueueLengthLimit)}));
}

}  // namespace shill