// Copyright 2019 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 "src/media/audio/audio_core/shared/reporter.h"

#include <lib/fpromise/single_threaded_executor.h>
#include <lib/inspect/testing/cpp/inspect.h>
#include <lib/sys/cpp/component_context.h>
#include <lib/sys/cpp/testing/component_context_provider.h>

#include <optional>

#include "src/lib/fxl/strings/string_printf.h"
#include "src/lib/testing/loop_fixture/test_loop_fixture.h"
#include "src/media/audio/audio_core/shared/audio_admin.h"

namespace media::audio {
namespace {

using ::inspect::testing::BoolIs;
using ::inspect::testing::ChildrenMatch;
using ::inspect::testing::DoubleIs;
using ::inspect::testing::IntIs;
using ::inspect::testing::NameMatches;
using ::inspect::testing::NodeMatches;
using ::inspect::testing::PropertyList;
using ::inspect::testing::StringIs;
using ::inspect::testing::UintIs;
using ::testing::AllOf;
using ::testing::IsEmpty;
using ::testing::IsSupersetOf;

::testing::Matcher<const ::inspect::Hierarchy&> NodeAlive(const std::string& name) {
  return NodeMatches(
      AllOf(NameMatches(name), PropertyList(Contains(UintIs("time since death (ns)", 0)))));
}

::testing::Matcher<const ::inspect::Hierarchy&> NodeDead(const std::string& name) {
  return NodeMatches(
      AllOf(NameMatches(name), Not(PropertyList(Contains(UintIs("time since death (ns)", 0))))));
}

class ReporterTest : public gtest::TestLoopFixture {
 public:
  ReporterTest()
      : under_test_(*component_context_provider_.context(), dispatcher(), dispatcher(), false) {}

  inspect::Hierarchy GetHierarchy() {
    zx::vmo duplicate = under_test_.inspector().DuplicateVmo();
    if (duplicate.get() == ZX_HANDLE_INVALID) {
      return inspect::Hierarchy();
    }

    auto ret = inspect::ReadFromVmo(duplicate);
    EXPECT_TRUE(ret.is_ok());
    if (ret.is_ok()) {
      return ret.take_value();
    }

    return inspect::Hierarchy();
  }

  inspect::Hierarchy GetHierarchyLazyValues() {
    fpromise::result<inspect::Hierarchy> result;
    fpromise::single_threaded_executor exec;
    exec.schedule_task(
        inspect::ReadFromInspector(under_test_.inspector())
            .then([&](fpromise::result<inspect::Hierarchy>& res) { result = std::move(res); }));
    exec.run();
    EXPECT_TRUE(result.is_ok());
    return result.take_value();
  }

