1 // 2 // Copyright (C) 2015 Google, Inc. 3 // 4 // Licensed under the Apache License, Version 2.0 (the "License"); 5 // you may not use this file except in compliance with the License. 6 // You may obtain a copy of the License at: 7 // 8 // http://www.apache.org/licenses/LICENSE-2.0 9 // 10 // Unless required by applicable law or agreed to in writing, software 11 // distributed under the License is distributed on an "AS IS" BASIS, 12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 // See the License for the specific language governing permissions and 14 // limitations under the License. 15 // 16 17 #include <base/macros.h> 18 #include <gtest/gtest.h> 19 20 #include "service/adapter.h" 21 #include "service/hal/fake_bluetooth_gatt_interface.h" 22 #include "service/hal/fake_bluetooth_interface.h" 23 24 namespace bluetooth { 25 namespace { 26 27 class AdapterTest : public ::testing::Test { 28 public: 29 AdapterTest() = default; 30 ~AdapterTest() override = default; 31 32 void SetUp() override { 33 fake_hal_manager_ = hal::FakeBluetoothInterface::GetManager(); 34 fake_hal_iface_ = new hal::FakeBluetoothInterface(); 35 hal::BluetoothInterface::InitializeForTesting(fake_hal_iface_); 36 37 // Initialize GATT interface with default handlers. 38 hal::BluetoothGattInterface::InitializeForTesting( 39 new hal::FakeBluetoothGattInterface(nullptr, nullptr, nullptr, 40 nullptr)); 41 42 adapter_ = Adapter::Create(); 43 } 44 45 void TearDown() override { 46 adapter_.reset(); 47 hal::BluetoothGattInterface::CleanUp(); 48 hal::BluetoothInterface::CleanUp(); 49 } 50 51 protected: 52 hal::FakeBluetoothInterface* fake_hal_iface_; 53 hal::FakeBluetoothInterface::Manager* fake_hal_manager_; 54 std::unique_ptr<Adapter> adapter_; 55 56 private: 57 DISALLOW_COPY_AND_ASSIGN(AdapterTest); 58 }; 59 60 class TestObserver final : public bluetooth::Adapter::Observer { 61 public: 62 explicit TestObserver(bluetooth::Adapter* adapter) 63 : adapter_(adapter), 64 prev_state_(bluetooth::ADAPTER_STATE_INVALID), 65 cur_state_(bluetooth::ADAPTER_STATE_INVALID), 66 last_device_connected_state_(false) { 67 CHECK(adapter_); 68 adapter_->AddObserver(this); 69 } 70 71 ~TestObserver() override { adapter_->RemoveObserver(this); } 72 73 bluetooth::AdapterState prev_state() const { return prev_state_; } 74 bluetooth::AdapterState cur_state() const { return cur_state_; } 75 76 std::string last_connection_state_address() const { 77 return last_connection_state_address_; 78 } 79 80 bool last_device_connected_state() const { 81 return last_device_connected_state_; 82 } 83 84 // bluetooth::Adapter::Observer override: 85 void OnAdapterStateChanged(bluetooth::Adapter* adapter, 86 bluetooth::AdapterState prev_state, 87 bluetooth::AdapterState new_state) override { 88 ASSERT_EQ(adapter_, adapter); 89 prev_state_ = prev_state; 90 cur_state_ = new_state; 91 } 92 93 void OnDeviceConnectionStateChanged(Adapter* adapter, 94 const std::string& device_address, 95 bool connected) override { 96 ASSERT_EQ(adapter_, adapter); 97 last_connection_state_address_ = device_address; 98 last_device_connected_state_ = connected; 99 } 100 101 private: 102 bluetooth::Adapter* adapter_; 103 bluetooth::AdapterState prev_state_, cur_state_; 104 std::string last_connection_state_address_; 105 bool last_device_connected_state_; 106 107 DISALLOW_COPY_AND_ASSIGN(TestObserver); 108 }; 109 110 TEST_F(AdapterTest, IsEnabled) { 111 EXPECT_FALSE(adapter_->IsEnabled()); 112 113 fake_hal_iface_->NotifyAdapterStateChanged(BT_STATE_ON); 114 EXPECT_TRUE(adapter_->IsEnabled()); 115 116 fake_hal_iface_->NotifyAdapterStateChanged(BT_STATE_OFF); 117 EXPECT_FALSE(adapter_->IsEnabled()); 118 } 119 120 TEST_F(AdapterTest, Enable) { 121 TestObserver observer(adapter_.get()); 122 123 EXPECT_FALSE(adapter_->IsEnabled()); 124 EXPECT_EQ(bluetooth::ADAPTER_STATE_OFF, adapter_->GetState()); 125 126 // Enable fails at HAL level 127 EXPECT_FALSE(adapter_->Enable(false)); 128 EXPECT_EQ(bluetooth::ADAPTER_STATE_OFF, adapter_->GetState()); 129 130 // Enable success 131 fake_hal_manager_->enable_succeed = true; 132 EXPECT_TRUE(adapter_->Enable(false)); 133 134 // Should have received a state update. 135 EXPECT_EQ(bluetooth::ADAPTER_STATE_OFF, observer.prev_state()); 136 EXPECT_EQ(bluetooth::ADAPTER_STATE_TURNING_ON, observer.cur_state()); 137 138 // Enable fails because not disabled 139 EXPECT_EQ(bluetooth::ADAPTER_STATE_TURNING_ON, adapter_->GetState()); 140 EXPECT_FALSE(adapter_->Enable(false)); 141 142 // Adapter state updates properly 143 fake_hal_iface_->NotifyAdapterStateChanged(BT_STATE_ON); 144 EXPECT_EQ(bluetooth::ADAPTER_STATE_ON, adapter_->GetState()); 145 146 // Should have received a state update. 147 EXPECT_EQ(bluetooth::ADAPTER_STATE_TURNING_ON, observer.prev_state()); 148 EXPECT_EQ(bluetooth::ADAPTER_STATE_ON, observer.cur_state()); 149 150 // Enable fails because already enabled 151 EXPECT_FALSE(adapter_->Enable(false)); 152 } 153 154 TEST_F(AdapterTest, Disable) { 155 TestObserver observer(adapter_.get()); 156 157 fake_hal_manager_->disable_succeed = true; 158 EXPECT_FALSE(adapter_->IsEnabled()); 159 EXPECT_EQ(bluetooth::ADAPTER_STATE_OFF, adapter_->GetState()); 160 161 // Disable fails because already disabled 162 EXPECT_FALSE(adapter_->Disable()); 163 EXPECT_EQ(bluetooth::ADAPTER_STATE_OFF, adapter_->GetState()); 164 165 // Disable success 166 fake_hal_iface_->NotifyAdapterStateChanged(BT_STATE_ON); 167 168 // Should have received a state update. 169 EXPECT_EQ(bluetooth::ADAPTER_STATE_OFF, observer.prev_state()); 170 EXPECT_EQ(bluetooth::ADAPTER_STATE_ON, observer.cur_state()); 171 172 EXPECT_TRUE(adapter_->Disable()); 173 174 // Should have received a state update. 175 EXPECT_EQ(bluetooth::ADAPTER_STATE_ON, observer.prev_state()); 176 EXPECT_EQ(bluetooth::ADAPTER_STATE_TURNING_OFF, observer.cur_state()); 177 178 // Disable fails because not enabled 179 EXPECT_EQ(bluetooth::ADAPTER_STATE_TURNING_OFF, adapter_->GetState()); 180 EXPECT_FALSE(adapter_->Disable()); 181 182 fake_hal_iface_->NotifyAdapterStateChanged(BT_STATE_ON); 183 EXPECT_EQ(bluetooth::ADAPTER_STATE_ON, adapter_->GetState()); 184 185 // Should have received a state update. 186 EXPECT_EQ(bluetooth::ADAPTER_STATE_TURNING_OFF, observer.prev_state()); 187 EXPECT_EQ(bluetooth::ADAPTER_STATE_ON, observer.cur_state()); 188 189 // Disable fails at HAL level 190 fake_hal_manager_->disable_succeed = false; 191 EXPECT_FALSE(adapter_->Disable()); 192 193 // Should have received a state update. In this case we will receive two 194 // updates: one going from OFF to TURNING_OFF, and one going from TURNING_OFF 195 // back to ON since we failed to initiate the disable operation. 196 EXPECT_EQ(bluetooth::ADAPTER_STATE_TURNING_OFF, observer.prev_state()); 197 EXPECT_EQ(bluetooth::ADAPTER_STATE_ON, observer.cur_state()); 198 199 // Update state to OFF. Should receive a state update. 200 fake_hal_iface_->NotifyAdapterStateChanged(BT_STATE_OFF); 201 EXPECT_EQ(bluetooth::ADAPTER_STATE_ON, observer.prev_state()); 202 EXPECT_EQ(bluetooth::ADAPTER_STATE_OFF, observer.cur_state()); 203 } 204 205 TEST_F(AdapterTest, GetName) { 206 EXPECT_EQ(bluetooth::Adapter::kDefaultName, adapter_->GetName()); 207 208 const char kTestAdapterName[] = "Test Adapter Name"; 209 210 fake_hal_iface_->NotifyAdapterNamePropertyChanged(kTestAdapterName); 211 EXPECT_EQ(kTestAdapterName, adapter_->GetName()); 212 } 213 214 TEST_F(AdapterTest, SetName) { 215 bt_bdname_t hal_name; 216 217 // Name too large. 218 EXPECT_FALSE(adapter_->SetName(std::string(sizeof(hal_name.name), 'a'))); 219 220 // Valid length. 221 EXPECT_FALSE(adapter_->SetName("Test Name")); 222 fake_hal_manager_->set_property_succeed = true; 223 EXPECT_TRUE(adapter_->SetName("Test Name")); 224 } 225 226 TEST_F(AdapterTest, GetAddress) { 227 EXPECT_EQ(bluetooth::Adapter::kDefaultAddress, adapter_->GetAddress()); 228 229 const RawAddress kTestAdapterInput = {{0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc}}; 230 const char kTestAdapterAddressOutput[] = "12:34:56:78:9A:BC"; 231 232 fake_hal_iface_->NotifyAdapterAddressPropertyChanged(&kTestAdapterInput); 233 EXPECT_EQ(kTestAdapterAddressOutput, adapter_->GetAddress()); 234 } 235 236 TEST_F(AdapterTest, IsMultiAdvertisementSupported) { 237 EXPECT_FALSE(adapter_->IsMultiAdvertisementSupported()); 238 239 bt_local_le_features_t features; 240 memset(&features, 0, sizeof(features)); 241 242 features.max_adv_instance = 10; // Some high number. 243 fake_hal_iface_->NotifyAdapterLocalLeFeaturesPropertyChanged(&features); 244 EXPECT_TRUE(adapter_->IsMultiAdvertisementSupported()); 245 246 features.max_adv_instance = 0; // Low number. 247 fake_hal_iface_->NotifyAdapterLocalLeFeaturesPropertyChanged(&features); 248 EXPECT_FALSE(adapter_->IsMultiAdvertisementSupported()); 249 } 250 251 TEST_F(AdapterTest, IsDeviceConnected) { 252 const char kDeviceAddr[] = "12:34:56:78:9A:BC"; 253 TestObserver observer(adapter_.get()); 254 255 EXPECT_FALSE(adapter_->IsDeviceConnected(kDeviceAddr)); 256 257 RawAddress hal_addr; 258 ASSERT_TRUE(RawAddress::FromString(kDeviceAddr, hal_addr)); 259 260 // status != BT_STATUS_SUCCESS should be ignored 261 fake_hal_iface_->NotifyAclStateChangedCallback(BT_STATUS_FAIL, hal_addr, 262 BT_ACL_STATE_CONNECTED); 263 EXPECT_FALSE(adapter_->IsDeviceConnected(kDeviceAddr)); 264 EXPECT_TRUE(observer.last_connection_state_address().empty()); 265 EXPECT_FALSE(observer.last_device_connected_state()); 266 267 // Connected 268 fake_hal_iface_->NotifyAclStateChangedCallback(BT_STATUS_SUCCESS, hal_addr, 269 BT_ACL_STATE_CONNECTED); 270 EXPECT_TRUE(adapter_->IsDeviceConnected(kDeviceAddr)); 271 EXPECT_EQ(kDeviceAddr, observer.last_connection_state_address()); 272 EXPECT_TRUE(observer.last_device_connected_state()); 273 274 // Disconnected 275 fake_hal_iface_->NotifyAclStateChangedCallback(BT_STATUS_SUCCESS, hal_addr, 276 BT_ACL_STATE_DISCONNECTED); 277 EXPECT_FALSE(adapter_->IsDeviceConnected(kDeviceAddr)); 278 EXPECT_EQ(kDeviceAddr, observer.last_connection_state_address()); 279 EXPECT_FALSE(observer.last_device_connected_state()); 280 } 281 282 } // namespace 283 } // namespace bluetooth 284
