athena/resource_manager/memory_pressure_notifier_unittest.cc

   1 /// Copyright 2014 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 "athena/resource_manager/memory_pressure_notifier.h"
   6 #include "athena/resource_manager/public/resource_manager_delegate.h"
   7 #include "athena/test/athena_test_base.h"
   8
   9 namespace athena {
  10 namespace test {
  11
  12 namespace {
  13
  14 // Our OS delegate abstraction class to override the memory fill level.
  15 class TestResourceManagerDelegate : public ResourceManagerDelegate {
  16  public:
  17   TestResourceManagerDelegate() : memory_fill_level_percent_(0) {}
  18   virtual ~TestResourceManagerDelegate() {}
  19
  20   virtual int GetUsedMemoryInPercent() OVERRIDE {
  21     timer_called_++;
  22     return memory_fill_level_percent_;
  23   }
  24
  25   virtual int MemoryPressureIntervalInMS() OVERRIDE {
  26     return 5;
  27   }
  28
  29   void set_memory_fill_level_percent(int memory_fill_level_percent) {
  30     memory_fill_level_percent_ = memory_fill_level_percent;
  31   }
  32
  33   // Returns the number of timer calls to the GetMemoryInPercent() calls.
  34   int timer_called() { return timer_called_; }
  35
  36  private:
  37   // The to be returned memory fill level value in percent.
  38   int memory_fill_level_percent_;
  39
  40   // How often was the timer calling the GetUsedMemoryInPercent() function.
  41   int timer_called_;
  42
  43   DISALLOW_COPY_AND_ASSIGN(TestResourceManagerDelegate);
  44 };
  45
  46 // Our memory pressure observer class.
  47 class TestMemoryPressureObserver : public MemoryPressureObserver {
  48  public:
  49   TestMemoryPressureObserver(ResourceManagerDelegate* delegate)
  50       : delegate_(delegate),
  51         number_of_calls_(0),
  52         pressure_(MEMORY_PRESSURE_UNKNOWN) {}
  53   virtual ~TestMemoryPressureObserver() {}
  54
  55   // The observer.
  56   virtual void OnMemoryPressure(MemoryPressure pressure) OVERRIDE {
  57     number_of_calls_++;
  58     pressure_ = pressure;
  59   }
  60
  61   virtual ResourceManagerDelegate* GetDelegate() OVERRIDE {
  62     return delegate_.get();
  63   }
  64
  65   int number_of_calls() { return number_of_calls_; }
  66   MemoryPressureObserver::MemoryPressure pressure() { return pressure_; }
  67
  68  private:
  69   scoped_ptr<ResourceManagerDelegate> delegate_;
  70
  71   // Number of calls received.
  72   int number_of_calls_;
  73
  74   // Last posted memory pressure.
  75   MemoryPressureObserver::MemoryPressure pressure_;
  76
  77   DISALLOW_COPY_AND_ASSIGN(TestMemoryPressureObserver);
  78 };
  79
  80 }  // namespace
  81
  82 // Our testing base.
  83 class MemoryPressureTest : public AthenaTestBase {
  84  public:
  85   MemoryPressureTest() : test_resource_manager_delegate_(NULL) {}
  86   virtual ~MemoryPressureTest() {}
  87
  88   // AthenaTestBase:
  89   virtual void SetUp() OVERRIDE {
  90     AthenaTestBase::SetUp();
  91     // Create and install our TestAppContentDelegate with instrumentation.
  92     test_resource_manager_delegate_ =
  93         new TestResourceManagerDelegate();
  94     test_memory_pressure_observer_.reset(new TestMemoryPressureObserver(
  95         test_resource_manager_delegate_));
  96     memory_pressure_notifier_.reset(
  97         new MemoryPressureNotifier(test_memory_pressure_observer_.get()));
  98   }
  99
 100   virtual void TearDown() OVERRIDE {
 101     memory_pressure_notifier_.reset();
 102     RunAllPendingInMessageLoop();
 103     test_memory_pressure_observer_.reset();
 104     AthenaTestBase::TearDown();
 105   }
 106
 107  protected:
 108   TestResourceManagerDelegate* test_resource_manager_delegate() {
 109     return test_resource_manager_delegate_;
 110   }
 111
 112   TestMemoryPressureObserver* test_memory_pressure_observer() {
 113     return test_memory_pressure_observer_.get();
 114   }
 115
 116   // Waits until a timer interrupt occurs. Returns false if no timer is
 117   // registered.
 118   bool WaitForTimer() {
 119     int first_counter = test_resource_manager_delegate()->timer_called();
 120     // Wait up to 500ms for any poll on our memory status function from the
 121     // MemoryPressureNotifier.
 122     for (int i = 0; i < 500; ++i) {
 123       if (test_resource_manager_delegate()->timer_called() != first_counter)
 124         return true;
 125       usleep(1);
 126       RunAllPendingInMessageLoop();
 127     }
 128     return false;
 129   }
 130
 131  private:
 132   // Not owned: the resource manager delegate.
 133   TestResourceManagerDelegate* test_resource_manager_delegate_;
 134   scoped_ptr<TestMemoryPressureObserver> test_memory_pressure_observer_;
 135   scoped_ptr<MemoryPressureNotifier> memory_pressure_notifier_;
 136   DISALLOW_COPY_AND_ASSIGN(MemoryPressureTest);
 137 };
 138
 139 // Only creates and destroys it to see that the system gets properly shut down.
 140 TEST_F(MemoryPressureTest, SimpleTest) {
 141 }
 142
 143 // Test that we get only a single call while the memory pressure is low.
 144 TEST_F(MemoryPressureTest, OneEventOnLowPressure) {
 145   ASSERT_TRUE(WaitForTimer());
 146   // No call should have happened at this time to the
 147   EXPECT_FALSE(test_memory_pressure_observer()->number_of_calls());
 148   // Set to something below 50% and check that we still get no call.
 149   test_resource_manager_delegate()->set_memory_fill_level_percent(49);
 150   ASSERT_TRUE(WaitForTimer());
 151   EXPECT_EQ(1, test_memory_pressure_observer()->number_of_calls());
 152   EXPECT_EQ(MemoryPressureObserver::MEMORY_PRESSURE_LOW,
 153             test_memory_pressure_observer()->pressure());
 154   ASSERT_TRUE(WaitForTimer());
 155   EXPECT_EQ(1, test_memory_pressure_observer()->number_of_calls());
 156   EXPECT_EQ(MemoryPressureObserver::MEMORY_PRESSURE_LOW,
 157             test_memory_pressure_observer()->pressure());
 158 }
 159
 160 // Test that we get a |MEMORY_PRESSURE_UNKNOWN| if it cannot be determined.
 161 TEST_F(MemoryPressureTest, TestNoCallsOnMemoryPressureUnknown) {
 162   test_resource_manager_delegate()->set_memory_fill_level_percent(0);
 163   ASSERT_TRUE(WaitForTimer());
 164   // We shouldn't have gotten a single call.
 165   EXPECT_FALSE(test_memory_pressure_observer()->number_of_calls());
 166   // And the memory pressure should be unknown.
 167   EXPECT_EQ(MemoryPressureObserver::MEMORY_PRESSURE_UNKNOWN,
 168             test_memory_pressure_observer()->pressure());
 169 }
 170
 171 // Test that we get a change to MODERATE if the memory pressure is at 60%.
 172 TEST_F(MemoryPressureTest, TestModeratePressure) {
 173   test_resource_manager_delegate()->set_memory_fill_level_percent(60);
 174   ASSERT_TRUE(WaitForTimer());
 175   // At least one call should have happened.
 176   int calls = test_memory_pressure_observer()->number_of_calls();
 177   EXPECT_TRUE(calls);
 178   EXPECT_EQ(MemoryPressureObserver::MEMORY_PRESSURE_MODERATE,
 179             test_memory_pressure_observer()->pressure());
 180   // Even if the value does not change, we should get more calls.
 181   ASSERT_TRUE(WaitForTimer());
 182   EXPECT_LT(calls, test_memory_pressure_observer()->number_of_calls());
 183   EXPECT_EQ(MemoryPressureObserver::MEMORY_PRESSURE_MODERATE,
 184             test_memory_pressure_observer()->pressure());
 185 }
 186
 187 // Test that increasing and decreasing the memory pressure does the right thing.
 188 TEST_F(MemoryPressureTest, TestPressureUpAndDown) {
 189   test_resource_manager_delegate()->set_memory_fill_level_percent(60);
 190   ASSERT_TRUE(WaitForTimer());
 191   // At least one call should have happened.
 192   int calls1 = test_memory_pressure_observer()->number_of_calls();
 193   EXPECT_TRUE(calls1);
 194   EXPECT_EQ(MemoryPressureObserver::MEMORY_PRESSURE_MODERATE,
 195             test_memory_pressure_observer()->pressure());
 196
 197   // Check to the next level.
 198   test_resource_manager_delegate()->set_memory_fill_level_percent(80);
 199   ASSERT_TRUE(WaitForTimer());
 200   int calls2 = test_memory_pressure_observer()->number_of_calls();
 201   EXPECT_LT(calls1, calls2);
 202   EXPECT_EQ(MemoryPressureObserver::MEMORY_PRESSURE_HIGH,
 203             test_memory_pressure_observer()->pressure());
 204
 205   // Check to no pressure again.
 206   test_resource_manager_delegate()->set_memory_fill_level_percent(20);
 207   ASSERT_TRUE(WaitForTimer());
 208   int calls3 = test_memory_pressure_observer()->number_of_calls();
 209   EXPECT_LT(calls2, calls3);
 210   EXPECT_EQ(MemoryPressureObserver::MEMORY_PRESSURE_LOW,
 211             test_memory_pressure_observer()->pressure());
 212
 213   // Even if the value does not change, we should not get any more calls.
 214   ASSERT_TRUE(WaitForTimer());
 215   EXPECT_EQ(calls3, test_memory_pressure_observer()->number_of_calls());
 216   EXPECT_EQ(MemoryPressureObserver::MEMORY_PRESSURE_LOW,
 217             test_memory_pressure_observer()->pressure());
 218 }
 219
 220 }  // namespace test
 221 }  // namespace athena