Home | History | Annotate | Download | only in test 
      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 "base/compiler_specific.h"
      6 #include "base/memory/scoped_ptr.h"
      7 #include "base/strings/string_number_conversions.h"
      8 #include "base/strings/utf_string_conversions.h"
      9 #include "base/test/test_reg_util_win.h"
     10 #include "base/time/time.h"
     11 #include "testing/gtest/include/gtest/gtest.h"
     12 
     13 namespace registry_util {
     14 
     15 namespace {
     16 const wchar_t kTestKeyPath[] = L"Software\\Chromium\\Foo\\Baz\\TestKey";
     17 const wchar_t kTestValueName[] = L"TestValue";
     18 }  // namespace
     19 
     20 class RegistryOverrideManagerTest : public testing::Test {
     21  protected:
     22   RegistryOverrideManagerTest() {
     23     // We assign a fake test key path to our test RegistryOverrideManager
     24     // so we don't interfere with any actual RegistryOverrideManagers running
     25     // on the system. This fake path will be auto-deleted by other
     26     // RegistryOverrideManagers in case we crash.
     27     fake_test_key_root_ = registry_util::GenerateTempKeyPath();
     28 
     29     // Ensure a clean test environment.
     30     base::win::RegKey key(HKEY_CURRENT_USER);
     31     key.DeleteKey(fake_test_key_root_.c_str());
     32     key.DeleteKey(kTestKeyPath);
     33   }
     34 
     35   virtual ~RegistryOverrideManagerTest() {
     36     base::win::RegKey key(HKEY_CURRENT_USER);
     37     key.DeleteKey(fake_test_key_root_.c_str());
     38   }
     39 
     40   void AssertKeyExists(const base::string16& key_path) {
     41     base::win::RegKey key;
     42     ASSERT_EQ(ERROR_SUCCESS,
     43               key.Open(HKEY_CURRENT_USER, key_path.c_str(), KEY_READ))
     44         << key_path << " does not exist.";
     45   }
     46 
     47   void AssertKeyAbsent(const base::string16& key_path) {
     48     base::win::RegKey key;
     49     ASSERT_NE(ERROR_SUCCESS,
     50               key.Open(HKEY_CURRENT_USER, key_path.c_str(), KEY_READ))
     51         << key_path << " exists but it should not.";
     52   }
     53 
     54   void CreateKey(const base::string16& key_path) {
     55     base::win::RegKey key;
     56     EXPECT_EQ(ERROR_SUCCESS,
     57               key.Create(HKEY_CURRENT_USER, key_path.c_str(), KEY_ALL_ACCESS));
     58   }
     59 
     60   base::string16 FakeOverrideManagerPath(const base::Time& time) {
     61     return fake_test_key_root_ + L"\\" +
     62            base::Int64ToString16(time.ToInternalValue());
     63   }
     64 
     65   void CreateManager(const base::Time& timestamp) {
     66     manager_.reset(new RegistryOverrideManager(timestamp, fake_test_key_root_));
     67     manager_->OverrideRegistry(HKEY_CURRENT_USER);
     68   }
     69 
     70   base::string16 fake_test_key_root_;
     71   scoped_ptr<RegistryOverrideManager> manager_;
     72 };
     73 
     74 TEST_F(RegistryOverrideManagerTest, Basic) {
     75   CreateManager(base::Time::Now());
     76 
     77   base::win::RegKey create_key;
     78   EXPECT_EQ(ERROR_SUCCESS,
     79             create_key.Create(HKEY_CURRENT_USER, kTestKeyPath, KEY_ALL_ACCESS));
     80   EXPECT_TRUE(create_key.Valid());
     81   EXPECT_EQ(ERROR_SUCCESS, create_key.WriteValue(kTestValueName, 42));
     82   create_key.Close();
     83 
     84   AssertKeyExists(kTestKeyPath);
     85 
     86   DWORD value;
     87   base::win::RegKey read_key;
     88   EXPECT_EQ(ERROR_SUCCESS,
     89             read_key.Open(HKEY_CURRENT_USER, kTestKeyPath, KEY_READ));
     90   EXPECT_TRUE(read_key.Valid());
     91   EXPECT_EQ(ERROR_SUCCESS, read_key.ReadValueDW(kTestValueName, &value));
     92   EXPECT_EQ(42, value);
     93   read_key.Close();
     94 
     95   manager_.reset();
     96 
     97   AssertKeyAbsent(kTestKeyPath);
     98 }
     99 
    100 TEST_F(RegistryOverrideManagerTest, DeleteStaleKeys) {
    101   base::Time::Exploded kTestTimeExploded = {2013, 11, 1, 4, 0, 0, 0, 0};
    102   base::Time kTestTime = base::Time::FromUTCExploded(kTestTimeExploded);
    103 
    104   base::string16 path_garbage = fake_test_key_root_ + L"\\Blah";
    105   base::string16 path_very_stale =
    106       FakeOverrideManagerPath(kTestTime - base::TimeDelta::FromDays(100));
    107   base::string16 path_stale =
    108       FakeOverrideManagerPath(kTestTime - base::TimeDelta::FromDays(5));
    109   base::string16 path_current =
    110       FakeOverrideManagerPath(kTestTime - base::TimeDelta::FromMinutes(1));
    111   base::string16 path_future =
    112       FakeOverrideManagerPath(kTestTime + base::TimeDelta::FromMinutes(1));
    113 
    114   CreateKey(path_garbage);
    115   CreateKey(path_very_stale);
    116   CreateKey(path_stale);
    117   CreateKey(path_current);
    118   CreateKey(path_future);
    119 
    120   CreateManager(kTestTime);
    121   manager_.reset();
    122 
    123   AssertKeyAbsent(path_garbage);
    124   AssertKeyAbsent(path_very_stale);
    125   AssertKeyAbsent(path_stale);
    126   AssertKeyExists(path_current);
    127   AssertKeyExists(path_future);
    128 }
    129 
    130 }  // namespace registry_util
    131