chrome/browser/private_working_set_snapshot_win_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 "chrome/browser/private_working_set_snapshot.h"
   6
   7 #include "base/win/windows_version.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9
  10 using PrivateWorkingSetSnapshotWinTest = testing::Test;
  11
  12 TEST_F(PrivateWorkingSetSnapshotWinTest, FindPidSelfTest) {
  13   // The Pdh APIs are supported on Windows XP and above, but the "Working Set -
  14   // Private" counter that PrivateWorkingSetSnapshot depends on is not defined
  15   // until Windows Vista and is not reliable until Windows 7. Early-out to avoid
  16   // test failure.
  17   if (base::win::GetVersion() <= base::win::VERSION_VISTA)
  18     return;
  19
  20   // Sample this process.
  21   base::ProcessId pid = base::GetCurrentProcId();
  22
  23   PrivateWorkingSetSnapshot private_ws_snapshot;
  24
  25   private_ws_snapshot.AddToMonitorList("unit_tests");
  26   private_ws_snapshot.Sample();
  27
  28   size_t private_ws = private_ws_snapshot.GetPrivateWorkingSet(pid);
  29   if (private_ws == 0) {
  30     // The Pdh APIs which PrivateWorkingSetSnapshot depends on are flaky and
  31     // sometimes (~5% of the time on win_chromium_rel_ng) give back a result of
  32     // zero. This is handled seamlessly in task manager by falling back to the
  33     // old calculations so it is not a critical failure. Checking for this case
  34     // and skipping the test stops flaky-test failures.
  35     return;
  36   }
  37
  38   // Private working set is difficult to predict but should be at least several
  39   // MB. Initial tests show a value of 19+ MB depending on how many tests and
  40   // processes are used. Anomalously small or large values would warrant
  41   // investigation.
  42   EXPECT_GT(private_ws, 2000000u);
  43   // Check that the WS is less than 1500 MB. This is set very high to reduce the
  44   // chance that unrelated changes could ever make this fail. This mostly just
  45   // checks against some uncaught error that might return 0xFFFFFFFF. When run
  46   // under Dr Memory the private working set was seen to be about 850 MB, which
  47   // is why such a high threshold has been chosen.
  48   EXPECT_LT(private_ws, 1500000000u);
  49
  50   // Allocate and touch a large block of memory (vector's constructor will zero
  51   // every entry). This will increase the private working set.
  52   const size_t alloc_size = 10000000;
  53   std::vector<char> big_memory(alloc_size);
  54
  55   size_t private_ws2 = private_ws_snapshot.GetPrivateWorkingSet(pid);
  56   EXPECT_EQ(private_ws, private_ws2) << "GetPrivateWorkingSet should be "
  57                                         "consistent until the next call to "
  58                                         "Sample()";
  59
  60   private_ws_snapshot.Sample();
  61   size_t private_ws3 = private_ws_snapshot.GetPrivateWorkingSet(pid);
  62   EXPECT_GT(private_ws3, private_ws2 + alloc_size / 2)
  63       << "GetPrivateWorkingSet should increase as we allocate more memory";
  64 }