chrome/browser/apps/ephemeral_app_service_unittest.cc

   1 // Copyright 2013 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 <algorithm>
   6
   7 #include "base/rand_util.h"
   8 #include "base/strings/string_number_conversions.h"
   9 #include "base/time/time.h"
  10 #include "chrome/browser/apps/ephemeral_app_service.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 namespace {
  14
  15 // Generate a time N number of days before the reference time.
  16 // The generated time can be randomized.
  17 base::Time GetPastTime(const base::Time& reference_time,
  18                        int days_before,
  19                        bool randomize_time = false) {
  20   base::Time generated_time =
  21       reference_time - base::TimeDelta::FromDays(days_before);
  22
  23   // Add an hour so that the time is well within the number of days before.
  24   generated_time += base::TimeDelta::FromHours(1);
  25
  26   // Add a random number of seconds between 0 - 10 hours.
  27   if (randomize_time)
  28     generated_time += base::TimeDelta::FromSeconds(base::RandInt(0, 36000));
  29
  30   return generated_time;
  31 }
  32
  33 }  // namespace
  34
  35 class EphemeralAppServiceTest : public testing::Test {
  36  protected:
  37   typedef EphemeralAppService::LaunchTimeAppMap LaunchTimeAppMap;
  38
  39   EphemeralAppServiceTest() {}
  40   ~EphemeralAppServiceTest() override {}
  41
  42   void RunTest(int ephemeral_app_count,
  43                const LaunchTimeAppMap& launch_times,
  44                const std::set<std::string>& expected_removed_ids) {
  45     std::set<std::string> remove_app_ids;
  46     EphemeralAppService::GetAppsToRemove(ephemeral_app_count,
  47                                          launch_times,
  48                                          &remove_app_ids);
  49     EXPECT_EQ(expected_removed_ids, remove_app_ids);
  50   }
  51
  52   void RunTestCheckLRU(int ephemeral_app_count,
  53                        LaunchTimeAppMap& launch_times,
  54                        int expected_removed_count) {
  55     std::set<std::string> remove_app_ids;
  56     EphemeralAppService::GetAppsToRemove(ephemeral_app_count,
  57                                          launch_times,
  58                                          &remove_app_ids);
  59     EXPECT_EQ(expected_removed_count, (int) remove_app_ids.size());
  60
  61     // Move the launch times of removed apps to another map.
  62     LaunchTimeAppMap removed_apps;
  63     for (LaunchTimeAppMap::iterator it = launch_times.begin();
  64          it != launch_times.end(); ) {
  65       if (remove_app_ids.find(it->second) != remove_app_ids.end()) {
  66         removed_apps.insert(*it);
  67         launch_times.erase(it++);
  68       } else {
  69         ++it;
  70       }
  71     }
  72
  73     if (launch_times.empty())
  74       return;
  75
  76     // Verify that the removed apps have launch times earlier than or equal to
  77     // all retained apps. We can actually just compare with the first entry in
  78     // |launch_times| but will make no implementation assumptions.
  79     for (LaunchTimeAppMap::const_iterator removed = removed_apps.begin();
  80          removed != removed_apps.end(); ++removed) {
  81       for (LaunchTimeAppMap::iterator retained = launch_times.begin();
  82          retained != launch_times.end(); ++retained) {
  83         EXPECT_LE(removed->first, retained->first);
  84       }
  85     }
  86   }
  87
  88   // Generate X app launch times, N days before the reference time.
  89   // If |generated_ids| is not NULL, the generated app IDs will be added
  90   // to the set.
  91   void GenerateLaunchTimes(const base::Time& reference_time,
  92                            int days_before,
  93                            int count,
  94                            LaunchTimeAppMap* launch_times,
  95                            std::set<std::string>* generated_ids = NULL) {
  96     for (int i = 0; i < count; ++i) {
  97       std::string app_id = base::SizeTToString(launch_times->size());
  98       launch_times->insert(std::make_pair(
  99           GetPastTime(reference_time, days_before, true),
 100           app_id));
 101
 102       if (generated_ids)
 103         generated_ids->insert(app_id);
 104     }
 105   }
 106
 107   // Add inactive apps that should always be removed by garbage collection.
 108   void AddInactiveApps(const base::Time& reference_time,
 109                        int count,
 110                        LaunchTimeAppMap* launch_times,
 111                        std::set<std::string>* generated_ids = NULL) {
 112     GenerateLaunchTimes(reference_time,
 113                         EphemeralAppService::kAppInactiveThreshold + 1,
 114                         count,
 115                         launch_times,
 116                         generated_ids);
 117   }
 118
 119   // Add recently launched apps that should NOT be removed by garbage
 120   // collection regardless of the number of cached ephemeral apps.
 121   void AddRecentlyLaunchedApps(const base::Time& reference_time,
 122                                int count,
 123                                LaunchTimeAppMap* launch_times,
 124                                std::set<std::string>* generated_ids = NULL) {
 125     GenerateLaunchTimes(reference_time,
 126                         EphemeralAppService::kAppKeepThreshold,
 127                         count,
 128                         launch_times,
 129                         generated_ids);
 130   }
 131
 132   // Add apps launched between the kAppInactiveThreshold and kAppKeepThreshold,
 133   // which may or may not be removed by garbage collection depending on the
 134   // number of ephemeral apps in the cache.
 135   void AddIntermediateApps(const base::Time& reference_time,
 136                            int count,
 137                            LaunchTimeAppMap* launch_times,
 138                            std::set<std::string>* generated_ids = NULL) {
 139     int days_before = base::RandInt(EphemeralAppService::kAppKeepThreshold + 1,
 140                                     EphemeralAppService::kAppInactiveThreshold);
 141     GenerateLaunchTimes(reference_time,
 142                         days_before,
 143                         count,
 144                         launch_times,
 145                         generated_ids);
 146   }
 147 };
 148
 149 // Verify that inactive apps are removed even if the cache has not reached
 150 // capacity.
 151 // Test case: | inactive |
 152 // Expected output: All inactive apps removed.
 153 TEST_F(EphemeralAppServiceTest, RemoveInactiveApps) {
 154   base::Time time_now = base::Time::Now();
 155   LaunchTimeAppMap launch_times;
 156   std::set<std::string> expected_removed_ids;
 157
 158   AddInactiveApps(
 159       time_now,
 160       EphemeralAppService::kMaxEphemeralAppsCount / 5,
 161       &launch_times,
 162       &expected_removed_ids);
 163   RunTest(launch_times.size(), launch_times, expected_removed_ids);
 164 }
 165
 166 // Verify that inactive apps are removed even if the cache has not reached
 167 // capacity.
 168 // Test case: | inactive | intermediate | recently launched |
 169 // Expected output: All inactive apps removed, other apps retained.
 170 TEST_F(EphemeralAppServiceTest, RemoveInactiveAppsKeepOthers) {
 171   base::Time time_now = base::Time::Now();
 172   LaunchTimeAppMap launch_times;
 173   std::set<std::string> expected_removed_ids;
 174
 175   AddInactiveApps(
 176       time_now,
 177       EphemeralAppService::kMaxEphemeralAppsCount / 5,
 178       &launch_times,
 179       &expected_removed_ids);
 180   AddIntermediateApps(
 181       time_now,
 182       EphemeralAppService::kMaxEphemeralAppsCount / 5,
 183       &launch_times);
 184   AddRecentlyLaunchedApps(
 185       time_now,
 186       EphemeralAppService::kMaxEphemeralAppsCount / 5,
 187       &launch_times);
 188   RunTest(launch_times.size(), launch_times, expected_removed_ids);
 189 }
 190
 191 // Verify that recently launched apps will not be removed, even when the cache
 192 // overflows.
 193 // Test case: | recently launched |
 194 // Expected output: All recently launched apps retained.
 195 TEST_F(EphemeralAppServiceTest, KeepRecentLaunch) {
 196   base::Time time_now = base::Time::Now();
 197   LaunchTimeAppMap launch_times;
 198
 199   AddRecentlyLaunchedApps(
 200       time_now,
 201       3,
 202       &launch_times);
 203   RunTest(launch_times.size(), launch_times, std::set<std::string>());
 204
 205   AddRecentlyLaunchedApps(
 206       time_now,
 207       EphemeralAppService::kMaxEphemeralAppsCount,
 208       &launch_times); // overflow
 209   RunTest(launch_times.size(), launch_times, std::set<std::string>());
 210 }
 211
 212 // Verify that recently launched apps will not be removed, even when the cache
 213 // overflows.
 214 // Test case: | intermediate (overflow) | recently launched (overflow) |
 215 // Expected output: All recently launched apps retained, intermediate apps
 216 // removed.
 217 TEST_F(EphemeralAppServiceTest, KeepRecentLaunchRemoveOthers) {
 218   base::Time time_now = base::Time::Now();
 219   LaunchTimeAppMap launch_times;
 220   std::set<std::string> expected_removed_ids;
 221
 222   AddRecentlyLaunchedApps(
 223       time_now,
 224       EphemeralAppService::kMaxEphemeralAppsCount + 3,
 225       &launch_times); // overflow
 226   AddIntermediateApps(
 227       time_now,
 228       3,
 229       &launch_times,
 230       &expected_removed_ids); // overflow
 231   RunTest(launch_times.size(), launch_times, expected_removed_ids);
 232 }
 233
 234 // Verify that the LRU algorithm is implemented correctly.
 235 // Test case: | intermediate (overflow) |
 236 // Expected output: The least recently launched apps are removed.
 237 TEST_F(EphemeralAppServiceTest, RemoveOverflow) {
 238   base::Time time_now = base::Time::Now();
 239   LaunchTimeAppMap launch_times;
 240
 241   const int kOverflow = 3;
 242   AddIntermediateApps(
 243       time_now,
 244       EphemeralAppService::kMaxEphemeralAppsCount + kOverflow,
 245       &launch_times); // overflow
 246   RunTestCheckLRU(launch_times.size(), launch_times, kOverflow);
 247 }
 248
 249 // Verify that GetAppsToRemove() takes into account the number of running apps,
 250 // since they are not included in the launch times.
 251 // Test case: | intermediate (overflow) | running apps |
 252 // Expected output: The least recently launched apps are removed.
 253 TEST_F(EphemeralAppServiceTest, RemoveOverflowWithRunningApps) {
 254   base::Time time_now = base::Time::Now();
 255   LaunchTimeAppMap launch_times;
 256
 257   const int kRunningApps = 3;
 258   AddIntermediateApps(
 259       time_now,
 260       EphemeralAppService::kMaxEphemeralAppsCount,
 261       &launch_times);  // overflow
 262   RunTestCheckLRU(
 263       launch_times.size() + kRunningApps,
 264       launch_times,
 265       kRunningApps);
 266 }