[tracing] Switch to new heap dump format.

base/trace_event/heap_profiler_string_deduplicator_unittest.cc

+// Copyright 2017 The Chromium 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 "base/trace_event/heap_profiler_string_deduplicator.h"
+
+#include <memory>
+#include <string>
+
+#include "base/memory/ptr_util.h"
+#include "base/trace_event/trace_event_argument.h"
+#include "base/values.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace base {
+namespace trace_event {
+
+namespace {
+
+// Calls StringDeduplicator::ExportIncrementally() and returns ListValue
+// with exported entries.
+std::unique_ptr<ListValue> ExportEntriesIncrementally(
+    StringDeduplicator* dedup) {
+  TracedValue traced_value;
+  traced_value.BeginArray("");
+  dedup->ExportIncrementally(&traced_value);
+  traced_value.EndArray();
+
+  auto base_value = traced_value.ToBaseValue();
+  const DictionaryValue* dictionary;
+  const ListValue* entries;
+  if (!base_value->GetAsDictionary(&dictionary) ||
+      !dictionary->GetList("", &entries)) {
+    return nullptr;
+  }
+
+  return WrapUnique(entries->DeepCopy());
+}
+
+struct StringMapping {
+  const int id;
+  const char* const string;
+};
+
+std::unique_ptr<ListValue> ConvertMappingsToExportedEntries(
+    std::initializer_list<StringMapping> mappings) {
+  auto entries = MakeUnique<ListValue>();
+  for (const auto& mapping : mappings) {
+    auto entry = MakeUnique<DictionaryValue>();
+    entry->SetInteger("id", mapping.id);
+    entry->SetString("string", mapping.string);
+    entries->Append(std::move(entry));
+  }
+  return entries;
+}
+
+void ExpectIncrementalEntries(StringDeduplicator* dedup,
+                              std::initializer_list<StringMapping> mappings) {
+  auto entries = ExportEntriesIncrementally(dedup);
+  ASSERT_TRUE(entries);
+
+  auto expected_entries = ConvertMappingsToExportedEntries(mappings);
+  ASSERT_TRUE(expected_entries->Equals(entries.get()))
+      << "expected_entries = " << *expected_entries << "entries = " << *entries;
+}
+
+}  // namespace
+
+TEST(StringDeduplicatorTest, ImplicitId0) {
+  StringDeduplicator dedup;
+
+  // NULL string is mapped to an implicitly added ID #0.
+  ExpectIncrementalEntries(&dedup, {{0, "[null]"}});
+  ASSERT_EQ(0, dedup.Insert(nullptr));
+
+  // Even though ID #0 is exported as "[null]", it's distinct from
+  // explicitly added "[null]" string.
+  ASSERT_EQ(1, dedup.Insert("[null]"));
+  ExpectIncrementalEntries(&dedup, {{1, "[null]"}});
+}
+
+TEST(StringDeduplicatorTest, Deduplication) {
+  StringDeduplicator dedup;
+
+  ASSERT_EQ(1, dedup.Insert("foo"));
+  ASSERT_EQ(2, dedup.Insert("bar"));
+  ASSERT_EQ(3, dedup.Insert("baz"));
+
+  // Inserting again should return the same IDs.
+  ASSERT_EQ(2, dedup.Insert("bar"));
+  ASSERT_EQ(1, dedup.Insert("foo"));
+  ASSERT_EQ(3, dedup.Insert("baz"));
+
+  // Deduplication works on string contents, not on pointers,
+  // so inserting copies should yield the same IDs.
+  ASSERT_EQ(2, dedup.Insert(std::string("bar")));
+  ASSERT_EQ(1, dedup.Insert(std::string("foo")));
+}
+
+TEST(StringDeduplicatorTest, IncrementalExport) {
+  StringDeduplicator dedup;
+
+  ASSERT_EQ(1, dedup.Insert("foo"));
+  ASSERT_EQ(2, dedup.Insert("bar"));
+
+  ExpectIncrementalEntries(&dedup, {{0, "[null]"}, {1, "foo"}, {2, "bar"}});
+
+  ASSERT_EQ(2, dedup.Insert("bar"));
+  ASSERT_EQ(3, dedup.Insert("baz"));
+
+  ExpectIncrementalEntries(&dedup, {{3, "baz"}});
+
+  ExpectIncrementalEntries(&dedup, {});
+}
+
+}  // namespace trace_event
+}  // namespace base