chrome/browser/performance_monitor/database_unittest.cc

   1 // Copyright (c) 2012 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 #include <string>
   7 #include <vector>
   8
   9 #include "base/files/file_path.h"
  10 #include "base/files/scoped_temp_dir.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/time/time.h"
  13 #include "chrome/browser/performance_monitor/database.h"
  14 #include "chrome/browser/performance_monitor/key_builder.h"
  15 #include "chrome/browser/performance_monitor/metric.h"
  16 #include "chrome/browser/performance_monitor/performance_monitor_util.h"
  17 #include "extensions/common/extension.h"
  18 #include "extensions/common/manifest.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20 #include "third_party/leveldatabase/src/include/leveldb/db.h"
  21 #include "third_party/leveldatabase/src/include/leveldb/iterator.h"
  22
  23 using extensions::Extension;
  24 using extensions::Manifest;
  25
  26 namespace performance_monitor {
  27
  28 // A class which is friended by Database, in order to hold the private methods
  29 // and avoid friending all the different test classes.
  30 class DatabaseTestHelper {
  31  public:
  32   explicit DatabaseTestHelper(Database* database) : database_(database) { }
  33   ~DatabaseTestHelper() { }
  34
  35   bool Close() { return database_->Close(); }
  36
  37   // Override the check for a metric's validity and insert it in the database.
  38   // Note: This does not do extraneous updates, like updating the recent_db or
  39   // the max_value_map.
  40   bool AddInvalidMetric(std::string activity, Metric metric) {
  41     std::string metric_key =
  42         database_->key_builder_->CreateMetricKey(database_->clock_->GetTime(),
  43                                                  metric.type,
  44                                                  activity);
  45     leveldb::Status status =
  46         database_->metric_db_->Put(database_->write_options_,
  47                                    metric_key,
  48                                    metric.ValueAsString());
  49     return status.ok();
  50   }
  51
  52   // Writes an invalid event to the database; since events are stored as JSON
  53   // strings, this is equivalent to writing a garbage string.
  54   bool AddInvalidEvent(base::Time time, EventType type) {
  55     std::string key = database_->key_builder_->CreateEventKey(time, type);
  56     leveldb::Status status =
  57         database_->event_db_->Put(database_->write_options_, key, "fake_event");
  58     return status.ok();
  59   }
  60
  61   size_t GetNumberOfMetricEntries() {
  62     return GetNumberOfEntries(database_->metric_db_.get());
  63   }
  64   size_t GetNumberOfEventEntries() {
  65     return GetNumberOfEntries(database_->event_db_.get());
  66   }
  67
  68  private:
  69   // Returns the number of entries in a given database.
  70   size_t GetNumberOfEntries(leveldb::DB* level_db) {
  71     size_t number_of_entries = 0;
  72     scoped_ptr<leveldb::Iterator> iter(
  73         level_db->NewIterator(database_->read_options_));
  74     for (iter->SeekToFirst(); iter->Valid(); iter->Next())
  75       ++number_of_entries;
  76     return number_of_entries;
  77   }
  78
  79   Database* database_;
  80 };
  81
  82 // A clock that increments every access. Great for testing.
  83 class TestingClock : public Database::Clock {
  84  public:
  85   TestingClock()
  86       : counter_(0) {
  87   }
  88   explicit TestingClock(const TestingClock& other)
  89       : counter_(other.counter_) {
  90   }
  91   virtual ~TestingClock() {}
  92   virtual base::Time GetTime() OVERRIDE {
  93     return base::Time::FromInternalValue(++counter_);
  94   }
  95  private:
  96   int64 counter_;
  97 };
  98
  99 class PerformanceMonitorDatabaseEventTest : public ::testing::Test {
 100  protected:
 101   PerformanceMonitorDatabaseEventTest() {
 102     clock_ = new TestingClock();
 103     CHECK(temp_dir_.CreateUniqueTempDir());
 104     db_ = Database::Create(temp_dir_.path());
 105     CHECK(db_.get());
 106     db_->set_clock(scoped_ptr<Database::Clock>(clock_));
 107   }
 108
 109   virtual void SetUp() {
 110     ASSERT_TRUE(db_.get());
 111     PopulateDB();
 112   }
 113
 114   void PopulateDB() {
 115     InitEvents();
 116     db_->AddEvent(*install_event_1_.get());
 117     db_->AddEvent(*install_event_2_.get());
 118     db_->AddEvent(*uninstall_event_1_.get());
 119     db_->AddEvent(*uninstall_event_2_.get());
 120   }
 121
 122   scoped_ptr<Database> db_;
 123   Database::Clock* clock_;
 124   base::ScopedTempDir temp_dir_;
 125   scoped_ptr<Event> install_event_1_;
 126   scoped_ptr<Event> install_event_2_;
 127   scoped_ptr<Event> uninstall_event_1_;
 128   scoped_ptr<Event> uninstall_event_2_;
 129
 130  private:
 131   void InitEvents() {
 132     install_event_1_ = util::CreateExtensionEvent(
 133         EVENT_EXTENSION_INSTALL, clock_->GetTime(), "a", "extension 1",
 134         "http://foo.com", static_cast<int>(Manifest::UNPACKED), "0.1",
 135         "Test Test");
 136     install_event_2_ = util::CreateExtensionEvent(
 137         EVENT_EXTENSION_INSTALL, clock_->GetTime(), "b", "extension 2",
 138         "http://bar.com", static_cast<int>(Manifest::UNPACKED), "0.1",
 139         "Test Test");
 140     uninstall_event_1_ = util::CreateExtensionEvent(
 141         EVENT_EXTENSION_UNINSTALL, clock_->GetTime(), "a", "extension 1",
 142         "http://foo.com", static_cast<int>(Manifest::UNPACKED), "0.1",
 143         "Test Test");
 144     uninstall_event_2_ = util::CreateExtensionEvent(
 145         EVENT_EXTENSION_UNINSTALL, clock_->GetTime(), "b", "extension 2",
 146         "http://bar.com", static_cast<int>(Manifest::UNPACKED), "0.1",
 147         "Test Test");
 148   }
 149 };
 150
 151 class PerformanceMonitorDatabaseMetricTest : public ::testing::Test {
 152  protected:
 153   PerformanceMonitorDatabaseMetricTest() {
 154     clock_ = new TestingClock();
 155     CHECK(temp_dir_.CreateUniqueTempDir());
 156     db_ = Database::Create(temp_dir_.path());
 157     CHECK(db_.get());
 158     db_->set_clock(scoped_ptr<Database::Clock>(clock_));
 159     activity_ = std::string("A");
 160   }
 161
 162   virtual void SetUp() {
 163     ASSERT_TRUE(db_.get());
 164     PopulateDB();
 165   }
 166
 167   void PopulateDB() {
 168     db_->AddMetric(kProcessChromeAggregate,
 169                    Metric(METRIC_CPU_USAGE, clock_->GetTime(), 50.5));
 170     db_->AddMetric(activity_,
 171                    Metric(METRIC_CPU_USAGE, clock_->GetTime(), 13.1));
 172     db_->AddMetric(kProcessChromeAggregate,
 173                    Metric(METRIC_PRIVATE_MEMORY_USAGE,
 174                           clock_->GetTime(),
 175                           1000000.0));
 176     db_->AddMetric(activity_,
 177                    Metric(METRIC_PRIVATE_MEMORY_USAGE,
 178                           clock_->GetTime(),
 179                           3000000.0));
 180   }
 181
 182   scoped_ptr<Database> db_;
 183   Database::Clock* clock_;
 184   base::ScopedTempDir temp_dir_;
 185   std::string activity_;
 186 };
 187
 188 ////// PerformanceMonitorDatabaseSetupTests ////////////////////////////////////
 189 TEST(PerformanceMonitorDatabaseSetupTest, OpenClose) {
 190   base::ScopedTempDir temp_dir;
 191   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 192   scoped_ptr<Database> db = Database::Create(temp_dir.path());
 193   ASSERT_TRUE(db.get());
 194   DatabaseTestHelper helper(db.get());
 195   ASSERT_TRUE(helper.Close());
 196 }
 197
 198 TEST(PerformanceMonitorDatabaseSetupTest, ActiveInterval) {
 199   base::ScopedTempDir temp_dir;
 200   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 201
 202   TestingClock* clock_1 = new TestingClock();
 203   base::Time start_time = clock_1->GetTime();
 204
 205   scoped_ptr<Database> db_1 = Database::Create(temp_dir.path());
 206   db_1->set_clock(scoped_ptr<Database::Clock>(clock_1));
 207   DatabaseTestHelper helper1(db_1.get());
 208   db_1->AddStateValue("test", "test");
 209   ASSERT_TRUE(db_1.get());
 210   ASSERT_TRUE(helper1.Close());
 211
 212   TestingClock* clock_2 = new TestingClock(*clock_1);
 213   base::Time mid_time = clock_2->GetTime();
 214   scoped_ptr<Database> db_2 = Database::Create(temp_dir.path());
 215   db_2->set_clock(scoped_ptr<Database::Clock>(clock_2));
 216   DatabaseTestHelper helper2(db_2.get());
 217   db_2->AddStateValue("test", "test");
 218   ASSERT_TRUE(db_2.get());
 219   ASSERT_TRUE(helper2.Close());
 220
 221   TestingClock* clock_3 = new TestingClock(*clock_2);
 222   base::Time end_time = clock_3->GetTime();
 223   scoped_ptr<Database> db_3 = Database::Create(temp_dir.path());
 224   db_3->set_clock(scoped_ptr<Database::Clock>(clock_3));
 225   db_3->AddStateValue("test", "test");
 226   ASSERT_TRUE(db_3.get());
 227
 228   std::vector<TimeRange> active_interval = db_3->GetActiveIntervals(start_time,
 229                                                                     end_time);
 230   ASSERT_EQ(active_interval.size(), 2u);
 231   ASSERT_TRUE(active_interval[0].start > start_time &&
 232               active_interval[0].end < mid_time);
 233   ASSERT_TRUE(active_interval[1].start > mid_time &&
 234               active_interval[1].end < end_time);
 235 }
 236
 237 TEST(PerformanceMonitorDatabaseSetupTest,
 238      ActiveIntervalRetrievalDuringActiveInterval) {
 239   base::ScopedTempDir temp_dir;
 240   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 241
 242   TestingClock* clock = new TestingClock();
 243   scoped_ptr<Database> db = Database::Create(temp_dir.path());
 244   db->set_clock(scoped_ptr<Database::Clock>(clock));
 245   db->AddStateValue("test", "test");
 246   base::Time start_time = clock->GetTime();
 247   db->AddStateValue("test", "test");
 248   base::Time end_time = clock->GetTime();
 249   db->AddStateValue("test", "test");
 250
 251   std::vector<TimeRange> active_interval = db->GetActiveIntervals(start_time,
 252                                                                   end_time);
 253   ASSERT_EQ(1u, active_interval.size());
 254   EXPECT_LT(active_interval[0].start, start_time);
 255   EXPECT_GT(active_interval[0].end, start_time);
 256 }
 257
 258 TEST(PerformanceMonitorDatabaseSetupTest,
 259      ActiveIntervalRetrievalAfterActiveInterval) {
 260   base::ScopedTempDir temp_dir;
 261   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 262
 263   TestingClock* clock = new TestingClock();
 264   scoped_ptr<Database> db = Database::Create(temp_dir.path());
 265   db->set_clock(scoped_ptr<Database::Clock>(clock));
 266   db->AddStateValue("test", "test");
 267
 268   base::Time start_time = clock->GetTime();
 269   base::Time end_time = clock->GetTime();
 270   std::vector<TimeRange> active_interval = db->GetActiveIntervals(start_time,
 271                                                                   end_time);
 272   EXPECT_TRUE(active_interval.empty());
 273 }
 274
 275 ////// PerformanceMonitorDatabaseEventTests ////////////////////////////////////
 276 TEST_F(PerformanceMonitorDatabaseEventTest, GetAllEvents) {
 277   Database::EventVector events = db_->GetEvents();
 278   ASSERT_EQ(4u, events.size());
 279   EXPECT_TRUE(events[0]->data()->Equals(install_event_1_->data()));
 280   EXPECT_TRUE(events[1]->data()->Equals(install_event_2_->data()));
 281   EXPECT_TRUE(events[2]->data()->Equals(uninstall_event_1_->data()));
 282   EXPECT_TRUE(events[3]->data()->Equals(uninstall_event_2_->data()));
 283 }
 284
 285 TEST_F(PerformanceMonitorDatabaseMetricTest, GetMaxMetric) {
 286   Metric stat;
 287   EXPECT_EQ(0.0, db_->GetMaxStatsForActivityAndMetric(activity_,
 288                                                       METRIC_PAGE_LOAD_TIME));
 289
 290   EXPECT_EQ(1000000,
 291             db_->GetMaxStatsForActivityAndMetric(METRIC_PRIVATE_MEMORY_USAGE));
 292
 293   db_->AddMetric(kProcessChromeAggregate,
 294                  Metric(METRIC_PRIVATE_MEMORY_USAGE, clock_->GetTime(), 99.0));
 295   EXPECT_EQ(1000000,
 296             db_->GetMaxStatsForActivityAndMetric(METRIC_PRIVATE_MEMORY_USAGE));
 297
 298   db_->AddMetric(kProcessChromeAggregate,
 299                  Metric(METRIC_PRIVATE_MEMORY_USAGE,
 300                         clock_->GetTime(),
 301                         6000000.0));
 302   EXPECT_EQ(6000000,
 303             db_->GetMaxStatsForActivityAndMetric(METRIC_PRIVATE_MEMORY_USAGE));
 304 }
 305
 306 TEST_F(PerformanceMonitorDatabaseEventTest, GetAllEventTypes) {
 307   Database::EventTypeSet types = db_->GetEventTypes();
 308   ASSERT_EQ(2u, types.size());
 309   ASSERT_EQ(1u, types.count(EVENT_EXTENSION_INSTALL));
 310   ASSERT_EQ(1u, types.count(EVENT_EXTENSION_UNINSTALL));
 311 }
 312
 313 TEST_F(PerformanceMonitorDatabaseEventTest, GetEventInTimeRange) {
 314   base::Time start_time = clock_->GetTime();
 315   scoped_ptr<Event> crash_event = util::CreateRendererFailureEvent(
 316       clock_->GetTime(), EVENT_RENDERER_CRASH, "http://www.google.com/");
 317   db_->AddEvent(*crash_event.get());
 318   Database::EventVector events = db_->GetEvents(start_time, clock_->GetTime());
 319   ASSERT_EQ(1u, events.size());
 320   EXPECT_TRUE(events[0]->data()->Equals(crash_event->data()));
 321 }
 322
 323 TEST_F(PerformanceMonitorDatabaseEventTest, GetInstallEvents) {
 324   Database::EventVector events = db_->GetEvents(EVENT_EXTENSION_INSTALL);
 325   ASSERT_EQ(2u, events.size());
 326   EXPECT_TRUE(events[0]->data()->Equals(install_event_1_->data()));
 327   EXPECT_TRUE(events[1]->data()->Equals(install_event_2_->data()));
 328 }
 329
 330 TEST_F(PerformanceMonitorDatabaseEventTest, InvalidEvents) {
 331   DatabaseTestHelper helper(db_.get());
 332
 333   // Insert an invalid event into the database; verify it is inserted.
 334   size_t original_number_of_entries = helper.GetNumberOfEventEntries();
 335   ASSERT_TRUE(helper.AddInvalidEvent(
 336       clock_->GetTime(), EVENT_EXTENSION_INSTALL));
 337   ASSERT_EQ(original_number_of_entries + 1u, helper.GetNumberOfEventEntries());
 338
 339   // Should not retrieve the invalid event.
 340   Database::EventVector events = db_->GetEvents();
 341   ASSERT_EQ(original_number_of_entries, events.size());
 342
 343   // Invalid event should have been deleted.
 344   ASSERT_EQ(original_number_of_entries, helper.GetNumberOfEventEntries());
 345 }
 346
 347 TEST_F(PerformanceMonitorDatabaseEventTest, GetUnusedEventType) {
 348   Database::EventVector events = db_->GetEvents(EVENT_EXTENSION_DISABLE);
 349   ASSERT_TRUE(events.empty());
 350   events = db_->GetEvents(EVENT_EXTENSION_DISABLE, clock_->GetTime(),
 351                           clock_->GetTime());
 352   ASSERT_TRUE(events.empty());
 353 }
 354
 355 TEST_F(PerformanceMonitorDatabaseEventTest, GetEventsTimeRange) {
 356   base::Time start_time = clock_->GetTime();
 357   scoped_ptr<Event> new_install_event =
 358       util::CreateExtensionEvent(EVENT_EXTENSION_INSTALL, clock_->GetTime(),
 359                                  "c", "test extension", "http://foo.com",
 360                                  static_cast<int>(Manifest::UNPACKED), "0.1",
 361                                  "Test Test");
 362   scoped_ptr<Event> new_uninstall_event =
 363       util::CreateExtensionEvent(EVENT_EXTENSION_UNINSTALL, clock_->GetTime(),
 364                                  "c", "test extension", "http://foo.com",
 365                                  static_cast<int>(Manifest::UNPACKED), "0.1",
 366                                  "Test Test");
 367   base::Time end_time = clock_->GetTime();
 368   db_->AddEvent(*new_install_event.get());
 369   db_->AddEvent(*new_uninstall_event.get());
 370   Database::EventVector events = db_->GetEvents(start_time, end_time);
 371   ASSERT_EQ(2u, events.size());
 372   EXPECT_TRUE(events[0]->data()->Equals(new_install_event->data()));
 373   EXPECT_TRUE(events[1]->data()->Equals(new_uninstall_event->data()));
 374   events = db_->GetEvents(
 375       EVENT_EXTENSION_INSTALL, start_time, end_time);
 376   ASSERT_EQ(1u, events.size());
 377   EXPECT_TRUE(events[0]->data()->Equals(new_install_event->data()));
 378 }
 379
 380 ////// PerformanceMonitorDatabaseMetricTests ///////////////////////////////////
 381 TEST_F(PerformanceMonitorDatabaseMetricTest, GetActiveMetrics) {
 382   Database::MetricTypeSet active_metrics =
 383     db_->GetActiveMetrics(base::Time(), clock_->GetTime());
 384
 385   Database::MetricTypeSet expected_metrics;
 386   expected_metrics.insert(METRIC_CPU_USAGE);
 387   expected_metrics.insert(METRIC_PRIVATE_MEMORY_USAGE);
 388   EXPECT_EQ(expected_metrics, active_metrics);
 389 }
 390
 391 TEST_F(PerformanceMonitorDatabaseMetricTest, GetRecentMetric) {
 392   Metric stat;
 393   ASSERT_TRUE(db_->GetRecentStatsForActivityAndMetric(activity_,
 394       METRIC_PRIVATE_MEMORY_USAGE, &stat));
 395   EXPECT_EQ(3000000, stat.value);
 396
 397   ASSERT_TRUE(db_->GetRecentStatsForActivityAndMetric(METRIC_CPU_USAGE, &stat));
 398   EXPECT_EQ(50.5, stat.value);
 399
 400   base::ScopedTempDir dir;
 401   CHECK(dir.CreateUniqueTempDir());
 402   scoped_ptr<Database> db = Database::Create(dir.path());
 403   CHECK(db.get());
 404   db->set_clock(scoped_ptr<Database::Clock>(new TestingClock()));
 405   EXPECT_FALSE(db->GetRecentStatsForActivityAndMetric(METRIC_CPU_USAGE, &stat));
 406 }
 407
 408 TEST_F(PerformanceMonitorDatabaseMetricTest, GetState) {
 409   std::string key("version");
 410   std::string value("1.0.0.0.1");
 411   db_->AddStateValue(key, value);
 412   EXPECT_EQ(db_->GetStateValue(key), value);
 413 }
 414
 415 TEST_F(PerformanceMonitorDatabaseMetricTest, GetStateOverride) {
 416   std::string key("version");
 417   std::string value_1("1.0.0.0.0");
 418   std::string value_2("1.0.0.0.1");
 419   db_->AddStateValue(key, value_1);
 420   db_->AddStateValue(key, value_2);
 421   EXPECT_EQ(db_->GetStateValue(key), value_2);
 422 }
 423
 424 TEST_F(PerformanceMonitorDatabaseMetricTest, GetStatsForActivityAndMetric) {
 425   Database::MetricVector stats = *db_->GetStatsForActivityAndMetric(
 426       activity_, METRIC_CPU_USAGE, base::Time(), clock_->GetTime());
 427   ASSERT_EQ(1u, stats.size());
 428   EXPECT_EQ(13.1, stats[0].value);
 429   base::Time before = clock_->GetTime();
 430   db_->AddMetric(activity_,
 431                  Metric(METRIC_CPU_USAGE, clock_->GetTime(), 18.0));
 432   stats = *db_->GetStatsForActivityAndMetric(activity_, METRIC_CPU_USAGE,
 433                                             before, clock_->GetTime());
 434   ASSERT_EQ(1u, stats.size());
 435   EXPECT_EQ(18, stats[0].value);
 436   stats = *db_->GetStatsForActivityAndMetric(activity_, METRIC_CPU_USAGE);
 437   ASSERT_EQ(2u, stats.size());
 438   EXPECT_EQ(13.1, stats[0].value);
 439   EXPECT_EQ(18, stats[1].value);
 440   stats = *db_->GetStatsForActivityAndMetric(METRIC_PRIVATE_MEMORY_USAGE);
 441   ASSERT_EQ(1u, stats.size());
 442   EXPECT_EQ(1000000, stats[0].value);
 443   stats = *db_->GetStatsForActivityAndMetric(activity_, METRIC_CPU_USAGE,
 444                                             clock_->GetTime(),
 445                                             clock_->GetTime());
 446   EXPECT_TRUE(stats.empty());
 447 }
 448
 449 TEST_F(PerformanceMonitorDatabaseMetricTest, GetStatsForMetricByActivity) {
 450   Database::MetricVectorMap stats_map = db_->GetStatsForMetricByActivity(
 451       METRIC_CPU_USAGE, base::Time(), clock_->GetTime());
 452   ASSERT_EQ(2u, stats_map.size());
 453   linked_ptr<Database::MetricVector> stats = stats_map[activity_];
 454   ASSERT_EQ(1u, stats->size());
 455   EXPECT_EQ(13.1, stats->at(0).value);
 456   stats = stats_map[kProcessChromeAggregate];
 457   ASSERT_EQ(1u, stats->size());
 458   EXPECT_EQ(50.5, stats->at(0).value);
 459   stats_map = db_->GetStatsForMetricByActivity(
 460       METRIC_CPU_USAGE, clock_->GetTime(), clock_->GetTime());
 461   EXPECT_EQ(0u, stats_map.size());
 462   base::Time before = clock_->GetTime();
 463   db_->AddMetric(activity_,
 464                  Metric(METRIC_CPU_USAGE, clock_->GetTime(), 18.0));
 465   stats_map = db_->GetStatsForMetricByActivity(METRIC_CPU_USAGE, before,
 466                                                clock_->GetTime());
 467   ASSERT_EQ(1u, stats_map.size());
 468   stats = stats_map[activity_];
 469   ASSERT_EQ(1u, stats->size());
 470   EXPECT_EQ(18, stats->at(0).value);
 471 }
 472
 473 TEST_F(PerformanceMonitorDatabaseMetricTest, InvalidMetrics) {
 474   DatabaseTestHelper helper(db_.get());
 475   Metric invalid_metric(METRIC_CPU_USAGE, clock_->GetTime(), -5.0);
 476   ASSERT_FALSE(invalid_metric.IsValid());
 477
 478   // Find the original number of entries in the database.
 479   size_t original_number_of_entries = helper.GetNumberOfMetricEntries();
 480   Database::MetricVector stats = *db_->GetStatsForActivityAndMetric(
 481       activity_, METRIC_CPU_USAGE, base::Time(), clock_->GetTime());
 482   size_t original_number_of_cpu_entries = stats.size();
 483
 484   // Check that the database normally refuses to insert bad metrics.
 485   EXPECT_FALSE(db_->AddMetric(invalid_metric));
 486
 487   // Verify that it was not inserted into the database.
 488   stats = *db_->GetStatsForActivityAndMetric(
 489       activity_, METRIC_CPU_USAGE, base::Time(), clock_->GetTime());
 490   ASSERT_EQ(original_number_of_cpu_entries, stats.size());
 491
 492   // Forcefully insert it into the database.
 493   ASSERT_TRUE(helper.AddInvalidMetric(activity_, invalid_metric));
 494   ASSERT_EQ(original_number_of_entries + 1u, helper.GetNumberOfMetricEntries());
 495
 496   // Try to retrieve it; should only get one result.
 497   stats = *db_->GetStatsForActivityAndMetric(
 498       activity_, METRIC_CPU_USAGE, base::Time(), clock_->GetTime());
 499   ASSERT_EQ(original_number_of_cpu_entries, stats.size());
 500
 501   // Entry should have been deleted in the database.
 502   ASSERT_EQ(original_number_of_entries, helper.GetNumberOfMetricEntries());
 503 }
 504
 505 TEST_F(PerformanceMonitorDatabaseMetricTest, GetFullRange) {
 506   db_->AddMetric(kProcessChromeAggregate,
 507                  Metric(METRIC_CPU_USAGE, clock_->GetTime(), 3.4));
 508   db_->AddMetric(kProcessChromeAggregate,
 509                  Metric(METRIC_CPU_USAGE, clock_->GetTime(), 21.0));
 510   Database::MetricVector stats =
 511       *db_->GetStatsForActivityAndMetric(METRIC_CPU_USAGE);
 512   ASSERT_EQ(3u, stats.size());
 513   ASSERT_EQ(50.5, stats[0].value);
 514   ASSERT_EQ(3.4, stats[1].value);
 515   ASSERT_EQ(21, stats[2].value);
 516 }
 517
 518 TEST_F(PerformanceMonitorDatabaseMetricTest, GetRange) {
 519   base::Time start = clock_->GetTime();
 520   db_->AddMetric(kProcessChromeAggregate,
 521                  Metric(METRIC_CPU_USAGE, clock_->GetTime(), 3.0));
 522   db_->AddMetric(kProcessChromeAggregate,
 523                  Metric(METRIC_CPU_USAGE, clock_->GetTime(), 9.0));
 524   base::Time end = clock_->GetTime();
 525   db_->AddMetric(kProcessChromeAggregate,
 526                  Metric(METRIC_CPU_USAGE, clock_->GetTime(), 21.0));
 527   Database::MetricVector stats =
 528       *db_->GetStatsForActivityAndMetric(METRIC_CPU_USAGE, start, end);
 529   ASSERT_EQ(2u, stats.size());
 530   ASSERT_EQ(3, stats[0].value);
 531   ASSERT_EQ(9, stats[1].value);
 532 }
 533
 534 }  // namespace performance_monitor