bluetooth_adapter_win_unittest.cc 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466
  1. // Copyright (c) 2012 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. #include <memory>
  5. #include <string>
  6. #include <vector>
  7. #include "base/bind.h"
  8. #include "base/callback_helpers.h"
  9. #include "base/memory/ptr_util.h"
  10. #include "base/memory/raw_ptr.h"
  11. #include "base/memory/ref_counted.h"
  12. #include "base/strings/string_number_conversions.h"
  13. #include "base/test/bind.h"
  14. #include "base/test/test_simple_task_runner.h"
  15. #include "device/bluetooth/bluetooth_adapter.h"
  16. #include "device/bluetooth/bluetooth_adapter_win.h"
  17. #include "device/bluetooth/bluetooth_classic_win.h"
  18. #include "device/bluetooth/bluetooth_device.h"
  19. #include "device/bluetooth/bluetooth_discovery_session_outcome.h"
  20. #include "device/bluetooth/bluetooth_task_manager_win.h"
  21. #include "device/bluetooth/test/test_bluetooth_adapter_observer.h"
  22. #include "testing/gtest/include/gtest/gtest.h"
  23. namespace {
  24. const char kAdapterAddress[] = "A1:B2:C3:D4:E5:F6";
  25. const char kAdapterName[] = "Bluetooth Adapter Name";
  26. const char kTestAudioSdpName[] = "Audio";
  27. const char kTestAudioSdpName2[] = "Audio2";
  28. const char kTestAudioSdpBytes[] =
  29. "35510900000a00010001090001350319110a09000435103506190100090019350619001909"
  30. "010209000535031910020900093508350619110d090102090100250c417564696f20536f75"
  31. "726365090311090001";
  32. const device::BluetoothUUID kTestAudioSdpUuid("110a");
  33. void MakeDeviceState(const std::string& name,
  34. const std::string& address,
  35. device::BluetoothTaskManagerWin::DeviceState* state) {
  36. state->name = name;
  37. state->address = address;
  38. state->bluetooth_class = 0;
  39. state->authenticated = false;
  40. state->connected = false;
  41. }
  42. } // namespace
  43. namespace device {
  44. class BluetoothAdapterWinTest : public testing::Test {
  45. public:
  46. BluetoothAdapterWinTest()
  47. : ui_task_runner_(new base::TestSimpleTaskRunner()),
  48. bluetooth_task_runner_(new base::TestSimpleTaskRunner()),
  49. adapter_(new BluetoothAdapterWin()),
  50. adapter_win_(static_cast<BluetoothAdapterWin*>(adapter_.get())),
  51. observer_(adapter_),
  52. init_callback_called_(false) {
  53. adapter_win_->InitForTest(
  54. base::BindOnce(&BluetoothAdapterWinTest::RunInitCallback,
  55. base::Unretained(this)),
  56. nullptr, nullptr, ui_task_runner_, bluetooth_task_runner_);
  57. }
  58. void SetUp() override {
  59. num_start_discovery_callbacks_ = 0;
  60. num_start_discovery_error_callbacks_ = 0;
  61. num_stop_discovery_callbacks_ = 0;
  62. num_stop_discovery_error_callbacks_ = 0;
  63. }
  64. void RunInitCallback() { init_callback_called_ = true; }
  65. // This queue is used to store discovery sessions after a successful start so
  66. // we can test stopping discovery and so the destructor is not called
  67. base::queue<std::unique_ptr<BluetoothDiscoverySession>>
  68. active_discovery_sessions_;
  69. void DiscoverySessionCallbackPassthrough(
  70. base::OnceClosure callback,
  71. std::unique_ptr<BluetoothDiscoverySession> new_session) {
  72. active_discovery_sessions_.push(std::move(new_session));
  73. std::move(callback).Run();
  74. }
  75. void IncrementNumStartDiscoveryCallbacks() {
  76. num_start_discovery_callbacks_++;
  77. }
  78. void IncrementNumStartDiscoveryErrorCallbacks() {
  79. num_start_discovery_error_callbacks_++;
  80. }
  81. void IncrementNumStopDiscoveryCallbacks() { num_stop_discovery_callbacks_++; }
  82. void IncrementNumStopDiscoveryErrorCallbacks(
  83. UMABluetoothDiscoverySessionOutcome) {
  84. num_stop_discovery_error_callbacks_++;
  85. }
  86. void IncrementNumStopErrorCallbacks() {
  87. ++num_stop_discovery_error_callbacks_;
  88. }
  89. typedef base::OnceCallback<void(UMABluetoothDiscoverySessionOutcome)>
  90. DiscoverySessionErrorCallback;
  91. using ErrorCallback = base::OnceClosure;
  92. void CallStartDiscoverySession() {
  93. adapter_win_->StartDiscoverySession(
  94. /*client_name=*/std::string(),
  95. base::BindOnce(
  96. &BluetoothAdapterWinTest::DiscoverySessionCallbackPassthrough,
  97. base::Unretained(this),
  98. base::BindOnce(
  99. &BluetoothAdapterWinTest::IncrementNumStartDiscoveryCallbacks,
  100. base::Unretained(this))),
  101. base::BindOnce(
  102. &BluetoothAdapterWinTest::IncrementNumStartDiscoveryErrorCallbacks,
  103. base::Unretained(this)));
  104. }
  105. void StopTopDiscoverySession(base::OnceClosure callback,
  106. ErrorCallback error_callback) {
  107. active_discovery_sessions_.front()->Stop(std::move(callback),
  108. std::move(error_callback));
  109. active_discovery_sessions_.pop();
  110. }
  111. protected:
  112. scoped_refptr<base::TestSimpleTaskRunner> ui_task_runner_;
  113. scoped_refptr<base::TestSimpleTaskRunner> bluetooth_task_runner_;
  114. scoped_refptr<BluetoothAdapter> adapter_;
  115. raw_ptr<BluetoothAdapterWin> adapter_win_;
  116. TestBluetoothAdapterObserver observer_;
  117. bool init_callback_called_;
  118. int num_start_discovery_callbacks_;
  119. int num_start_discovery_error_callbacks_;
  120. int num_stop_discovery_callbacks_;
  121. int num_stop_discovery_error_callbacks_;
  122. };
  123. TEST_F(BluetoothAdapterWinTest, AdapterNotPresent) {
  124. BluetoothTaskManagerWin::AdapterState state;
  125. adapter_win_->AdapterStateChanged(state);
  126. EXPECT_FALSE(adapter_win_->IsPresent());
  127. }
  128. TEST_F(BluetoothAdapterWinTest, AdapterPresent) {
  129. BluetoothTaskManagerWin::AdapterState state;
  130. state.address = kAdapterAddress;
  131. state.name = kAdapterName;
  132. adapter_win_->AdapterStateChanged(state);
  133. EXPECT_TRUE(adapter_win_->IsPresent());
  134. }
  135. TEST_F(BluetoothAdapterWinTest, AdapterPresentChanged) {
  136. BluetoothTaskManagerWin::AdapterState state;
  137. state.address = kAdapterAddress;
  138. state.name = kAdapterName;
  139. adapter_win_->AdapterStateChanged(state);
  140. EXPECT_EQ(1, observer_.present_changed_count());
  141. adapter_win_->AdapterStateChanged(state);
  142. EXPECT_EQ(1, observer_.present_changed_count());
  143. BluetoothTaskManagerWin::AdapterState empty_state;
  144. adapter_win_->AdapterStateChanged(empty_state);
  145. EXPECT_EQ(2, observer_.present_changed_count());
  146. }
  147. TEST_F(BluetoothAdapterWinTest, AdapterPoweredChanged) {
  148. BluetoothTaskManagerWin::AdapterState state;
  149. state.powered = true;
  150. adapter_win_->AdapterStateChanged(state);
  151. EXPECT_EQ(1, observer_.powered_changed_count());
  152. adapter_win_->AdapterStateChanged(state);
  153. EXPECT_EQ(1, observer_.powered_changed_count());
  154. state.powered = false;
  155. adapter_win_->AdapterStateChanged(state);
  156. EXPECT_EQ(2, observer_.powered_changed_count());
  157. }
  158. TEST_F(BluetoothAdapterWinTest, AdapterInitialized) {
  159. EXPECT_FALSE(adapter_win_->IsInitialized());
  160. EXPECT_FALSE(init_callback_called_);
  161. BluetoothTaskManagerWin::AdapterState state;
  162. adapter_win_->AdapterStateChanged(state);
  163. EXPECT_TRUE(adapter_win_->IsInitialized());
  164. EXPECT_TRUE(init_callback_called_);
  165. }
  166. TEST_F(BluetoothAdapterWinTest, SingleStartDiscovery) {
  167. bluetooth_task_runner_->ClearPendingTasks();
  168. CallStartDiscoverySession();
  169. EXPECT_FALSE(ui_task_runner_->HasPendingTask());
  170. EXPECT_EQ(1u, bluetooth_task_runner_->NumPendingTasks());
  171. EXPECT_FALSE(adapter_->IsDiscovering());
  172. EXPECT_EQ(0, num_start_discovery_callbacks_);
  173. adapter_win_->DiscoveryStarted(true);
  174. ui_task_runner_->RunPendingTasks();
  175. EXPECT_TRUE(adapter_->IsDiscovering());
  176. EXPECT_EQ(1, num_start_discovery_callbacks_);
  177. EXPECT_EQ(1, observer_.discovering_changed_count());
  178. }
  179. TEST_F(BluetoothAdapterWinTest, SingleStartDiscoveryFailure) {
  180. CallStartDiscoverySession();
  181. adapter_win_->DiscoveryStarted(false);
  182. ui_task_runner_->RunPendingTasks();
  183. EXPECT_FALSE(adapter_->IsDiscovering());
  184. EXPECT_EQ(1, num_start_discovery_error_callbacks_);
  185. EXPECT_EQ(0, observer_.discovering_changed_count());
  186. }
  187. TEST_F(BluetoothAdapterWinTest, MultipleStartDiscoveries) {
  188. bluetooth_task_runner_->ClearPendingTasks();
  189. int num_discoveries = 5;
  190. for (int i = 0; i < num_discoveries; i++) {
  191. CallStartDiscoverySession();
  192. EXPECT_EQ(1u, bluetooth_task_runner_->NumPendingTasks());
  193. }
  194. EXPECT_FALSE(ui_task_runner_->HasPendingTask());
  195. EXPECT_FALSE(adapter_->IsDiscovering());
  196. EXPECT_EQ(0, num_start_discovery_callbacks_);
  197. adapter_win_->DiscoveryStarted(true);
  198. ui_task_runner_->RunPendingTasks();
  199. EXPECT_TRUE(adapter_->IsDiscovering());
  200. EXPECT_EQ(num_discoveries, num_start_discovery_callbacks_);
  201. EXPECT_EQ(1, observer_.discovering_changed_count());
  202. }
  203. TEST_F(BluetoothAdapterWinTest, MultipleStartDiscoveriesFailure) {
  204. int num_discoveries = 5;
  205. for (int i = 0; i < num_discoveries; i++) {
  206. CallStartDiscoverySession();
  207. }
  208. // Fake callback from OS for initial start call.
  209. adapter_win_->DiscoveryStarted(false);
  210. // Fake callback from OS for second call which includes the 4 remaining starts
  211. // calls.
  212. adapter_win_->DiscoveryStarted(false);
  213. EXPECT_FALSE(adapter_->IsDiscovering());
  214. EXPECT_EQ(num_discoveries, num_start_discovery_error_callbacks_);
  215. EXPECT_EQ(0, observer_.discovering_changed_count());
  216. }
  217. TEST_F(BluetoothAdapterWinTest, MultipleStartDiscoveriesAfterDiscovering) {
  218. CallStartDiscoverySession();
  219. adapter_win_->DiscoveryStarted(true);
  220. ui_task_runner_->RunPendingTasks();
  221. EXPECT_TRUE(adapter_->IsDiscovering());
  222. EXPECT_EQ(1, num_start_discovery_callbacks_);
  223. bluetooth_task_runner_->ClearPendingTasks();
  224. for (int i = 0; i < 5; i++) {
  225. int num_start_discovery_callbacks = num_start_discovery_callbacks_;
  226. CallStartDiscoverySession();
  227. EXPECT_TRUE(adapter_->IsDiscovering());
  228. EXPECT_FALSE(bluetooth_task_runner_->HasPendingTask());
  229. EXPECT_FALSE(ui_task_runner_->HasPendingTask());
  230. EXPECT_EQ(num_start_discovery_callbacks + 1,
  231. num_start_discovery_callbacks_);
  232. }
  233. EXPECT_EQ(1, observer_.discovering_changed_count());
  234. }
  235. TEST_F(BluetoothAdapterWinTest, StartDiscoveryAfterDiscoveringFailure) {
  236. CallStartDiscoverySession();
  237. adapter_win_->DiscoveryStarted(false);
  238. ui_task_runner_->RunPendingTasks();
  239. EXPECT_FALSE(adapter_->IsDiscovering());
  240. EXPECT_EQ(1, num_start_discovery_error_callbacks_);
  241. CallStartDiscoverySession();
  242. adapter_win_->DiscoveryStarted(true);
  243. ui_task_runner_->RunPendingTasks();
  244. EXPECT_TRUE(adapter_->IsDiscovering());
  245. EXPECT_EQ(1, num_start_discovery_callbacks_);
  246. }
  247. TEST_F(BluetoothAdapterWinTest, SingleStopDiscovery) {
  248. CallStartDiscoverySession();
  249. adapter_win_->DiscoveryStarted(true);
  250. ui_task_runner_->ClearPendingTasks();
  251. StopTopDiscoverySession(
  252. base::BindOnce(
  253. &BluetoothAdapterWinTest::IncrementNumStopDiscoveryCallbacks,
  254. base::Unretained(this)),
  255. ErrorCallback());
  256. EXPECT_TRUE(adapter_->IsDiscovering());
  257. EXPECT_EQ(0, num_stop_discovery_callbacks_);
  258. bluetooth_task_runner_->ClearPendingTasks();
  259. adapter_win_->DiscoveryStopped();
  260. ui_task_runner_->RunPendingTasks();
  261. EXPECT_FALSE(adapter_->IsDiscovering());
  262. EXPECT_EQ(1, num_stop_discovery_callbacks_);
  263. EXPECT_FALSE(bluetooth_task_runner_->HasPendingTask());
  264. EXPECT_EQ(2, observer_.discovering_changed_count());
  265. }
  266. TEST_F(BluetoothAdapterWinTest, MultipleStopDiscoveries) {
  267. int num_discoveries = 5;
  268. for (int i = 0; i < num_discoveries; i++) {
  269. CallStartDiscoverySession();
  270. }
  271. adapter_win_->DiscoveryStarted(true);
  272. ui_task_runner_->RunPendingTasks();
  273. bluetooth_task_runner_->ClearPendingTasks();
  274. for (int i = 0; i < num_discoveries - 1; i++) {
  275. StopTopDiscoverySession(
  276. base::BindOnce(
  277. &BluetoothAdapterWinTest::IncrementNumStopDiscoveryCallbacks,
  278. base::Unretained(this)),
  279. ErrorCallback());
  280. EXPECT_FALSE(bluetooth_task_runner_->HasPendingTask());
  281. ui_task_runner_->RunPendingTasks();
  282. EXPECT_EQ(i + 1, num_stop_discovery_callbacks_);
  283. }
  284. StopTopDiscoverySession(
  285. base::BindOnce(
  286. &BluetoothAdapterWinTest::IncrementNumStopDiscoveryCallbacks,
  287. base::Unretained(this)),
  288. ErrorCallback());
  289. EXPECT_EQ(1u, bluetooth_task_runner_->NumPendingTasks());
  290. EXPECT_TRUE(adapter_->IsDiscovering());
  291. adapter_win_->DiscoveryStopped();
  292. ui_task_runner_->RunPendingTasks();
  293. EXPECT_FALSE(adapter_->IsDiscovering());
  294. EXPECT_EQ(num_discoveries, num_stop_discovery_callbacks_);
  295. EXPECT_EQ(2, observer_.discovering_changed_count());
  296. }
  297. TEST_F(BluetoothAdapterWinTest,
  298. StartDiscoveryAndStartDiscoveryAndStopDiscoveries) {
  299. CallStartDiscoverySession();
  300. adapter_win_->DiscoveryStarted(true);
  301. CallStartDiscoverySession();
  302. ui_task_runner_->RunPendingTasks();
  303. bluetooth_task_runner_->ClearPendingTasks();
  304. StopTopDiscoverySession(
  305. base::BindOnce(
  306. &BluetoothAdapterWinTest::IncrementNumStopDiscoveryCallbacks,
  307. base::Unretained(this)),
  308. ErrorCallback());
  309. EXPECT_FALSE(bluetooth_task_runner_->HasPendingTask());
  310. StopTopDiscoverySession(
  311. base::BindOnce(
  312. &BluetoothAdapterWinTest::IncrementNumStopDiscoveryCallbacks,
  313. base::Unretained(this)),
  314. ErrorCallback());
  315. EXPECT_EQ(1u, bluetooth_task_runner_->NumPendingTasks());
  316. }
  317. TEST_F(BluetoothAdapterWinTest,
  318. StartDiscoveryAndStopDiscoveryAndStartDiscovery) {
  319. CallStartDiscoverySession();
  320. adapter_win_->DiscoveryStarted(true);
  321. EXPECT_TRUE(adapter_->IsDiscovering());
  322. ui_task_runner_->RunPendingTasks();
  323. active_discovery_sessions_.front()->Stop(
  324. base::BindOnce(
  325. &BluetoothAdapterWinTest::IncrementNumStopDiscoveryCallbacks,
  326. base::Unretained(this)),
  327. ErrorCallback());
  328. adapter_win_->DiscoveryStopped();
  329. ui_task_runner_->RunPendingTasks();
  330. EXPECT_FALSE(adapter_->IsDiscovering());
  331. CallStartDiscoverySession();
  332. adapter_win_->DiscoveryStarted(true);
  333. EXPECT_TRUE(adapter_->IsDiscovering());
  334. }
  335. TEST_F(BluetoothAdapterWinTest, StartDiscoveryBeforeDiscoveryStopped) {
  336. CallStartDiscoverySession();
  337. adapter_win_->DiscoveryStarted(true);
  338. ui_task_runner_->RunPendingTasks();
  339. StopTopDiscoverySession(
  340. base::BindOnce(
  341. &BluetoothAdapterWinTest::IncrementNumStopDiscoveryCallbacks,
  342. base::Unretained(this)),
  343. ErrorCallback());
  344. CallStartDiscoverySession();
  345. bluetooth_task_runner_->ClearPendingTasks();
  346. adapter_win_->DiscoveryStopped();
  347. EXPECT_EQ(1u, bluetooth_task_runner_->NumPendingTasks());
  348. }
  349. TEST_F(BluetoothAdapterWinTest, DevicesPolled) {
  350. std::vector<std::unique_ptr<BluetoothTaskManagerWin::DeviceState>> devices;
  351. devices.push_back(std::make_unique<BluetoothTaskManagerWin::DeviceState>());
  352. devices.push_back(std::make_unique<BluetoothTaskManagerWin::DeviceState>());
  353. devices.push_back(std::make_unique<BluetoothTaskManagerWin::DeviceState>());
  354. BluetoothTaskManagerWin::DeviceState* android_phone_state = devices[0].get();
  355. BluetoothTaskManagerWin::DeviceState* laptop_state = devices[1].get();
  356. BluetoothTaskManagerWin::DeviceState* iphone_state = devices[2].get();
  357. MakeDeviceState("phone", "A1:B2:C3:D4:E5:E0", android_phone_state);
  358. MakeDeviceState("laptop", "A1:B2:C3:D4:E5:E1", laptop_state);
  359. MakeDeviceState("phone", "A1:B2:C3:D4:E5:E2", iphone_state);
  360. // Add 3 devices
  361. observer_.Reset();
  362. adapter_win_->DevicesPolled(devices);
  363. EXPECT_EQ(3, observer_.device_added_count());
  364. EXPECT_EQ(0, observer_.device_removed_count());
  365. EXPECT_EQ(0, observer_.device_changed_count());
  366. // Change a device name
  367. android_phone_state->name = std::string("phone2");
  368. observer_.Reset();
  369. adapter_win_->DevicesPolled(devices);
  370. EXPECT_EQ(0, observer_.device_added_count());
  371. EXPECT_EQ(0, observer_.device_removed_count());
  372. EXPECT_EQ(1, observer_.device_changed_count());
  373. // Change a device address
  374. android_phone_state->address = "A1:B2:C3:D4:E5:E6";
  375. observer_.Reset();
  376. adapter_win_->DevicesPolled(devices);
  377. EXPECT_EQ(1, observer_.device_added_count());
  378. EXPECT_EQ(1, observer_.device_removed_count());
  379. EXPECT_EQ(0, observer_.device_changed_count());
  380. // Remove a device
  381. devices.erase(devices.begin());
  382. observer_.Reset();
  383. adapter_win_->DevicesPolled(devices);
  384. EXPECT_EQ(0, observer_.device_added_count());
  385. EXPECT_EQ(1, observer_.device_removed_count());
  386. EXPECT_EQ(0, observer_.device_changed_count());
  387. // Add a service
  388. laptop_state->service_record_states.push_back(
  389. std::make_unique<BluetoothTaskManagerWin::ServiceRecordState>());
  390. BluetoothTaskManagerWin::ServiceRecordState* audio_state =
  391. laptop_state->service_record_states.back().get();
  392. audio_state->name = kTestAudioSdpName;
  393. base::HexStringToBytes(kTestAudioSdpBytes, &audio_state->sdp_bytes);
  394. observer_.Reset();
  395. adapter_win_->DevicesPolled(devices);
  396. EXPECT_EQ(0, observer_.device_added_count());
  397. EXPECT_EQ(0, observer_.device_removed_count());
  398. EXPECT_EQ(1, observer_.device_changed_count());
  399. // Change a service
  400. audio_state->name = kTestAudioSdpName2;
  401. observer_.Reset();
  402. adapter_win_->DevicesPolled(devices);
  403. EXPECT_EQ(0, observer_.device_added_count());
  404. EXPECT_EQ(0, observer_.device_removed_count());
  405. EXPECT_EQ(1, observer_.device_changed_count());
  406. // Remove a service
  407. laptop_state->service_record_states.clear();
  408. observer_.Reset();
  409. adapter_win_->DevicesPolled(devices);
  410. EXPECT_EQ(0, observer_.device_added_count());
  411. EXPECT_EQ(0, observer_.device_removed_count());
  412. EXPECT_EQ(1, observer_.device_changed_count());
  413. }
  414. } // namespace device