device/bluetooth/bluetooth_adapter_win_unittest.cc

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