Example Bluetooth ARC++ test changes.

components/arc/bluetooth/arc_bluetooth_bridge_unittest.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/arc/bluetooth/arc_bluetooth_bridge.h"
 
 #include <string>
 #include <vector>
 
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "components/arc/bluetooth/bluetooth_type_converters.h"
 #include "components/arc/common/bluetooth.mojom.h"
 #include "components/arc/test/fake_arc_bridge_service.h"
 #include "components/arc/test/fake_bluetooth_instance.h"
+#include "device/bluetooth/dbus/bluez_dbus_manager.h"
+#include "device/bluetooth/dbus/fake_bluetooth_adapter_client.h"
+#include "device/bluetooth/dbus/fake_bluetooth_device_client.h"
 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
 #include "device/bluetooth/test/mock_bluetooth_device.h"
 #include "device/bluetooth/test/mock_bluetooth_gatt_characteristic.h"
 #include "device/bluetooth/test/mock_bluetooth_gatt_descriptor.h"
 #include "device/bluetooth/test/mock_bluetooth_gatt_service.h"
 #include "mojo/public/cpp/bindings/array.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace arc {
 
 namespace {
 
 const char kAddressStr[] = "1A:2B:3C:4D:5E:6F";
 const char kDeviceName[] = "DeviceName";
-const uint32_t kDeviceClass = 0x2580;
-const int16_t kDeviceRssi = -45;
-const char kServiceID[] = "/org/bluez/hci0/dev_1A_2B_3C_4D_5E_6F/service180f";
-const char kServiceUUID[] = "180f";
-const char kCharID[] =
-    "/org/bluez/hci0/dev_1A_2B_3C_4D_5E_6F/service180f/char2a19";
-const char kCharUUID[] = "2a19";
+const char kServiceUUID[] = "0000180f-0000-1000-8000-00805f9b34fb";
+const char kCharUUID[] = "00002a19-0000-1000-8000-00805f9b34fb";
 const uint16_t kCharUUIDInt = 0x2a19;
 
-class FakeArcBluetoothBridge : public ArcBluetoothBridge {
- public:
-  FakeArcBluetoothBridge(ArcBridgeService* bridge_service,
-                         device::MockBluetoothAdapter* adapter)
-      : ArcBluetoothBridge(bridge_service, true /* test_flag */) {
-    SetAdapterForTest(adapter);
-  }
-
-  void OnAdapterInitialized(scoped_refptr<device::BluetoothAdapter> adapter) {}
-};
-
 }  // namespace
 
 class ArcBluetoothBridgeTest : public testing::Test {
  public:
-  ArcBluetoothBridgeTest() {}
+  ArcBluetoothBridgeTest()
+      : fake_arc_bridge_service_(nullptr),
+        fake_bluetooth_instance_(nullptr),
+        arc_bluetooth_bridge_(nullptr),
+        fake_bluetooth_device_client_(nullptr) {}
 
  protected:
+  void AddTestDevice() {
+    device_uuids_.emplace_back(kServiceUUID);
+    device_uuids_.emplace_back(kCharUUID);
+
+    fake_bluetooth_device_client_->CreateTestDevice(
+        dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
+        kDeviceName, kDeviceName, kAddressStr, device_uuids_);
+
+    remote_addr_ = mojom::BluetoothAddress::From(std::string(kAddressStr));
+
+    service_id_ = mojom::BluetoothGattServiceID::New();
+    service_id_->is_primary = true;
+    service_id_->id = mojom::BluetoothGattID::New();
+    service_id_->id->inst_id = 0;
+    service_id_->id->uuid =
+        mojom::BluetoothUUID::From(device::BluetoothUUID(kServiceUUID));
+
+    char_id_ = mojom::BluetoothGattID::New();
+    char_id_->inst_id = 0;
+    char_id_->uuid =
+        mojom::BluetoothUUID::From(device::BluetoothUUID(kCharUUID));
+  };
+
   FakeArcBridgeService* fake_arc_bridge_service_;
-  FakeArcBluetoothBridge* fake_arc_bluetooth_bridge_;
-  FakeBluetoothInstance* fake_bluetooth_instance;
-  device::MockBluetoothAdapter* fake_adapter_;
-  device::MockBluetoothDevice* fake_device_;
-  device::MockBluetoothGattService* fake_service_;
-  device::MockBluetoothGattCharacteristic* fake_char_;
-  std::vector<device::BluetoothUUID> device_uuids_;
+  FakeBluetoothInstance* fake_bluetooth_instance_;
+  ArcBluetoothBridge* arc_bluetooth_bridge_;
+  scoped_refptr<device::BluetoothAdapter> adapter_;
+  std::vector<std::string> device_uuids_;
 
-  mojom::BluetoothAddressPtr remote_addr;
-  mojom::BluetoothGattServiceIDPtr service_id;
-  mojom::BluetoothGattIDPtr char_id;
+  mojom::BluetoothAddressPtr remote_addr_;
+  mojom::BluetoothGattServiceIDPtr service_id_;
+  mojom::BluetoothGattIDPtr char_id_;
 
  private:
+  void OnAdapterInitialized(scoped_refptr<device::BluetoothAdapter> adapter) {
+    adapter_ = adapter;
+    get_adapter_run_loop_.Quit();
+  }
+
   void SetUp() override {
+    std::unique_ptr<bluez::BluezDBusManagerSetter> dbus_setter =
+        bluez::BluezDBusManager::GetSetterForTesting();
+    fake_bluetooth_device_client_ = new bluez::FakeBluetoothDeviceClient;
+    fake_bluetooth_device_client_->RemoveAllDevices();
+    dbus_setter->SetBluetoothDeviceClient(
+        std::unique_ptr<bluez::BluetoothDeviceClient>(
+            fake_bluetooth_device_client_));
+
     fake_arc_bridge_service_ = new FakeArcBridgeService();
+    fake_bluetooth_instance_ = static_cast<FakeBluetoothInstance*>(
+        fake_arc_bridge_service_->bluetooth_instance());
 
-    fake_adapter_ = new testing::NiceMock<device::MockBluetoothAdapter>();
-    fake_arc_bluetooth_bridge_ =
-        new FakeArcBluetoothBridge(fake_arc_bridge_service_, fake_adapter_);
+    arc_bluetooth_bridge_ = new ArcBluetoothBridge(fake_arc_bridge_service_);
 
-    fake_device_ = new testing::NiceMock<device::MockBluetoothDevice>(
-        fake_adapter_, 0 /* bluetooth_class */, kDeviceName, kAddressStr,
-        false /* paired */, false /* connected */);
-    ON_CALL(*fake_device_, GetBluetoothClass())
-        .WillByDefault(testing::Return(kDeviceClass));
-    ON_CALL(*fake_device_, GetInquiryRSSI())
-        .WillByDefault(testing::Return(kDeviceRssi));
-
-    device_uuids_.emplace_back(device::BluetoothUUID(kServiceUUID));
-    device_uuids_.emplace_back(device::BluetoothUUID(kCharUUID));
-    ON_CALL(*fake_device_, GetUUIDs())
-        .WillByDefault(testing::Return(device_uuids_));
-
-    fake_adapter_->AddMockDevice(base::WrapUnique(fake_device_));
-    ON_CALL(*fake_adapter_, GetDevices())
-        .WillByDefault(testing::Return(fake_adapter_->GetConstMockDevices()));
-    ON_CALL(*fake_adapter_, GetDevice("1A:2B:3C:4D:5E:6F"))
-        .WillByDefault(testing::Return(fake_device_));
-
-    fake_service_ = new testing::NiceMock<device::MockBluetoothGattService>(
-        fake_device_, kServiceID, device::BluetoothUUID(kServiceUUID),
-        true /* is_primary */, true /* is_local */);
-    fake_device_->AddMockService(base::WrapUnique(fake_service_));
-    ON_CALL(*fake_device_, GetGattServices())
-        .WillByDefault(testing::Return(fake_device_->GetMockServices()));
-
-    fake_char_ = new testing::NiceMock<device::MockBluetoothGattCharacteristic>(
-        fake_service_, kCharID, device::BluetoothUUID(kCharUUID),
-        true /*is_local*/, device::BluetoothGattCharacteristic::PROPERTY_READ,
-        device::BluetoothGattCharacteristic::PERMISSION_READ);
-    fake_service_->AddMockCharacteristic(base::WrapUnique(fake_char_));
-    ON_CALL(*fake_service_, GetCharacteristics())
-        .WillByDefault(
-            testing::Return(fake_service_->GetMockCharacteristics()));
-
-    remote_addr = mojom::BluetoothAddress::From(std::string(kAddressStr));
-
-    service_id = mojom::BluetoothGattServiceID::New();
-    service_id->is_primary = true;
-    service_id->id = mojom::BluetoothGattID::New();
-    service_id->id->inst_id = 0;
-    service_id->id->uuid =
-        mojom::BluetoothUUID::From(device::BluetoothUUID(kServiceUUID));
-
-    char_id = mojom::BluetoothGattID::New();
-    char_id->inst_id = 0;
-    char_id->uuid =
-        mojom::BluetoothUUID::From(device::BluetoothUUID(kCharUUID));
-
-    mojom::BluetoothInstancePtr bluetooth_instance_ptr;
-    fake_bluetooth_instance = new FakeBluetoothInstance();
-    fake_arc_bluetooth_bridge_->SetBluetoothInstanceForTest(
-        fake_bluetooth_instance);
+    device::BluetoothAdapterFactory::GetAdapter(base::Bind(
+        &ArcBluetoothBridgeTest::OnAdapterInitialized, base::Unretained(this)));
+    // We will quit the loop once we get the adapter.
+    get_adapter_run_loop_.Run();
   }
 
   void TearDown() override {
-    fake_arc_bluetooth_bridge_->SetAdapterForTest(nullptr);
-    fake_arc_bluetooth_bridge_->SetBluetoothInstanceForTest(nullptr);
+    delete arc_bluetooth_bridge_;
     delete fake_arc_bridge_service_;
   }
+
+  base::MessageLoop message_loop_;
+  base::RunLoop get_adapter_run_loop_;
+  bluez::FakeBluetoothDeviceClient* fake_bluetooth_device_client_;
 };
 
 // Invoke OnDiscoveryStarted to send cached device to BT instance,
 // and check correctness of the device properties sent via arc bridge.
 TEST_F(ArcBluetoothBridgeTest, DeviceFound) {
-  fake_arc_bluetooth_bridge_->OnDiscoveryStarted(nullptr);
-
-  EXPECT_EQ((size_t)1, fake_bluetooth_instance->device_found_data().size());
+  AddTestDevice();
+  arc_bluetooth_bridge_->OnDiscoveryStarted(nullptr);
+  EXPECT_EQ((size_t)1, fake_bluetooth_instance_->device_found_data().size());
   const mojo::Array<mojom::BluetoothPropertyPtr>& prop =
-      fake_bluetooth_instance->device_found_data().back();
+      fake_bluetooth_instance_->device_found_data().back();
 
   EXPECT_EQ((size_t)7, prop.size());
   EXPECT_TRUE(prop[0]->is_bdname());
   EXPECT_EQ(std::string(kDeviceName), prop[0]->get_bdname());
   EXPECT_TRUE(prop[1]->is_bdaddr());
   EXPECT_EQ(std::string(kAddressStr), prop[1]->get_bdaddr()->To<std::string>());
   EXPECT_TRUE(prop[2]->is_uuids());
-  EXPECT_EQ(device_uuids_,
-            prop[2]->get_uuids().To<std::vector<device::BluetoothUUID>>());
+  EXPECT_EQ(
+      device_uuids_[0],
+      prop[2]->get_uuids().To<std::vector<device::BluetoothUUID>>()[0].value());
+  EXPECT_EQ(
+      device_uuids_[1],
+      prop[2]->get_uuids().To<std::vector<device::BluetoothUUID>>()[1].value());
   EXPECT_TRUE(prop[3]->is_device_class());
-  EXPECT_EQ(kDeviceClass, prop[3]->get_device_class());
   EXPECT_TRUE(prop[4]->is_device_type());
   EXPECT_EQ(mojom::BluetoothDeviceType::DUAL, prop[4]->get_device_type());
   EXPECT_TRUE(prop[5]->is_remote_friendly_name());
   EXPECT_EQ(std::string(kDeviceName), prop[5]->get_remote_friendly_name());
   EXPECT_TRUE(prop[6]->is_remote_rssi());
-  EXPECT_EQ(kDeviceRssi, prop[6]->get_remote_rssi());
 }
 
 // Invoke OnDiscoveryStarted to send cached device to BT instance,
 // and check correctness of the Advertising data sent via arc bridge.
 TEST_F(ArcBluetoothBridgeTest, LEDeviceFound) {
+  fake_arc_bridge_service_->set_bluetooth_version(0);
+  AddTestDevice();
+  arc_bluetooth_bridge_->OnDiscoveryStarted(nullptr);
   // Check that we check bluetooth_instance version correctly.
-  fake_arc_bluetooth_bridge_->OnDiscoveryStarted(nullptr);
-  EXPECT_EQ((size_t)0, fake_bluetooth_instance->le_device_found_data().size());
+  EXPECT_EQ((size_t)0, fake_bluetooth_instance_->le_device_found_data().size());
 
-  fake_arc_bluetooth_bridge_->SetBluetoothVersionForTest(1);
-  fake_arc_bluetooth_bridge_->OnDiscoveryStarted(nullptr);
-  EXPECT_EQ((size_t)1, fake_bluetooth_instance->le_device_found_data().size());
+  fake_arc_bridge_service_->set_bluetooth_version(1);
+  arc_bluetooth_bridge_->OnDiscoveryStarted(nullptr);
+  EXPECT_EQ((size_t)1, fake_bluetooth_instance_->le_device_found_data().size());
 
   const mojom::BluetoothAddressPtr& addr =
-      fake_bluetooth_instance->le_device_found_data().back()->addr();
-  int32_t rssi = fake_bluetooth_instance->le_device_found_data().back()->rssi();
+      fake_bluetooth_instance_->le_device_found_data().back()->addr();
+  //  int32_t rssi =
+  //  fake_bluetooth_instance_->le_device_found_data().back()->rssi();
   const mojo::Array<mojom::BluetoothAdvertisingDataPtr>& adv_data =
-      fake_bluetooth_instance->le_device_found_data().back()->adv_data();
+      fake_bluetooth_instance_->le_device_found_data().back()->adv_data();
 
   EXPECT_EQ(std::string(kAddressStr), addr->To<std::string>());
-  EXPECT_EQ(kDeviceRssi, rssi);
   EXPECT_EQ((size_t)1, adv_data.size());
 
   EXPECT_TRUE(adv_data[0]->is_local_name());
   EXPECT_EQ(std::string(kDeviceName),
             adv_data[0]->get_local_name().To<std::string>());
 }
 
 // Invoke GetGattDB and check correctness of the GattDB sent via arc bridge.
 TEST_F(ArcBluetoothBridgeTest, GetGattDB) {
-  fake_arc_bluetooth_bridge_->GetGattDB(remote_addr.Clone());
+  AddTestDevice();
+  arc_bluetooth_bridge_->GetGattDB(remote_addr_.Clone());
 
-  EXPECT_EQ((size_t)1, fake_bluetooth_instance->gatt_db_result().size());
+  EXPECT_EQ((size_t)1, fake_bluetooth_instance_->gatt_db_result().size());
 
   const mojom::BluetoothAddressPtr& addr =
-      fake_bluetooth_instance->gatt_db_result().back()->remote_addr();
+      fake_bluetooth_instance_->gatt_db_result().back()->remote_addr();
   const mojo::Array<mojom::BluetoothGattDBElementPtr>& db =
-      fake_bluetooth_instance->gatt_db_result().back()->db();
+      fake_bluetooth_instance_->gatt_db_result().back()->db();
 
   EXPECT_EQ(std::string(kAddressStr), addr->To<std::string>());
   EXPECT_EQ((size_t)2, db.size());
 
   EXPECT_EQ(device::BluetoothUUID(kServiceUUID),
             db[0]->uuid.To<device::BluetoothUUID>());
   EXPECT_EQ(mojom::BluetoothGattDBAttributeType::BTGATT_DB_PRIMARY_SERVICE,
             db[0]->type);
   EXPECT_EQ(kCharUUIDInt, db[0]->start_handle);
   EXPECT_EQ(kCharUUIDInt, db[0]->end_handle);
 
   EXPECT_EQ(device::BluetoothUUID(kCharUUID),
             db[1]->uuid.To<device::BluetoothUUID>());
   EXPECT_EQ(mojom::BluetoothGattDBAttributeType::BTGATT_DB_CHARACTERISTIC,
             db[1]->type);
   EXPECT_EQ(device::BluetoothGattCharacteristic::PROPERTY_READ,
             db[1]->properties);
 }
 
 }  // namespace arc