base/trace_event/memory_dump_manager_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_dump_manager.h"
   6
   7 #include "base/trace_event/memory_dump_provider.h"
   8 #include "base/trace_event/process_memory_dump.h"
   9 #include "testing/gmock/include/gmock/gmock.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11
  12 using testing::_;
  13
  14 namespace base {
  15 namespace trace_event {
  16
  17 class MemoryDumpManagerTest : public testing::Test {
  18  public:
  19   void SetUp() override {
  20     mdm_.reset(new MemoryDumpManager());
  21     MemoryDumpManager::SetInstanceForTesting(mdm_.get());
  22     ASSERT_EQ(mdm_, MemoryDumpManager::GetInstance());
  23     MemoryDumpManager::GetInstance()->Initialize();
  24   }
  25
  26   void TearDown() override {
  27     MemoryDumpManager::SetInstanceForTesting(nullptr);
  28     mdm_.reset();
  29     TraceLog::DeleteForTesting();
  30   }
  31
  32  protected:
  33   const char* const kTraceCategory = MemoryDumpManager::kTraceCategory;
  34
  35   void EnableTracing(const char* category) {
  36     TraceLog::GetInstance()->SetEnabled(
  37         CategoryFilter(category), TraceLog::RECORDING_MODE, TraceOptions());
  38   }
  39
  40   void DisableTracing() { TraceLog::GetInstance()->SetDisabled(); }
  41
  42   scoped_ptr<MemoryDumpManager> mdm_;
  43
  44  private:
  45   // We want our singleton torn down after each test.
  46   ShadowingAtExitManager at_exit_manager_;
  47 };
  48
  49 class MockDumpProvider : public MemoryDumpProvider {
  50  public:
  51   MOCK_METHOD1(DumpInto, void(ProcessMemoryDump* pmd));
  52 };
  53
  54 TEST_F(MemoryDumpManagerTest, SingleDumper) {
  55   MockDumpProvider mdp;
  56   mdm_->RegisterDumpProvider(&mdp);
  57
  58   // Check that the dumper is not called if the memory category is not enabled.
  59   EnableTracing("foo-and-bar-but-not-memory");
  60   EXPECT_CALL(mdp, DumpInto(_)).Times(0);
  61   mdm_->RequestDumpPoint(DumpPointType::EXPLICITLY_TRIGGERED);
  62   DisableTracing();
  63
  64   // Now repeat enabling the memory category and check that the dumper is
  65   // invoked this time.
  66   EnableTracing(kTraceCategory);
  67   EXPECT_CALL(mdp, DumpInto(_)).Times(3);
  68   for (int i = 0; i < 3; ++i)
  69     mdm_->RequestDumpPoint(DumpPointType::EXPLICITLY_TRIGGERED);
  70   DisableTracing();
  71
  72   mdm_->UnregisterDumpProvider(&mdp);
  73
  74   // Finally check the unregister logic (no calls to the mdp after unregister).
  75   EnableTracing(kTraceCategory);
  76   EXPECT_CALL(mdp, DumpInto(_)).Times(0);
  77   mdm_->RequestDumpPoint(DumpPointType::EXPLICITLY_TRIGGERED);
  78   TraceLog::GetInstance()->SetDisabled();
  79 }
  80
  81 TEST_F(MemoryDumpManagerTest, UnregisterDumperWhileTracing) {
  82   MockDumpProvider mdp;
  83   mdm_->RegisterDumpProvider(&mdp);
  84
  85   EnableTracing(kTraceCategory);
  86   EXPECT_CALL(mdp, DumpInto(_)).Times(1);
  87   mdm_->RequestDumpPoint(DumpPointType::EXPLICITLY_TRIGGERED);
  88
  89   mdm_->UnregisterDumpProvider(&mdp);
  90   EXPECT_CALL(mdp, DumpInto(_)).Times(0);
  91   mdm_->RequestDumpPoint(DumpPointType::EXPLICITLY_TRIGGERED);
  92
  93   DisableTracing();
  94 }
  95
  96 TEST_F(MemoryDumpManagerTest, MultipleDumpers) {
  97   MockDumpProvider mdp1;
  98   MockDumpProvider mdp2;
  99
 100   // Enable only mdp1.
 101   mdm_->RegisterDumpProvider(&mdp1);
 102   EnableTracing(kTraceCategory);
 103   EXPECT_CALL(mdp1, DumpInto(_)).Times(1);
 104   EXPECT_CALL(mdp2, DumpInto(_)).Times(0);
 105   mdm_->RequestDumpPoint(DumpPointType::EXPLICITLY_TRIGGERED);
 106   DisableTracing();
 107
 108   // Invert: enable mdp1 and disable mdp2.
 109   mdm_->UnregisterDumpProvider(&mdp1);
 110   mdm_->RegisterDumpProvider(&mdp2);
 111   EnableTracing(kTraceCategory);
 112   EXPECT_CALL(mdp1, DumpInto(_)).Times(0);
 113   EXPECT_CALL(mdp2, DumpInto(_)).Times(1);
 114   mdm_->RequestDumpPoint(DumpPointType::EXPLICITLY_TRIGGERED);
 115   DisableTracing();
 116
 117   // Enable both mdp1 and mdp2.
 118   mdm_->RegisterDumpProvider(&mdp1);
 119   EnableTracing(kTraceCategory);
 120   EXPECT_CALL(mdp1, DumpInto(_)).Times(1);
 121   EXPECT_CALL(mdp2, DumpInto(_)).Times(1);
 122   mdm_->RequestDumpPoint(DumpPointType::EXPLICITLY_TRIGGERED);
 123   DisableTracing();
 124 }
 125
 126 }  // namespace trace_Event
 127 }  // namespace base