Update unit tests for BluetoothDevice::GetPrimaryServicesByUUID() etc.

device/bluetooth/bluetooth_device_unittest.cc

 // Copyright 2014 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 "device/bluetooth/bluetooth_device.h"
 
 #include <stddef.h>
 
 #include "base/macros.h"
 #include "base/run_loop.h"
@@ skipping 30 matching lines @@
 
 }  // namespace
 
 #endif
 
 using UUIDSet = BluetoothDevice::UUIDSet;
 using ServiceDataMap = BluetoothDevice::ServiceDataMap;
 
 class BluetoothGetServiceOrCharacteristicTest : public BluetoothTest {
  public:
-  // Creates |device_|, |services_|.
+  // Creates |device_|, |service_uuids_|.
   void FakeServiceBoilerplate() {
     InitWithFakeAdapter();
     StartLowEnergyDiscoverySession();
     device_ = SimulateLowEnergyDevice(3);
     EXPECT_FALSE(device_->IsConnected());
 
     // Connect to the device.
     ResetEventCounts();
     device_->CreateGattConnection(GetGattConnectionCallback(Call::EXPECTED),
                                   GetConnectErrorCallback(Call::NOT_EXPECTED));
     TestBluetoothAdapterObserver observer(adapter_);
     SimulateGattConnection(device_);
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(device_->IsConnected());
 
     // Discover services.
-    services_.push_back("00000000-0000-1000-8000-00805f9b34fb");
+    service_uuids_.push_back(kTestUUIDGenericAccess);
     // 2 duplicate UUIDs creating 2 instances.
-    services_.push_back("00000001-0000-1000-8000-00805f9b34fb");
-    services_.push_back("00000001-0000-1000-8000-00805f9b34fb");
-    SimulateGattServicesDiscovered(device_, services_);
+    service_uuids_.push_back(kTestUUIDHeartRate);
+    service_uuids_.push_back(kTestUUIDHeartRate);
+    SimulateGattServicesDiscovered(device_, service_uuids_);
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(device_->IsGattServicesDiscoveryComplete());
   }
 
  protected:
   BluetoothDevice* device_ = nullptr;
-  std::vector<std::string> services_;
+  std::vector<std::string> service_uuids_;
 };
 
 TEST(BluetoothDeviceTest, CanonicalizeAddressFormat_AcceptsAllValidFormats) {
   // There are three valid separators (':', '-', and none).
   // Case shouldn't matter.
   const char* const kValidFormats[] = {
     "1A:2B:3C:4D:5E:6F",
     "1a:2B:3c:4D:5e:6F",
     "1a:2b:3c:4d:5e:6f",
     "1A-2B-3C-4D-5E-6F",
@@ skipping 1420 matching lines @@
 
   BluetoothDevice* device2 = SimulateLowEnergyDevice(6);
   EXPECT_EQ(BLUETOOTH_TRANSPORT_DUAL, device2->GetType());
 
   BluetoothDevice* device3 = SimulateClassicDevice();
   EXPECT_EQ(BLUETOOTH_TRANSPORT_CLASSIC, device3->GetType());
 }
 #endif  // defined(OS_CHROMEOS) || defined(OS_LINUX)
 
 #if defined(OS_ANDROID) || defined(OS_MACOSX)
+// TODO(https://crbug.com/507419): Run test on Windows once Bluetooth
+// connection is implemented.
 TEST_F(BluetoothGetServiceOrCharacteristicTest, GetPrimaryServices) {
   if (!PlatformSupportsLowEnergy()) {
     LOG(WARNING) << "Low Energy Bluetooth unavailable, skipping unit test.";
     return;
   }
   ASSERT_NO_FATAL_FAILURE(FakeServiceBoilerplate());
 
   EXPECT_EQ(3u, device_->GetPrimaryServices().size());
 }
 
 TEST_F(BluetoothGetServiceOrCharacteristicTest, GetPrimaryServicesByUUID) {
   if (!PlatformSupportsLowEnergy()) {
     LOG(WARNING) << "Low Energy Bluetooth unavailable, skipping unit test.";
     return;
   }
   ASSERT_NO_FATAL_FAILURE(FakeServiceBoilerplate());
 
-  EXPECT_EQ(
-      1u,
-      device_->GetPrimaryServicesByUUID(BluetoothUUID(services_[0])).size());
-  EXPECT_EQ(
-      2u,
-      device_->GetPrimaryServicesByUUID(BluetoothUUID(services_[1])).size());
-  std::string service_uuid_not_exist_in_setup =
-      "00000002-0000-1000-8000-00805f9b34fb";
-  EXPECT_TRUE(device_
-                  ->GetPrimaryServicesByUUID(
-                      BluetoothUUID(service_uuid_not_exist_in_setup))
-                  .empty());
+  {
+    std::vector<BluetoothRemoteGattService*> services =
+        device_->GetPrimaryServicesByUUID(BluetoothUUID(service_uuids_[0]));
+    EXPECT_EQ(1u, services.size());
+    EXPECT_EQ(BluetoothUUID(service_uuids_[0]), services[0]->GetUUID());
+  }
+
+  {
+    std::vector<BluetoothRemoteGattService*> services =
+        device_->GetPrimaryServicesByUUID(BluetoothUUID(service_uuids_[1]));
+    EXPECT_EQ(2u, services.size());
+    EXPECT_EQ(BluetoothUUID(service_uuids_[1]), services[0]->GetUUID());
+    EXPECT_EQ(BluetoothUUID(service_uuids_[1]), services[1]->GetUUID());
+
+    EXPECT_TRUE(device_
+                    ->GetPrimaryServicesByUUID(BluetoothUUID(
+                        BluetoothTestBase::kTestUUIDGenericAttribute))
+                    .empty());
+
+    EXPECT_NE(services[0]->GetIdentifier(), services[1]->GetIdentifier());
+  }
 }
 
 TEST_F(BluetoothGetServiceOrCharacteristicTest, GetCharacteristicsByUUID) {
   if (!PlatformSupportsLowEnergy()) {
     LOG(WARNING) << "Low Energy Bluetooth unavailable, skipping unit test.";
     return;
   }
   ASSERT_NO_FATAL_FAILURE(FakeServiceBoilerplate());
 
   std::vector<BluetoothRemoteGattService*> primary_services =
       device_->GetPrimaryServices();
   std::string service_instance_id0 = primary_services[0]->GetIdentifier();
   std::string service_instance_id1 = primary_services[1]->GetIdentifier();
   std::string service_instance_id2 = primary_services[2]->GetIdentifier();
 
-  std::string characteristic_uuid0 = "00000002-0000-1000-8000-00805f9b34fb";
-  std::string characteristic_uuid1 = "00000003-0000-1000-8000-00805f9b34fb";
+  std::string characteristic_uuid0 = "00002a00-0000-1000-8000-00805f9b34fb";

[ortuno, 2017/04/04 03:32:12]

Move these to bluetooth_test.h

[juncai, 2017/04/04 20:33:40]

Not used any more.

+  std::string characteristic_uuid1 = "00002a37-0000-1000-8000-00805f9b34fb";
   SimulateGattCharacteristic(primary_services[0], characteristic_uuid0,
                              0 /* properties */);
+  // 2 duplicate UUIDs creating 2 instances.
+  SimulateGattCharacteristic(primary_services[1], characteristic_uuid1,
+                             0 /* properties */);
   SimulateGattCharacteristic(primary_services[1], characteristic_uuid1,
                              0 /* properties */);
   SimulateGattCharacteristic(primary_services[2], characteristic_uuid1,
                              0 /* properties */);
 
-  EXPECT_EQ(1u,
-            device_
-                ->GetCharacteristicsByUUID(service_instance_id0,
-                                           BluetoothUUID(characteristic_uuid0))
-                .size());
-  EXPECT_EQ(1u,
-            device_
-                ->GetCharacteristicsByUUID(service_instance_id1,
-                                           BluetoothUUID(characteristic_uuid1))
-                .size());
-  EXPECT_EQ(1u,
-            device_
-                ->GetCharacteristicsByUUID(service_instance_id2,
-                                           BluetoothUUID(characteristic_uuid1))
-                .size());
+  {
+    std::vector<BluetoothRemoteGattCharacteristic*> characteristics =
+        device_->GetCharacteristicsByUUID(service_instance_id0,
+                                          BluetoothUUID(characteristic_uuid0));
+    EXPECT_EQ(1u, characteristics.size());
+    EXPECT_EQ(BluetoothUUID(characteristic_uuid0),
+              characteristics[0]->GetUUID());
+  }
+
+  {
+    std::vector<BluetoothRemoteGattCharacteristic*> characteristics =
+        device_->GetCharacteristicsByUUID(service_instance_id1,
+                                          BluetoothUUID(characteristic_uuid1));
+    EXPECT_EQ(2u, characteristics.size());
+    EXPECT_EQ(BluetoothUUID(characteristic_uuid1),
+              characteristics[0]->GetUUID());
+    EXPECT_EQ(BluetoothUUID(characteristic_uuid1),
+              characteristics[1]->GetUUID());
+  }

[ortuno, 2017/04/04 03:32:12]

Compare the identifiers to make sure they are two different characteristics.

[juncai, 2017/04/04 20:33:40]

Done.

+
+  {
+    std::vector<BluetoothRemoteGattCharacteristic*> characteristics =
+        device_->GetCharacteristicsByUUID(service_instance_id2,
+                                          BluetoothUUID(characteristic_uuid1));
+    EXPECT_EQ(1u, characteristics.size());
+    EXPECT_EQ(BluetoothUUID(characteristic_uuid1),
+              characteristics[0]->GetUUID());
+  }
 
   std::string service_instance_id_not_exist_in_setup =
       "non-existent platform specific service instance id";
   EXPECT_TRUE(
       device_
           ->GetCharacteristicsByUUID(service_instance_id_not_exist_in_setup,
                                      BluetoothUUID(characteristic_uuid0))
           .empty());
   EXPECT_TRUE(
       device_
           ->GetCharacteristicsByUUID(service_instance_id_not_exist_in_setup,
                                      BluetoothUUID(characteristic_uuid1))
           .empty());
 
   std::string characteristic_uuid_not_exist_in_setup =

[ortuno, 2017/04/04 03:32:12]

Also move this to bluetooth_test.h

[juncai, 2017/04/04 20:33:40]

Not used any more.

       "00000005-0000-1000-8000-00805f9b34fb";
   EXPECT_TRUE(device_
                   ->GetCharacteristicsByUUID(
                       service_instance_id0,
                       BluetoothUUID(characteristic_uuid_not_exist_in_setup))
                   .empty());
   EXPECT_TRUE(device_
                   ->GetCharacteristicsByUUID(
                       service_instance_id1,
                       BluetoothUUID(characteristic_uuid_not_exist_in_setup))
                   .empty());
   EXPECT_TRUE(device_
                   ->GetCharacteristicsByUUID(
                       service_instance_id2,
                       BluetoothUUID(characteristic_uuid_not_exist_in_setup))
                   .empty());
 }
 #endif  // defined(OS_ANDROID) || defined(OS_MACOSX)
 
 }  // namespace device