PlatformAudio requires audio device

Author: stephen-derosa

src/tests/integration/test_platform_audio.cpp

@@ -79,14 +79,19 @@ class PlatformTrackCollectorDelegate : public RoomDelegate {
 class PlatformAudioIntegrationTest : public LiveKitTestBase {};
 
 // Publishing a platform-ADM-backed audio track should reach a remote
-// participant exactly like a manually fed AudioSource track. No real
-// microphone is required: the source captures silence on headless runners,
-// but the publish/subscribe round-trip still completes.
+// participant exactly like a manually fed AudioSource track. Unlike AudioSource,
+// PlatformAudio requires a working platform Audio Device Module: constructing it
+// throws PlatformAudioError when no ADM is available (e.g. a headless runner with
+// no audio subsystem), so the test is skipped in that environment.
 TEST_F(PlatformAudioIntegrationTest, PublishPlatformAudioTrackEndToEnd) {
   EXPECT_TRUE(config_.available) << "Missing integration configuration";
 
   std::unique_ptr<PlatformAudio> platform_audio;
-  EXPECT_NO_THROW(platform_audio = std::make_unique<PlatformAudio>());
+  try {
+    platform_audio = std::make_unique<PlatformAudio>();
+  } catch (const PlatformAudioError& error) {
+    GTEST_SKIP() << "PlatformAudio unavailable: " << error.what();
+  }
 
   RoomOptions options;
   options.auto_subscribe = true;
@@ -125,7 +130,11 @@ TEST_F(PlatformAudioIntegrationTest, UnpublishPlatformAudioTrackPropagates) {
   EXPECT_TRUE(config_.available) << "Missing integration configuration";
 
   std::unique_ptr<PlatformAudio> platform_audio;
-  EXPECT_NO_THROW(platform_audio = std::make_unique<PlatformAudio>());
+  try {
+    platform_audio = std::make_unique<PlatformAudio>();
+  } catch (const PlatformAudioError& error) {
+    GTEST_SKIP() << "PlatformAudio unavailable: " << error.what();
+  }
 
   RoomOptions options;
   options.auto_subscribe = true;
@@ -176,7 +185,11 @@ TEST_F(PlatformAudioIntegrationTest, MultipleSourcesFromOneManagerPublish) {
   EXPECT_TRUE(config_.available) << "Missing integration configuration";
 
   std::unique_ptr<PlatformAudio> platform_audio;
-  EXPECT_NO_THROW(platform_audio = std::make_unique<PlatformAudio>());
+  try {
+    platform_audio = std::make_unique<PlatformAudio>();
+  } catch (const PlatformAudioError& error) {
+    GTEST_SKIP() << "PlatformAudio unavailable: " << error.what();
+  }
 
   RoomOptions options;
   options.auto_subscribe = true;
@@ -221,14 +234,19 @@ TEST_F(PlatformAudioIntegrationTest, MultipleSourcesFromOneManagerPublish) {
 
 // Audio captured by the platform Audio Device Module must actually stream to a
 // remote participant as decoded frames, not merely produce a subscribed track.
-// PlatformAudioSource captures the real microphone (silence on headless
-// runners), so this verifies frames *flow* end-to-end without asserting on
-// their content.
+// PlatformAudioSource captures the real microphone, so this verifies frames
+// *flow* end-to-end without asserting on their content. PlatformAudio requires a
+// working platform ADM, so the test is skipped when one is unavailable (e.g. a
+// headless runner with no audio subsystem).
 TEST_F(PlatformAudioIntegrationTest, PlatformAudioFramesReachRemote) {
   EXPECT_TRUE(config_.available) << "Missing integration configuration";
 
   std::unique_ptr<PlatformAudio> platform_audio;
-  EXPECT_NO_THROW(platform_audio = std::make_unique<PlatformAudio>());
+  try {
+    platform_audio = std::make_unique<PlatformAudio>();
+  } catch (const PlatformAudioError& error) {
+    GTEST_SKIP() << "PlatformAudio unavailable: " << error.what();
+  }
 
   RoomOptions options;
   options.auto_subscribe = true;

src/tests/unit/test_platform_audio.cpp

@@ -50,7 +50,11 @@ TEST_F(PlatformAudioTest, DeviceInfoStoresStableId) {
 
 TEST_F(PlatformAudioTest, CreateSourceAndTrackWhenAvailable) {
   std::unique_ptr<PlatformAudio> platform_audio;
-  EXPECT_NO_THROW(platform_audio = std::make_unique<PlatformAudio>());
+  try {
+    platform_audio = std::make_unique<PlatformAudio>();
+  } catch (const PlatformAudioError& error) {
+    GTEST_SKIP() << "PlatformAudio unavailable: " << error.what();
+  }
 
   const auto source = platform_audio->createAudioSource();
   ASSERT_NE(source, nullptr);
@@ -64,7 +68,11 @@ TEST_F(PlatformAudioTest, CreateSourceAndTrackWhenAvailable) {
 
 TEST_F(PlatformAudioTest, MovedFromManagerThrowsOnUseButCountsAreSafe) {
   std::unique_ptr<PlatformAudio> platform_audio;
-  EXPECT_NO_THROW(platform_audio = std::make_unique<PlatformAudio>());
+  try {
+    platform_audio = std::make_unique<PlatformAudio>();
+  } catch (const PlatformAudioError& error) {
+    GTEST_SKIP() << "PlatformAudio unavailable: " << error.what();
+  }
 
   PlatformAudio moved_to = std::move(*platform_audio);
   PlatformAudio& moved_from = *platform_audio;
@@ -86,7 +94,11 @@ TEST_F(PlatformAudioTest, MovedFromManagerThrowsOnUseButCountsAreSafe) {
 
 TEST_F(PlatformAudioTest, CopySharesHandleStateAndOutlivesOriginal) {
   std::unique_ptr<PlatformAudio> platform_audio;
-  EXPECT_NO_THROW(platform_audio = std::make_unique<PlatformAudio>());
+  try {
+    platform_audio = std::make_unique<PlatformAudio>();
+  } catch (const PlatformAudioError& error) {
+    GTEST_SKIP() << "PlatformAudio unavailable: " << error.what();
+  }
 
   // A copy shares the underlying handle, so the cached counts agree.
   PlatformAudio copy = *platform_audio;
@@ -105,7 +117,11 @@ TEST_F(PlatformAudioTest, CopySharesHandleStateAndOutlivesOriginal) {
 
 TEST_F(PlatformAudioTest, CreateSourceWithCustomOptions) {
   std::unique_ptr<PlatformAudio> platform_audio;
-  EXPECT_NO_THROW(platform_audio = std::make_unique<PlatformAudio>());
+  try {
+    platform_audio = std::make_unique<PlatformAudio>();
+  } catch (const PlatformAudioError& error) {
+    GTEST_SKIP() << "PlatformAudio unavailable: " << error.what();
+  }
 
   PlatformAudioOptions options;
   options.echo_cancellation = false;
@@ -120,7 +136,11 @@ TEST_F(PlatformAudioTest, CreateSourceWithCustomOptions) {
 
 TEST_F(PlatformAudioTest, EnumerateDevicesAndSelectWhenAvailable) {
   std::unique_ptr<PlatformAudio> platform_audio;
-  EXPECT_NO_THROW(platform_audio = std::make_unique<PlatformAudio>());
+  try {
+    platform_audio = std::make_unique<PlatformAudio>();
+  } catch (const PlatformAudioError& error) {
+    GTEST_SKIP() << "PlatformAudio unavailable: " << error.what();
+  }
 
   // Enumeration must succeed even on headless runners (it may return empty).
   std::vector<AudioDeviceInfo> recording_devices;