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