base/android/meminfo_dump_provider_unittest.cc

   1 // Copyright 2023 The Chromium Authors
   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/android/meminfo_dump_provider.h"
   6 #include "base/android/build_info.h"
   7 #include "base/trace_event/base_tracing.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9
  10 #include <cstdint>
  11 #include <map>
  12 #include <string>
  13
  14 namespace base::android {
  15
  16 namespace {
  17 std::map<std::string, uint64_t> GetEntries(
  18     base::trace_event::MemoryAllocatorDump* dump) {
  19   std::map<std::string, uint64_t> entries;
  20   for (const auto& entry : dump->entries()) {
  21     EXPECT_EQ(entry.entry_type,
  22               base::trace_event::MemoryAllocatorDump::Entry::kUint64);
  23     entries.insert({entry.name, entry.value_uint64});
  24   }
  25   return entries;
  26 }
  27 }  // namespace
  28
  29 TEST(MeminfoDumpProviderTest, Simple) {
  30   auto& instance = MeminfoDumpProvider::Initialize();
  31
  32   base::trace_event::MemoryDumpArgs args{};
  33   args.level_of_detail = base::trace_event::MemoryDumpLevelOfDetail::kDetailed;
  34   base::trace_event::ProcessMemoryDump first_pmd{args};
  35
  36   bool success = instance.OnMemoryDump(args, &first_pmd);
  37   ASSERT_TRUE(success);
  38   base::trace_event::MemoryAllocatorDump* first_dump =
  39       first_pmd.GetAllocatorDump(MeminfoDumpProvider::kDumpName);
  40   ASSERT_TRUE(first_dump);
  41
  42   std::map<std::string, uint64_t> first_entries = GetEntries(first_dump);
  43
  44   EXPECT_TRUE(first_entries.contains(
  45       MeminfoDumpProvider::kIsStaleName));  // Cannot assert on the value.
  46   // Expect the values to not be 0, that would indicate that the values are not
  47   // reported.
  48   ASSERT_TRUE(
  49       first_entries.contains(MeminfoDumpProvider::kPrivateDirtyMetricName));
  50   ASSERT_TRUE(first_entries.contains(MeminfoDumpProvider::kPssMetricName));
  51   EXPECT_GT(first_entries[MeminfoDumpProvider::kPrivateDirtyMetricName], 0u);
  52   EXPECT_GT(first_entries[MeminfoDumpProvider::kPssMetricName], 0u);
  53
  54   base::trace_event::ProcessMemoryDump second_pmd{args};
  55   ASSERT_TRUE(instance.OnMemoryDump(args, &second_pmd));
  56   base::trace_event::MemoryAllocatorDump* second_dump =
  57       second_pmd.GetAllocatorDump(MeminfoDumpProvider::kDumpName);
  58   ASSERT_TRUE(second_dump);
  59   std::map<std::string, uint64_t> second_entries = GetEntries(second_dump);
  60
  61   EXPECT_TRUE(second_entries.contains(MeminfoDumpProvider::kIsStaleName));
  62   EXPECT_TRUE(
  63       second_entries[MeminfoDumpProvider::kIsStaleName]);  // Entries are stale
  64                                                            // this time.
  65   ASSERT_TRUE(
  66       second_entries.contains(MeminfoDumpProvider::kPrivateDirtyMetricName));
  67   ASSERT_TRUE(second_entries.contains(MeminfoDumpProvider::kPssMetricName));
  68   if (BuildInfo::GetInstance()->sdk_int() >= SdkVersion::SDK_VERSION_Q) {
  69     // Stale values are reported.
  70     EXPECT_EQ(first_entries[MeminfoDumpProvider::kPrivateDirtyMetricName],
  71               second_entries[MeminfoDumpProvider::kPrivateDirtyMetricName]);
  72     EXPECT_EQ(first_entries[MeminfoDumpProvider::kPssMetricName],
  73               second_entries[MeminfoDumpProvider::kPssMetricName]);
  74   }
  75 }
  76
  77 TEST(MeminfoDumpProviderTest, NoStaleReportsInBackgroundDumps) {
  78   auto& instance = MeminfoDumpProvider::Initialize();
  79
  80   // First dump, data may or may not be stale.
  81   {
  82     base::trace_event::MemoryDumpArgs args{};
  83     args.level_of_detail =
  84         base::trace_event::MemoryDumpLevelOfDetail::kDetailed;
  85     base::trace_event::ProcessMemoryDump pmd{args};
  86     ASSERT_TRUE(instance.OnMemoryDump(args, &pmd));
  87   }
  88
  89   // Second one, stale data, should not report.
  90   {
  91     base::trace_event::MemoryDumpArgs args{};
  92     args.level_of_detail =
  93         base::trace_event::MemoryDumpLevelOfDetail::kBackground;
  94     base::trace_event::ProcessMemoryDump pmd{args};
  95     ASSERT_TRUE(instance.OnMemoryDump(args, &pmd));
  96     base::trace_event::MemoryAllocatorDump* dump =
  97         pmd.GetAllocatorDump(MeminfoDumpProvider::kDumpName);
  98     EXPECT_FALSE(dump);
  99   }
 100 }
 101
 102 }  // namespace base::android