device/bluetooth/bluetooth_task_manager_win_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/bind.h"
   6 #include "base/memory/ref_counted.h"
   7 #include "base/test/test_pending_task.h"
   8 #include "base/test/test_simple_task_runner.h"
   9 #include "device/bluetooth/bluetooth_init_win.h"
  10 #include "device/bluetooth/bluetooth_task_manager_win.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 namespace {
  14
  15 class BluetoothTaskObserver : public device::BluetoothTaskManagerWin::Observer {
  16  public:
  17   BluetoothTaskObserver()
  18       : num_adapter_state_changed_(0),
  19         num_discovery_started_(0),
  20         num_discovery_stopped_(0) {
  21   }
  22
  23   virtual ~BluetoothTaskObserver() {
  24   }
  25
  26   virtual void AdapterStateChanged(
  27     const device::BluetoothTaskManagerWin::AdapterState& state) override {
  28     num_adapter_state_changed_++;
  29   }
  30
  31   virtual void DiscoveryStarted(bool success) override {
  32     num_discovery_started_++;
  33   }
  34
  35   virtual void DiscoveryStopped() override {
  36     num_discovery_stopped_++;
  37   }
  38
  39   int num_adapter_state_changed() const {
  40     return num_adapter_state_changed_;
  41   }
  42
  43   int num_discovery_started() const {
  44     return num_discovery_started_;
  45   }
  46
  47   int num_discovery_stopped() const {
  48     return num_discovery_stopped_;
  49   }
  50
  51  private:
  52    int num_adapter_state_changed_;
  53    int num_discovery_started_;
  54    int num_discovery_stopped_;
  55 };
  56
  57 }  // namespace
  58
  59 namespace device {
  60
  61 class BluetoothTaskManagerWinTest : public testing::Test {
  62  public:
  63   BluetoothTaskManagerWinTest()
  64       : ui_task_runner_(new base::TestSimpleTaskRunner()),
  65         bluetooth_task_runner_(new base::TestSimpleTaskRunner()),
  66         task_manager_(new BluetoothTaskManagerWin(ui_task_runner_)),
  67         has_bluetooth_stack_(device::bluetooth_init_win::HasBluetoothStack()) {
  68     task_manager_->InitializeWithBluetoothTaskRunner(bluetooth_task_runner_);
  69   }
  70
  71   virtual void SetUp() {
  72     task_manager_->AddObserver(&observer_);
  73   }
  74
  75   virtual void TearDown() {
  76     task_manager_->RemoveObserver(&observer_);
  77   }
  78
  79   int GetPollingIntervalMs() const {
  80     return BluetoothTaskManagerWin::kPollIntervalMs;
  81   }
  82
  83  protected:
  84   scoped_refptr<base::TestSimpleTaskRunner> ui_task_runner_;
  85   scoped_refptr<base::TestSimpleTaskRunner> bluetooth_task_runner_;
  86   scoped_refptr<BluetoothTaskManagerWin> task_manager_;
  87   BluetoothTaskObserver observer_;
  88   const bool has_bluetooth_stack_;
  89 };
  90
  91 TEST_F(BluetoothTaskManagerWinTest, StartPolling) {
  92   EXPECT_EQ(1, bluetooth_task_runner_->GetPendingTasks().size());
  93 }
  94
  95 TEST_F(BluetoothTaskManagerWinTest, PollAdapterIfBluetoothStackIsAvailable) {
  96   bluetooth_task_runner_->RunPendingTasks();
  97   int num_expected_pending_tasks = has_bluetooth_stack_ ? 1 : 0;
  98   EXPECT_EQ(num_expected_pending_tasks,
  99             bluetooth_task_runner_->GetPendingTasks().size());
 100 }
 101
 102 TEST_F(BluetoothTaskManagerWinTest, Polling) {
 103   if (!has_bluetooth_stack_)
 104     return;
 105
 106   int num_polls = 5;
 107
 108   for (int i = 0; i < num_polls; i++) {
 109     bluetooth_task_runner_->RunPendingTasks();
 110   }
 111
 112   ui_task_runner_->RunPendingTasks();
 113   EXPECT_EQ(num_polls, observer_.num_adapter_state_changed());
 114 }
 115
 116 TEST_F(BluetoothTaskManagerWinTest, SetPowered) {
 117   if (!has_bluetooth_stack_)
 118     return;
 119
 120   bluetooth_task_runner_->ClearPendingTasks();
 121   base::Closure closure;
 122   task_manager_->PostSetPoweredBluetoothTask(true, closure, closure);
 123
 124   EXPECT_EQ(1, bluetooth_task_runner_->GetPendingTasks().size());
 125   bluetooth_task_runner_->RunPendingTasks();
 126   EXPECT_TRUE(ui_task_runner_->GetPendingTasks().size() >= 1);
 127 }
 128
 129 TEST_F(BluetoothTaskManagerWinTest, Discovery) {
 130   if (!has_bluetooth_stack_)
 131     return;
 132
 133   bluetooth_task_runner_->RunPendingTasks();
 134   bluetooth_task_runner_->ClearPendingTasks();
 135   task_manager_->PostStartDiscoveryTask();
 136   bluetooth_task_runner_->RunPendingTasks();
 137   ui_task_runner_->RunPendingTasks();
 138   EXPECT_EQ(1, observer_.num_discovery_started());
 139   task_manager_->PostStopDiscoveryTask();
 140   bluetooth_task_runner_->RunPendingTasks();
 141   ui_task_runner_->RunPendingTasks();
 142   EXPECT_EQ(1, observer_.num_discovery_stopped());
 143 }
 144
 145 }  // namespace device