Index: components/arc/bluetooth/arc_bluetooth_bridge_unittest.cc |
diff --git a/components/arc/bluetooth/arc_bluetooth_bridge_unittest.cc b/components/arc/bluetooth/arc_bluetooth_bridge_unittest.cc |
index b4c9f80d82e5e5a4ab669c0d7515b5b460d465f6..8c2cfaeb65c3b1d4d95b3ad110979e0e2a28dfc3 100644 |
--- a/components/arc/bluetooth/arc_bluetooth_bridge_unittest.cc |
+++ b/components/arc/bluetooth/arc_bluetooth_bridge_unittest.cc |
@@ -7,10 +7,15 @@ |
#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" |
@@ -26,124 +31,99 @@ 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_; |
- |
- mojom::BluetoothAddressPtr remote_addr; |
- mojom::BluetoothGattServiceIDPtr service_id; |
- mojom::BluetoothGattIDPtr char_id; |
+ 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_; |
private: |
+ void OnAdapterInitialized(scoped_refptr<device::BluetoothAdapter> adapter) { |
+ adapter_ = adapter; |
+ get_adapter_run_loop_.Quit(); |
+ } |
+ |
void SetUp() override { |
- fake_arc_bridge_service_ = new FakeArcBridgeService(); |
+ 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_adapter_ = new testing::NiceMock<device::MockBluetoothAdapter>(); |
- fake_arc_bluetooth_bridge_ = |
- new FakeArcBluetoothBridge(fake_arc_bridge_service_, fake_adapter_); |
- |
- 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)); |
+ fake_arc_bridge_service_ = new FakeArcBridgeService(); |
+ fake_bluetooth_instance_ = static_cast<FakeBluetoothInstance*>( |
+ fake_arc_bridge_service_->bluetooth_instance()); |
- char_id = mojom::BluetoothGattID::New(); |
- char_id->inst_id = 0; |
- char_id->uuid = |
- mojom::BluetoothUUID::From(device::BluetoothUUID(kCharUUID)); |
+ arc_bluetooth_bridge_ = new ArcBluetoothBridge(fake_arc_bridge_service_); |
- 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()); |
@@ -151,37 +131,41 @@ TEST_F(ArcBluetoothBridgeTest, DeviceFound) { |
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()); |
@@ -191,14 +175,15 @@ TEST_F(ArcBluetoothBridgeTest, LEDeviceFound) { |
// 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()); |