/*
 * Copyright (C) 2021 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "perfetto/tracing/traced_value.h"

#include <array>
#include <deque>
#include <forward_list>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <unordered_map>
#include <unordered_set>

#include "perfetto/base/template_util.h"
#include "perfetto/protozero/scattered_heap_buffer.h"
#include "perfetto/test/traced_value_test_support.h"
#include "perfetto/tracing/debug_annotation.h"
#include "perfetto/tracing/track_event.h"
#include "protos/perfetto/trace/test_event.pb.h"
#include "protos/perfetto/trace/test_event.pbzero.h"
#include "protos/perfetto/trace/track_event/debug_annotation.gen.h"
#include "protos/perfetto/trace/track_event/debug_annotation.pb.h"
#include "test/gtest_and_gmock.h"

namespace perfetto {

// static asserts checking for conversion support for known types.

#define ASSERT_TYPE_SUPPORTED(T)                           \
  static_assert(check_traced_value_support<T>::value, ""); \
  static_assert(internal::has_traced_value_support<T>::value, "")

#define ASSERT_TYPE_NOT_SUPPORTED(T) \
  static_assert(!internal::has_traced_value_support<T>::value, "")

struct NonSupportedType {};

ASSERT_TYPE_SUPPORTED(bool);

ASSERT_TYPE_NOT_SUPPORTED(NonSupportedType);

// Integer types.
ASSERT_TYPE_SUPPORTED(short int);
ASSERT_TYPE_SUPPORTED(unsigned short int);
ASSERT_TYPE_SUPPORTED(int);
ASSERT_TYPE_SUPPORTED(unsigned int);
ASSERT_TYPE_SUPPORTED(long int);
ASSERT_TYPE_SUPPORTED(unsigned long int);
ASSERT_TYPE_SUPPORTED(long long int);
ASSERT_TYPE_SUPPORTED(unsigned long long int);

// References and const references types.
ASSERT_TYPE_SUPPORTED(int&);
ASSERT_TYPE_SUPPORTED(const int&);
ASSERT_TYPE_NOT_SUPPORTED(NonSupportedType&);
ASSERT_TYPE_NOT_SUPPORTED(const NonSupportedType&);

// Character types.
ASSERT_TYPE_SUPPORTED(signed char);
ASSERT_TYPE_SUPPORTED(unsigned char);
ASSERT_TYPE_SUPPORTED(char);
ASSERT_TYPE_SUPPORTED(wchar_t);

// Float types.
ASSERT_TYPE_SUPPORTED(float);
ASSERT_TYPE_SUPPORTED(double);
ASSERT_TYPE_SUPPORTED(long double);

// Strings.
ASSERT_TYPE_SUPPORTED(const char*);
ASSERT_TYPE_SUPPORTED(const char[]);
ASSERT_TYPE_SUPPORTED(const char[2]);
ASSERT_TYPE_SUPPORTED(std::string);

// Pointers.
ASSERT_TYPE_SUPPORTED(int*);
ASSERT_TYPE_SUPPORTED(const int*);
ASSERT_TYPE_SUPPORTED(void*);
ASSERT_TYPE_SUPPORTED(const void*);
ASSERT_TYPE_SUPPORTED(std::nullptr_t);
ASSERT_TYPE_NOT_SUPPORTED(NonSupportedType*);
ASSERT_TYPE_NOT_SUPPORTED(const NonSupportedType*);

// Arrays.
ASSERT_TYPE_NOT_SUPPORTED(int[]);
ASSERT_TYPE_NOT_SUPPORTED(const int[]);
ASSERT_TYPE_NOT_SUPPORTED(NonSupportedType[]);
ASSERT_TYPE_NOT_SUPPORTED(const NonSupportedType[]);
ASSERT_TYPE_SUPPORTED(int (&)[3]);
ASSERT_TYPE_SUPPORTED(const int (&)[3]);
ASSERT_TYPE_NOT_SUPPORTED(NonSupportedType (&)[3]);
ASSERT_TYPE_NOT_SUPPORTED(const NonSupportedType (&)[3]);

// STL containers.
ASSERT_TYPE_SUPPORTED(std::vector<int>);
ASSERT_TYPE_NOT_SUPPORTED(std::vector<NonSupportedType>);

using array_int_t = std::array<int, 4>;
ASSERT_TYPE_SUPPORTED(array_int_t);
ASSERT_TYPE_SUPPORTED(std::deque<int>);
ASSERT_TYPE_SUPPORTED(std::forward_list<int>);
ASSERT_TYPE_SUPPORTED(std::list<int>);
ASSERT_TYPE_NOT_SUPPORTED(std::stack<int>);
ASSERT_TYPE_NOT_SUPPORTED(std::queue<int>);
ASSERT_TYPE_NOT_SUPPORTED(std::priority_queue<int>);
ASSERT_TYPE_SUPPORTED(std::set<int>);
ASSERT_TYPE_SUPPORTED(std::multiset<int>);
using map_int_int_t = std::map<int, int>;
ASSERT_TYPE_NOT_SUPPORTED(map_int_int_t);
using multimap_int_int_t = std::multimap<int, int>;
ASSERT_TYPE_NOT_SUPPORTED(multimap_int_int_t);
ASSERT_TYPE_SUPPORTED(std::unordered_set<int>);
ASSERT_TYPE_SUPPORTED(std::unordered_multiset<int>);
using unordered_map_int_int_t = std::unordered_map<int, int>;
ASSERT_TYPE_NOT_SUPPORTED(unordered_map_int_int_t);
using unordered_multimap_int_int_t = std::unordered_multimap<int, int>;
ASSERT_TYPE_NOT_SUPPORTED(unordered_multimap_int_int_t);

// unique_ptr.
ASSERT_TYPE_SUPPORTED(std::unique_ptr<int>);
ASSERT_TYPE_NOT_SUPPORTED(std::unique_ptr<NonSupportedType>);

TEST(TracedValueTest, FlatDictionary_Explicit) {
  protozero::HeapBuffered<protos::pbzero::DebugAnnotation> message;
  {
    auto dict =
        internal::CreateTracedValueFromProto(message.get()).WriteDictionary();
    dict.AddItem("bool").WriteBoolean(true);
    dict.AddItem("double").WriteDouble(0.0);
    dict.AddItem("int").WriteInt64(2014);
    dict.AddItem("string").WriteString("string");
    dict.AddItem("truncated_string").WriteString("truncated_string", 9);
    dict.AddItem("ptr").WritePointer(reinterpret_cast<void*>(0x1234));
  }
  EXPECT_EQ(
      "{bool:true,double:0,int:2014,string:string,truncated_string:truncated,"
      "ptr:0x1234}",
      internal::DebugAnnotationToString(message.SerializeAsString()));
}

TEST(TracedValueTest, FlatDictionary_Short) {
  protozero::HeapBuffered<protos::pbzero::DebugAnnotation> message;
  {
    auto dict =
        internal::CreateTracedValueFromProto(message.get()).WriteDictionary();
    dict.Add("bool", true);
    dict.Add("double", 0.0);
    dict.Add("int", 2014);
    dict.Add("string", "string");
    dict.Add("ptr", reinterpret_cast<void*>(0x1234));
  }
  EXPECT_EQ("{bool:true,double:0,int:2014,string:string,ptr:0x1234}",
            internal::DebugAnnotationToString(message.SerializeAsString()));
}

TEST(TracedValueTest, Hierarchy_Explicit) {
  protozero::HeapBuffered<protos::pbzero::DebugAnnotation> message;
  {
    auto root_dict =
        internal::CreateTracedValueFromProto(message.get()).WriteDictionary();
    {
      auto array = root_dict.AddItem("a1").WriteArray();
      array.AppendItem().WriteInt64(1);
      array.AppendItem().WriteBoolean(true);
      {
        auto dict = array.AppendItem().WriteDictionary();
        dict.AddItem("i2").WriteInt64(3);
      }
    }
    root_dict.AddItem("b0").WriteBoolean(true);
    root_dict.AddItem("d0").WriteDouble(0.0);
    {
      auto dict1 = root_dict.AddItem("dict1").WriteDictionary();
      {
        auto dict2 = dict1.AddItem("dict2").WriteDictionary();
        dict2.AddItem("b2").WriteBoolean(false);
      }
      dict1.AddItem("i1").WriteInt64(2014);
      dict1.AddItem("s1").WriteString("foo");
    }
    root_dict.AddItem("i0").WriteInt64(2014);
    root_dict.AddItem("s0").WriteString("foo");
  }

  EXPECT_EQ(
      "{"
      "a1:[1,true,{i2:3}],"
      "b0:true,"
      "d0:0,"
      "dict1:{dict2:{b2:false},i1:2014,s1:foo},"
      "i0:2014,"
      "s0:foo}",
      internal::DebugAnnotationToString(message.SerializeAsString()));
}

TEST(TracedValueTest, Hierarchy_Short) {
  protozero::HeapBuffered<protos::pbzero::DebugAnnotation> message;
  {
    auto root_dict =
        internal::CreateTracedValueFromProto(message.get()).WriteDictionary();
    {
      auto array = root_dict.AddArray("a1");
      array.Append(1);
      array.Append(true);
      {
        auto dict = array.AppendDictionary();
        dict.Add("i2", 3);
      }
    }
    root_dict.Add("b0", true);
    root_dict.Add("d0", 0.0);
    {
      auto dict1 = root_dict.AddDictionary("dict1");
      {
        auto dict2 = dict1.AddDictionary("dict2");
        dict2.Add("b2", false);
      }
      dict1.Add("i1", 2014);
      dict1.Add("s1", "foo");
    }
    root_dict.Add("i0", 2014);
    root_dict.Add("s0", "foo");
  }

  EXPECT_EQ(
      "{"
      "a1:[1,true,{i2:3}],"
      "b0:true,"
      "d0:0,"
      "dict1:{dict2:{b2:false},i1:2014,s1:foo},"
      "i0:2014,"
      "s0:foo}",
      internal::DebugAnnotationToString(message.SerializeAsString()));
}

namespace {

class HasWriteIntoTracedValueConvertorMember {
 public:
  void WriteIntoTracedValue(TracedValue context) const {
    auto dict = std::move(context).WriteDictionary();
    dict.Add("int", 42);
    dict.Add("bool", false);
  }
};

class HasWriteIntoTraceConvertorMember {
 public:
  void WriteIntoTrace(TracedValue context) const {
    auto dict = std::move(context).WriteDictionary();
    dict.Add("int", 42);
    dict.Add("bool", false);
  }
};

class HasExternalWriteIntoTraceConvertor {};
class HasExternalWriteIntoTracedValueConvertor {};

class HasAllConversionMethods {
 public:
  void WriteIntoTracedValue(TracedValue context) const {
    std::move(context).WriteString("T::WriteIntoTracedValue");
  }

  void operator()(TracedValue context) const {
    std::move(context).WriteString("T::()");
  }
};

class NoConversions {};

class HasConstWriteMember {
 public:
  void WriteIntoTracedValue(TracedValue context) const {
    std::move(context).WriteString("T::WriteIntoTracedValue const");
  }
};

class HasNonConstWriteMember {
 public:
  void WriteIntoTracedValue(TracedValue context) {
    std::move(context).WriteString("T::WriteIntoTracedValue");
  }
};

class HasConstAndNonConstWriteMember {
 public:
  void WriteIntoTracedValue(TracedValue context) {
    std::move(context).WriteString("T::WriteIntoTracedValue");
  }

  void WriteIntoTracedValue(TracedValue context) const {
    std::move(context).WriteString("T::WriteIntoTracedValue const");
  }
};

}  // namespace

template <>
struct TraceFormatTraits<HasExternalWriteIntoTraceConvertor> {
  static void WriteIntoTrace(TracedValue context,
                             const HasExternalWriteIntoTraceConvertor&) {
    std::move(context).WriteString("TraceFormatTraits::WriteIntoTrace");
  }
};

template <>
struct TraceFormatTraits<HasExternalWriteIntoTracedValueConvertor> {
  static void WriteIntoTracedValue(
      TracedValue context,
      const HasExternalWriteIntoTracedValueConvertor&) {
    std::move(context).WriteString("TraceFormatTraits::WriteIntoTracedValue");
  }
};

template <>
struct TraceFormatTraits<HasAllConversionMethods> {
  static void WriteIntoTracedValue(TracedValue context,
                                   const HasAllConversionMethods&) {
    std::move(context).WriteString("TraceFormatTraits::WriteIntoTracedValue");
  }
};

template <typename T>
std::string ToStringWithFallback(T&& value, const std::string& fallback) {
  protozero::HeapBuffered<protos::pbzero::DebugAnnotation> message;
  WriteIntoTracedValueWithFallback(
      internal::CreateTracedValueFromProto(message.get()),
      std::forward<T>(value), fallback);
  return internal::DebugAnnotationToString(message.SerializeAsString());
}

ASSERT_TYPE_SUPPORTED(HasWriteIntoTraceConvertorMember);
ASSERT_TYPE_SUPPORTED(HasWriteIntoTracedValueConvertorMember);
ASSERT_TYPE_SUPPORTED(HasExternalWriteIntoTraceConvertor);
ASSERT_TYPE_SUPPORTED(HasExternalWriteIntoTracedValueConvertor);
ASSERT_TYPE_SUPPORTED(HasAllConversionMethods);

ASSERT_TYPE_SUPPORTED(HasConstWriteMember);
ASSERT_TYPE_SUPPORTED(HasConstWriteMember&);
ASSERT_TYPE_SUPPORTED(HasConstWriteMember*);
ASSERT_TYPE_SUPPORTED(std::unique_ptr<HasConstWriteMember>);
ASSERT_TYPE_SUPPORTED(std::vector<HasConstWriteMember>);
ASSERT_TYPE_SUPPORTED(const HasConstWriteMember);
ASSERT_TYPE_SUPPORTED(const HasConstWriteMember&);
ASSERT_TYPE_SUPPORTED(const HasConstWriteMember*);
ASSERT_TYPE_SUPPORTED(std::unique_ptr<const HasConstWriteMember>);
ASSERT_TYPE_SUPPORTED(const std::vector<HasConstWriteMember>);
ASSERT_TYPE_SUPPORTED(std::vector<const HasConstWriteMember*>);

ASSERT_TYPE_SUPPORTED(HasNonConstWriteMember);
ASSERT_TYPE_SUPPORTED(HasNonConstWriteMember&);
ASSERT_TYPE_SUPPORTED(HasNonConstWriteMember*);
ASSERT_TYPE_SUPPORTED(std::unique_ptr<HasNonConstWriteMember>);
ASSERT_TYPE_SUPPORTED(std::vector<HasNonConstWriteMember>);
ASSERT_TYPE_NOT_SUPPORTED(const HasNonConstWriteMember);
ASSERT_TYPE_NOT_SUPPORTED(const HasNonConstWriteMember&);
ASSERT_TYPE_NOT_SUPPORTED(const HasNonConstWriteMember*);
ASSERT_TYPE_NOT_SUPPORTED(std::unique_ptr<const HasNonConstWriteMember>);
ASSERT_TYPE_NOT_SUPPORTED(const std::vector<HasNonConstWriteMember>);
ASSERT_TYPE_NOT_SUPPORTED(std::vector<const HasNonConstWriteMember*>);

ASSERT_TYPE_SUPPORTED(HasConstAndNonConstWriteMember);
ASSERT_TYPE_SUPPORTED(HasConstAndNonConstWriteMember&);
ASSERT_TYPE_SUPPORTED(HasConstAndNonConstWriteMember*);
ASSERT_TYPE_SUPPORTED(std::unique_ptr<HasConstAndNonConstWriteMember>);
ASSERT_TYPE_SUPPORTED(const HasConstAndNonConstWriteMember);
ASSERT_TYPE_SUPPORTED(const HasConstAndNonConstWriteMember&);
ASSERT_TYPE_SUPPORTED(const HasConstAndNonConstWriteMember*);
ASSERT_TYPE_SUPPORTED(std::unique_ptr<const HasConstAndNonConstWriteMember*>);

TEST(TracedValueTest, UserDefinedConvertors) {
  HasWriteIntoTraceConvertorMember value1;
  EXPECT_EQ(TracedValueToString(value1), "{int:42,bool:false}");
  EXPECT_EQ(TracedValueToString(&value1), "{int:42,bool:false}");

  HasWriteIntoTracedValueConvertorMember value2;
  EXPECT_EQ(TracedValueToString(value2), "{int:42,bool:false}");
  EXPECT_EQ(TracedValueToString(&value2), "{int:42,bool:false}");

  HasExternalWriteIntoTracedValueConvertor value3;
  EXPECT_EQ(TracedValueToString(value3),
            "TraceFormatTraits::WriteIntoTracedValue");
  EXPECT_EQ(TracedValueToString(&value3),
            "TraceFormatTraits::WriteIntoTracedValue");

  HasExternalWriteIntoTraceConvertor value4;
  EXPECT_EQ(TracedValueToString(value4), "TraceFormatTraits::WriteIntoTrace");
  EXPECT_EQ(TracedValueToString(&value4), "TraceFormatTraits::WriteIntoTrace");

  HasAllConversionMethods value5;
  EXPECT_EQ(TracedValueToString(value5), "T::WriteIntoTracedValue");
  EXPECT_EQ(TracedValueToString(&value5), "T::WriteIntoTracedValue");
}

TEST(TracedValueTest, WriteAsLambda) {
  EXPECT_EQ("42", TracedValueToString([&](TracedValue context) {
              std::move(context).WriteInt64(42);
            }));
}

#if PERFETTO_DCHECK_IS_ON()
// This death test makes sense only when dchecks are enabled.
TEST(TracedValueTest, FailOnIncorrectUsage) {
  // A new call to AddItem is not allowed before the previous result is
  // consumed.
  EXPECT_DEATH(

      {
        protozero::HeapBuffered<protos::pbzero::DebugAnnotation> message;
        auto dict = internal::CreateTracedValueFromProto(message.get())
                        .WriteDictionary();
        auto scope1 = dict.AddItem("key1");
        auto scope2 = dict.AddItem("key2");
        std::move(scope1).WriteInt64(1);
        std::move(scope2).WriteInt64(2);
      },
      "");

  // A new call to AppendItem is not allowed before the previous result is
  // consumed.
  EXPECT_DEATH(
      {
        protozero::HeapBuffered<protos::pbzero::DebugAnnotation> message;
        auto array =
            internal::CreateTracedValueFromProto(message.get()).WriteArray();
        auto scope1 = array.AppendItem();
        auto scope2 = array.AppendItem();
        std::move(scope1).WriteInt64(1);
        std::move(scope2).WriteInt64(2);
      },
      "");

  // Writing to parent scope is not allowed.
  EXPECT_DEATH(
      {
        protozero::HeapBuffered<protos::pbzero::DebugAnnotation> message;
        auto outer_dict = internal::CreateTracedValueFromProto(message.get())
                              .WriteDictionary();
        {
          auto inner_dict = outer_dict.AddDictionary("inner");
          outer_dict.Add("key", "value");
        }
      },
      "");
}
#endif  // PERFETTO_DCHECK_IS_ON()

TEST(TracedValueTest, PrimitiveTypesSupport) {
  EXPECT_EQ("0x0", TracedValueToString(nullptr));
  EXPECT_EQ("0x1", TracedValueToString(reinterpret_cast<void*>(1)));

  const int int_value = 1;
  EXPECT_EQ("1", TracedValueToString(int_value));
  EXPECT_EQ("1", TracedValueToString(&int_value));

  EXPECT_EQ("1.5", TracedValueToString(1.5));
  EXPECT_EQ("true", TracedValueToString(true));
  EXPECT_EQ("foo", TracedValueToString("foo"));
  EXPECT_EQ("bar", TracedValueToString(std::string("bar")));
}

TEST(TracedValueTest, UniquePtrSupport) {
  std::unique_ptr<int> value1;
  EXPECT_EQ("0x0", TracedValueToString(value1));

  std::unique_ptr<int> value2(new int(4));
  EXPECT_EQ("4", TracedValueToString(value2));
}

namespace {

enum OldStyleEnum { kFoo, kBar };

enum class NewStyleEnum { kValue1, kValue2 };

enum class EnumWithPrettyPrint { kValue1, kValue2 };

}  // namespace

template <>
struct TraceFormatTraits<EnumWithPrettyPrint> {
  static void WriteIntoTracedValue(TracedValue context,
                                   EnumWithPrettyPrint value) {
    switch (value) {
      case EnumWithPrettyPrint::kValue1:
        std::move(context).WriteString("value1");
        return;
      case EnumWithPrettyPrint::kValue2:
        std::move(context).WriteString("value2");
        return;
    }
  }
};

TEST(TracedValueTest, EnumSupport) {
  EXPECT_EQ(TracedValueToString(kFoo), "0");
  EXPECT_EQ(TracedValueToString(NewStyleEnum::kValue2), "1");
  EXPECT_EQ(TracedValueToString(EnumWithPrettyPrint::kValue2), "value2");
}

TEST(TracedValueTest, ContainerSupport) {
  std::vector<std::list<int>> value1{{1, 2}, {3, 4}};
  EXPECT_EQ("[[1,2],[3,4]]", TracedValueToString(value1));
}

TEST(TracedValueTest, WriteWithFallback) {
  EXPECT_EQ("1", ToStringWithFallback(1, "fallback"));
  EXPECT_EQ("true", ToStringWithFallback(true, "fallback"));
  EXPECT_EQ("fallback", ToStringWithFallback(NonSupportedType(), "fallback"));
}

TEST(TracedValueTest, ConstAndNotConstSupport) {
  {
    HasConstWriteMember value;
    EXPECT_EQ("T::WriteIntoTracedValue const", TracedValueToString(value));
    EXPECT_EQ("T::WriteIntoTracedValue const", TracedValueToString(&value));

    std::vector<HasConstWriteMember> arr(1, value);
    EXPECT_EQ("[T::WriteIntoTracedValue const]", TracedValueToString(arr));
  }

  {
    const HasConstWriteMember value;
    EXPECT_EQ("T::WriteIntoTracedValue const", TracedValueToString(value));
    EXPECT_EQ("T::WriteIntoTracedValue const", TracedValueToString(&value));

    const std::vector<HasConstWriteMember> arr(1, value);
    EXPECT_EQ("[T::WriteIntoTracedValue const]", TracedValueToString(arr));
  }

  {
    HasNonConstWriteMember value;
    EXPECT_EQ("T::WriteIntoTracedValue", TracedValueToString(value));
    EXPECT_EQ("T::WriteIntoTracedValue", TracedValueToString(&value));

    std::vector<HasNonConstWriteMember> arr(1, value);
    EXPECT_EQ("[T::WriteIntoTracedValue]", TracedValueToString(arr));
  }

  {
    HasConstAndNonConstWriteMember value;
    EXPECT_EQ("T::WriteIntoTracedValue", TracedValueToString(value));
    EXPECT_EQ("T::WriteIntoTracedValue", TracedValueToString(&value));

    std::vector<HasConstAndNonConstWriteMember> arr(1, value);
    EXPECT_EQ("[T::WriteIntoTracedValue]", TracedValueToString(arr));
  }

  {
    const HasConstAndNonConstWriteMember value;
    EXPECT_EQ("T::WriteIntoTracedValue const", TracedValueToString(value));
    EXPECT_EQ("T::WriteIntoTracedValue const", TracedValueToString(&value));

    const std::vector<HasConstAndNonConstWriteMember> arr(1, value);
    EXPECT_EQ("[T::WriteIntoTracedValue const]", TracedValueToString(arr));
  }
}

// Note: interning of the dictionary keys is not implemented yet, so there is no
// difference in behaviour for StaticString and DynamicString yet.
TEST(TracedValueTest, DictionaryKeys) {
  EXPECT_EQ("{literal:1}", TracedValueToString([&](TracedValue context) {
              auto dict = std::move(context).WriteDictionary();
              dict.Add("literal", 1);
            }));

  EXPECT_EQ("{static:1}", TracedValueToString([&](TracedValue context) {
              auto dict = std::move(context).WriteDictionary();
              const char* key = "static";
              dict.Add(StaticString{key}, 1);
            }));

  EXPECT_EQ("{dynamic:1}", TracedValueToString([&](TracedValue context) {
              auto dict = std::move(context).WriteDictionary();
              std::string key = "dynamic";
              dict.Add(DynamicString{key.data()}, 1);
            }));

  EXPECT_EQ("{dynamic:1}", TracedValueToString([&](TracedValue context) {
              auto dict = std::move(context).WriteDictionary();
              std::string key = "dynamic";
              dict.Add(DynamicString{key.data(), key.length()}, 1);
            }));

  EXPECT_EQ("{dynamic:1}", TracedValueToString([&](TracedValue context) {
              auto dict = std::move(context).WriteDictionary();
              std::string key = "dynamic";
              dict.Add(DynamicString{key}, 1);
            }));
}

TEST(TracedValueTest, EmptyDict) {
  EXPECT_EQ("{}", TracedValueToString([&](TracedValue context) {
              auto dict = std::move(context).WriteDictionary();
            }));
}

TEST(TracedValueTest, EmptyArray) {
  // For now we do not distinguish between empty arrays and empty dicts on proto
  // level as trace processor ignores them anyway.
  EXPECT_EQ("{}", TracedValueToString([&](TracedValue context) {
              auto array = std::move(context).WriteArray();
            }));
}

TEST(TracedValueTest, WriteTypedProto_Explicit) {
  protozero::HeapBuffered<protos::pbzero::DebugAnnotation> message;
  WriteIntoTracedValue(
      internal::CreateTracedValueFromProto(message.get()),
      [](perfetto::TracedValue context) {
        perfetto::TracedProto<protos::pbzero::TestEvent::TestPayload> proto =
            std::move(context)
                .WriteProto<protos::pbzero::TestEvent::TestPayload>();
        proto->set_single_string("payload");
      });

  protos::DebugAnnotation annotation;
  annotation.ParseFromString(message.SerializeAsString());
  EXPECT_EQ(annotation.proto_type_name(),
            ".perfetto.protos.TestEvent.TestPayload");

  protos::TestEvent::TestPayload payload;
  payload.ParseFromString(annotation.proto_value());
  EXPECT_EQ(payload.single_string(), "payload");
}

TEST(TracedValueTest, WriteTypedProto_Implicit) {
  protozero::HeapBuffered<protos::pbzero::DebugAnnotation> message;
  WriteIntoTracedValue(
      internal::CreateTracedValueFromProto(message.get()),
      [](perfetto::TracedProto<protos::pbzero::TestEvent::TestPayload> proto) {
        proto->set_single_string("payload");
      });

  protos::DebugAnnotation annotation;
  annotation.ParseFromString(message.SerializeAsString());
  EXPECT_EQ(annotation.proto_type_name(),
            ".perfetto.protos.TestEvent.TestPayload");

  protos::TestEvent::TestPayload payload;
  payload.ParseFromString(annotation.proto_value());
  EXPECT_EQ(payload.single_string(), "payload");
}

TEST(TracedValueTest, ImplicitTracedDictionary) {
  EXPECT_EQ("{key:value}", TracedValueToString([&](TracedDictionary dict) {
              dict.Add("key", "value");
            }));
}

TEST(TracedValueTest, ImplicitTracedArray) {
  EXPECT_EQ("[1]",
            TracedValueToString([&](TracedArray array) { array.Append(1); }));
}

TEST(TracedValueTest, TracedProtoInDict) {
  struct Foo {
    void WriteIntoTrace(
        perfetto::TracedProto<protos::pbzero::TestEvent::TestPayload> message) {
      message->set_single_int(42);
    }
  };
  Foo foo;
  protozero::HeapBuffered<protos::pbzero::DebugAnnotation> message;
  WriteIntoTracedValue(internal::CreateTracedValueFromProto(message.get()),
                       [&](TracedDictionary dict) { dict.Add("foo", foo); });
  protos::DebugAnnotation annotation;
  annotation.ParseFromString(message.SerializeAsString());
  EXPECT_EQ(annotation.dict_entries_size(), 1);
  EXPECT_EQ(annotation.dict_entries(0).name(), "foo");
  EXPECT_EQ(annotation.dict_entries(0).proto_type_name(),
            ".perfetto.protos.TestEvent.TestPayload");

  protos::TestEvent::TestPayload payload;
  payload.ParseFromString(annotation.dict_entries(0).proto_value());
  EXPECT_EQ(payload.single_int(), 42);
}

TEST(TracedValueTest, PointerToTracedProtoInDict) {
  struct Foo {
    void WriteIntoTrace(
        perfetto::TracedProto<protos::pbzero::TestEvent::TestPayload> message) {
      message->set_single_int(42);
    }
  };
  Foo foo;
  protozero::HeapBuffered<protos::pbzero::DebugAnnotation> message;
  WriteIntoTracedValue(internal::CreateTracedValueFromProto(message.get()),
                       [&](TracedDictionary dict) { dict.Add("foo", &foo); });
  protos::DebugAnnotation annotation;
  annotation.ParseFromString(message.SerializeAsString());
  EXPECT_EQ(annotation.dict_entries_size(), 1);
  EXPECT_EQ(annotation.dict_entries(0).name(), "foo");
  EXPECT_EQ(annotation.dict_entries(0).proto_type_name(),
            ".perfetto.protos.TestEvent.TestPayload");

  protos::TestEvent::TestPayload payload;
  payload.ParseFromString(annotation.dict_entries(0).proto_value());
  EXPECT_EQ(payload.single_int(), 42);
}

TEST(TracedValueTest, UniquePointerToTracedProtoInDict) {
  struct Foo {
    void WriteIntoTrace(
        perfetto::TracedProto<protos::pbzero::TestEvent::TestPayload> message) {
      message->set_single_int(42);
    }
  };
  std::unique_ptr<Foo> foo(new Foo());
  protozero::HeapBuffered<protos::pbzero::DebugAnnotation> message;
  WriteIntoTracedValue(internal::CreateTracedValueFromProto(message.get()),
                       [&](TracedDictionary dict) { dict.Add("foo", foo); });
  protos::DebugAnnotation annotation;
  annotation.ParseFromString(message.SerializeAsString());
  EXPECT_EQ(annotation.dict_entries_size(), 1);
  EXPECT_EQ(annotation.dict_entries(0).name(), "foo");
  EXPECT_EQ(annotation.dict_entries(0).proto_type_name(),
            ".perfetto.protos.TestEvent.TestPayload");

  protos::TestEvent::TestPayload payload;
  payload.ParseFromString(annotation.dict_entries(0).proto_value());
  EXPECT_EQ(payload.single_int(), 42);
}

}  // namespace perfetto