base/trace_event/memory_allocator_dump_unittest.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/trace_event/memory_allocator_dump.h"
   6
   7 #include "base/format_macros.h"
   8 #include "base/strings/stringprintf.h"
   9 #include "base/trace_event/memory_allocator_dump_guid.h"
  10 #include "base/trace_event/memory_dump_provider.h"
  11 #include "base/trace_event/memory_dump_session_state.h"
  12 #include "base/trace_event/process_memory_dump.h"
  13 #include "base/trace_event/trace_event_argument.h"
  14 #include "base/values.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16
  17 namespace base {
  18 namespace trace_event {
  19
  20 namespace {
  21
  22 class FakeMemoryAllocatorDumpProvider : public MemoryDumpProvider {
  23  public:
  24   bool OnMemoryDump(ProcessMemoryDump* pmd) override {
  25     MemoryAllocatorDump* root_heap =
  26         pmd->CreateAllocatorDump("foobar_allocator");
  27
  28     root_heap->AddScalar(MemoryAllocatorDump::kNameSize,
  29                          MemoryAllocatorDump::kUnitsBytes, 4096);
  30     root_heap->AddScalar(MemoryAllocatorDump::kNameObjectsCount,
  31                          MemoryAllocatorDump::kUnitsObjects, 42);
  32     root_heap->AddScalar("attr1", "units1", 1234);
  33     root_heap->AddString("attr2", "units2", "string_value");
  34     root_heap->AddScalarF("attr3", "units3", 42.5f);
  35
  36     MemoryAllocatorDump* sub_heap =
  37         pmd->CreateAllocatorDump("foobar_allocator/sub_heap");
  38     sub_heap->AddScalar(MemoryAllocatorDump::kNameSize,
  39                         MemoryAllocatorDump::kUnitsBytes, 1);
  40     sub_heap->AddScalar(MemoryAllocatorDump::kNameObjectsCount,
  41                         MemoryAllocatorDump::kUnitsObjects, 3);
  42
  43     pmd->CreateAllocatorDump("foobar_allocator/sub_heap/empty");
  44     // Leave the rest of sub heap deliberately uninitialized, to check that
  45     // CreateAllocatorDump returns a properly zero-initialized object.
  46
  47     return true;
  48   }
  49 };
  50
  51 scoped_ptr<Value> CheckAttribute(const MemoryAllocatorDump* dump,
  52                                  const std::string& name,
  53                                  const char* expected_type,
  54                                  const char* expected_units) {
  55   scoped_ptr<Value> raw_attrs = dump->attributes_for_testing()->ToBaseValue();
  56   DictionaryValue* args = nullptr;
  57   DictionaryValue* arg = nullptr;
  58   std::string arg_value;
  59   const Value* out_value = nullptr;
  60   EXPECT_TRUE(raw_attrs->GetAsDictionary(&args));
  61   EXPECT_TRUE(args->GetDictionary(name, &arg));
  62   EXPECT_TRUE(arg->GetString("type", &arg_value));
  63   EXPECT_EQ(expected_type, arg_value);
  64   EXPECT_TRUE(arg->GetString("units", &arg_value));
  65   EXPECT_EQ(expected_units, arg_value);
  66   EXPECT_TRUE(arg->Get("value", &out_value));
  67   return out_value ? out_value->CreateDeepCopy() : scoped_ptr<Value>();
  68 }
  69
  70 void CheckString(const MemoryAllocatorDump* dump,
  71                  const std::string& name,
  72                  const char* expected_type,
  73                  const char* expected_units,
  74                  const std::string& expected_value) {
  75   std::string attr_str_value;
  76   auto attr_value = CheckAttribute(dump, name, expected_type, expected_units);
  77   EXPECT_TRUE(attr_value->GetAsString(&attr_str_value));
  78   EXPECT_EQ(expected_value, attr_str_value);
  79 }
  80
  81 void CheckScalar(const MemoryAllocatorDump* dump,
  82                  const std::string& name,
  83                  const char* expected_units,
  84                  uint64 expected_value) {
  85   CheckString(dump, name, MemoryAllocatorDump::kTypeScalar, expected_units,
  86               StringPrintf("%" PRIx64, expected_value));
  87 }
  88
  89 void CheckScalarF(const MemoryAllocatorDump* dump,
  90                   const std::string& name,
  91                   const char* expected_units,
  92                   double expected_value) {
  93   auto attr_value = CheckAttribute(dump, name, MemoryAllocatorDump::kTypeScalar,
  94                                    expected_units);
  95   double attr_double_value;
  96   EXPECT_TRUE(attr_value->GetAsDouble(&attr_double_value));
  97   EXPECT_EQ(expected_value, attr_double_value);
  98 }
  99
 100 }  // namespace
 101
 102 TEST(MemoryAllocatorDumpTest, GuidGeneration) {
 103   scoped_ptr<MemoryAllocatorDump> mad(
 104       new MemoryAllocatorDump("foo", nullptr, MemoryAllocatorDumpGuid(0x42u)));
 105   ASSERT_EQ("42", mad->guid().ToString());
 106
 107   // If the dumper does not provide a Guid, the MAD will make one up on the
 108   // flight. Furthermore that Guid will stay stable across across multiple
 109   // snapshots if the |absolute_name| of the dump doesn't change
 110   mad.reset(new MemoryAllocatorDump("bar", nullptr));
 111   const MemoryAllocatorDumpGuid guid_bar = mad->guid();
 112   ASSERT_FALSE(guid_bar.empty());
 113   ASSERT_FALSE(guid_bar.ToString().empty());
 114   ASSERT_EQ(guid_bar, mad->guid());
 115
 116   mad.reset(new MemoryAllocatorDump("bar", nullptr));
 117   const MemoryAllocatorDumpGuid guid_bar_2 = mad->guid();
 118   ASSERT_EQ(guid_bar, guid_bar_2);
 119
 120   mad.reset(new MemoryAllocatorDump("baz", nullptr));
 121   const MemoryAllocatorDumpGuid guid_baz = mad->guid();
 122   ASSERT_NE(guid_bar, guid_baz);
 123 }
 124
 125 TEST(MemoryAllocatorDumpTest, DumpIntoProcessMemoryDump) {
 126   FakeMemoryAllocatorDumpProvider fmadp;
 127   ProcessMemoryDump pmd(make_scoped_refptr(new MemoryDumpSessionState()));
 128
 129   fmadp.OnMemoryDump(&pmd);
 130
 131   ASSERT_EQ(3u, pmd.allocator_dumps().size());
 132
 133   const MemoryAllocatorDump* root_heap =
 134       pmd.GetAllocatorDump("foobar_allocator");
 135   ASSERT_NE(nullptr, root_heap);
 136   EXPECT_EQ("foobar_allocator", root_heap->absolute_name());
 137   CheckScalar(root_heap, MemoryAllocatorDump::kNameSize,
 138               MemoryAllocatorDump::kUnitsBytes, 4096);
 139   CheckScalar(root_heap, MemoryAllocatorDump::kNameObjectsCount,
 140               MemoryAllocatorDump::kUnitsObjects, 42);
 141   CheckScalar(root_heap, "attr1", "units1", 1234);
 142   CheckString(root_heap, "attr2", MemoryAllocatorDump::kTypeString, "units2",
 143               "string_value");
 144   CheckScalarF(root_heap, "attr3", "units3", 42.5f);
 145
 146   const MemoryAllocatorDump* sub_heap =
 147       pmd.GetAllocatorDump("foobar_allocator/sub_heap");
 148   ASSERT_NE(nullptr, sub_heap);
 149   EXPECT_EQ("foobar_allocator/sub_heap", sub_heap->absolute_name());
 150   CheckScalar(sub_heap, MemoryAllocatorDump::kNameSize,
 151               MemoryAllocatorDump::kUnitsBytes, 1);
 152   CheckScalar(sub_heap, MemoryAllocatorDump::kNameObjectsCount,
 153               MemoryAllocatorDump::kUnitsObjects, 3);
 154   const MemoryAllocatorDump* empty_sub_heap =
 155       pmd.GetAllocatorDump("foobar_allocator/sub_heap/empty");
 156   ASSERT_NE(nullptr, empty_sub_heap);
 157   EXPECT_EQ("foobar_allocator/sub_heap/empty", empty_sub_heap->absolute_name());
 158   auto raw_attrs = empty_sub_heap->attributes_for_testing()->ToBaseValue();
 159   DictionaryValue* attrs = nullptr;
 160   ASSERT_TRUE(raw_attrs->GetAsDictionary(&attrs));
 161   ASSERT_FALSE(attrs->HasKey(MemoryAllocatorDump::kNameSize));
 162   ASSERT_FALSE(attrs->HasKey(MemoryAllocatorDump::kNameObjectsCount));
 163
 164   // Check that the AsValueInfo doesn't hit any DCHECK.
 165   scoped_refptr<TracedValue> traced_value(new TracedValue());
 166   pmd.AsValueInto(traced_value.get());
 167 }
 168
 169 // DEATH tests are not supported in Android / iOS.
 170 #if !defined(NDEBUG) && !defined(OS_ANDROID) && !defined(OS_IOS)
 171 TEST(MemoryAllocatorDumpTest, ForbidDuplicatesDeathTest) {
 172   FakeMemoryAllocatorDumpProvider fmadp;
 173   ProcessMemoryDump pmd(make_scoped_refptr(new MemoryDumpSessionState()));
 174   pmd.CreateAllocatorDump("foo_allocator");
 175   pmd.CreateAllocatorDump("bar_allocator/heap");
 176   ASSERT_DEATH(pmd.CreateAllocatorDump("foo_allocator"), "");
 177   ASSERT_DEATH(pmd.CreateAllocatorDump("bar_allocator/heap"), "");
 178   ASSERT_DEATH(pmd.CreateAllocatorDump(""), "");
 179 }
 180 #endif
 181
 182 }  // namespace trace_event
 183 }  // namespace base