Merge branch 'google3' to master, roll forward up to cl/355302206.

2026-09-16 15:36:12 -04:00 · 2021-02-04 13:34:05 -08:00
parent d7ae99de6e 48e1c47a93
commit 133dddeccb
41 changed files with 1194 additions and 472 deletions
@@ -26,12 +26,23 @@ namespace location {
 namespace nearby {
 namespace {

+using FeatureFlags = FeatureFlags::Flags;
+
+constexpr FeatureFlags kTestCases[] = {
+    FeatureFlags{
+        .enable_cancellation_flag = true,
+    },
+    FeatureFlags{
+        .enable_cancellation_flag = false,
+    },
+};
+
 constexpr absl::Duration kWaitDuration = absl::Milliseconds(1000);
 constexpr absl::string_view kServiceID{"com.google.location.nearby.apps.test"};
 constexpr absl::string_view kAdvertisementString{"\x0a\x0b\x0c\x0d"};
 constexpr absl::string_view kFastAdvertisementServiceUuid{"\xf3\xfe"};

-class BleMediumTest : public ::testing::Test {
+class BleMediumTest : public ::testing::TestWithParam<FeatureFlags> {
 protected:
  using DiscoveredPeripheralCallback = BleMedium::DiscoveredPeripheralCallback;
  using AcceptedConnectionCallback = BleMedium::AcceptedConnectionCallback;
@@ -41,6 +52,139 @@ class BleMediumTest : public ::testing::Test {
  MediumEnvironment& env_{MediumEnvironment::Instance()};
 };

+TEST_P(BleMediumTest, CanStartAcceptingConnectionsAndConnect) {
+  FeatureFlags feature_flags = GetParam();
+  env_.SetFeatureFlags(feature_flags);
+  env_.Start();
+  BluetoothAdapter adapter_a_;
+  BluetoothAdapter adapter_b_;
+  BleMedium ble_a{adapter_a_};
+  BleMedium ble_b{adapter_b_};
+  std::string service_id(kServiceID);
+  ByteArray advertisement_bytes{std::string(kAdvertisementString)};
+  std::string fast_advertisement_service_uuid(kFastAdvertisementServiceUuid);
+  CountDownLatch found_latch(1);
+  CountDownLatch accepted_latch(1);
+
+  BlePeripheral* discovered_peripheral = nullptr;
+  ble_a.StartScanning(
+      service_id, fast_advertisement_service_uuid,
+      DiscoveredPeripheralCallback{
+          .peripheral_discovered_cb =
+              [&found_latch, &discovered_peripheral](
+                  BlePeripheral& peripheral, const std::string& service_id,
+                  const ByteArray& advertisement_bytes,
+                  bool fast_advertisement) {
+                NEARBY_LOG(
+                    INFO,
+                    "Peripheral discovered: %s, %p, fast advertisement: %d",
+                    peripheral.GetName().c_str(), &peripheral,
+                    fast_advertisement);
+                discovered_peripheral = &peripheral;
+                found_latch.CountDown();
+              },
+      });
+  ble_b.StartAdvertising(service_id, advertisement_bytes,
+                         fast_advertisement_service_uuid);
+  ble_b.StartAcceptingConnections(
+      service_id,
+      AcceptedConnectionCallback{
+          .accepted_cb = [&accepted_latch](BleSocket socket,
+                                           const std::string& service_id) {
+            NEARBY_LOG(INFO, "Connection accepted: socket=%p, service_id=%s",
+                       &socket, service_id.c_str());
+            accepted_latch.CountDown();
+          }});
+  EXPECT_TRUE(found_latch.Await(kWaitDuration).result());
+
+  BleSocket socket_a;
+  EXPECT_FALSE(socket_a.IsValid());
+  {
+    SingleThreadExecutor client_executor;
+    client_executor.Execute(
+        [&ble_a, &socket_a, discovered_peripheral, &service_id]() {
+          CancellationFlag flag;
+          socket_a = ble_a.Connect(*discovered_peripheral, service_id, &flag);
+        });
+  }
+  EXPECT_TRUE(accepted_latch.Await(kWaitDuration).result());
+  EXPECT_TRUE(socket_a.IsValid());
+  ble_b.StopAdvertising(service_id);
+  ble_a.StopScanning(service_id);
+  env_.Stop();
+}
+
+TEST_P(BleMediumTest, CanCancelConnect) {
+  FeatureFlags feature_flags = GetParam();
+  env_.SetFeatureFlags(feature_flags);
+  env_.Start();
+  BluetoothAdapter adapter_a_;
+  BluetoothAdapter adapter_b_;
+  BleMedium ble_a{adapter_a_};
+  BleMedium ble_b{adapter_b_};
+  std::string service_id(kServiceID);
+  ByteArray advertisement_bytes{std::string(kAdvertisementString)};
+  std::string fast_advertisement_service_uuid(kFastAdvertisementServiceUuid);
+  CountDownLatch found_latch(1);
+  CountDownLatch accepted_latch(1);
+
+  BlePeripheral* discovered_peripheral = nullptr;
+  ble_a.StartScanning(
+      service_id, fast_advertisement_service_uuid,
+      DiscoveredPeripheralCallback{
+          .peripheral_discovered_cb =
+              [&found_latch, &discovered_peripheral](
+                  BlePeripheral& peripheral, const std::string& service_id,
+                  const ByteArray& advertisement_bytes,
+                  bool fast_advertisement) {
+                NEARBY_LOG(
+                    INFO,
+                    "Peripheral discovered: %s, %p, fast advertisement: %d",
+                    peripheral.GetName().c_str(), &peripheral,
+                    fast_advertisement);
+                discovered_peripheral = &peripheral;
+                found_latch.CountDown();
+              },
+      });
+  ble_b.StartAdvertising(service_id, advertisement_bytes,
+                         fast_advertisement_service_uuid);
+  ble_b.StartAcceptingConnections(
+      service_id,
+      AcceptedConnectionCallback{
+          .accepted_cb = [&accepted_latch](BleSocket socket,
+                                           const std::string& service_id) {
+            NEARBY_LOG(INFO, "Connection accepted: socket=%p, service_id=%s",
+                       &socket, service_id.c_str());
+            accepted_latch.CountDown();
+          }});
+  EXPECT_TRUE(found_latch.Await(kWaitDuration).result());
+
+  BleSocket socket_a;
+  EXPECT_FALSE(socket_a.IsValid());
+  {
+    SingleThreadExecutor client_executor;
+    client_executor.Execute(
+        [&ble_a, &socket_a, discovered_peripheral, &service_id]() {
+          CancellationFlag flag(true);
+          socket_a = ble_a.Connect(*discovered_peripheral, service_id, &flag);
+        });
+  }
+  // If FeatureFlag is disabled, Cancelled is false as no-op.
+  if (!feature_flags.enable_cancellation_flag) {
+    EXPECT_TRUE(accepted_latch.Await(kWaitDuration).result());
+    EXPECT_TRUE(socket_a.IsValid());
+  } else {
+    EXPECT_FALSE(accepted_latch.Await(kWaitDuration).result());
+    EXPECT_FALSE(socket_a.IsValid());
+  }
+  ble_b.StopAdvertising(service_id);
+  ble_a.StopScanning(service_id);
+  env_.Stop();
+}
+
+INSTANTIATE_TEST_SUITE_P(ParametrisedBleMediumTest, BleMediumTest,
+                         ::testing::ValuesIn(kTestCases));
+
 TEST_F(BleMediumTest, ConstructorDestructorWorks) {
  env_.Start();
  BluetoothAdapter adapter_a_;
@@ -156,65 +300,6 @@ TEST_F(BleMediumTest, CanStopDiscovery) {
  env_.Stop();
 }

-TEST_F(BleMediumTest, CanStartAcceptingConnectionsAndConnect) {
-  env_.Start();
-  BluetoothAdapter adapter_a_;
-  BluetoothAdapter adapter_b_;
-  BleMedium ble_a{adapter_a_};
-  BleMedium ble_b{adapter_b_};
-  std::string service_id(kServiceID);
-  ByteArray advertisement_bytes{std::string(kAdvertisementString)};
-  std::string fast_advertisement_service_uuid(kFastAdvertisementServiceUuid);
-  CountDownLatch found_latch(1);
-  CountDownLatch accepted_latch(1);
-
-  BlePeripheral* discovered_peripheral = nullptr;
-  ble_a.StartScanning(
-      service_id, fast_advertisement_service_uuid,
-      DiscoveredPeripheralCallback{
-          .peripheral_discovered_cb =
-              [&found_latch, &discovered_peripheral](
-                  BlePeripheral& peripheral, const std::string& service_id,
-                  const ByteArray& advertisement_bytes,
-                  bool fast_advertisement) {
-                NEARBY_LOG(
-                    INFO,
-                    "Peripheral discovered: %s, %p, fast advertisement: %d",
-                    peripheral.GetName().c_str(), &peripheral,
-                    fast_advertisement);
-                discovered_peripheral = &peripheral;
-                found_latch.CountDown();
-              },
-      });
-  ble_b.StartAdvertising(service_id, advertisement_bytes,
-                         fast_advertisement_service_uuid);
-  ble_b.StartAcceptingConnections(
-      service_id,
-      AcceptedConnectionCallback{
-          .accepted_cb = [&accepted_latch](BleSocket socket,
-                                           const std::string& service_id) {
-            NEARBY_LOG(INFO, "Connection accepted: socket=%p, service_id=%s",
-                       &socket, service_id.c_str());
-            accepted_latch.CountDown();
-          }});
-  EXPECT_TRUE(found_latch.Await(kWaitDuration).result());
-
-  BleSocket socket_a;
-  EXPECT_FALSE(socket_a.IsValid());
-  {
-    SingleThreadExecutor client_executor;
-    client_executor.Execute(
-        [&ble_a, &socket_a, discovered_peripheral, &service_id]() {
-          socket_a = ble_a.Connect(*discovered_peripheral, service_id);
-        });
-  }
-  EXPECT_TRUE(accepted_latch.Await(kWaitDuration).result());
-  EXPECT_TRUE(socket_a.IsValid());
-  ble_b.StopAdvertising(service_id);
-  ble_a.StopScanning(service_id);
-  env_.Stop();
-}
-
 }  // namespace
 }  // namespace nearby
 }  // namespace location