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
25 namespace bluetooth {
26 namespace {
27
28 class AdapterTest : public ::testing::Test {
29 public:
30 AdapterTest() = default;
31 ~AdapterTest() override = default;
32
SetUp()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
TearDown()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
61 class TestObserver final : public bluetooth::Adapter::Observer {
62 public:
TestObserver(bluetooth::Adapter * adapter)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
~TestObserver()72 ~TestObserver() override { adapter_->RemoveObserver(this); }
73
prev_state() const74 bluetooth::AdapterState prev_state() const { return prev_state_; }
cur_state() const75 bluetooth::AdapterState cur_state() const { return cur_state_; }
76
last_connection_state_address() const77 std::string last_connection_state_address() const {
78 return last_connection_state_address_;
79 }
80
last_device_connected_state() const81 bool last_device_connected_state() const {
82 return last_device_connected_state_;
83 }
84
85 // bluetooth::Adapter::Observer override:
OnAdapterStateChanged(bluetooth::Adapter * adapter,bluetooth::AdapterState prev_state,bluetooth::AdapterState new_state)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
OnDeviceConnectionStateChanged(Adapter * adapter,const std::string & device_address,bool connected)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
TEST_F(AdapterTest,IsEnabled)111 TEST_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
TEST_F(AdapterTest,Enable)121 TEST_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
TEST_F(AdapterTest,Disable)155 TEST_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
TEST_F(AdapterTest,GetName)206 TEST_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
TEST_F(AdapterTest,SetName)215 TEST_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
TEST_F(AdapterTest,GetAddress)227 TEST_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
TEST_F(AdapterTest,IsMultiAdvertisementSupported)237 TEST_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
TEST_F(AdapterTest,IsDeviceConnected)252 TEST_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