device/bluetooth/bluetooth_adapter_unittest.cc

   1 // Copyright 2014 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/memory/ref_counted.h"
   6 #include "device/bluetooth/bluetooth_adapter.h"
   7 #include "device/bluetooth/bluetooth_device.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9
  10 using device::BluetoothAdapter;
  11 using device::BluetoothDevice;
  12
  13 namespace device {
  14
  15 class TestBluetoothAdapter : public BluetoothAdapter {
  16  public:
  17   TestBluetoothAdapter() {
  18   }
  19
  20   virtual void AddObserver(BluetoothAdapter::Observer* observer) OVERRIDE {
  21   }
  22
  23   virtual void RemoveObserver(BluetoothAdapter::Observer* observer) OVERRIDE {
  24
  25   }
  26
  27   virtual std::string GetAddress() const OVERRIDE {
  28     return "";
  29   }
  30
  31   virtual std::string GetName() const OVERRIDE {
  32     return "";
  33   }
  34
  35   virtual void SetName(const std::string& name,
  36                        const base::Closure& callback,
  37                        const ErrorCallback& error_callback) OVERRIDE {
  38   }
  39
  40   virtual bool IsInitialized() const OVERRIDE {
  41     return false;
  42   }
  43
  44   virtual bool IsPresent() const OVERRIDE {
  45     return false;
  46   }
  47
  48   virtual bool IsPowered() const OVERRIDE {
  49     return false;
  50   }
  51
  52   virtual void SetPowered(
  53       bool powered,
  54       const base::Closure& callback,
  55       const ErrorCallback& error_callback) OVERRIDE {
  56   }
  57
  58   virtual bool IsDiscoverable() const OVERRIDE {
  59     return false;
  60   }
  61
  62   virtual void SetDiscoverable(
  63       bool discoverable,
  64       const base::Closure& callback,
  65       const ErrorCallback& error_callback) OVERRIDE {
  66   }
  67
  68   virtual bool IsDiscovering() const OVERRIDE {
  69     return false;
  70   }
  71
  72   virtual void StartDiscoverySession(
  73       const DiscoverySessionCallback& callback,
  74       const ErrorCallback& error_callback) OVERRIDE {
  75   }
  76
  77   virtual void ReadLocalOutOfBandPairingData(
  78       const BluetoothAdapter::BluetoothOutOfBandPairingDataCallback& callback,
  79       const ErrorCallback& error_callback) OVERRIDE {
  80   }
  81
  82  protected:
  83   virtual ~TestBluetoothAdapter() {}
  84
  85   virtual void AddDiscoverySession(
  86       const base::Closure& callback,
  87       const ErrorCallback& error_callback) OVERRIDE {
  88   }
  89
  90   virtual void RemoveDiscoverySession(
  91       const base::Closure& callback,
  92       const ErrorCallback& error_callback) OVERRIDE {
  93   }
  94
  95   virtual void RemovePairingDelegateInternal(
  96       BluetoothDevice::PairingDelegate* pairing_delegate) OVERRIDE {
  97   }
  98 };
  99
 100 class TestPairingDelegate : public BluetoothDevice::PairingDelegate {
 101   public:
 102    virtual void RequestPinCode(BluetoothDevice* device) OVERRIDE {}
 103    virtual void RequestPasskey(BluetoothDevice* device) OVERRIDE {}
 104    virtual void DisplayPinCode(BluetoothDevice* device,
 105                                const std::string& pincode) OVERRIDE {}
 106    virtual void DisplayPasskey(BluetoothDevice* device,
 107                                uint32 passkey) OVERRIDE {}
 108    virtual void KeysEntered(BluetoothDevice* device,
 109                             uint32 entered) OVERRIDE {}
 110    virtual void ConfirmPasskey(BluetoothDevice* device,
 111                                uint32 passkey) OVERRIDE {}
 112    virtual void AuthorizePairing(BluetoothDevice* device) OVERRIDE {}
 113 };
 114
 115
 116 TEST(BluetoothAdapterTest, NoDefaultPairingDelegate) {
 117   scoped_refptr<BluetoothAdapter> adapter = new TestBluetoothAdapter();
 118
 119   // Verify that when there is no registered pairing delegate, NULL is returned.
 120   EXPECT_TRUE(adapter->DefaultPairingDelegate() == NULL);
 121 }
 122
 123 TEST(BluetoothAdapterTest, OneDefaultPairingDelegate) {
 124   scoped_refptr<BluetoothAdapter> adapter = new TestBluetoothAdapter();
 125
 126   // Verify that when there is one registered pairing delegate, it is returned.
 127   TestPairingDelegate delegate;
 128
 129   adapter->AddPairingDelegate(&delegate,
 130                               BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_LOW);
 131
 132   EXPECT_EQ(&delegate, adapter->DefaultPairingDelegate());
 133 }
 134
 135 TEST(BluetoothAdapterTest, SamePriorityDelegates) {
 136   scoped_refptr<BluetoothAdapter> adapter = new TestBluetoothAdapter();
 137
 138   // Verify that when there are two registered pairing delegates of the same
 139   // priority, the first one registered is returned.
 140   TestPairingDelegate delegate1, delegate2;
 141
 142   adapter->AddPairingDelegate(&delegate1,
 143                               BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_LOW);
 144   adapter->AddPairingDelegate(&delegate2,
 145                               BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_LOW);
 146
 147   EXPECT_EQ(&delegate1, adapter->DefaultPairingDelegate());
 148
 149   // After unregistering the first, the second can be returned.
 150   adapter->RemovePairingDelegate(&delegate1);
 151
 152   EXPECT_EQ(&delegate2, adapter->DefaultPairingDelegate());
 153 }
 154
 155 TEST(BluetoothAdapterTest, HighestPriorityDelegate) {
 156   scoped_refptr<BluetoothAdapter> adapter = new TestBluetoothAdapter();
 157
 158   // Verify that when there are two registered pairing delegates, the one with
 159   // the highest priority is returned.
 160   TestPairingDelegate delegate1, delegate2;
 161
 162   adapter->AddPairingDelegate(&delegate1,
 163                               BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_LOW);
 164   adapter->AddPairingDelegate(&delegate2,
 165                               BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
 166
 167   EXPECT_EQ(&delegate2, adapter->DefaultPairingDelegate());
 168 }
 169
 170 TEST(BluetoothAdapterTest, UnregisterDelegate) {
 171   scoped_refptr<BluetoothAdapter> adapter = new TestBluetoothAdapter();
 172
 173   // Verify that after unregistering a delegate, NULL is returned.
 174   TestPairingDelegate delegate;
 175
 176   adapter->AddPairingDelegate(&delegate,
 177                               BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_LOW);
 178   adapter->RemovePairingDelegate(&delegate);
 179
 180   EXPECT_TRUE(adapter->DefaultPairingDelegate() == NULL);
 181 }
 182
 183 }  // namespace device