// 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 <fuchsia/inspect/cpp/fidl.h>
#include <lib/fit/defer.h>
#include <lib/inspect/inspect.h>
#include <lib/inspect/testing/inspect.h>

#include "gmock/gmock.h"
#include "gtest/gtest.h"

namespace {

using inspect::Object;
using inspect::ObjectHierarchy;
using testing::AllOf;
using testing::IsEmpty;
using testing::UnorderedElementsAre;
using namespace inspect::testing;

// Convenience function for reading an ObjectHierarchy snapshot from a Tree.
ObjectHierarchy GetHierarchy(const inspect::Tree& tree) {
  zx::vmo duplicate;
  if (tree.GetVmo().duplicate(ZX_RIGHT_SAME_RIGHTS, &duplicate) != ZX_OK) {
    return ObjectHierarchy();
  }
  auto ret = inspect::ReadFromVmo(std::move(duplicate));
  EXPECT_TRUE(ret.is_ok());
  if (ret.is_ok()) {
    return ret.take_value();
  }
  return ObjectHierarchy();
}

TEST(InspectVmo, Object) {
  auto tree = inspect::Inspector().CreateTree("test");
  EXPECT_THAT(GetHierarchy(tree),
              NodeMatches(AllOf(NameMatches("test"), PropertyList(IsEmpty()),
                                MetricList(IsEmpty()))));
}

class ValueWrapper {
 public:
  ValueWrapper(Object obj, int val)
      : object_(std::move(obj)),
        value_(object_.CreateIntMetric("value", val)) {}

