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