  sys::testing::ComponentContextProvider component_context_provider_;
  Reporter under_test_;
};

// Test reporter initial state.
TEST_F(ReporterTest, InitialState) {
  auto hierarchy = GetHierarchy();

  // Expect metrics with default values in the root node.
  EXPECT_THAT(hierarchy,
              NodeMatches(AllOf(NameMatches("root"),
                                PropertyList(IsSupersetOf({
                                    UintIs("count of failures to connect to device", 0),
                                    UintIs("count of failures to obtain device stream channel", 0),
                                    UintIs("count of failures to start a device", 0),
                                })))));

  // Expect empty child nodes for devices and client ports.
  EXPECT_THAT(
      hierarchy,
      ChildrenMatch(UnorderedElementsAre(
          AllOf(NodeMatches(AllOf(NameMatches("output devices"), PropertyList(IsEmpty()),
                                  PropertyList(IsEmpty()))),
                ChildrenMatch(IsEmpty())),
          AllOf(NodeMatches(AllOf(NameMatches("input devices"), PropertyList(IsEmpty()),
                                  PropertyList(IsEmpty()))),
                ChildrenMatch(IsEmpty())),
          AllOf(NodeMatches(AllOf(NameMatches("renderers"), PropertyList(IsEmpty()),
                                  PropertyList(IsEmpty()))),
                ChildrenMatch(IsEmpty())),
          AllOf(NodeMatches(AllOf(NameMatches("capturers"), PropertyList(IsEmpty()),
                                  PropertyList(IsEmpty()))),
                ChildrenMatch(IsEmpty())),
          AllOf(NodeMatches(
                    AllOf(NameMatches("thermal state"),
                          PropertyList(UnorderedElementsAre(UintIs("num thermal states", 1))))),
                ChildrenMatch(UnorderedElementsAre(NodeMatches(
                    AllOf(NameMatches("normal"),
                          Not(PropertyList(Contains(UintIs("total duration (ns)", 0))))))))),
          AllOf(NodeMatches(NameMatches("thermal state transitions")),
                ChildrenMatch(UnorderedElementsAre(NodeMatches(
                    AllOf(NameMatches("1"),
                          PropertyList(IsSupersetOf({
                              BoolIs("active", true),
                              StringIs("state", "normal"),
                          })),
                          Not(PropertyList(Contains(UintIs("duration (ns)", 0))))))))),
          AllOf(NodeMatches(AllOf(NameMatches("volume controls"), PropertyList(IsEmpty()),
                                  PropertyList(IsEmpty()))),
                ChildrenMatch(IsEmpty())),
          AllOf(NodeMatches(AllOf(NameMatches("active usage policies"),
                                  PropertyList(UnorderedElementsAre(
                                      DoubleIs("none gain db", 0.0), DoubleIs("duck gain db", 0.0),
                                      DoubleIs("mute gain db", 0.0))))),
                ChildrenMatch(Contains(NodeMatches(
                    AllOf(NameMatches("1"), PropertyList(Contains(BoolIs("active", true)))))))))));
}

// Test methods that update metrics in the root node.
TEST_F(ReporterTest, RootMetrics) {
  under_test_.FailedToConnectToDevice("", false, 0);
  under_test_.FailedToObtainStreamChannel("", false, 0);
  under_test_.FailedToObtainStreamChannel("", false, 0);
  under_test_.FailedToStartDevice("");
  under_test_.FailedToStartDevice("");
  under_test_.FailedToStartDevice("");

  EXPECT_THAT(GetHierarchy(),
              NodeMatches(AllOf(NameMatches("root"),
                                PropertyList(IsSupersetOf({
                                    UintIs("count of failures to connect to device", 1),
                                    UintIs("count of failures to obtain device stream channel", 2u),
                                    UintIs("count of failures to start a device", 3u),
                                })))));
}

// Test methods that add and remove devices.
TEST_F(ReporterTest, AddRemoveDevices) {
  std::vector<Reporter::Container<Reporter::OutputDevice, Reporter::kObjectsToCache>::Ptr> outputs;
  std::vector<Reporter::Container<Reporter::InputDevice, Reporter::kObjectsToCache>::Ptr> inputs;
  for (size_t k = 0; k < 5; k++) {
    outputs.push_back(under_test_.CreateOutputDevice(fxl::StringPrintf("output_device_%lu", k),
                                                     fxl::StringPrintf("output_thread_%lu", k)));
  }
  for (size_t k = 0; k < 5; k++) {
    inputs.push_back(under_test_.CreateInputDevice(fxl::StringPrintf("input_device_%lu", k),
                                                   fxl::StringPrintf("input_thread_%lu", k)));
  }

  EXPECT_THAT(GetHierarchyLazyValues(),
              ChildrenMatch(IsSupersetOf({
                  AllOf(NodeMatches(NameMatches("output devices")),
                        ChildrenMatch(UnorderedElementsAre(
                            NodeAlive("output_device_0"), NodeAlive("output_device_1"),
                            NodeAlive("output_device_2"), NodeAlive("output_device_3"),
                            NodeAlive("output_device_4")))),
                  AllOf(NodeMatches(NameMatches("input devices")),
                        ChildrenMatch(UnorderedElementsAre(
                            NodeAlive("input_device_0"), NodeAlive("input_device_1"),
                            NodeAlive("input_device_2"), NodeAlive("input_device_3"),
                            NodeAlive("input_device_4")))),
              })));

  outputs[0].Drop();
  outputs[1].Drop();
  outputs[2].Drop();
  outputs[3].Drop();
  inputs[0].Drop();
  inputs[1].Drop();
  inputs[2].Drop();
  inputs[3].Drop();

  EXPECT_THAT(GetHierarchyLazyValues(),
              ChildrenMatch(IsSupersetOf({
                  AllOf(NodeMatches(NameMatches("output devices")),
                        ChildrenMatch(UnorderedElementsAre(
                            NodeDead("output_device_0"), NodeDead("output_device_1"),
                            NodeDead("output_device_2"), NodeDead("output_device_3"),
                            NodeAlive("output_device_4")))),
                  AllOf(NodeMatches(NameMatches("input devices")),
                        ChildrenMatch(UnorderedElementsAre(
                            NodeDead("input_device_0"), NodeDead("input_device_1"),
                            NodeDead("input_device_2"), NodeDead("input_device_3"),
                            NodeAlive("input_device_4")))),
              })));

  outputs[4].Drop();
  inputs[4].Drop();

  // Garbage collect [0].
  EXPECT_THAT(GetHierarchyLazyValues(),
              ChildrenMatch(IsSupersetOf({
                  AllOf(NodeMatches(NameMatches("output devices")),
                        ChildrenMatch(UnorderedElementsAre(
                            NodeDead("output_device_1"), NodeDead("output_device_2"),
                            NodeDead("output_device_3"), NodeDead("output_device_4")))),
                  AllOf(NodeMatches(NameMatches("input devices")),
                        ChildrenMatch(UnorderedElementsAre(
                            NodeDead("input_device_1"), NodeDead("input_device_2"),
                            NodeDead("input_device_3"), NodeDead("input_device_4")))),
              })));
}

// Test methods that change device metrics.
TEST_F(ReporterTest, DeviceMetrics) {
  auto output_device = under_test_.CreateOutputDevice("output_device", "output_thread");
  auto input_device = under_test_.CreateInputDevice("input_device", "input_thread");

  // Note: GetHierachy uses ReadFromVmo, which cannot read lazy values.
  EXPECT_THAT(
      GetHierarchy(),
      ChildrenMatch(UnorderedElementsAre(
          AllOf(NodeMatches(NameMatches("output devices")),
                ChildrenMatch(UnorderedElementsAre(AllOf(
                    NodeMatches(AllOf(NameMatches("output_device"),
                                      PropertyList(UnorderedElementsAre(
                                          StringIs("mixer thread name", "output_thread"))))),
                    ChildrenMatch(UnorderedElementsAre(
                        NodeMatches(AllOf(NameMatches("driver"),
                                          PropertyList(UnorderedElementsAre(
                                              UintIs("initial internal delay (ns)", 0),
                                              UintIs("current internal delay (ns)", 0),
                                              IntIs("time of latest internal delay change", 0),
                                              UintIs("initial external delay (ns)", 0),
                                              UintIs("current external delay (ns)", 0),
                                              IntIs("time of latest external delay change", 0),
                                              UintIs("driver transfer (bytes)", 0),
                                              StringIs("name", "unknown"))))),
                        NodeMatches(AllOf(
                            NameMatches("format"),
                            PropertyList(UnorderedElementsAre(StringIs("sample format", "unknown"),
                                                              UintIs("channels", 0),
                                                              UintIs("frames per second", 0))))),
                        NodeMatches(AllOf(
                            NameMatches("device gain"),
                            PropertyList(UnorderedElementsAre(
                                DoubleIs("gain db", 0.0), BoolIs("muted", false),
                                BoolIs("agc supported", false), BoolIs("agc enabled", false))))),
                        NodeMatches(AllOf(NameMatches("device underflows"),
                                          PropertyList(UnorderedElementsAre(
                                              UintIs("count", 0), UintIs("duration (ns)", 0),
                                              UintIs("session count", 0))))),
                        NodeMatches(AllOf(NameMatches("pipeline underflows"),
                                          PropertyList(UnorderedElementsAre(
                                              UintIs("count", 0), UintIs("duration (ns)", 0),
                                              UintIs("session count", 0))))))))))),
          AllOf(NodeMatches(NameMatches("input devices")),
                ChildrenMatch(UnorderedElementsAre(AllOf(
                    NodeMatches(AllOf(NameMatches("input_device"),
                                      PropertyList(UnorderedElementsAre(
                                          StringIs("mixer thread name", "input_thread"))))),
                    ChildrenMatch(UnorderedElementsAre(
                        NodeMatches(AllOf(NameMatches("driver"),
                                          PropertyList(UnorderedElementsAre(
                                              UintIs("initial internal delay (ns)", 0),
                                              UintIs("current internal delay (ns)", 0),
                                              IntIs("time of latest internal delay change", 0),
                                              UintIs("initial external delay (ns)", 0),
                                              UintIs("current external delay (ns)", 0),
                                              IntIs("time of latest external delay change", 0),
                                              UintIs("driver transfer (bytes)", 0),
                                              StringIs("name", "unknown"))))),
                        NodeMatches(AllOf(
                            NameMatches("format"),
                            PropertyList(UnorderedElementsAre(StringIs("sample format", "unknown"),
                                                              UintIs("channels", 0),
                                                              UintIs("frames per second", 0))))),
                        NodeMatches(AllOf(NameMatches("device gain"),
                                          PropertyList(UnorderedElementsAre(
                                              DoubleIs("gain db", 0.0), BoolIs("muted", false),
                                              BoolIs("agc supported", false),
                                              BoolIs("agc enabled", false))))))))))),
          AllOf(NodeMatches(NameMatches("renderers")), ChildrenMatch(IsEmpty())),
          AllOf(NodeMatches(NameMatches("capturers")), ChildrenMatch(IsEmpty())),
          AllOf(NodeMatches(
                    AllOf(NameMatches("thermal state"),
                          PropertyList(UnorderedElementsAre(UintIs("num thermal states", 1))))),
                ChildrenMatch(UnorderedElementsAre(NodeMatches(
                    AllOf(NameMatches("normal"),
                          Not(PropertyList(Contains(UintIs("total duration (ns)", 0))))))))),
          AllOf(NodeMatches(NameMatches("thermal state transitions")),
                ChildrenMatch(UnorderedElementsAre(NodeMatches(
                    AllOf(NameMatches("1"),
                          PropertyList(IsSupersetOf({
                              BoolIs("active", true),
                              StringIs("state", "normal"),
                          })),
                          Not(PropertyList(Contains(UintIs("duration (ns)", 0))))))))),
          AllOf(NodeMatches(NameMatches("volume controls")), ChildrenMatch(IsEmpty())),
          AllOf(NodeMatches(AllOf(NameMatches("active usage policies"),
                                  PropertyList(UnorderedElementsAre(
                                      DoubleIs("none gain db", 0.0), DoubleIs("duck gain db", 0.0),
                                      DoubleIs("mute gain db", 0.0))))),
                ChildrenMatch(Contains(NodeMatches(
                    AllOf(NameMatches("1"), PropertyList(Contains(BoolIs("active", true)))))))))));

  output_device->StartSession(zx::time(0));
  output_device->DeviceUnderflow(zx::time(10), zx::time(15));
  output_device->DeviceUnderflow(zx::time(25), zx::time(30));
  output_device->StopSession(zx::time(50));
  output_device->StartSession(zx::time(90));
  output_device->DeviceUnderflow(zx::time(91), zx::time(92));
  output_device->PipelineUnderflow(zx::time(93), zx::time(96));
  output_device->StopSession(zx::time(100));

  EXPECT_THAT(
      GetHierarchy(),
      ChildrenMatch(Contains(AllOf(
          NodeMatches(NameMatches("output devices")),
          ChildrenMatch(Contains(ChildrenMatch(IsSupersetOf({
              NodeMatches(AllOf(
                  NameMatches("device underflows"),
                  PropertyList(UnorderedElementsAre(UintIs("count", 3), UintIs("duration (ns)", 11),
                                                    UintIs("session count", 2))))),
              NodeMatches(AllOf(
                  NameMatches("pipeline underflows"),
                  PropertyList(UnorderedElementsAre(UintIs("count", 1), UintIs("duration (ns)", 3),
                                                    UintIs("session count", 2))))),
          }))))))));
}

// Test method Device::SetGainInfo.
TEST_F(ReporterTest, DeviceSetGainInfo) {
  auto output_device = under_test_.CreateOutputDevice("output_device", "output_thread");

  // Expect initial device metric values.
  EXPECT_THAT(
      GetHierarchy(),
      ChildrenMatch(UnorderedElementsAre(
          AllOf(NodeMatches(NameMatches("output devices")),
                ChildrenMatch(UnorderedElementsAre(AllOf(
                    NodeMatches(AllOf(NameMatches("output_device"),
                                      PropertyList(UnorderedElementsAre(
                                          StringIs("mixer thread name", "output_thread"))))),
                    ChildrenMatch(Contains(NodeMatches(AllOf(
                        NameMatches("device gain"),
                        PropertyList(UnorderedElementsAre(
                            DoubleIs("gain db", 0.0), BoolIs("muted", false),
                            BoolIs("agc supported", false), BoolIs("agc enabled", false))))))))))),
          AllOf(NodeMatches(NameMatches("input devices")), ChildrenMatch(IsEmpty())),
          AllOf(NodeMatches(NameMatches("renderers")), ChildrenMatch(IsEmpty())),
          AllOf(NodeMatches(NameMatches("capturers")), ChildrenMatch(IsEmpty())),
          AllOf(NodeMatches(
                    AllOf(NameMatches("thermal state"),
                          PropertyList(UnorderedElementsAre(UintIs("num thermal states", 1))))),
                ChildrenMatch(UnorderedElementsAre(NodeMatches(
                    AllOf(NameMatches("normal"),
                          Not(PropertyList(Contains(UintIs("total duration (ns)", 0))))))))),
          AllOf(NodeMatches(NameMatches("thermal state transitions")),
                ChildrenMatch(UnorderedElementsAre(NodeMatches(
                    AllOf(NameMatches("1"),
                          PropertyList(IsSupersetOf({
                              BoolIs("active", true),
                              StringIs("state", "normal"),
                          })),
                          Not(PropertyList(Contains(UintIs("duration (ns)", 0))))))))),
          AllOf(NodeMatches(NameMatches("volume controls")), ChildrenMatch(IsEmpty())),
          AllOf(NodeMatches(AllOf(NameMatches("active usage policies"),
                                  PropertyList(UnorderedElementsAre(
                                      DoubleIs("none gain db", 0.0), DoubleIs("duck gain db", 0.0),
                                      DoubleIs("mute gain db", 0.0))))),
                ChildrenMatch(Contains(NodeMatches(
                    AllOf(NameMatches("1"), PropertyList(Contains(BoolIs("active", true)))))))))));

  fuchsia::media::AudioGainInfo gain_info_a{
      .gain_db = -1.0f,
      .flags = fuchsia::media::AudioGainInfoFlags::MUTE |
               fuchsia::media::AudioGainInfoFlags::AGC_SUPPORTED |
               fuchsia::media::AudioGainInfoFlags::AGC_ENABLED};

  output_device->SetGainInfo(gain_info_a, {});

  // Expect initial device metric values to remain, since no AudioGainValidFlags were set.
  EXPECT_THAT(
      GetHierarchy(),
      ChildrenMatch(Contains(AllOf(
          NodeMatches(NameMatches("output devices")),
          ChildrenMatch(UnorderedElementsAre(AllOf(
              NodeMatches(NameMatches("output_device")),
              ChildrenMatch(Contains(NodeMatches(AllOf(
                  NameMatches("device gain"),
                  PropertyList(UnorderedElementsAre(
                      DoubleIs("gain db", 0.0), BoolIs("muted", false),
                      BoolIs("agc supported", false), BoolIs("agc enabled", false))))))))))))));

  output_device->SetGainInfo(gain_info_a, fuchsia::media::AudioGainValidFlags::GAIN_VALID);

  // Expect a gain change.
  EXPECT_THAT(
      GetHierarchy(),
      ChildrenMatch(Contains(AllOf(
          NodeMatches(NameMatches("output devices")),
          ChildrenMatch(UnorderedElementsAre(AllOf(
              NodeMatches(NameMatches("output_device")),
              ChildrenMatch(Contains(NodeMatches(AllOf(
                  NameMatches("device gain"),
                  PropertyList(UnorderedElementsAre(
                      DoubleIs("gain db", -1.0), BoolIs("muted", false),
                      BoolIs("agc supported", false), BoolIs("agc enabled", false))))))))))))));

  output_device->SetGainInfo(gain_info_a, fuchsia::media::AudioGainValidFlags::MUTE_VALID);

  // Expect a mute change.
  EXPECT_THAT(
      GetHierarchy(),
      ChildrenMatch(Contains(AllOf(
          NodeMatches(NameMatches("output devices")),
          ChildrenMatch(UnorderedElementsAre(AllOf(
              NodeMatches(NameMatches("output_device")),
              ChildrenMatch(Contains(NodeMatches(AllOf(
                  NameMatches("device gain"),
                  PropertyList(UnorderedElementsAre(
                      DoubleIs("gain db", -1.0), BoolIs("muted", true),
                      BoolIs("agc supported", false), BoolIs("agc enabled", false))))))))))))));

  output_device->SetGainInfo(gain_info_a, fuchsia::media::AudioGainValidFlags::AGC_VALID);

  // Expect an AGC change.
  EXPECT_THAT(
      GetHierarchy(),
      ChildrenMatch(Contains(
          AllOf(NodeMatches(NameMatches("output devices")),
                ChildrenMatch(UnorderedElementsAre(AllOf(
                    NodeMatches(NameMatches("output_device")),
                    ChildrenMatch(Contains(NodeMatches(AllOf(
                        NameMatches("device gain"),
                        PropertyList(UnorderedElementsAre(
                            DoubleIs("gain db", -1.0), BoolIs("muted", true),
                            BoolIs("agc supported", true), BoolIs("agc enabled", true))))))))))))));

  fuchsia::media::AudioGainInfo gain_info_b{
      .gain_db = -2.0f, .flags = fuchsia::media::AudioGainInfoFlags::AGC_SUPPORTED};
  output_device->SetGainInfo(gain_info_b, fuchsia::media::AudioGainValidFlags::GAIN_VALID |
                                              fuchsia::media::AudioGainValidFlags::MUTE_VALID |
                                              fuchsia::media::AudioGainValidFlags::AGC_VALID);

  // Expect all changes.
  EXPECT_THAT(
      GetHierarchy(),
      ChildrenMatch(Contains(AllOf(
          NodeMatches(NameMatches("output devices")),
          ChildrenMatch(UnorderedElementsAre(AllOf(
              NodeMatches(NameMatches("output_device")),
              ChildrenMatch(Contains(NodeMatches(AllOf(
                  NameMatches("device gain"),
                  PropertyList(UnorderedElementsAre(
                      DoubleIs("gain db", -2.0), BoolIs("muted", false),
                      BoolIs("agc supported", true), BoolIs("agc enabled", false))))))))))))));
}

// Test the method that updates the delays reported by the device.
TEST_F(ReporterTest, DeviceDelays) {
  auto output_device = under_test_.CreateOutputDevice("output_device", "output_thread");
  auto input_device = under_test_.CreateInputDevice("input_device", "input_thread");

  EXPECT_THAT(
      GetHierarchy(),
      ChildrenMatch(IsSupersetOf({
          AllOf(NodeMatches(NameMatches("output devices")),
                ChildrenMatch(UnorderedElementsAre(AllOf(
                    NodeMatches(NameMatches("output_device")),
                    ChildrenMatch(IsSupersetOf({
                        NodeMatches(AllOf(NameMatches("driver"),
                                          PropertyList(UnorderedElementsAre(
                                              UintIs("initial internal delay (ns)", 0),
                                              UintIs("current internal delay (ns)", 0),
                                              IntIs("time of latest internal delay change", 0),
                                              UintIs("initial external delay (ns)", 0),
                                              UintIs("current external delay (ns)", 0),
                                              IntIs("time of latest external delay change", 0),
                                              UintIs("driver transfer (bytes)", 0),
                                              StringIs("name", "unknown"))))),
                    })))))),
          AllOf(NodeMatches(NameMatches("input devices")),
                ChildrenMatch(UnorderedElementsAre(AllOf(
                    NodeMatches(NameMatches("input_device")),
                    ChildrenMatch(IsSupersetOf({
                        NodeMatches(AllOf(NameMatches("driver"),
                                          PropertyList(UnorderedElementsAre(
                                              UintIs("initial internal delay (ns)", 0),
                                              UintIs("current internal delay (ns)", 0),
                                              IntIs("time of latest internal delay change", 0),
                                              UintIs("initial external delay (ns)", 0),
                                              UintIs("current external delay (ns)", 0),
                                              IntIs("time of latest external delay change", 0),
                                              UintIs("driver transfer (bytes)", 0),
                                              StringIs("name", "unknown"))))),
                    })))))),
      })));

  // For output device, update internal delay; external delay is unknown (and thus not updated).
  const auto kChangeTime1 = 7654321ull;
  const auto kIntDelay1 = 4321ull;
  // For input device, update internal and external delays.
  const auto kChangeTime2 = 1234ull;
  const auto kIntDelay2 = 1234567ull;
  const auto kExtDelay2 = 654321ull;

  output_device->UpdateDelays(zx::time(kChangeTime1), zx::nsec(kIntDelay1), std::nullopt);
  input_device->UpdateDelays(zx::time(kChangeTime2), zx::nsec(kIntDelay2), zx::nsec(kExtDelay2));

  EXPECT_THAT(
      GetHierarchy(),
      ChildrenMatch(IsSupersetOf({
          AllOf(
              NodeMatches(NameMatches("output devices")),
              ChildrenMatch(UnorderedElementsAre(AllOf(
                  NodeMatches(NameMatches("output_device")),
                  ChildrenMatch(IsSupersetOf({
                      NodeMatches(AllOf(
                          NameMatches("driver"),
                          PropertyList(UnorderedElementsAre(
                              UintIs("initial internal delay (ns)", 0),
                              UintIs("current internal delay (ns)", kIntDelay1),
                              IntIs("time of latest internal delay change", kChangeTime1),
                              UintIs("initial external delay (ns)", 0),
                              UintIs("current external delay (ns)", 0),
                              IntIs("time of latest external delay change", 0),
                              UintIs("driver transfer (bytes)", 0), StringIs("name", "unknown"))))),
                  })))))),
          AllOf(
              NodeMatches(NameMatches("input devices")),
              ChildrenMatch(UnorderedElementsAre(AllOf(
                  NodeMatches(NameMatches("input_device")),
                  ChildrenMatch(IsSupersetOf({
                      NodeMatches(AllOf(
                          NameMatches("driver"),
                          PropertyList(UnorderedElementsAre(
                              UintIs("initial internal delay (ns)", 0),
                              UintIs("current internal delay (ns)", kIntDelay2),
                              IntIs("time of latest internal delay change", kChangeTime2),
                              UintIs("initial external delay (ns)", 0),
                              UintIs("current external delay (ns)", kExtDelay2),
                              IntIs("time of latest external delay change", kChangeTime2),
                              UintIs("driver transfer (bytes)", 0), StringIs("name", "unknown"))))),
                  })))))),
      })));

  // For output, update both delays at a time less than previous change. Internal delay should not
  // change, but external delay should (its most recent value is the initial value at time 0).
  const auto kChangeTime3 = 654321ull;  // < kChangeTime1
  const auto kIntDelay3 = 54321ull;
  const auto kExtDelay3 = 12345ull;
  // For input, update internal delay only.
  const auto kChangeTime4 = 12345678ull;
  const auto kIntDelay4 = 123456ull;

  output_device->UpdateDelays(zx::time(kChangeTime3), zx::nsec(kIntDelay3), zx::nsec(kExtDelay3));
  input_device->UpdateDelays(zx::time(kChangeTime4), zx::nsec(kIntDelay4), std::nullopt);

  EXPECT_THAT(
      GetHierarchy(),
      ChildrenMatch(IsSupersetOf({
          AllOf(
              NodeMatches(NameMatches("output devices")),
              ChildrenMatch(UnorderedElementsAre(AllOf(
                  NodeMatches(NameMatches("output_device")),
                  ChildrenMatch(IsSupersetOf({
                      NodeMatches(AllOf(
                          NameMatches("driver"),
                          PropertyList(UnorderedElementsAre(
                              UintIs("initial internal delay (ns)", 0),
                              UintIs("current internal delay (ns)", kIntDelay1),
                              IntIs("time of latest internal delay change", kChangeTime1),
                              UintIs("initial external delay (ns)", 0),
                              UintIs("current external delay (ns)", kExtDelay3),
                              IntIs("time of latest external delay change", kChangeTime3),
                              UintIs("driver transfer (bytes)", 0), StringIs("name", "unknown"))))),
                  })))))),
          AllOf(
              NodeMatches(NameMatches("input devices")),
              ChildrenMatch(UnorderedElementsAre(AllOf(
                  NodeMatches(NameMatches("input_device")),
                  ChildrenMatch(IsSupersetOf({
                      NodeMatches(AllOf(
                          NameMatches("driver"),
                          PropertyList(UnorderedElementsAre(
                              UintIs("initial internal delay (ns)", 0),
                              UintIs("current internal delay (ns)", kIntDelay4),
                              IntIs("time of latest internal delay change", kChangeTime4),
                              UintIs("initial external delay (ns)", 0),
                              UintIs("current external delay (ns)", kExtDelay2),
                              IntIs("time of latest external delay change", kChangeTime2),
                              UintIs("driver transfer (bytes)", 0), StringIs("name", "unknown"))))),
                  })))))),
      })));
}

// Test methods that add and remove client ports.
TEST_F(ReporterTest, AddRemoveClientPorts) {
  std::vector<Reporter::Container<Reporter::Renderer, Reporter::kObjectsToCache>::Ptr> renderers;
  std::vector<Reporter::Container<Reporter::Capturer, Reporter::kObjectsToCache>::Ptr> capturers;
  for (size_t k = 0; k < 5; k++) {
    renderers.push_back(under_test_.CreateRenderer());
  }
  for (size_t k = 0; k < 5; k++) {
    capturers.push_back(under_test_.CreateCapturer(fxl::StringPrintf("capture_thread_%lu", k)));
  }

  EXPECT_THAT(
      GetHierarchyLazyValues(),
      ChildrenMatch(IsSupersetOf({
          AllOf(NodeMatches(NameMatches("renderers")),
                ChildrenMatch(UnorderedElementsAre(NodeAlive("1"), NodeAlive("2"), NodeAlive("3"),
                                                   NodeAlive("4"), NodeAlive("5")))),
          AllOf(NodeMatches(NameMatches("capturers")),
                ChildrenMatch(UnorderedElementsAre(NodeAlive("1"), NodeAlive("2"), NodeAlive("3"),
                                                   NodeAlive("4"), NodeAlive("5")))),
      })));

  renderers[0].Drop();
  renderers[1].Drop();
  renderers[2].Drop();
  renderers[3].Drop();
  capturers[0].Drop();
  capturers[1].Drop();
  capturers[2].Drop();
  capturers[3].Drop();

  EXPECT_THAT(
      GetHierarchyLazyValues(),
      ChildrenMatch(IsSupersetOf({
          AllOf(NodeMatches(NameMatches("renderers")),
                ChildrenMatch(UnorderedElementsAre(NodeDead("1"), NodeDead("2"), NodeDead("3"),
                                                   NodeDead("4"), NodeAlive("5")))),
          AllOf(NodeMatches(NameMatches("capturers")),
                ChildrenMatch(UnorderedElementsAre(NodeDead("1"), NodeDead("2"), NodeDead("3"),
                                                   NodeDead("4"), NodeAlive("5")))),
      })));

  renderers[4].Drop();
  capturers[4].Drop();

  // Garbage collect [0].
  EXPECT_THAT(GetHierarchyLazyValues(),
              ChildrenMatch(IsSupersetOf({
                  AllOf(NodeMatches(NameMatches("renderers")),
                        ChildrenMatch(UnorderedElementsAre(NodeDead("2"), NodeDead("3"),
                                                           NodeDead("4"), NodeDead("5")))),
                  AllOf(NodeMatches(NameMatches("capturers")),
                        ChildrenMatch(UnorderedElementsAre(NodeDead("2"), NodeDead("3"),
                                                           NodeDead("4"), NodeDead("5")))),
              })));
}

// Tests methods that change renderer metrics, that aren't tested in other cases.
TEST_F(ReporterTest, RendererMetrics) {
  auto renderer = under_test_.CreateRenderer();

  EXPECT_THAT(
      GetHierarchy(),
      ChildrenMatch(Contains(AllOf(
          NodeMatches(NameMatches("renderers")),
          ChildrenMatch(UnorderedElementsAre(AllOf(
              NodeMatches(AllOf(NameMatches("1"),
                                PropertyList(UnorderedElementsAre(
                                    UintIs("initial min lead time (ns)", 0),
                                    UintIs("current min lead time (ns)", 0),
                                    IntIs("time of latest min lead time change", 0),
                                    StringIs("usage", "default"))))),
              ChildrenMatch(UnorderedElementsAre(
                  NodeMatches(AllOf(NameMatches("format"),
                                    PropertyList(UnorderedElementsAre(
                                        StringIs("sample format", "unknown"), UintIs("channels", 0),
                                        UintIs("frames per second", 0))))),
                  NodeMatches(
                      AllOf(NameMatches("gain"),
                            PropertyList(UnorderedElementsAre(
                                DoubleIs("gain db", 0.0), BoolIs("muted", false),
                                UintIs("calls to SetGainWithRamp", 0),
                                DoubleIs("complete stream gain (post-volume) dbfs", 0.0))))),
                  NodeMatches(AllOf(NameMatches("presentation timestamps"),
                                    PropertyList(UnorderedElementsAre(
                                        DoubleIs("pts continuity threshold (s)", 0.0),
                                        UintIs("pts units denominator", 1),
                                        UintIs("pts units numerator", 1'000'000'000))))),
                  AllOf(NodeMatches(NameMatches("payload buffers")), ChildrenMatch(IsEmpty())),
                  NodeMatches(AllOf(NameMatches("packet queue underflows"),
                                    PropertyList(UnorderedElementsAre(
                                        UintIs("count", 0), UintIs("duration (ns)", 0),
                                        UintIs("session count", 0))))),
                  NodeMatches(AllOf(NameMatches("continuity underflows"),
                                    PropertyList(UnorderedElementsAre(
                                        UintIs("count", 0), UintIs("duration (ns)", 0),
                                        UintIs("session count", 0))))),
                  NodeMatches(AllOf(NameMatches("timestamp underflows"),
                                    PropertyList(UnorderedElementsAre(
                                        UintIs("count", 0), UintIs("duration (ns)", 0),
                                        UintIs("session count", 0))))))))))))));

  renderer->SetUsage(RenderUsage::MEDIA);
  renderer->SetFormat(
      Format::Create({
                         .sample_format = fuchsia::media::AudioSampleFormat::SIGNED_16,
                         .channels = 2,
                         .frames_per_second = 48000,
                     })
          .take_value());

  renderer->AddPayloadBuffer(0, 4096);
  renderer->AddPayloadBuffer(10, 8192);
  renderer->SendPacket(fuchsia::media::StreamPacket{
      .payload_buffer_id = 10,
  });

  renderer->SetGain(-1.0);
  renderer->SetMute(true);
  renderer->SetGainWithRamp(-1.0, zx::sec(1), fuchsia::media::audio::RampType::SCALE_LINEAR);
  renderer->SetGainWithRamp(-1.0, zx::sec(1), fuchsia::media::audio::RampType::SCALE_LINEAR);
  renderer->SetCompleteGain(-6.0);

  renderer->SetPtsContinuityThreshold(5.0);
  renderer->SetPtsUnits(1234567, 3);

  renderer->StartSession(zx::time(0));

  renderer->PacketQueueUnderflow(zx::time(10), zx::time(15));

  renderer->ContinuityUnderflow(zx::time(20), zx::time(30));
  renderer->ContinuityUnderflow(zx::time(40), zx::time(50));

  renderer->TimestampUnderflow(zx::time(0), zx::time(15));
  renderer->TimestampUnderflow(zx::time(30), zx::time(45));
  renderer->TimestampUnderflow(zx::time(60), zx::time(75));

  renderer->StopSession(zx::time(100));

  EXPECT_THAT(
      GetHierarchy(),
      ChildrenMatch(Contains(AllOf(
          NodeMatches(NameMatches("renderers")),
          ChildrenMatch(UnorderedElementsAre(AllOf(
              NodeMatches(AllOf(NameMatches("1"),
                                PropertyList(UnorderedElementsAre(
                                    UintIs("initial min lead time (ns)", 0),
                                    UintIs("current min lead time (ns)", 0),
                                    IntIs("time of latest min lead time change", 0),
                                    StringIs("usage", "RenderUsage::MEDIA"))))),
              ChildrenMatch(UnorderedElementsAre(
                  NodeMatches(AllOf(
                      NameMatches("format"),
                      PropertyList(UnorderedElementsAre(
                          StringIs("sample format", "SIGNED_16"), UintIs("channels", 2),
                          UintIs("frames per second", 48000))))),
                  NodeMatches(AllOf(
                      NameMatches("gain"),
                      PropertyList(UnorderedElementsAre(
                          DoubleIs("gain db", -1.0), BoolIs("muted", true),
                          UintIs("calls to SetGainWithRamp", 2),
                          DoubleIs("complete stream gain (post-volume) dbfs", -6.0))))),
                  NodeMatches(AllOf(NameMatches("presentation timestamps"),
                                    PropertyList(UnorderedElementsAre(
                                        DoubleIs("pts continuity threshold (s)", 5.0),
                                        UintIs("pts units denominator", 3),
                                        UintIs("pts units numerator", 1234567))))),
                  AllOf(NodeMatches(NameMatches("payload buffers")),
                        ChildrenMatch(UnorderedElementsAre(
                            NodeMatches(AllOf(NameMatches("0"),
                                              PropertyList(UnorderedElementsAre(
                                                  UintIs("size", 4096), UintIs("packets", 0))))),
                            NodeMatches(AllOf(NameMatches("10"),
                                              PropertyList(UnorderedElementsAre(
                                                  UintIs("size", 8192), UintIs("packets", 1)))))))),
                  NodeMatches(AllOf(NameMatches("packet queue underflows"),
                                    PropertyList(UnorderedElementsAre(
                                        UintIs("count", 1), UintIs("duration (ns)", 5),
                                        UintIs("session count", 1))))),
                  NodeMatches(AllOf(NameMatches("continuity underflows"),
                                    PropertyList(UnorderedElementsAre(
                                        UintIs("count", 2), UintIs("duration (ns)", 20),
                                        UintIs("session count", 1))))),
                  NodeMatches(AllOf(NameMatches("timestamp underflows"),
                                    PropertyList(UnorderedElementsAre(
                                        UintIs("count", 3), UintIs("duration (ns)", 45),
                                        UintIs("session count", 1))))))))))))));
}

// Tests methods that change renderer minimum lead time metrics.
TEST_F(ReporterTest, RendererMinLeadTime) {
  auto renderer = under_test_.CreateRenderer();
  EXPECT_THAT(GetHierarchy(),
              ChildrenMatch(Contains(
                  AllOf(NodeMatches(NameMatches("renderers")),
                        ChildrenMatch(UnorderedElementsAre(NodeMatches(AllOf(
                            NameMatches("1"), PropertyList(IsSupersetOf({
                                                  UintIs("initial min lead time (ns)", 0),
                                                  UintIs("current min lead time (ns)", 0),
                                                  IntIs("time of latest min lead time change", 0),
                                              }))))))))));

  // SetInitialMinLeadTime is optional; UpdateMinLeadTime can be called immediately.
  constexpr auto kCurrentMinLeadTime1 = 321ull;
  constexpr auto kTimeOfMinLeadTimeChange1 = 123ll;
  renderer->UpdateMinLeadTime(zx::nsec(kCurrentMinLeadTime1), zx::time(kTimeOfMinLeadTimeChange1));
  EXPECT_THAT(GetHierarchy(),
              ChildrenMatch(Contains(AllOf(
                  NodeMatches(NameMatches("renderers")),
                  ChildrenMatch(UnorderedElementsAre(NodeMatches(AllOf(
                      NameMatches("1"),
                      PropertyList(IsSupersetOf({
                          UintIs("initial min lead time (ns)", 0),  // Retains value from ctor
                          UintIs("current min lead time (ns)", kCurrentMinLeadTime1),
                          IntIs("time of latest min lead time change", kTimeOfMinLeadTimeChange1),
                      }))))))))));

  // We expect the initial and current values to change, and the time-of-update to be reset.
  constexpr auto kInitialMinLeadTime2 = 1'000'000ull;
  renderer->SetInitialMinLeadTime(zx::nsec(kInitialMinLeadTime2));
  EXPECT_THAT(
      GetHierarchy(),
      ChildrenMatch(Contains(AllOf(
          NodeMatches(NameMatches("renderers")),
          ChildrenMatch(UnorderedElementsAre(NodeMatches(AllOf(
              NameMatches("1"), PropertyList(IsSupersetOf({
                                    UintIs("initial min lead time (ns)", kInitialMinLeadTime2),
                                    UintIs("current min lead time (ns)", kInitialMinLeadTime2),
                                    IntIs("time of latest min lead time change", 0),  // Was reset
                                }))))))))));

  // We expect the current value and time-of-update value to change.
  constexpr auto kCurrentMinLeadTime3 = 12'345'678ull;
  constexpr auto kTimeOfMinLeadTimeChange3 = 987'654'321ll;
  renderer->UpdateMinLeadTime(zx::nsec(kCurrentMinLeadTime3), zx::time(kTimeOfMinLeadTimeChange3));
  EXPECT_THAT(GetHierarchy(),
              ChildrenMatch(Contains(AllOf(
                  NodeMatches(NameMatches("renderers")),
                  ChildrenMatch(UnorderedElementsAre(NodeMatches(AllOf(
                      NameMatches("1"),
                      PropertyList(IsSupersetOf({
                          UintIs("initial min lead time (ns)", kInitialMinLeadTime2),
                          UintIs("current min lead time (ns)", kCurrentMinLeadTime3),
                          IntIs("time of latest min lead time change", kTimeOfMinLeadTimeChange3),
                      }))))))))));

  // The time-of-update is before the previous one, so we expect no change.
  constexpr auto kCurrentMinLeadTime4 = 1'234'567ull;
  constexpr auto kTimeOfMinLeadTimeChange4 = 87'654'321ll;  // less than kTimeOfMinLeadTimeChange3
  renderer->UpdateMinLeadTime(zx::nsec(kCurrentMinLeadTime4), zx::time(kTimeOfMinLeadTimeChange4));
  EXPECT_THAT(GetHierarchy(),
              ChildrenMatch(Contains(AllOf(
                  NodeMatches(NameMatches("renderers")),
                  ChildrenMatch(UnorderedElementsAre(NodeMatches(AllOf(
                      NameMatches("1"),
                      PropertyList(IsSupersetOf({
                          UintIs("initial min lead time (ns)", kInitialMinLeadTime2),
                          UintIs("current min lead time (ns)", kCurrentMinLeadTime3),
                          IntIs("time of latest min lead time change", kTimeOfMinLeadTimeChange3),
                      }))))))))));
}

// Tests methods that change capturer metrics, that aren't tested in other cases.
TEST_F(ReporterTest, CapturerMetrics) {
  auto capturer = under_test_.CreateCapturer("thread");

  EXPECT_THAT(
      GetHierarchy(),
      ChildrenMatch(Contains(AllOf(
          NodeMatches(NameMatches("capturers")),
          ChildrenMatch(UnorderedElementsAre(AllOf(
              NodeMatches(AllOf(
                  NameMatches("1"),
                  PropertyList(UnorderedElementsAre(
                      UintIs("initial presentation delay (ns)", 0),
                      UintIs("current presentation delay (ns)", 0),
                      IntIs("time of latest presentation delay change", 0),
                      StringIs("usage", "default"), StringIs("mixer thread name", "thread"))))),
              ChildrenMatch(UnorderedElementsAre(
                  NodeMatches(AllOf(NameMatches("format"),
                                    PropertyList(UnorderedElementsAre(
                                        StringIs("sample format", "unknown"), UintIs("channels", 0),
                                        UintIs("frames per second", 0))))),
                  NodeMatches(
                      AllOf(NameMatches("gain"),
                            PropertyList(UnorderedElementsAre(
                                DoubleIs("gain db", 0.0), BoolIs("muted", false),
                                UintIs("calls to SetGainWithRamp", 0),
                                DoubleIs("complete stream gain (post-volume) dbfs", 0.0))))),
                  AllOf(NodeMatches(NameMatches("payload buffers")), ChildrenMatch(IsEmpty())),
                  NodeMatches(AllOf(NameMatches("overflows"),
                                    PropertyList(UnorderedElementsAre(
                                        UintIs("count", 0), UintIs("duration (ns)", 0),
                                        UintIs("session count", 0))))))))))))));

  capturer->SetUsage(CaptureUsage::FOREGROUND);
  capturer->SetFormat(
      Format::Create({
                         .sample_format = fuchsia::media::AudioSampleFormat::SIGNED_16,
                         .channels = 2,
                         .frames_per_second = 48000,
                     })
          .take_value());

  capturer->AddPayloadBuffer(0, 4096);
  capturer->AddPayloadBuffer(10, 8192);
  capturer->SendPacket(fuchsia::media::StreamPacket{
      .payload_buffer_id = 10,
  });

  capturer->SetGain(-1.0);
  capturer->SetMute(true);
  capturer->SetGainWithRamp(-1.0, zx::sec(1), fuchsia::media::audio::RampType::SCALE_LINEAR);
  capturer->SetGainWithRamp(-1.0, zx::sec(1), fuchsia::media::audio::RampType::SCALE_LINEAR);

  capturer->StartSession(zx::time(0));

  capturer->Overflow(zx::time(60), zx::time(65));

  capturer->StopSession(zx::time(100));

  EXPECT_THAT(
      GetHierarchy(),
      ChildrenMatch(Contains(AllOf(
          NodeMatches(NameMatches("capturers")),
          ChildrenMatch(UnorderedElementsAre(AllOf(
              NodeMatches(AllOf(NameMatches("1"),
                                PropertyList(UnorderedElementsAre(
                                    UintIs("initial presentation delay (ns)", 0),
                                    UintIs("current presentation delay (ns)", 0),
                                    IntIs("time of latest presentation delay change", 0),
                                    StringIs("usage", "CaptureUsage::FOREGROUND"),
                                    StringIs("mixer thread name", "thread"))))),
              ChildrenMatch(UnorderedElementsAre(
                  NodeMatches(AllOf(
                      NameMatches("format"),
                      PropertyList(UnorderedElementsAre(StringIs("sample format", "SIGNED_16"),
                                                        UintIs("channels", 2),
                                                        UintIs("frames per second", 48000))))),
                  NodeMatches(
                      AllOf(NameMatches("gain"),
                            PropertyList(UnorderedElementsAre(
                                DoubleIs("gain db", -1.0), BoolIs("muted", true),
                                UintIs("calls to SetGainWithRamp", 2),
                                DoubleIs("complete stream gain (post-volume) dbfs", 0.0))))),
                  AllOf(NodeMatches(NameMatches("payload buffers")),
                        ChildrenMatch(UnorderedElementsAre(
                            NodeMatches(AllOf(NameMatches("0"),
                                              PropertyList(UnorderedElementsAre(
                                                  UintIs("size", 4096), UintIs("packets", 0))))),
                            NodeMatches(AllOf(NameMatches("10"),
                                              PropertyList(UnorderedElementsAre(
                                                  UintIs("size", 8192), UintIs("packets", 1)))))))),
                  NodeMatches(AllOf(NameMatches("overflows"),
                                    PropertyList(UnorderedElementsAre(
                                        UintIs("count", 1), UintIs("duration (ns)", 5),
                                        UintIs("session count", 1))))))))))))));
}

// Tests methods that change capturer presentation delay metrics.
TEST_F(ReporterTest, CapturerPresentationDelay) {
  auto capturer = under_test_.CreateCapturer("capture_thread");
  EXPECT_THAT(GetHierarchy(),
              ChildrenMatch(Contains(AllOf(
                  NodeMatches(NameMatches("capturers")),
                  ChildrenMatch(UnorderedElementsAre(NodeMatches(AllOf(
                      NameMatches("1"), PropertyList(IsSupersetOf({
                                            UintIs("initial presentation delay (ns)", 0),
                                            UintIs("current presentation delay (ns)", 0),
                                            IntIs("time of latest presentation delay change", 0),
                                        }))))))))));

  // SetInitialPresentationDelay is optional; UpdatePresentationDelay can be called immediately.
  constexpr auto kCurrentPresDelay1 = 432ull;
  constexpr auto kTimeOfPresDelayChange1 = 234ll;
  capturer->UpdatePresentationDelay(zx::nsec(kCurrentPresDelay1),
                                    zx::time(kTimeOfPresDelayChange1));
  EXPECT_THAT(
      GetHierarchy(),
      ChildrenMatch(Contains(
          AllOf(NodeMatches(NameMatches("capturers")),
                ChildrenMatch(UnorderedElementsAre(NodeMatches(AllOf(
                    NameMatches("1"),
                    PropertyList(IsSupersetOf({
                        UintIs("initial presentation delay (ns)", 0),  // Retains value from ctor.
                        UintIs("current presentation delay (ns)", kCurrentPresDelay1),
                        IntIs("time of latest presentation delay change", kTimeOfPresDelayChange1),
                    }))))))))));

  // We expect the initial and current values to change, and the time-of-update to be reset.
  constexpr auto kInitialPresentationDelay2 = 2'000'000ull;
  capturer->SetInitialPresentationDelay(zx::nsec(kInitialPresentationDelay2));
  EXPECT_THAT(GetHierarchy(),
              ChildrenMatch(Contains(AllOf(
                  NodeMatches(NameMatches("capturers")),
                  ChildrenMatch(UnorderedElementsAre(NodeMatches(AllOf(
                      NameMatches("1"),
                      PropertyList(IsSupersetOf({
                          UintIs("initial presentation delay (ns)", kInitialPresentationDelay2),
                          UintIs("current presentation delay (ns)", kInitialPresentationDelay2),
                          IntIs("time of latest presentation delay change", 0),  // Was reset
                      }))))))))));

  // We expect the current value and time-of-update value to change.
  constexpr auto kCurrentPresDelay3 = 23'456'789ull;
  constexpr auto kTimeOfPresDelayChange3 = 876'543'210ll;
  capturer->UpdatePresentationDelay(zx::nsec(kCurrentPresDelay3),
                                    zx::time(kTimeOfPresDelayChange3));
  EXPECT_THAT(
      GetHierarchy(),
      ChildrenMatch(Contains(
          AllOf(NodeMatches(NameMatches("capturers")),
                ChildrenMatch(UnorderedElementsAre(NodeMatches(AllOf(
                    NameMatches("1"),
                    PropertyList(IsSupersetOf({
                        UintIs("initial presentation delay (ns)", kInitialPresentationDelay2),
                        UintIs("current presentation delay (ns)", kCurrentPresDelay3),
                        IntIs("time of latest presentation delay change", kTimeOfPresDelayChange3),
                    }))))))))));

  // The time-of-update is before the previous one, so we expect no change.
  constexpr auto kCurrentPresDelay4 = 2'345'678ull;
  constexpr auto kTimeOfPresDelayChange4 = 76'543'210ll;  // Less than kTime...Change3
  capturer->UpdatePresentationDelay(zx::nsec(kCurrentPresDelay4),
                                    zx::time(kTimeOfPresDelayChange4));
  EXPECT_THAT(
      GetHierarchy(),
      ChildrenMatch(Contains(
          AllOf(NodeMatches(NameMatches("capturers")),
                ChildrenMatch(UnorderedElementsAre(NodeMatches(AllOf(
                    NameMatches("1"),
                    PropertyList(IsSupersetOf({
                        UintIs("initial presentation delay (ns)", kInitialPresentationDelay2),
                        UintIs("current presentation delay (ns)", kCurrentPresDelay3),
                        IntIs("time of latest presentation delay change", kTimeOfPresDelayChange3),
                    }))))))))));
}

// Tests ThermalStateTracker methods.
TEST_F(ReporterTest, SetThermalStateMetrics) {
  under_test_.SetNumThermalStates(3);
  under_test_.SetThermalState(0);
  // Expect first thermal state metric values.
  EXPECT_THAT(
      GetHierarchyLazyValues(),
      ChildrenMatch(Contains(AllOf(
          NodeMatches(AllOf(NameMatches("thermal state"),
                            PropertyList(UnorderedElementsAre(UintIs("num thermal states", 3))))),
          ChildrenMatch(UnorderedElementsAre(NodeMatches(
              AllOf(NameMatches("normal"),
                    Not(PropertyList(Contains(UintIs("total duration (ns)", 0))))))))))));
  // Expect second thermal state metric values, with first thermal state metrics stored.
  under_test_.SetThermalState(2);
  EXPECT_THAT(
      GetHierarchyLazyValues(),
      ChildrenMatch(Contains(AllOf(
          NodeMatches(AllOf(NameMatches("thermal state"),
                            PropertyList(UnorderedElementsAre(UintIs("num thermal states", 3))))),
          ChildrenMatch(UnorderedElementsAre(
              NodeMatches(AllOf(NameMatches("normal"),
                                Not(PropertyList(Contains(UintIs("total duration (ns)", 0)))))),
              NodeMatches(AllOf(NameMatches("2"), Not(PropertyList(Contains(
                                                      UintIs("total duration (ns)", 0))))))))))));
  // Expect values to be unchanged, since state 2 has already been triggered.
  under_test_.SetThermalState(2);
  EXPECT_THAT(
      GetHierarchyLazyValues(),
      ChildrenMatch(Contains(AllOf(
          NodeMatches(AllOf(NameMatches("thermal state"),
                            PropertyList(UnorderedElementsAre(UintIs("num thermal states", 3))))),
          ChildrenMatch(UnorderedElementsAre(
              NodeMatches(AllOf(NameMatches("normal"),
                                Not(PropertyList(Contains(UintIs("total duration (ns)", 0)))))),
              NodeMatches(AllOf(NameMatches("2"), Not(PropertyList(Contains(
                                                      UintIs("total duration (ns)", 0))))))))))));
}

// Test caching of ThermalStates up to limit Reporter::kThermalStatesToCache == 8.
TEST_F(ReporterTest, CacheThermalStateTransitions) {
  // Reporter initializes thermal state to 0.
  under_test_.SetThermalState(1);  // ThermalState 2, first cached
  under_test_.SetThermalState(2);
  under_test_.SetThermalState(0);
  under_test_.SetThermalState(1);
  under_test_.SetThermalState(2);
  under_test_.SetThermalState(1);
  under_test_.SetThermalState(2);
  under_test_.SetThermalState(2);  // Skip duplicate.
  under_test_.SetThermalState(0);  // ThermalState 9, final cached
  under_test_.SetThermalState(1);  // ThermalState 10, alive

  // Expect most recent 8 thermal state metric values.
  EXPECT_THAT(
      GetHierarchyLazyValues(),
      ChildrenMatch(Contains(AllOf(
          NodeMatches(NameMatches("thermal state transitions")),
          ChildrenMatch(UnorderedElementsAre(
              NodeMatches(AllOf(NameMatches("2"),
                                PropertyList(IsSupersetOf({
                                    BoolIs("active", false),
                                    StringIs("state", "1"),
                                })),
                                Not(PropertyList(Contains(UintIs("duration (ns)", 0)))))),
              NodeMatches(AllOf(NameMatches("3"),
                                PropertyList(IsSupersetOf({
                                    BoolIs("active", false),
                                    StringIs("state", "2"),
                                })),
                                Not(PropertyList(Contains(UintIs("duration (ns)", 0)))))),
              NodeMatches(AllOf(NameMatches("4"),
                                PropertyList(IsSupersetOf({
                                    BoolIs("active", false),
                                    StringIs("state", "normal"),
                                })),
                                Not(PropertyList(Contains(UintIs("duration (ns)", 0)))))),
              NodeMatches(AllOf(NameMatches("5"),
                                PropertyList(IsSupersetOf({
                                    BoolIs("active", false),
                                    StringIs("state", "1"),
                                })),
                                Not(PropertyList(Contains(UintIs("duration (ns)", 0)))))),
              NodeMatches(AllOf(NameMatches("6"),
                                PropertyList(IsSupersetOf({
                                    BoolIs("active", false),
                                    StringIs("state", "2"),
                                })),
                                Not(PropertyList(Contains(UintIs("duration (ns)", 0)))))),
              NodeMatches(AllOf(NameMatches("7"),
                                PropertyList(IsSupersetOf({
                                    BoolIs("active", false),
                                    StringIs("state", "1"),
                                })),
                                Not(PropertyList(Contains(UintIs("duration (ns)", 0)))))),
              NodeMatches(AllOf(NameMatches("8"),
                                PropertyList(IsSupersetOf({
                                    BoolIs("active", false),
                                    StringIs("state", "2"),
                                })),
                                Not(PropertyList(Contains(UintIs("duration (ns)", 0)))))),
              NodeMatches(AllOf(NameMatches("9"),
                                PropertyList(IsSupersetOf({
                                    BoolIs("active", false),
                                    StringIs("state", "normal"),
                                })),
                                Not(PropertyList(Contains(UintIs("duration (ns)", 0)))))),
              NodeMatches(AllOf(NameMatches("10"),
                                PropertyList(IsSupersetOf({
                                    BoolIs("active", true),
                                    StringIs("state", "1"),
                                })),
                                Not(PropertyList(Contains(UintIs("duration (ns)", 0))))))))))));
}

// Test VolumeControl methods.
TEST_F(ReporterTest, VolumeControlMetrics) {
  auto volume_control = under_test_.CreateVolumeControl();

  // Expect initial volume control metrics.
  EXPECT_THAT(
      GetHierarchy(),
      ChildrenMatch(Contains(AllOf(
          NodeMatches(NameMatches("volume controls")),
          ChildrenMatch(Contains(AllOf(
              NodeMatches(AllOf(NameMatches("1"), PropertyList(UnorderedElementsAre(
                                                      UintIs("client count", 0),
                                                      StringIs("name", "unknown - no clients"))))),
              ChildrenMatch(Contains(
                  AllOf(NodeMatches(NameMatches("volume settings")),
                        ChildrenMatch(UnorderedElementsAre(NodeMatches(AllOf(
                            NameMatches("1"), PropertyList(UnorderedElementsAre(
                                                  BoolIs("active", true), BoolIs("mute", false),
                                                  DoubleIs("volume", 0.0)))))))))))))))));

  volume_control->SetVolumeMute(0.5, true);
  volume_control->AddBinding("RenderUsage::MEDIA");
  volume_control->AddBinding("RenderUsage::MEDIA");

  // Expect |volume_control| settings to be reflected, with past volume settings cached.
  EXPECT_THAT(
      GetHierarchy(),
      ChildrenMatch(Contains(AllOf(
          NodeMatches(NameMatches("volume controls")),
          ChildrenMatch(Contains(AllOf(
              NodeMatches(AllOf(NameMatches("1"), PropertyList(UnorderedElementsAre(
                                                      UintIs("client count", 2),
                                                      StringIs("name", "RenderUsage::MEDIA"))))),
              ChildrenMatch(Contains(
                  AllOf(NodeMatches(NameMatches("volume settings")),
                        ChildrenMatch(UnorderedElementsAre(
                            NodeMatches(AllOf(NameMatches("1"),
                                              PropertyList(UnorderedElementsAre(
                                                  BoolIs("active", false), BoolIs("mute", false),
                                                  DoubleIs("volume", 0.0))))),
                            NodeMatches(AllOf(NameMatches("2"),
                                              PropertyList(UnorderedElementsAre(
                                                  BoolIs("active", true), BoolIs("mute", true),
                                                  DoubleIs("volume", 0.5)))))))))))))))));
}

// Test methods that change audio policy metrics.
TEST_F(ReporterTest, AudioPolicyMetrics) {
  // Expect behavior gains to be logged, and initial active audio policy to have no active usages.
  under_test_.SetAudioPolicyBehaviorGain(
      AudioAdmin::BehaviorGain({.none_gain_db = 0., .duck_gain_db = -10., .mute_gain_db = -100.}));
  EXPECT_THAT(
      GetHierarchy(),
      ChildrenMatch(Contains(AllOf(
          NodeMatches(AllOf(NameMatches("active usage policies"),
                            PropertyList(UnorderedElementsAre(DoubleIs("none gain db", 0.0),
                                                              DoubleIs("duck gain db", -10.0),
                                                              DoubleIs("mute gain db", -100.0))))),
          ChildrenMatch(Contains(NodeMatches(
              AllOf(NameMatches("1"), PropertyList(Contains(BoolIs("active", true)))))))))));

  // Structures to hold active usages and usage behaviors.
  std::vector<fuchsia::media::Usage> active_usages;
  std::array<fuchsia::media::Behavior, fuchsia::media::RENDER_USAGE_COUNT> render_usage_behaviors;
  std::array<fuchsia::media::Behavior, fuchsia::media::CAPTURE_USAGE_COUNT> capture_usage_behaviors;
  render_usage_behaviors.fill(fuchsia::media::Behavior::NONE);
  capture_usage_behaviors.fill(fuchsia::media::Behavior::NONE);

  // Expect active RenderUsage::MEDIA to be logged, with default policy NONE.
  active_usages.push_back(
      fuchsia::media::Usage::WithRenderUsage((fuchsia::media::AudioRenderUsage::MEDIA)));
  under_test_.UpdateActiveUsagePolicy(active_usages, render_usage_behaviors,
                                      capture_usage_behaviors);
  EXPECT_THAT(
      GetHierarchy(),
      ChildrenMatch(Contains(AllOf(
          NodeMatches(AllOf(NameMatches("active usage policies"),
                            PropertyList(UnorderedElementsAre(DoubleIs("none gain db", 0.0),
                                                              DoubleIs("duck gain db", -10.0),
                                                              DoubleIs("mute gain db", -100.0))))),
          ChildrenMatch(UnorderedElementsAre(
              NodeMatches(AllOf(NameMatches("1"), PropertyList(Contains(BoolIs("active", false))))),
              NodeMatches(AllOf(
                  NameMatches("2"),
                  PropertyList(UnorderedElementsAre(
                      BoolIs("active", true), StringIs("RenderUsage::MEDIA", "NONE")))))))))));

  // Expect active RenderUsage::MEDIA and CaptureUsage::SYSTEM_AGENT to be logged, with DUCK applied
  // to MEDIA.
  active_usages.push_back(
      fuchsia::media::Usage::WithCaptureUsage((fuchsia::media::AudioCaptureUsage::SYSTEM_AGENT)));
  render_usage_behaviors[static_cast<int>(fuchsia::media::AudioRenderUsage::MEDIA)] =
      fuchsia::media::Behavior::DUCK;
  under_test_.UpdateActiveUsagePolicy(active_usages, render_usage_behaviors,
                                      capture_usage_behaviors);
  EXPECT_THAT(
      GetHierarchy(),
      ChildrenMatch(Contains(AllOf(
          NodeMatches(AllOf(NameMatches("active usage policies"),
                            PropertyList(UnorderedElementsAre(DoubleIs("none gain db", 0.0),
                                                              DoubleIs("duck gain db", -10.0),
                                                              DoubleIs("mute gain db", -100.0))))),
          ChildrenMatch(UnorderedElementsAre(
              NodeMatches(AllOf(NameMatches("1"), PropertyList(Contains(BoolIs("active", false))))),
              NodeMatches(AllOf(NameMatches("2"), PropertyList(UnorderedElementsAre(
                                                      BoolIs("active", false),
                                                      StringIs("RenderUsage::MEDIA", "NONE"))))),
              NodeMatches(AllOf(NameMatches("3"),
                                PropertyList(UnorderedElementsAre(
                                    BoolIs("active", true), StringIs("RenderUsage::MEDIA", "DUCK"),
                                    StringIs("CaptureUsage::SYSTEM_AGENT", "NONE")))))))))));
}
}  // namespace
}  // namespace media::audio