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
5 #include <string>
6
7 #include "base/bind.h"
8 #include "base/memory/ref_counted.h"
9 #include "base/test/test_simple_task_runner.h"
10 #include "device/bluetooth/bluetooth_adapter.h"
11 #include "device/bluetooth/bluetooth_adapter_win.h"
12 #include "device/bluetooth/bluetooth_device.h"
13 #include "device/bluetooth/bluetooth_task_manager_win.h"
14 #include "testing/gtest/include/gtest/gtest.h"
15
16 namespace {
17
18 const char kAdapterAddress[] = "Bluetooth Adapter Address";
19 const char kAdapterName[] = "Bluetooth Adapter Name";
20
21
MakeDeviceState(const std::string & name,const std::string & address,device::BluetoothTaskManagerWin::DeviceState * state)22 void MakeDeviceState(const std::string& name,
23 const std::string& address,
24 device::BluetoothTaskManagerWin::DeviceState* state) {
25 state->name = name;
26 state->address = address;
27 state->bluetooth_class = 0;
28 state->authenticated = false;
29 state->connected = false;
30 }
31
32 class AdapterObserver : public device::BluetoothAdapter::Observer {
33 public:
AdapterObserver()34 AdapterObserver()
35 : num_present_changed_(0),
36 num_powered_changed_(0),
37 num_discovering_changed_(0),
38 num_device_added_(0) {
39 }
40
AdapterPresentChanged(device::BluetoothAdapter * adapter,bool present)41 virtual void AdapterPresentChanged(
42 device::BluetoothAdapter* adapter, bool present) OVERRIDE {
43 num_present_changed_++;
44 }
45
AdapterPoweredChanged(device::BluetoothAdapter * adapter,bool powered)46 virtual void AdapterPoweredChanged(
47 device::BluetoothAdapter* adapter, bool powered) OVERRIDE {
48 num_powered_changed_++;
49 }
50
AdapterDiscoveringChanged(device::BluetoothAdapter * adapter,bool discovering)51 virtual void AdapterDiscoveringChanged(
52 device::BluetoothAdapter* adapter, bool discovering) OVERRIDE {
53 num_discovering_changed_++;
54 }
55
DeviceAdded(device::BluetoothAdapter * adapter,device::BluetoothDevice * device)56 virtual void DeviceAdded(
57 device::BluetoothAdapter* adapter,
58 device::BluetoothDevice* device) OVERRIDE {
59 num_device_added_++;
60 }
61
num_present_changed() const62 int num_present_changed() const {
63 return num_present_changed_;
64 }
65
num_powered_changed() const66 int num_powered_changed() const {
67 return num_powered_changed_;
68 }
69
num_discovering_changed() const70 int num_discovering_changed() const {
71 return num_discovering_changed_;
72 }
73
num_device_added() const74 int num_device_added() const {
75 return num_device_added_;
76 }
77
78 private:
79 int num_present_changed_;
80 int num_powered_changed_;
81 int num_discovering_changed_;
82 int num_device_added_;
83 };
84
85 } // namespace
86
87 namespace device {
88
89 class BluetoothAdapterWinTest : public testing::Test {
90 public:
BluetoothAdapterWinTest()91 BluetoothAdapterWinTest()
92 : ui_task_runner_(new base::TestSimpleTaskRunner()),
93 bluetooth_task_runner_(new base::TestSimpleTaskRunner()),
94 adapter_(new BluetoothAdapterWin(
95 base::Bind(&BluetoothAdapterWinTest::RunInitCallback,
96 base::Unretained(this)))),
97 adapter_win_(static_cast<BluetoothAdapterWin*>(adapter_.get())),
98 init_callback_called_(false) {
99 adapter_win_->InitForTest(ui_task_runner_, bluetooth_task_runner_);
100 }
101
SetUp()102 virtual void SetUp() OVERRIDE {
103 adapter_win_->AddObserver(&adapter_observer_);
104 num_start_discovery_callbacks_ = 0;
105 num_start_discovery_error_callbacks_ = 0;
106 num_stop_discovery_callbacks_ = 0;
107 num_stop_discovery_error_callbacks_ = 0;
108 }
109
TearDown()110 virtual void TearDown() OVERRIDE {
111 adapter_win_->RemoveObserver(&adapter_observer_);
112 }
113
RunInitCallback()114 void RunInitCallback() {
115 init_callback_called_ = true;
116 }
117
IncrementNumStartDiscoveryCallbacks()118 void IncrementNumStartDiscoveryCallbacks() {
119 num_start_discovery_callbacks_++;
120 }
121
IncrementNumStartDiscoveryErrorCallbacks()122 void IncrementNumStartDiscoveryErrorCallbacks() {
123 num_start_discovery_error_callbacks_++;
124 }
125
IncrementNumStopDiscoveryCallbacks()126 void IncrementNumStopDiscoveryCallbacks() {
127 num_stop_discovery_callbacks_++;
128 }
129
IncrementNumStopDiscoveryErrorCallbacks()130 void IncrementNumStopDiscoveryErrorCallbacks() {
131 num_stop_discovery_error_callbacks_++;
132 }
133
134 protected:
135 scoped_refptr<base::TestSimpleTaskRunner> ui_task_runner_;
136 scoped_refptr<base::TestSimpleTaskRunner> bluetooth_task_runner_;
137 scoped_refptr<BluetoothAdapter> adapter_;
138 BluetoothAdapterWin* adapter_win_;
139 AdapterObserver adapter_observer_;
140 bool init_callback_called_;
141 int num_start_discovery_callbacks_;
142 int num_start_discovery_error_callbacks_;
143 int num_stop_discovery_callbacks_;
144 int num_stop_discovery_error_callbacks_;
145 };
146
TEST_F(BluetoothAdapterWinTest,AdapterNotPresent)147 TEST_F(BluetoothAdapterWinTest, AdapterNotPresent) {
148 BluetoothTaskManagerWin::AdapterState state;
149 adapter_win_->AdapterStateChanged(state);
150 EXPECT_FALSE(adapter_win_->IsPresent());
151 }
152
TEST_F(BluetoothAdapterWinTest,AdapterPresent)153 TEST_F(BluetoothAdapterWinTest, AdapterPresent) {
154 BluetoothTaskManagerWin::AdapterState state;
155 state.address = kAdapterAddress;
156 state.name = kAdapterName;
157 adapter_win_->AdapterStateChanged(state);
158 EXPECT_TRUE(adapter_win_->IsPresent());
159 }
160
TEST_F(BluetoothAdapterWinTest,AdapterPresentChanged)161 TEST_F(BluetoothAdapterWinTest, AdapterPresentChanged) {
162 BluetoothTaskManagerWin::AdapterState state;
163 state.address = kAdapterAddress;
164 state.name = kAdapterName;
165 adapter_win_->AdapterStateChanged(state);
166 EXPECT_EQ(1, adapter_observer_.num_present_changed());
167 adapter_win_->AdapterStateChanged(state);
168 EXPECT_EQ(1, adapter_observer_.num_present_changed());
169 BluetoothTaskManagerWin::AdapterState empty_state;
170 adapter_win_->AdapterStateChanged(empty_state);
171 EXPECT_EQ(2, adapter_observer_.num_present_changed());
172 }
173
TEST_F(BluetoothAdapterWinTest,AdapterPoweredChanged)174 TEST_F(BluetoothAdapterWinTest, AdapterPoweredChanged) {
175 BluetoothTaskManagerWin::AdapterState state;
176 state.powered = true;
177 adapter_win_->AdapterStateChanged(state);
178 EXPECT_EQ(1, adapter_observer_.num_powered_changed());
179 adapter_win_->AdapterStateChanged(state);
180 EXPECT_EQ(1, adapter_observer_.num_powered_changed());
181 state.powered = false;
182 adapter_win_->AdapterStateChanged(state);
183 EXPECT_EQ(2, adapter_observer_.num_powered_changed());
184 }
185
TEST_F(BluetoothAdapterWinTest,AdapterInitialized)186 TEST_F(BluetoothAdapterWinTest, AdapterInitialized) {
187 EXPECT_FALSE(adapter_win_->IsInitialized());
188 EXPECT_FALSE(init_callback_called_);
189 BluetoothTaskManagerWin::AdapterState state;
190 adapter_win_->AdapterStateChanged(state);
191 EXPECT_TRUE(adapter_win_->IsInitialized());
192 EXPECT_TRUE(init_callback_called_);
193 }
194
TEST_F(BluetoothAdapterWinTest,SingleStartDiscovery)195 TEST_F(BluetoothAdapterWinTest, SingleStartDiscovery) {
196 bluetooth_task_runner_->ClearPendingTasks();
197 adapter_win_->StartDiscovering(
198 base::Bind(&BluetoothAdapterWinTest::IncrementNumStartDiscoveryCallbacks,
199 base::Unretained(this)),
200 BluetoothAdapter::ErrorCallback());
201 EXPECT_TRUE(ui_task_runner_->GetPendingTasks().empty());
202 EXPECT_EQ(1, bluetooth_task_runner_->GetPendingTasks().size());
203 EXPECT_FALSE(adapter_->IsDiscovering());
204 EXPECT_EQ(0, num_start_discovery_callbacks_);
205 adapter_win_->DiscoveryStarted(true);
206 ui_task_runner_->RunPendingTasks();
207 EXPECT_TRUE(adapter_->IsDiscovering());
208 EXPECT_EQ(1, num_start_discovery_callbacks_);
209 EXPECT_EQ(1, adapter_observer_.num_discovering_changed());
210 }
211
TEST_F(BluetoothAdapterWinTest,SingleStartDiscoveryFailure)212 TEST_F(BluetoothAdapterWinTest, SingleStartDiscoveryFailure) {
213 adapter_win_->StartDiscovering(
214 base::Closure(),
215 base::Bind(
216 &BluetoothAdapterWinTest::IncrementNumStartDiscoveryErrorCallbacks,
217 base::Unretained(this)));
218 adapter_win_->DiscoveryStarted(false);
219 ui_task_runner_->RunPendingTasks();
220 EXPECT_FALSE(adapter_->IsDiscovering());
221 EXPECT_EQ(1, num_start_discovery_error_callbacks_);
222 EXPECT_EQ(0, adapter_observer_.num_discovering_changed());
223 }
224
TEST_F(BluetoothAdapterWinTest,MultipleStartDiscoveries)225 TEST_F(BluetoothAdapterWinTest, MultipleStartDiscoveries) {
226 bluetooth_task_runner_->ClearPendingTasks();
227 int num_discoveries = 5;
228 for (int i = 0; i < num_discoveries; i++) {
229 adapter_win_->StartDiscovering(
230 base::Bind(
231 &BluetoothAdapterWinTest::IncrementNumStartDiscoveryCallbacks,
232 base::Unretained(this)),
233 BluetoothAdapter::ErrorCallback());
234 EXPECT_EQ(1, bluetooth_task_runner_->GetPendingTasks().size());
235 }
236 EXPECT_TRUE(ui_task_runner_->GetPendingTasks().empty());
237 EXPECT_FALSE(adapter_->IsDiscovering());
238 EXPECT_EQ(0, num_start_discovery_callbacks_);
239 adapter_win_->DiscoveryStarted(true);
240 ui_task_runner_->RunPendingTasks();
241 EXPECT_TRUE(adapter_->IsDiscovering());
242 EXPECT_EQ(num_discoveries, num_start_discovery_callbacks_);
243 EXPECT_EQ(1, adapter_observer_.num_discovering_changed());
244 }
245
TEST_F(BluetoothAdapterWinTest,MultipleStartDiscoveriesFailure)246 TEST_F(BluetoothAdapterWinTest, MultipleStartDiscoveriesFailure) {
247 int num_discoveries = 5;
248 for (int i = 0; i < num_discoveries; i++) {
249 adapter_win_->StartDiscovering(
250 base::Closure(),
251 base::Bind(
252 &BluetoothAdapterWinTest::IncrementNumStartDiscoveryErrorCallbacks,
253 base::Unretained(this)));
254 }
255 adapter_win_->DiscoveryStarted(false);
256 ui_task_runner_->RunPendingTasks();
257 EXPECT_FALSE(adapter_->IsDiscovering());
258 EXPECT_EQ(num_discoveries, num_start_discovery_error_callbacks_);
259 EXPECT_EQ(0, adapter_observer_.num_discovering_changed());
260 }
261
TEST_F(BluetoothAdapterWinTest,MultipleStartDiscoveriesAfterDiscovering)262 TEST_F(BluetoothAdapterWinTest, MultipleStartDiscoveriesAfterDiscovering) {
263 adapter_win_->StartDiscovering(
264 base::Bind(&BluetoothAdapterWinTest::IncrementNumStartDiscoveryCallbacks,
265 base::Unretained(this)),
266 BluetoothAdapter::ErrorCallback());
267 adapter_win_->DiscoveryStarted(true);
268 ui_task_runner_->RunPendingTasks();
269 EXPECT_TRUE(adapter_->IsDiscovering());
270 EXPECT_EQ(1, num_start_discovery_callbacks_);
271
272 bluetooth_task_runner_->ClearPendingTasks();
273 for (int i = 0; i < 5; i++) {
274 int num_start_discovery_callbacks = num_start_discovery_callbacks_;
275 adapter_win_->StartDiscovering(
276 base::Bind(
277 &BluetoothAdapterWinTest::IncrementNumStartDiscoveryCallbacks,
278 base::Unretained(this)),
279 BluetoothAdapter::ErrorCallback());
280 EXPECT_TRUE(adapter_->IsDiscovering());
281 EXPECT_TRUE(bluetooth_task_runner_->GetPendingTasks().empty());
282 EXPECT_TRUE(ui_task_runner_->GetPendingTasks().empty());
283 EXPECT_EQ(num_start_discovery_callbacks + 1,
284 num_start_discovery_callbacks_);
285 }
286 EXPECT_EQ(1, adapter_observer_.num_discovering_changed());
287 }
288
TEST_F(BluetoothAdapterWinTest,StartDiscoveryAfterDiscoveringFailure)289 TEST_F(BluetoothAdapterWinTest, StartDiscoveryAfterDiscoveringFailure) {
290 adapter_win_->StartDiscovering(
291 base::Closure(),
292 base::Bind(
293 &BluetoothAdapterWinTest::IncrementNumStartDiscoveryErrorCallbacks,
294 base::Unretained(this)));
295 adapter_win_->DiscoveryStarted(false);
296 ui_task_runner_->RunPendingTasks();
297 EXPECT_FALSE(adapter_->IsDiscovering());
298 EXPECT_EQ(1, num_start_discovery_error_callbacks_);
299
300 adapter_win_->StartDiscovering(
301 base::Bind(&BluetoothAdapterWinTest::IncrementNumStartDiscoveryCallbacks,
302 base::Unretained(this)),
303 BluetoothAdapter::ErrorCallback());
304 adapter_win_->DiscoveryStarted(true);
305 ui_task_runner_->RunPendingTasks();
306 EXPECT_TRUE(adapter_->IsDiscovering());
307 EXPECT_EQ(1, num_start_discovery_callbacks_);
308 }
309
TEST_F(BluetoothAdapterWinTest,SingleStopDiscovery)310 TEST_F(BluetoothAdapterWinTest, SingleStopDiscovery) {
311 adapter_win_->StartDiscovering(
312 base::Closure(), BluetoothAdapter::ErrorCallback());
313 adapter_win_->DiscoveryStarted(true);
314 ui_task_runner_->ClearPendingTasks();
315 adapter_win_->StopDiscovering(
316 base::Bind(&BluetoothAdapterWinTest::IncrementNumStopDiscoveryCallbacks,
317 base::Unretained(this)),
318 BluetoothAdapter::ErrorCallback());
319 EXPECT_TRUE(adapter_->IsDiscovering());
320 EXPECT_EQ(0, num_stop_discovery_callbacks_);
321 bluetooth_task_runner_->ClearPendingTasks();
322 adapter_win_->DiscoveryStopped();
323 ui_task_runner_->RunPendingTasks();
324 EXPECT_FALSE(adapter_->IsDiscovering());
325 EXPECT_EQ(1, num_stop_discovery_callbacks_);
326 EXPECT_TRUE(bluetooth_task_runner_->GetPendingTasks().empty());
327 EXPECT_EQ(2, adapter_observer_.num_discovering_changed());
328 }
329
TEST_F(BluetoothAdapterWinTest,MultipleStopDiscoveries)330 TEST_F(BluetoothAdapterWinTest, MultipleStopDiscoveries) {
331 int num_discoveries = 5;
332 for (int i = 0; i < num_discoveries; i++) {
333 adapter_win_->StartDiscovering(
334 base::Closure(), BluetoothAdapter::ErrorCallback());
335 }
336 adapter_win_->DiscoveryStarted(true);
337 ui_task_runner_->ClearPendingTasks();
338 bluetooth_task_runner_->ClearPendingTasks();
339 for (int i = 0; i < num_discoveries - 1; i++) {
340 adapter_win_->StopDiscovering(
341 base::Bind(&BluetoothAdapterWinTest::IncrementNumStopDiscoveryCallbacks,
342 base::Unretained(this)),
343 BluetoothAdapter::ErrorCallback());
344 EXPECT_TRUE(bluetooth_task_runner_->GetPendingTasks().empty());
345 ui_task_runner_->RunPendingTasks();
346 EXPECT_EQ(i + 1, num_stop_discovery_callbacks_);
347 }
348 adapter_win_->StopDiscovering(
349 base::Bind(&BluetoothAdapterWinTest::IncrementNumStopDiscoveryCallbacks,
350 base::Unretained(this)),
351 BluetoothAdapter::ErrorCallback());
352 EXPECT_EQ(1, bluetooth_task_runner_->GetPendingTasks().size());
353 EXPECT_TRUE(adapter_->IsDiscovering());
354 adapter_win_->DiscoveryStopped();
355 ui_task_runner_->RunPendingTasks();
356 EXPECT_FALSE(adapter_->IsDiscovering());
357 EXPECT_EQ(num_discoveries, num_stop_discovery_callbacks_);
358 EXPECT_EQ(2, adapter_observer_.num_discovering_changed());
359 }
360
TEST_F(BluetoothAdapterWinTest,StartDiscoveryAndStartDiscoveryAndStopDiscoveries)361 TEST_F(BluetoothAdapterWinTest,
362 StartDiscoveryAndStartDiscoveryAndStopDiscoveries) {
363 adapter_win_->StartDiscovering(
364 base::Bind(&BluetoothAdapterWinTest::IncrementNumStartDiscoveryCallbacks,
365 base::Unretained(this)),
366 BluetoothAdapter::ErrorCallback());
367 adapter_win_->DiscoveryStarted(true);
368 adapter_win_->StartDiscovering(
369 base::Bind(&BluetoothAdapterWinTest::IncrementNumStartDiscoveryCallbacks,
370 base::Unretained(this)),
371 BluetoothAdapter::ErrorCallback());
372 ui_task_runner_->ClearPendingTasks();
373 bluetooth_task_runner_->ClearPendingTasks();
374 adapter_win_->StopDiscovering(
375 base::Bind(&BluetoothAdapterWinTest::IncrementNumStopDiscoveryCallbacks,
376 base::Unretained(this)),
377 BluetoothAdapter::ErrorCallback());
378 EXPECT_TRUE(bluetooth_task_runner_->GetPendingTasks().empty());
379 adapter_win_->StopDiscovering(
380 base::Bind(&BluetoothAdapterWinTest::IncrementNumStopDiscoveryCallbacks,
381 base::Unretained(this)),
382 BluetoothAdapter::ErrorCallback());
383 EXPECT_EQ(1, bluetooth_task_runner_->GetPendingTasks().size());
384 }
385
TEST_F(BluetoothAdapterWinTest,StartDiscoveryAndStopDiscoveryAndStartDiscovery)386 TEST_F(BluetoothAdapterWinTest,
387 StartDiscoveryAndStopDiscoveryAndStartDiscovery) {
388 adapter_win_->StartDiscovering(
389 base::Closure(), BluetoothAdapter::ErrorCallback());
390 adapter_win_->DiscoveryStarted(true);
391 EXPECT_TRUE(adapter_->IsDiscovering());
392 adapter_win_->StopDiscovering(
393 base::Closure(), BluetoothAdapter::ErrorCallback());
394 adapter_win_->DiscoveryStopped();
395 EXPECT_FALSE(adapter_->IsDiscovering());
396 adapter_win_->StartDiscovering(
397 base::Closure(), BluetoothAdapter::ErrorCallback());
398 adapter_win_->DiscoveryStarted(true);
399 EXPECT_TRUE(adapter_->IsDiscovering());
400 }
401
TEST_F(BluetoothAdapterWinTest,StartDiscoveryBeforeDiscoveryStopped)402 TEST_F(BluetoothAdapterWinTest, StartDiscoveryBeforeDiscoveryStopped) {
403 adapter_win_->StartDiscovering(
404 base::Closure(), BluetoothAdapter::ErrorCallback());
405 adapter_win_->DiscoveryStarted(true);
406 adapter_win_->StopDiscovering(
407 base::Closure(), BluetoothAdapter::ErrorCallback());
408 adapter_win_->StartDiscovering(
409 base::Closure(), BluetoothAdapter::ErrorCallback());
410 bluetooth_task_runner_->ClearPendingTasks();
411 adapter_win_->DiscoveryStopped();
412 EXPECT_EQ(1, bluetooth_task_runner_->GetPendingTasks().size());
413 }
414
TEST_F(BluetoothAdapterWinTest,StopDiscoveryWithoutStartDiscovery)415 TEST_F(BluetoothAdapterWinTest, StopDiscoveryWithoutStartDiscovery) {
416 adapter_win_->StopDiscovering(
417 base::Closure(),
418 base::Bind(
419 &BluetoothAdapterWinTest::IncrementNumStopDiscoveryErrorCallbacks,
420 base::Unretained(this)));
421 EXPECT_EQ(1, num_stop_discovery_error_callbacks_);
422 }
423
TEST_F(BluetoothAdapterWinTest,StopDiscoveryBeforeDiscoveryStarted)424 TEST_F(BluetoothAdapterWinTest, StopDiscoveryBeforeDiscoveryStarted) {
425 adapter_win_->StartDiscovering(
426 base::Closure(), BluetoothAdapter::ErrorCallback());
427 adapter_win_->StopDiscovering(
428 base::Closure(), BluetoothAdapter::ErrorCallback());
429 bluetooth_task_runner_->ClearPendingTasks();
430 adapter_win_->DiscoveryStarted(true);
431 EXPECT_EQ(1, bluetooth_task_runner_->GetPendingTasks().size());
432 }
433
TEST_F(BluetoothAdapterWinTest,StartAndStopBeforeDiscoveryStarted)434 TEST_F(BluetoothAdapterWinTest, StartAndStopBeforeDiscoveryStarted) {
435 int num_expected_start_discoveries = 3;
436 int num_expected_stop_discoveries = 2;
437 for (int i = 0; i < num_expected_start_discoveries; i++) {
438 adapter_win_->StartDiscovering(
439 base::Bind(
440 &BluetoothAdapterWinTest::IncrementNumStartDiscoveryCallbacks,
441 base::Unretained(this)),
442 BluetoothAdapter::ErrorCallback());
443 }
444 for (int i = 0; i < num_expected_stop_discoveries; i++) {
445 adapter_win_->StopDiscovering(
446 base::Bind(
447 &BluetoothAdapterWinTest::IncrementNumStopDiscoveryCallbacks,
448 base::Unretained(this)),
449 BluetoothAdapter::ErrorCallback());
450 }
451 bluetooth_task_runner_->ClearPendingTasks();
452 adapter_win_->DiscoveryStarted(true);
453 EXPECT_TRUE(bluetooth_task_runner_->GetPendingTasks().empty());
454 ui_task_runner_->RunPendingTasks();
455 EXPECT_EQ(num_expected_start_discoveries, num_start_discovery_callbacks_);
456 EXPECT_EQ(num_expected_stop_discoveries, num_stop_discovery_callbacks_);
457 }
458
TEST_F(BluetoothAdapterWinTest,StopDiscoveryBeforeDiscoveryStartedAndFailed)459 TEST_F(BluetoothAdapterWinTest, StopDiscoveryBeforeDiscoveryStartedAndFailed) {
460 adapter_win_->StartDiscovering(
461 base::Closure(),
462 base::Bind(
463 &BluetoothAdapterWinTest::IncrementNumStartDiscoveryErrorCallbacks,
464 base::Unretained(this)));
465 adapter_win_->StopDiscovering(
466 base::Bind(
467 &BluetoothAdapterWinTest::IncrementNumStopDiscoveryCallbacks,
468 base::Unretained(this)),
469 BluetoothAdapter::ErrorCallback());
470 ui_task_runner_->ClearPendingTasks();
471 adapter_win_->DiscoveryStarted(false);
472 ui_task_runner_->RunPendingTasks();
473 EXPECT_EQ(1, num_start_discovery_error_callbacks_);
474 EXPECT_EQ(1, num_stop_discovery_callbacks_);
475 EXPECT_EQ(0, adapter_observer_.num_discovering_changed());
476 }
477
TEST_F(BluetoothAdapterWinTest,DevicesDiscovered)478 TEST_F(BluetoothAdapterWinTest, DevicesDiscovered) {
479 BluetoothTaskManagerWin::DeviceState* android_phone_state =
480 new BluetoothTaskManagerWin::DeviceState();
481 MakeDeviceState("phone", "android phone address", android_phone_state);
482 BluetoothTaskManagerWin::DeviceState* laptop_state =
483 new BluetoothTaskManagerWin::DeviceState();
484 MakeDeviceState("laptop", "laptop address", laptop_state);
485 BluetoothTaskManagerWin::DeviceState* iphone_state =
486 new BluetoothTaskManagerWin::DeviceState();
487 MakeDeviceState("phone", "iphone address", iphone_state);
488 ScopedVector<BluetoothTaskManagerWin::DeviceState> devices;
489 devices.push_back(android_phone_state);
490 devices.push_back(laptop_state);
491 devices.push_back(iphone_state);
492
493 adapter_win_->DevicesDiscovered(devices);
494 EXPECT_EQ(3, adapter_observer_.num_device_added());
495 }
496
497 } // namespace device
498