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 CreateRfcommService(
  78       const BluetoothUUID& uuid,
  79       const ServiceOptions& options,
  80       const CreateServiceCallback& callback,
  81       const CreateServiceErrorCallback& error_callback) OVERRIDE {
  82   }
  83
  84   virtual void CreateL2capService(
  85       const BluetoothUUID& uuid,
  86       const ServiceOptions& options,
  87       const CreateServiceCallback& callback,
  88       const CreateServiceErrorCallback& error_callback) OVERRIDE {
  89   }
  90
  91  protected:
  92   virtual ~TestBluetoothAdapter() {}
  93
  94   virtual void AddDiscoverySession(
  95       const base::Closure& callback,
  96       const ErrorCallback& error_callback) OVERRIDE {
  97   }
  98
  99   virtual void RemoveDiscoverySession(
 100       const base::Closure& callback,
 101       const ErrorCallback& error_callback) OVERRIDE {
 102   }
 103
 104   virtual void RemovePairingDelegateInternal(
 105       BluetoothDevice::PairingDelegate* pairing_delegate) OVERRIDE {
 106   }
 107 };
 108
 109 class TestPairingDelegate : public BluetoothDevice::PairingDelegate {
 110   public:
 111    virtual void RequestPinCode(BluetoothDevice* device) OVERRIDE {}
 112    virtual void RequestPasskey(BluetoothDevice* device) OVERRIDE {}
 113    virtual void DisplayPinCode(BluetoothDevice* device,
 114                                const std::string& pincode) OVERRIDE {}
 115    virtual void DisplayPasskey(BluetoothDevice* device,
 116                                uint32 passkey) OVERRIDE {}
 117    virtual void KeysEntered(BluetoothDevice* device,
 118                             uint32 entered) OVERRIDE {}
 119    virtual void ConfirmPasskey(BluetoothDevice* device,
 120                                uint32 passkey) OVERRIDE {}
 121    virtual void AuthorizePairing(BluetoothDevice* device) OVERRIDE {}
 122 };
 123
 124
 125 TEST(BluetoothAdapterTest, NoDefaultPairingDelegate) {
 126   scoped_refptr<BluetoothAdapter> adapter = new TestBluetoothAdapter();
 127
 128   // Verify that when there is no registered pairing delegate, NULL is returned.
 129   EXPECT_TRUE(adapter->DefaultPairingDelegate() == NULL);
 130 }
 131
 132 TEST(BluetoothAdapterTest, OneDefaultPairingDelegate) {
 133   scoped_refptr<BluetoothAdapter> adapter = new TestBluetoothAdapter();
 134
 135   // Verify that when there is one registered pairing delegate, it is returned.
 136   TestPairingDelegate delegate;
 137
 138   adapter->AddPairingDelegate(&delegate,
 139                               BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_LOW);
 140
 141   EXPECT_EQ(&delegate, adapter->DefaultPairingDelegate());
 142 }
 143
 144 TEST(BluetoothAdapterTest, SamePriorityDelegates) {
 145   scoped_refptr<BluetoothAdapter> adapter = new TestBluetoothAdapter();
 146
 147   // Verify that when there are two registered pairing delegates of the same
 148   // priority, the first one registered is returned.
 149   TestPairingDelegate delegate1, delegate2;
 150
 151   adapter->AddPairingDelegate(&delegate1,
 152                               BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_LOW);
 153   adapter->AddPairingDelegate(&delegate2,
 154                               BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_LOW);
 155
 156   EXPECT_EQ(&delegate1, adapter->DefaultPairingDelegate());
 157
 158   // After unregistering the first, the second can be returned.
 159   adapter->RemovePairingDelegate(&delegate1);
 160
 161   EXPECT_EQ(&delegate2, adapter->DefaultPairingDelegate());
 162 }
 163
 164 TEST(BluetoothAdapterTest, HighestPriorityDelegate) {
 165   scoped_refptr<BluetoothAdapter> adapter = new TestBluetoothAdapter();
 166
 167   // Verify that when there are two registered pairing delegates, the one with
 168   // the highest priority is returned.
 169   TestPairingDelegate delegate1, delegate2;
 170
 171   adapter->AddPairingDelegate(&delegate1,
 172                               BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_LOW);
 173   adapter->AddPairingDelegate(&delegate2,
 174                               BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
 175
 176   EXPECT_EQ(&delegate2, adapter->DefaultPairingDelegate());
 177 }
 178
 179 TEST(BluetoothAdapterTest, UnregisterDelegate) {
 180   scoped_refptr<BluetoothAdapter> adapter = new TestBluetoothAdapter();
 181
 182   // Verify that after unregistering a delegate, NULL is returned.
 183   TestPairingDelegate delegate;
 184
 185   adapter->AddPairingDelegate(&delegate,
 186                               BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_LOW);
 187   adapter->RemovePairingDelegate(&delegate);
 188
 189   EXPECT_TRUE(adapter->DefaultPairingDelegate() == NULL);
 190 }
 191
 192 }  // namespace device