src/media/audio/services/device_registry/provider_server_warning_unittest.cc

// Copyright 2022 The Fuchsia 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 <fidl/fuchsia.audio.device/cpp/fidl.h>
#include <fidl/fuchsia.hardware.audio/cpp/fidl.h>

#include <gtest/gtest.h>

#include "src/media/audio/services/device_registry/adr_server_unittest_base.h"
#include "src/media/audio/services/device_registry/provider_server.h"
#include "zircon/errors.h"

namespace media_audio {
namespace {

using Provider = fuchsia_audio_device::Provider;

// These tests rely upon a single, already-created Provider.
class ProviderServerCodecWarningTest : public AudioDeviceRegistryServerTestBase {};
class ProviderServerCompositeWarningTest : public AudioDeviceRegistryServerTestBase {};
class ProviderServerDaiWarningTest : public AudioDeviceRegistryServerTestBase {};
class ProviderServerStreamConfigWarningTest : public AudioDeviceRegistryServerTestBase {};

/////////////////////
// Codec tests
//
TEST_F(ProviderServerCodecWarningTest, MissingDeviceName) {
  auto provider = CreateTestProviderServer();
  ASSERT_EQ(ProviderServer::count(), 1u);
  auto fake_driver = CreateFakeCodecOutput();
  auto received_callback = false;

  fuchsia_audio_device::ProviderAddDeviceRequest request;
  // missing .device_name
  request.device_type(fuchsia_audio_device::DeviceType::kCodec);
  request.driver_client(fuchsia_audio_device::DriverClient::WithCodec(fake_driver->Enable()));

  provider->client()
      ->AddDevice(std::move(request))
      .Then([&received_callback](fidl::Result<Provider::AddDevice>& result) {
        received_callback = true;
        ASSERT_TRUE(result.is_error());
        ASSERT_TRUE(result.error_value().is_domain_error()) << result.error_value();
        EXPECT_EQ(result.error_value().domain_error(),
                  fuchsia_audio_device::ProviderAddDeviceError::kInvalidName)
            << result.error_value();
      });

  RunLoopUntilIdle();
  EXPECT_TRUE(received_callback);
  EXPECT_EQ(adr_service()->devices().size(), 0u);
  EXPECT_EQ(adr_service()->unhealthy_devices().size(), 0u);
  EXPECT_FALSE(provider_fidl_error_status().has_value()) << *provider_fidl_error_status();
}

TEST_F(ProviderServerCodecWarningTest, EmptyDeviceName) {
  auto provider = CreateTestProviderServer();
  ASSERT_EQ(ProviderServer::count(), 1u);
  auto fake_driver = CreateFakeCodecInput();
  auto received_callback = false;

  provider->client()
      ->AddDevice({{
          .device_name = "",  // empty .device_name
          .device_type = fuchsia_audio_device::DeviceType::kCodec,
          .driver_client = fuchsia_audio_device::DriverClient::WithCodec(fake_driver->Enable()),
      }})
      .Then([&received_callback](fidl::Result<Provider::AddDevice>& result) {
        received_callback = true;
        ASSERT_TRUE(result.is_error());
        ASSERT_TRUE(result.error_value().is_domain_error()) << result.error_value();
        EXPECT_EQ(result.error_value().domain_error(),
                  fuchsia_audio_device::ProviderAddDeviceError::kInvalidName)
            << result.error_value();
      });

  RunLoopUntilIdle();
  EXPECT_TRUE(received_callback);
  EXPECT_EQ(adr_service()->devices().size(), 0u);
  EXPECT_EQ(adr_service()->unhealthy_devices().size(), 0u);
  EXPECT_FALSE(provider_fidl_error_status().has_value()) << *provider_fidl_error_status();
}

TEST_F(ProviderServerCodecWarningTest, MissingDeviceType) {
  auto provider = CreateTestProviderServer();
  ASSERT_EQ(ProviderServer::count(), 1u);
  auto fake_driver = CreateFakeCodecNoDirection();
  auto received_callback = false;

  provider->client()
      ->AddDevice({{
          .device_name = "Test device name",
          // missing .device_type
          .driver_client = fuchsia_audio_device::DriverClient::WithCodec(fake_driver->Enable()),
      }})
      .Then([&received_callback](fidl::Result<Provider::AddDevice>& result) {
        received_callback = true;
        ASSERT_TRUE(result.is_error());
        ASSERT_TRUE(result.error_value().is_domain_error()) << result.error_value();
        EXPECT_EQ(result.error_value().domain_error(),
                  fuchsia_audio_device::ProviderAddDeviceError::kInvalidType)
            << result.error_value();
      });

  RunLoopUntilIdle();
  EXPECT_TRUE(received_callback);
  EXPECT_EQ(adr_service()->devices().size(), 0u);
  EXPECT_EQ(adr_service()->unhealthy_devices().size(), 0u);
  EXPECT_FALSE(provider_fidl_error_status().has_value()) << *provider_fidl_error_status();
}

TEST_F(ProviderServerCodecWarningTest, MissingDriverClient) {
  auto provider = CreateTestProviderServer();
  ASSERT_EQ(ProviderServer::count(), 1u);
  auto received_callback = false;

  provider->client()
      ->AddDevice({{
          .device_name = "Test device name",
          .device_type = fuchsia_audio_device::DeviceType::kCodec,
          // missing .driver_client
      }})
      .Then([&received_callback](fidl::Result<Provider::AddDevice>& result) {
        received_callback = true;
        ASSERT_TRUE(result.is_error());
        ASSERT_TRUE(result.error_value().is_domain_error()) << result.error_value();
        EXPECT_EQ(result.error_value().domain_error(),
                  fuchsia_audio_device::ProviderAddDeviceError::kInvalidDriverClient)
            << result.error_value();
      });

  RunLoopUntilIdle();
  EXPECT_TRUE(received_callback);
  EXPECT_EQ(adr_service()->devices().size(), 0u);
  EXPECT_EQ(adr_service()->unhealthy_devices().size(), 0u);
  EXPECT_FALSE(provider_fidl_error_status().has_value()) << *provider_fidl_error_status();
}

TEST_F(ProviderServerCodecWarningTest, InvalidDriverClient) {
  auto provider = CreateTestProviderServer();
  ASSERT_EQ(ProviderServer::count(), 1u);
  auto received_callback = false;

  provider->client()
      ->AddDevice({{
          .device_name = "Test device name",
          .device_type = fuchsia_audio_device::DeviceType::kCodec,
          .driver_client = fuchsia_audio_device::DriverClient::WithCodec(
              fidl::ClientEnd<fuchsia_hardware_audio::Codec>()),
      }})
      .Then([&received_callback](fidl::Result<Provider::AddDevice>& result) {
        received_callback = true;
        ASSERT_TRUE(result.is_error());
        ASSERT_TRUE(result.error_value().is_framework_error()) << result.error_value();
        EXPECT_EQ(result.error_value().framework_error().status(), ZX_ERR_INVALID_ARGS)
            << result.error_value();
      });

  RunLoopUntilIdle();
  EXPECT_TRUE(received_callback);
  EXPECT_EQ(adr_service()->devices().size(), 0u);
  EXPECT_EQ(adr_service()->unhealthy_devices().size(), 0u);
  ASSERT_TRUE(provider_fidl_error_status().has_value());
  EXPECT_EQ(*provider_fidl_error_status(), ZX_ERR_INVALID_ARGS);
}

TEST_F(ProviderServerCodecWarningTest, WrongDriverClient) {
  auto provider = CreateTestProviderServer();
  ASSERT_EQ(ProviderServer::count(), 1u);
  auto fake_driver = CreateFakeStreamConfigOutput();
  auto received_callback = false;

  provider->client()
      ->AddDevice({{
          .device_name = "Test device name",
          .device_type = fuchsia_audio_device::DeviceType::kCodec,
          // StreamConfig driver_client doesn't match kCodec.
          .driver_client =
              fuchsia_audio_device::DriverClient::WithStreamConfig(fake_driver->Enable()),
      }})
      .Then([&received_callback](fidl::Result<Provider::AddDevice>& result) {
        received_callback = true;
        ASSERT_TRUE(result.is_error());
        ASSERT_TRUE(result.error_value().is_domain_error()) << result.error_value();
        EXPECT_EQ(result.error_value().domain_error(),
                  fuchsia_audio_device::ProviderAddDeviceError::kWrongClientType)
            << result.error_value();
      });

  RunLoopUntilIdle();
  EXPECT_TRUE(received_callback);
  EXPECT_EQ(adr_service()->devices().size(), 0u);
  EXPECT_EQ(adr_service()->unhealthy_devices().size(), 0u);
  EXPECT_FALSE(provider_fidl_error_status().has_value()) << *provider_fidl_error_status();
}

/////////////////////
// Composite tests
//
// Remove this test, once Provider/AddDevice supports the Composite driver type.
TEST_F(ProviderServerCompositeWarningTest, MissingDeviceName) {
  auto provider = CreateTestProviderServer();
  ASSERT_EQ(ProviderServer::count(), 1u);
  auto fake_driver = CreateFakeComposite();
  auto received_callback = false;

  fuchsia_audio_device::ProviderAddDeviceRequest request;
  // missing .device_name
  request.device_type(fuchsia_audio_device::DeviceType::kComposite);
  request.driver_client(fuchsia_audio_device::DriverClient::WithComposite(fake_driver->Enable()));

  provider->client()
      ->AddDevice(std::move(request))
      .Then([&received_callback](fidl::Result<Provider::AddDevice>& result) {
        received_callback = true;
        ASSERT_TRUE(result.is_error());
        ASSERT_TRUE(result.error_value().is_domain_error()) << result.error_value();
        EXPECT_EQ(result.error_value().domain_error(),
                  fuchsia_audio_device::ProviderAddDeviceError::kInvalidName)
            << result.error_value();
      });

  RunLoopUntilIdle();
  EXPECT_TRUE(received_callback);
  EXPECT_EQ(adr_service()->devices().size(), 0u);
  EXPECT_EQ(adr_service()->unhealthy_devices().size(), 0u);
  EXPECT_FALSE(provider_fidl_error_status().has_value()) << *provider_fidl_error_status();
}

TEST_F(ProviderServerCompositeWarningTest, EmptyDeviceName) {
  auto provider = CreateTestProviderServer();
  ASSERT_EQ(ProviderServer::count(), 1u);
  auto fake_driver = CreateFakeComposite();
  auto received_callback = false;

  provider->client()
      ->AddDevice({{
          .device_name = "",  // empty .device_name
          .device_type = fuchsia_audio_device::DeviceType::kComposite,
          .driver_client = fuchsia_audio_device::DriverClient::WithComposite(fake_driver->Enable()),
      }})
      .Then([&received_callback](fidl::Result<Provider::AddDevice>& result) {
        received_callback = true;
        ASSERT_TRUE(result.is_error());
        ASSERT_TRUE(result.error_value().is_domain_error()) << result.error_value();
        EXPECT_EQ(result.error_value().domain_error(),
                  fuchsia_audio_device::ProviderAddDeviceError::kInvalidName)
            << result.error_value();
      });

  RunLoopUntilIdle();
  EXPECT_TRUE(received_callback);
  EXPECT_EQ(adr_service()->devices().size(), 0u);
  EXPECT_EQ(adr_service()->unhealthy_devices().size(), 0u);
  EXPECT_FALSE(provider_fidl_error_status().has_value()) << *provider_fidl_error_status();
}

TEST_F(ProviderServerCompositeWarningTest, MissingDeviceType) {
  auto provider = CreateTestProviderServer();
  ASSERT_EQ(ProviderServer::count(), 1u);
  auto fake_driver = CreateFakeComposite();
  auto received_callback = false;

  provider->client()
      ->AddDevice({{
          .device_name = "Test device name",
          // missing .device_type
          .driver_client = fuchsia_audio_device::DriverClient::WithComposite(fake_driver->Enable()),
      }})
      .Then([&received_callback](fidl::Result<Provider::AddDevice>& result) {
        received_callback = true;
        ASSERT_TRUE(result.is_error());
        ASSERT_TRUE(result.error_value().is_domain_error()) << result.error_value();
        EXPECT_EQ(result.error_value().domain_error(),
                  fuchsia_audio_device::ProviderAddDeviceError::kInvalidType)
            << result.error_value();
      });

  RunLoopUntilIdle();
  EXPECT_TRUE(received_callback);
  EXPECT_EQ(adr_service()->devices().size(), 0u);
  EXPECT_EQ(adr_service()->unhealthy_devices().size(), 0u);
  EXPECT_FALSE(provider_fidl_error_status().has_value()) << *provider_fidl_error_status();
}

TEST_F(ProviderServerCompositeWarningTest, MissingDriverClient) {
  auto provider = CreateTestProviderServer();
  ASSERT_EQ(ProviderServer::count(), 1u);
  auto received_callback = false;

  provider->client()
      ->AddDevice({{
          .device_name = "Test device name",
          .device_type = fuchsia_audio_device::DeviceType::kComposite,
          // missing .driver_client
      }})
      .Then([&received_callback](fidl::Result<Provider::AddDevice>& result) {
        received_callback = true;
        ASSERT_TRUE(result.is_error());
        ASSERT_TRUE(result.error_value().is_domain_error()) << result.error_value();
        EXPECT_EQ(result.error_value().domain_error(),
                  fuchsia_audio_device::ProviderAddDeviceError::kInvalidDriverClient)
            << result.error_value();
      });

  RunLoopUntilIdle();
  EXPECT_TRUE(received_callback);
  EXPECT_EQ(adr_service()->devices().size(), 0u);
  EXPECT_EQ(adr_service()->unhealthy_devices().size(), 0u);
  EXPECT_FALSE(provider_fidl_error_status().has_value()) << *provider_fidl_error_status();
}

TEST_F(ProviderServerCompositeWarningTest, InvalidDriverClient) {
  auto provider = CreateTestProviderServer();
  ASSERT_EQ(ProviderServer::count(), 1u);
  auto received_callback = false;

  provider->client()
      ->AddDevice({{
          .device_name = "Test device name",
          .device_type = fuchsia_audio_device::DeviceType::kComposite,
          .driver_client = fuchsia_audio_device::DriverClient::WithComposite(
              fidl::ClientEnd<fuchsia_hardware_audio::Composite>()),
      }})
      .Then([&received_callback](fidl::Result<Provider::AddDevice>& result) {
        received_callback = true;
        ASSERT_TRUE(result.is_error());
        ASSERT_TRUE(result.error_value().is_framework_error()) << result.error_value();
        EXPECT_EQ(result.error_value().framework_error().status(), ZX_ERR_INVALID_ARGS)
            << result.error_value();
      });

  RunLoopUntilIdle();
  EXPECT_TRUE(received_callback);
  EXPECT_EQ(adr_service()->devices().size(), 0u);
  EXPECT_EQ(adr_service()->unhealthy_devices().size(), 0u);
  ASSERT_TRUE(provider_fidl_error_status().has_value());
  EXPECT_EQ(*provider_fidl_error_status(), ZX_ERR_INVALID_ARGS);
}

TEST_F(ProviderServerCompositeWarningTest, WrongDriverClient) {
  auto provider = CreateTestProviderServer();
  ASSERT_EQ(ProviderServer::count(), 1u);
  auto fake_driver = CreateFakeStreamConfigOutput();
  auto received_callback = false;

  provider->client()
      ->AddDevice({{
          .device_name = "Test device name",
          .device_type = fuchsia_audio_device::DeviceType::kComposite,
          // StreamConfig driver_client doesn't match kComposite.
          .driver_client =
              fuchsia_audio_device::DriverClient::WithStreamConfig(fake_driver->Enable()),
      }})
      .Then([&received_callback](fidl::Result<Provider::AddDevice>& result) {
        received_callback = true;
        ASSERT_TRUE(result.is_error());
        ASSERT_TRUE(result.error_value().is_domain_error()) << result.error_value();
        EXPECT_EQ(result.error_value().domain_error(),
                  fuchsia_audio_device::ProviderAddDeviceError::kWrongClientType)
            << result.error_value();
      });

  RunLoopUntilIdle();
  EXPECT_TRUE(received_callback);
  EXPECT_EQ(adr_service()->devices().size(), 0u);
  EXPECT_EQ(adr_service()->unhealthy_devices().size(), 0u);
  EXPECT_FALSE(provider_fidl_error_status().has_value()) << *provider_fidl_error_status();
}

/////////////////////
// Dai tests
//
// Remove this test, once Provider/AddDevice supports the Dai driver type.
TEST_F(ProviderServerDaiWarningTest, Unsupported) {
  auto provider = CreateTestProviderServer();
  ASSERT_EQ(ProviderServer::count(), 1u);
  auto fake_driver = CreateFakeStreamConfigInput();
  auto received_callback = false;

  provider->client()
      ->AddDevice({{
          .device_name = "Test device name",
          .device_type = fuchsia_audio_device::DeviceType::kDai,
          // Set a Dai device_type and driver_client -- which ADR doesn't yet support.
          .driver_client = fuchsia_audio_device::DriverClient::WithDai(
              // (as elsewhere, the zx::channel is from FakeStreamConfig, but that's irrelevant)
              fidl::ClientEnd<fuchsia_hardware_audio::Dai>(fake_driver->Enable().TakeChannel())),
      }})
      .Then([&received_callback](fidl::Result<Provider::AddDevice>& result) {
        received_callback = true;
        ASSERT_TRUE(result.is_error());
        ASSERT_TRUE(result.error_value().is_domain_error()) << result.error_value();
        EXPECT_EQ(result.error_value().domain_error(),
                  fuchsia_audio_device::ProviderAddDeviceError::kWrongClientType)
            << result.error_value();
      });

  RunLoopUntilIdle();
  EXPECT_TRUE(received_callback);
  EXPECT_EQ(adr_service()->devices().size(), 0u);
  EXPECT_EQ(adr_service()->unhealthy_devices().size(), 0u);
  EXPECT_FALSE(provider_fidl_error_status().has_value()) << *provider_fidl_error_status();
}

/////////////////////
// StreamConfig tests
//
TEST_F(ProviderServerStreamConfigWarningTest, MissingDeviceName) {
  auto provider = CreateTestProviderServer();
  ASSERT_EQ(ProviderServer::count(), 1u);
  auto fake_driver = CreateFakeStreamConfigOutput();
  auto received_callback = false;

  provider->client()
      ->AddDevice({{
          // missing .device_name
          .device_type = fuchsia_audio_device::DeviceType::kOutput,
          .driver_client =
              fuchsia_audio_device::DriverClient::WithStreamConfig(fake_driver->Enable()),
      }})
      .Then([&received_callback](fidl::Result<Provider::AddDevice>& result) {
        received_callback = true;
        ASSERT_TRUE(result.is_error());
        ASSERT_TRUE(result.error_value().is_domain_error()) << result.error_value();
        EXPECT_EQ(result.error_value().domain_error(),
                  fuchsia_audio_device::ProviderAddDeviceError::kInvalidName)
            << result.error_value();
      });

  RunLoopUntilIdle();
  EXPECT_TRUE(received_callback);
  EXPECT_EQ(adr_service()->devices().size(), 0u);
  EXPECT_EQ(adr_service()->unhealthy_devices().size(), 0u);
}

TEST_F(ProviderServerStreamConfigWarningTest, EmptyDeviceName) {
  auto provider = CreateTestProviderServer();
  ASSERT_EQ(ProviderServer::count(), 1u);
  auto fake_driver = CreateFakeStreamConfigInput();
  auto received_callback = false;

  provider->client()
      ->AddDevice({{
          .device_name = "",  // empty .device_name
          .device_type = fuchsia_audio_device::DeviceType::kInput,
          .driver_client =
              fuchsia_audio_device::DriverClient::WithStreamConfig(fake_driver->Enable()),
      }})
      .Then([&received_callback](fidl::Result<Provider::AddDevice>& result) {
        received_callback = true;
        ASSERT_TRUE(result.is_error());
        ASSERT_TRUE(result.error_value().is_domain_error()) << result.error_value();
        EXPECT_EQ(result.error_value().domain_error(),
                  fuchsia_audio_device::ProviderAddDeviceError::kInvalidName)
            << result.error_value();
      });

  RunLoopUntilIdle();
  EXPECT_TRUE(received_callback);
  EXPECT_EQ(adr_service()->devices().size(), 0u);
  EXPECT_EQ(adr_service()->unhealthy_devices().size(), 0u);
  EXPECT_FALSE(provider_fidl_error_status().has_value()) << *provider_fidl_error_status();
}

TEST_F(ProviderServerStreamConfigWarningTest, MissingDeviceType) {
  auto provider = CreateTestProviderServer();
  ASSERT_EQ(ProviderServer::count(), 1u);
  auto fake_driver = CreateFakeStreamConfigOutput();
  auto received_callback = false;

  provider->client()
      ->AddDevice({{
          .device_name = "Test device name",
          // missing .device_type
          .driver_client =
              fuchsia_audio_device::DriverClient::WithStreamConfig(fake_driver->Enable()),
      }})
      .Then([&received_callback](fidl::Result<Provider::AddDevice>& result) {
        received_callback = true;
        ASSERT_TRUE(result.is_error());
        ASSERT_TRUE(result.error_value().is_domain_error()) << result.error_value();
        EXPECT_EQ(result.error_value().domain_error(),
                  fuchsia_audio_device::ProviderAddDeviceError::kInvalidType)
            << result.error_value();
      });

  RunLoopUntilIdle();
  EXPECT_TRUE(received_callback);
  EXPECT_EQ(adr_service()->devices().size(), 0u);
  EXPECT_EQ(adr_service()->unhealthy_devices().size(), 0u);
  EXPECT_FALSE(provider_fidl_error_status().has_value()) << *provider_fidl_error_status();
}

TEST_F(ProviderServerStreamConfigWarningTest, MissingDriverClient) {
  auto provider = CreateTestProviderServer();
  ASSERT_EQ(ProviderServer::count(), 1u);
  auto received_callback = false;

  provider->client()
      ->AddDevice({{
          .device_name = "Test device name",
          .device_type = fuchsia_audio_device::DeviceType::kOutput,
          // missing .driver_client
      }})
      .Then([&received_callback](fidl::Result<Provider::AddDevice>& result) {
        received_callback = true;
        ASSERT_TRUE(result.is_error());
        ASSERT_TRUE(result.error_value().is_domain_error()) << result.error_value();
        EXPECT_EQ(result.error_value().domain_error(),
                  fuchsia_audio_device::ProviderAddDeviceError::kInvalidDriverClient)
            << result.error_value();
      });

  RunLoopUntilIdle();
  EXPECT_TRUE(received_callback);
  EXPECT_EQ(adr_service()->devices().size(), 0u);
  EXPECT_EQ(adr_service()->unhealthy_devices().size(), 0u);
  EXPECT_FALSE(provider_fidl_error_status().has_value()) << *provider_fidl_error_status();
}

TEST_F(ProviderServerStreamConfigWarningTest, InvalidDriverClient) {
  auto provider = CreateTestProviderServer();
  ASSERT_EQ(ProviderServer::count(), 1u);
  auto received_callback = false;

  provider->client()
      ->AddDevice({{
          .device_name = "Test device name",
          .device_type = fuchsia_audio_device::DeviceType::kOutput,
          .driver_client = fuchsia_audio_device::DriverClient::WithStreamConfig(
              fidl::ClientEnd<fuchsia_hardware_audio::StreamConfig>()),
      }})
      .Then([&received_callback](fidl::Result<Provider::AddDevice>& result) {
        received_callback = true;
        ASSERT_TRUE(result.is_error());
        ASSERT_TRUE(result.error_value().is_framework_error()) << result.error_value();
        EXPECT_EQ(result.error_value().framework_error().status(), ZX_ERR_INVALID_ARGS)
            << result.error_value();
      });

  RunLoopUntilIdle();
  EXPECT_TRUE(received_callback);
  EXPECT_EQ(adr_service()->devices().size(), 0u);
  EXPECT_EQ(adr_service()->unhealthy_devices().size(), 0u);
  ASSERT_TRUE(provider_fidl_error_status().has_value());
  EXPECT_EQ(*provider_fidl_error_status(), ZX_ERR_INVALID_ARGS);
}

TEST_F(ProviderServerStreamConfigWarningTest, WrongDriverClient) {
  auto provider = CreateTestProviderServer();
  ASSERT_EQ(ProviderServer::count(), 1u);
  auto fake_driver = CreateFakeCodecOutput();
  auto received_callback = false;

  provider->client()
      ->AddDevice({{
          .device_name = "Test device name",
          .device_type = fuchsia_audio_device::DeviceType::kOutput,
          // Codec driver_client doesn't match kOutput.
          .driver_client = fuchsia_audio_device::DriverClient::WithCodec(fake_driver->Enable()),
      }})
      .Then([&received_callback](fidl::Result<Provider::AddDevice>& result) {
        received_callback = true;
        ASSERT_TRUE(result.is_error());
        ASSERT_TRUE(result.error_value().is_domain_error()) << result.error_value();
        EXPECT_EQ(result.error_value().domain_error(),
                  fuchsia_audio_device::ProviderAddDeviceError::kWrongClientType)
            << result.error_value();
      });

  RunLoopUntilIdle();
  EXPECT_TRUE(received_callback);
  EXPECT_EQ(adr_service()->devices().size(), 0u);
  EXPECT_EQ(adr_service()->unhealthy_devices().size(), 0u);
  EXPECT_FALSE(provider_fidl_error_status().has_value()) << *provider_fidl_error_status();
}

}  // namespace
}  // namespace media_audio