 private:
  Object object_;
  inspect::IntMetric value_;
};

TEST(InspectVmo, Child) {
  auto tree = inspect::Inspector().CreateTree("root");
  Object& root = tree.GetRoot();
  {
    // Create a child and check it exists.
    auto obj = root.CreateChild("child");
    EXPECT_THAT(
        GetHierarchy(tree),
        ChildrenMatch(UnorderedElementsAre(NodeMatches(NameMatches("child")))));

    auto obj2 = root.CreateChild("child2");
    EXPECT_THAT(GetHierarchy(tree), ChildrenMatch(UnorderedElementsAre(
                                        NodeMatches(NameMatches("child")),
                                        NodeMatches(NameMatches("child2")))));

    // Check assignment removes the old object.
    obj = root.CreateChild("newchild");
    EXPECT_THAT(GetHierarchy(tree), ChildrenMatch(UnorderedElementsAre(
                                        NodeMatches(NameMatches("newchild")),
                                        NodeMatches(NameMatches("child2")))));
  }
  // Check that the child is removed when it goes out of scope.
  EXPECT_THAT(GetHierarchy(tree), ChildrenMatch(IsEmpty()));
}

TEST(InspectVmo, ChildChaining) {
  auto tree = inspect::Inspector().CreateTree("root");
  Object& root = tree.GetRoot();
  {
    ValueWrapper v(root.CreateChild("child"), 100);
    EXPECT_THAT(
        GetHierarchy(tree),
        ChildrenMatch(UnorderedElementsAre(NodeMatches(AllOf(
            NameMatches("child"),
            MetricList(UnorderedElementsAre(IntMetricIs("value", 100))))))));
  }
  // Check that the child is removed when it goes out of scope.
  EXPECT_THAT(GetHierarchy(tree), ChildrenMatch(IsEmpty()));
}

template <typename Type>
void DefaultMetricTest() {
  Type default_metric;
  default_metric.Add(1);
  default_metric.Subtract(1);
  default_metric.Set(1);
}

template <typename Type>
void DefaultArrayTest() {
  Type default_metric;
  default_metric.Add(0, 1);
  default_metric.Subtract(0, 1);
  default_metric.Set(0, 1);
}

template <typename Type>
void DefaultHistogramTest() {
  Type default_metric;
  default_metric.Insert(0);
}

TEST(InspectVmo, Metrics) {
  DefaultMetricTest<inspect::IntMetric>();
  DefaultMetricTest<inspect::UIntMetric>();
  DefaultMetricTest<inspect::DoubleMetric>();

  auto tree = inspect::Inspector().CreateTree("root");
  Object& root = tree.GetRoot();
  {
    auto metric_int = root.CreateIntMetric("int", -10);
    metric_int.Add(5);
    metric_int.Subtract(4);
    auto metric_uint = root.CreateUIntMetric("uint", 10);
    metric_uint.Add(4);
    metric_uint.Subtract(5);
    auto metric_double = root.CreateDoubleMetric("double", 0.25);
    metric_double.Add(1);
    metric_double.Subtract(0.5);
    EXPECT_THAT(
        GetHierarchy(tree),
        NodeMatches(AllOf(NameMatches("root"),
                          MetricList(UnorderedElementsAre(
                              IntMetricIs("int", -9), UIntMetricIs("uint", 9),
                              DoubleMetricIs("double", 0.75))))));
  }
  // Check that the metrics are removed when they goes out of scope.
  EXPECT_THAT(GetHierarchy(tree), NodeMatches(MetricList(IsEmpty())));
}

TEST(InspectVmo, Arrays) {
  DefaultArrayTest<inspect::IntArray>();
  DefaultArrayTest<inspect::UIntArray>();
  DefaultArrayTest<inspect::DoubleArray>();

  auto tree = inspect::Inspector().CreateTree("root");
  Object& root = tree.GetRoot();
  {
    auto metric_int = root.CreateIntArray("int", 5);
    metric_int.Add(0, 5);
    metric_int.Subtract(2, 4);
    auto metric_uint = root.CreateUIntArray("uint", 5);
    metric_uint.Add(0, 5);
    metric_uint.Add(2, 5);
    metric_uint.Subtract(2, 4);
    auto metric_double = root.CreateDoubleArray("double", 5);
    metric_double.Add(0, 1);
    metric_double.Subtract(2, 0.5);
    EXPECT_THAT(
        GetHierarchy(tree),
        NodeMatches(AllOf(
            NameMatches("root"),
            MetricList(UnorderedElementsAre(
                IntArrayIs("int", ::testing::ElementsAre(5, 0, -4, 0, 0)),
                UIntArrayIs("uint", ::testing::ElementsAre(5, 0, 1, 0, 0)),
                DoubleArrayIs("double",
                              ::testing::ElementsAre(1, 0, -0.5, 0, 0)))))));
  }
  // Check that the metrics are removed when they goes out of scope.
  EXPECT_THAT(GetHierarchy(tree), NodeMatches(MetricList(IsEmpty())));
}

TEST(InspectVmo, LinearHistograms) {
  DefaultHistogramTest<inspect::LinearIntHistogramMetric>();
  DefaultHistogramTest<inspect::LinearUIntHistogramMetric>();
  DefaultHistogramTest<inspect::LinearDoubleHistogramMetric>();

  auto tree = inspect::Inspector().CreateTree("root");
  Object& root = tree.GetRoot();
  {
    auto metric_int = root.CreateLinearIntHistogramMetric("int", 10, 5, 5);
    metric_int.Insert(0, 2);
    metric_int.Insert(16);
    metric_int.Insert(230);
    auto expected_int_values = CreateExpectedLinearHistogramContents<int64_t>(
        10, 5, 5, {0, 0, 16, 230});
    EXPECT_THAT(expected_int_values,
                ::testing::ElementsAre(10, 5, 2, 0, 1, 0, 0, 0, 1));
    auto metric_uint = root.CreateLinearUIntHistogramMetric("uint", 10, 5, 5);
    metric_uint.Insert(0, 2);
    metric_uint.Insert(16);
    metric_uint.Insert(230);
    auto expected_uint_values = CreateExpectedLinearHistogramContents<uint64_t>(
        10, 5, 5, {0, 0, 16, 230});
    EXPECT_THAT(expected_uint_values,
                ::testing::ElementsAre(10, 5, 2, 0, 1, 0, 0, 0, 1));
    auto metric_double =
        root.CreateLinearDoubleHistogramMetric("double", 10, .5, 5);
    metric_double.Insert(0, 2);
    metric_double.Insert(11);
    metric_double.Insert(230);
    auto expected_double_values = CreateExpectedLinearHistogramContents<double>(
        10, .5, 5, {0, 0, 11, 230});
    EXPECT_THAT(expected_double_values,
                ::testing::ElementsAre(10, .5, 2, 0, 0, 1, 0, 0, 1));
    EXPECT_THAT(
        GetHierarchy(tree),
        NodeMatches(
            AllOf(NameMatches("root"),
                  MetricList(UnorderedElementsAre(
                      IntArrayIs("int", ::testing::Eq(expected_int_values)),
                      UIntArrayIs("uint", ::testing::Eq(expected_uint_values)),
                      DoubleArrayIs("double",
                                    ::testing::Eq(expected_double_values)))))));
  }
  // Check that the metrics are removed when they goes out of scope.
  EXPECT_THAT(GetHierarchy(tree), NodeMatches(MetricList(IsEmpty())));
}

TEST(InspectVmo, ExponentialHistograms) {
  DefaultHistogramTest<inspect::ExponentialIntHistogramMetric>();
  DefaultHistogramTest<inspect::ExponentialUIntHistogramMetric>();
  DefaultHistogramTest<inspect::ExponentialDoubleHistogramMetric>();

  auto tree = inspect::Inspector().CreateTree("root");
  Object& root = tree.GetRoot();
  {
    auto metric_int =
        root.CreateExponentialIntHistogramMetric("int", 1, 1, 2, 4);
    metric_int.Insert(0, 2);
    metric_int.Insert(8);
    metric_int.Insert(230);
    auto expected_int_values =
        CreateExpectedExponentialHistogramContents<int64_t>(1, 1, 2, 4,
                                                            {0, 0, 8, 230});
    EXPECT_THAT(expected_int_values,
                ::testing::ElementsAre(1, 1, 2, 2, 0, 0, 0, 1, 1));
    auto metric_uint =
        root.CreateExponentialUIntHistogramMetric("uint", 1, 1, 2, 4);
    metric_uint.Insert(0, 2);
    metric_uint.Insert(8);
    metric_uint.Insert(230);
    auto expected_uint_values =
        CreateExpectedExponentialHistogramContents<uint64_t>(1, 1, 2, 4,
                                                             {0, 0, 8, 230});
    EXPECT_THAT(expected_uint_values,
                ::testing::ElementsAre(1, 1, 2, 2, 0, 0, 0, 1, 1));
    auto metric_double =
        root.CreateExponentialDoubleHistogramMetric("double", 1, 1, 2, 4);
    metric_double.Insert(0, 2);
    metric_double.Insert(8);
    metric_double.Insert(230);
    auto expected_double_values =
        CreateExpectedExponentialHistogramContents<double>(1, 1, 2, 4,
                                                           {0, 0, 8, 230});
    EXPECT_THAT(expected_double_values,
                ::testing::ElementsAre(1, 1, 2, 2, 0, 0, 0, 1, 1));
    EXPECT_THAT(
        GetHierarchy(tree),
        NodeMatches(
            AllOf(NameMatches("root"),
                  MetricList(UnorderedElementsAre(
                      IntArrayIs("int", ::testing::Eq(expected_int_values)),
                      UIntArrayIs("uint", ::testing::Eq(expected_uint_values)),
                      DoubleArrayIs("double",
                                    ::testing::Eq(expected_double_values)))))));
  }
  // Check that the metrics are removed when they goes out of scope.
  EXPECT_THAT(GetHierarchy(tree), NodeMatches(MetricList(IsEmpty())));
}

TEST(InspectVmo, Properties) {
  auto tree = inspect::Inspector().CreateTree("root");
  Object& root = tree.GetRoot();
  {
    auto property_string = root.CreateStringProperty("str", "test");
    property_string.Set("valid");
    auto property_vector =
        root.CreateByteVectorProperty("vec", inspect::VectorValue(3, 'a'));
    property_vector.Set(inspect::VectorValue(3, 'b'));
    EXPECT_THAT(
        GetHierarchy(tree),
        NodeMatches(AllOf(
            NameMatches("root"),
            PropertyList(UnorderedElementsAre(
                StringPropertyIs("str", "valid"),
                ByteVectorPropertyIs("vec", inspect::VectorValue(3, 'b')))))));
  }
  // Check that the properties are removed when they goes out of scope.
  EXPECT_THAT(GetHierarchy(tree), NodeMatches(PropertyList(IsEmpty())));
}

TEST(InspectVmo, NestedValues) {
  auto tree = inspect::Inspector().CreateTree("root");
  Object& root = tree.GetRoot();
  {
    Object child_a = root.CreateChild("child_a");
    Object child_b = root.CreateChild("child_b");
    Object child_a_c = child_a.CreateChild("child_a_c");
    auto property_string = root.CreateStringProperty("str", "test");
    property_string.Set("valid");
    auto property_vector =
        root.CreateByteVectorProperty("vec", inspect::VectorValue(3, 'a'));

    auto a_value = child_a.CreateIntMetric("value", -10);
    auto b_prop = child_b.CreateStringProperty("version", "1.0");
    auto a_c_value = child_a_c.CreateDoubleMetric("volume", 0.25);

    EXPECT_THAT(
        GetHierarchy(tree),
        AllOf(
            NodeMatches(AllOf(NameMatches("root"),
                              PropertyList(UnorderedElementsAre(
                                  StringPropertyIs("str", "valid"),
                                  ByteVectorPropertyIs(
                                      "vec", inspect::VectorValue(3, 'a')))))),
            ChildrenMatch(UnorderedElementsAre(
                AllOf(NodeMatches(AllOf(NameMatches("child_a"),
                                        MetricList(UnorderedElementsAre(
                                            IntMetricIs("value", -10))))),
                      ChildrenMatch(UnorderedElementsAre(AllOf(NodeMatches(
                          AllOf(NameMatches("child_a_c"),
                                MetricList(UnorderedElementsAre(
                                    DoubleMetricIs("volume", 0.25))))))))),
                NodeMatches(
                    AllOf(NameMatches("child_b"),
                          PropertyList(UnorderedElementsAre(
                              StringPropertyIs("version", "1.0")))))))));
  }
  // Check that the properties are removed when they goes out of scope.
  EXPECT_THAT(GetHierarchy(tree), NodeMatches(PropertyList(IsEmpty())));
}
}  // namespace