base/win/registry_unittest.cc

   1 // Copyright (c) 2011 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/win/registry.h"
   6
   7 #include <cstring>
   8 #include <vector>
   9
  10 #include "base/bind.h"
  11 #include "base/compiler_specific.h"
  12 #include "base/message_loop/message_loop.h"
  13 #include "base/run_loop.h"
  14 #include "base/stl_util.h"
  15 #include "base/win/windows_version.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 namespace base {
  19 namespace win {
  20
  21 namespace {
  22
  23 class RegistryTest : public testing::Test {
  24  protected:
  25 #if defined(_WIN64)
  26   static const REGSAM kNativeViewMask = KEY_WOW64_64KEY;
  27   static const REGSAM kRedirectedViewMask = KEY_WOW64_32KEY;
  28 #else
  29   static const REGSAM kNativeViewMask = KEY_WOW64_32KEY;
  30   static const REGSAM kRedirectedViewMask = KEY_WOW64_64KEY;
  31 #endif  //  _WIN64
  32
  33   RegistryTest() {}
  34   void SetUp() override {
  35     // Create a temporary key.
  36     RegKey key(HKEY_CURRENT_USER, L"", KEY_ALL_ACCESS);
  37     key.DeleteKey(kRootKey);
  38     ASSERT_NE(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, kRootKey, KEY_READ));
  39     ASSERT_EQ(ERROR_SUCCESS, key.Create(HKEY_CURRENT_USER, kRootKey, KEY_READ));
  40     foo_software_key_ = L"Software\\";
  41     foo_software_key_ += kRootKey;
  42     foo_software_key_ += L"\\Foo";
  43   }
  44
  45   void TearDown() override {
  46     // Clean up the temporary key.
  47     RegKey key(HKEY_CURRENT_USER, L"", KEY_SET_VALUE);
  48     ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(kRootKey));
  49     ASSERT_NE(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, kRootKey, KEY_READ));
  50   }
  51
  52   static bool IsRedirectorPresent() {
  53 #if defined(_WIN64)
  54     return true;
  55 #else
  56     return OSInfo::GetInstance()->wow64_status() == OSInfo::WOW64_ENABLED;
  57 #endif
  58   }
  59
  60   const wchar_t* const kRootKey = L"Base_Registry_Unittest";
  61   std::wstring foo_software_key_;
  62
  63  private:
  64   DISALLOW_COPY_AND_ASSIGN(RegistryTest);
  65 };
  66
  67 // static
  68 const REGSAM RegistryTest::kNativeViewMask;
  69 const REGSAM RegistryTest::kRedirectedViewMask;
  70
  71 TEST_F(RegistryTest, ValueTest) {
  72   RegKey key;
  73
  74   std::wstring foo_key(kRootKey);
  75   foo_key += L"\\Foo";
  76   ASSERT_EQ(ERROR_SUCCESS, key.Create(HKEY_CURRENT_USER, foo_key.c_str(),
  77                                       KEY_READ));
  78
  79   {
  80     ASSERT_EQ(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, foo_key.c_str(),
  81                                       KEY_READ | KEY_SET_VALUE));
  82     ASSERT_TRUE(key.Valid());
  83
  84     const wchar_t kStringValueName[] = L"StringValue";
  85     const wchar_t kDWORDValueName[] = L"DWORDValue";
  86     const wchar_t kInt64ValueName[] = L"Int64Value";
  87     const wchar_t kStringData[] = L"string data";
  88     const DWORD kDWORDData = 0xdeadbabe;
  89     const int64 kInt64Data = 0xdeadbabedeadbabeLL;
  90
  91     // Test value creation
  92     ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(kStringValueName, kStringData));
  93     ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(kDWORDValueName, kDWORDData));
  94     ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(kInt64ValueName, &kInt64Data,
  95                                             sizeof(kInt64Data), REG_QWORD));
  96     EXPECT_EQ(3U, key.GetValueCount());
  97     EXPECT_TRUE(key.HasValue(kStringValueName));
  98     EXPECT_TRUE(key.HasValue(kDWORDValueName));
  99     EXPECT_TRUE(key.HasValue(kInt64ValueName));
 100
 101     // Test Read
 102     std::wstring string_value;
 103     DWORD dword_value = 0;
 104     int64 int64_value = 0;
 105     ASSERT_EQ(ERROR_SUCCESS, key.ReadValue(kStringValueName, &string_value));
 106     ASSERT_EQ(ERROR_SUCCESS, key.ReadValueDW(kDWORDValueName, &dword_value));
 107     ASSERT_EQ(ERROR_SUCCESS, key.ReadInt64(kInt64ValueName, &int64_value));
 108     EXPECT_STREQ(kStringData, string_value.c_str());
 109     EXPECT_EQ(kDWORDData, dword_value);
 110     EXPECT_EQ(kInt64Data, int64_value);
 111
 112     // Make sure out args are not touched if ReadValue fails
 113     const wchar_t* kNonExistent = L"NonExistent";
 114     ASSERT_NE(ERROR_SUCCESS, key.ReadValue(kNonExistent, &string_value));
 115     ASSERT_NE(ERROR_SUCCESS, key.ReadValueDW(kNonExistent, &dword_value));
 116     ASSERT_NE(ERROR_SUCCESS, key.ReadInt64(kNonExistent, &int64_value));
 117     EXPECT_STREQ(kStringData, string_value.c_str());
 118     EXPECT_EQ(kDWORDData, dword_value);
 119     EXPECT_EQ(kInt64Data, int64_value);
 120
 121     // Test delete
 122     ASSERT_EQ(ERROR_SUCCESS, key.DeleteValue(kStringValueName));
 123     ASSERT_EQ(ERROR_SUCCESS, key.DeleteValue(kDWORDValueName));
 124     ASSERT_EQ(ERROR_SUCCESS, key.DeleteValue(kInt64ValueName));
 125     EXPECT_EQ(0U, key.GetValueCount());
 126     EXPECT_FALSE(key.HasValue(kStringValueName));
 127     EXPECT_FALSE(key.HasValue(kDWORDValueName));
 128     EXPECT_FALSE(key.HasValue(kInt64ValueName));
 129   }
 130 }
 131
 132 TEST_F(RegistryTest, BigValueIteratorTest) {
 133   RegKey key;
 134   std::wstring foo_key(kRootKey);
 135   foo_key += L"\\Foo";
 136   ASSERT_EQ(ERROR_SUCCESS, key.Create(HKEY_CURRENT_USER, foo_key.c_str(),
 137                                       KEY_READ));
 138   ASSERT_EQ(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, foo_key.c_str(),
 139                                     KEY_READ | KEY_SET_VALUE));
 140   ASSERT_TRUE(key.Valid());
 141
 142   // Create a test value that is larger than MAX_PATH.
 143   std::wstring data(MAX_PATH * 2, L'a');
 144
 145   ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(data.c_str(), data.c_str()));
 146
 147   RegistryValueIterator iterator(HKEY_CURRENT_USER, foo_key.c_str());
 148   ASSERT_TRUE(iterator.Valid());
 149   EXPECT_STREQ(data.c_str(), iterator.Name());
 150   EXPECT_STREQ(data.c_str(), iterator.Value());
 151   // ValueSize() is in bytes, including NUL.
 152   EXPECT_EQ((MAX_PATH * 2 + 1) * sizeof(wchar_t), iterator.ValueSize());
 153   ++iterator;
 154   EXPECT_FALSE(iterator.Valid());
 155 }
 156
 157 TEST_F(RegistryTest, TruncatedCharTest) {
 158   RegKey key;
 159   std::wstring foo_key(kRootKey);
 160   foo_key += L"\\Foo";
 161   ASSERT_EQ(ERROR_SUCCESS, key.Create(HKEY_CURRENT_USER, foo_key.c_str(),
 162                                       KEY_READ));
 163   ASSERT_EQ(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, foo_key.c_str(),
 164                                     KEY_READ | KEY_SET_VALUE));
 165   ASSERT_TRUE(key.Valid());
 166
 167   const wchar_t kName[] = L"name";
 168   // kData size is not a multiple of sizeof(wchar_t).
 169   const uint8 kData[] = { 1, 2, 3, 4, 5 };
 170   EXPECT_EQ(5, arraysize(kData));
 171   ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(kName, kData,
 172                                           arraysize(kData), REG_BINARY));
 173
 174   RegistryValueIterator iterator(HKEY_CURRENT_USER, foo_key.c_str());
 175   ASSERT_TRUE(iterator.Valid());
 176   EXPECT_STREQ(kName, iterator.Name());
 177   // ValueSize() is in bytes.
 178   ASSERT_EQ(arraysize(kData), iterator.ValueSize());
 179   // Value() is NUL terminated.
 180   int end = (iterator.ValueSize() + sizeof(wchar_t) - 1) / sizeof(wchar_t);
 181   EXPECT_NE(L'\0', iterator.Value()[end-1]);
 182   EXPECT_EQ(L'\0', iterator.Value()[end]);
 183   EXPECT_EQ(0, std::memcmp(kData, iterator.Value(), arraysize(kData)));
 184   ++iterator;
 185   EXPECT_FALSE(iterator.Valid());
 186 }
 187
 188 TEST_F(RegistryTest, RecursiveDelete) {
 189   RegKey key;
 190   // Create kRootKey->Foo
 191   //                  \->Bar (TestValue)
 192   //                     \->Foo (TestValue)
 193   //                        \->Bar
 194   //                           \->Foo
 195   //                  \->Moo
 196   //                  \->Foo
 197   // and delete kRootKey->Foo
 198   std::wstring foo_key(kRootKey);
 199   foo_key += L"\\Foo";
 200   ASSERT_EQ(ERROR_SUCCESS,
 201             key.Create(HKEY_CURRENT_USER, foo_key.c_str(), KEY_WRITE));
 202   ASSERT_EQ(ERROR_SUCCESS, key.CreateKey(L"Bar", KEY_WRITE));
 203   ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(L"TestValue", L"TestData"));
 204   ASSERT_EQ(ERROR_SUCCESS,
 205             key.Create(HKEY_CURRENT_USER, foo_key.c_str(), KEY_WRITE));
 206   ASSERT_EQ(ERROR_SUCCESS, key.CreateKey(L"Moo", KEY_WRITE));
 207   ASSERT_EQ(ERROR_SUCCESS,
 208             key.Create(HKEY_CURRENT_USER, foo_key.c_str(), KEY_WRITE));
 209   ASSERT_EQ(ERROR_SUCCESS, key.CreateKey(L"Foo", KEY_WRITE));
 210   foo_key += L"\\Bar";
 211   ASSERT_EQ(ERROR_SUCCESS,
 212             key.Open(HKEY_CURRENT_USER, foo_key.c_str(), KEY_WRITE));
 213   foo_key += L"\\Foo";
 214   ASSERT_EQ(ERROR_SUCCESS, key.CreateKey(L"Foo", KEY_WRITE));
 215   ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(L"TestValue", L"TestData"));
 216   ASSERT_EQ(ERROR_SUCCESS,
 217             key.Open(HKEY_CURRENT_USER, foo_key.c_str(), KEY_READ));
 218
 219   ASSERT_EQ(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, kRootKey, KEY_WRITE));
 220   ASSERT_NE(ERROR_SUCCESS, key.DeleteKey(L"Bar"));
 221   ASSERT_NE(ERROR_SUCCESS, key.DeleteEmptyKey(L"Foo"));
 222   ASSERT_NE(ERROR_SUCCESS, key.DeleteEmptyKey(L"Foo\\Bar\\Foo"));
 223   ASSERT_NE(ERROR_SUCCESS, key.DeleteEmptyKey(L"Foo\\Bar"));
 224   ASSERT_EQ(ERROR_SUCCESS, key.DeleteEmptyKey(L"Foo\\Foo"));
 225
 226   ASSERT_EQ(ERROR_SUCCESS,
 227             key.Open(HKEY_CURRENT_USER, foo_key.c_str(), KEY_WRITE));
 228   ASSERT_EQ(ERROR_SUCCESS, key.CreateKey(L"Bar", KEY_WRITE));
 229   ASSERT_EQ(ERROR_SUCCESS, key.CreateKey(L"Foo", KEY_WRITE));
 230   ASSERT_EQ(ERROR_SUCCESS,
 231             key.Open(HKEY_CURRENT_USER, foo_key.c_str(), KEY_WRITE));
 232   ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(L""));
 233   ASSERT_NE(ERROR_SUCCESS,
 234             key.Open(HKEY_CURRENT_USER, foo_key.c_str(), KEY_READ));
 235
 236   ASSERT_EQ(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, kRootKey, KEY_WRITE));
 237   ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(L"Foo"));
 238   ASSERT_NE(ERROR_SUCCESS, key.DeleteKey(L"Foo"));
 239   ASSERT_NE(ERROR_SUCCESS,
 240             key.Open(HKEY_CURRENT_USER, foo_key.c_str(), KEY_READ));
 241 }
 242
 243 // This test requires running as an Administrator as it tests redirected
 244 // registry writes to HKLM\Software
 245 // http://msdn.microsoft.com/en-us/library/windows/desktop/aa384253.aspx
 246 // TODO(wfh): flaky test on Vista.  See http://crbug.com/377917
 247 TEST_F(RegistryTest, DISABLED_Wow64RedirectedFromNative) {
 248   if (!IsRedirectorPresent())
 249     return;
 250
 251   RegKey key;
 252
 253   // Test redirected key access from non-redirected.
 254   ASSERT_EQ(ERROR_SUCCESS,
 255             key.Create(HKEY_LOCAL_MACHINE,
 256                        foo_software_key_.c_str(),
 257                        KEY_WRITE | kRedirectedViewMask));
 258   ASSERT_NE(ERROR_SUCCESS,
 259             key.Open(HKEY_LOCAL_MACHINE, foo_software_key_.c_str(), KEY_READ));
 260   ASSERT_NE(ERROR_SUCCESS,
 261             key.Open(HKEY_LOCAL_MACHINE,
 262                      foo_software_key_.c_str(),
 263                      KEY_READ | kNativeViewMask));
 264
 265   // Open the non-redirected view of the parent and try to delete the test key.
 266   ASSERT_EQ(ERROR_SUCCESS,
 267             key.Open(HKEY_LOCAL_MACHINE, L"Software", KEY_SET_VALUE));
 268   ASSERT_NE(ERROR_SUCCESS, key.DeleteKey(kRootKey));
 269   ASSERT_EQ(ERROR_SUCCESS,
 270             key.Open(HKEY_LOCAL_MACHINE,
 271                      L"Software",
 272                      KEY_SET_VALUE | kNativeViewMask));
 273   ASSERT_NE(ERROR_SUCCESS, key.DeleteKey(kRootKey));
 274
 275   // Open the redirected view and delete the key created above.
 276   ASSERT_EQ(ERROR_SUCCESS,
 277             key.Open(HKEY_LOCAL_MACHINE,
 278                      L"Software",
 279                      KEY_SET_VALUE | kRedirectedViewMask));
 280   ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(kRootKey));
 281 }
 282
 283 // Test for the issue found in http://crbug.com/384587 where OpenKey would call
 284 // Close() and reset wow64_access_ flag to 0 and cause a NOTREACHED to hit on a
 285 // subsequent OpenKey call.
 286 TEST_F(RegistryTest, SameWowFlags) {
 287   RegKey key;
 288
 289   ASSERT_EQ(ERROR_SUCCESS,
 290             key.Open(HKEY_LOCAL_MACHINE,
 291                      L"Software",
 292                      KEY_READ | KEY_WOW64_64KEY));
 293   ASSERT_EQ(ERROR_SUCCESS,
 294             key.OpenKey(L"Microsoft",
 295                         KEY_READ | KEY_WOW64_64KEY));
 296   ASSERT_EQ(ERROR_SUCCESS,
 297             key.OpenKey(L"Windows",
 298                         KEY_READ | KEY_WOW64_64KEY));
 299 }
 300
 301 // TODO(wfh): flaky test on Vista.  See http://crbug.com/377917
 302 TEST_F(RegistryTest, DISABLED_Wow64NativeFromRedirected) {
 303   if (!IsRedirectorPresent())
 304     return;
 305   RegKey key;
 306
 307   // Test non-redirected key access from redirected.
 308   ASSERT_EQ(ERROR_SUCCESS,
 309             key.Create(HKEY_LOCAL_MACHINE,
 310                        foo_software_key_.c_str(),
 311                        KEY_WRITE | kNativeViewMask));
 312   ASSERT_EQ(ERROR_SUCCESS,
 313             key.Open(HKEY_LOCAL_MACHINE, foo_software_key_.c_str(), KEY_READ));
 314   ASSERT_NE(ERROR_SUCCESS,
 315             key.Open(HKEY_LOCAL_MACHINE,
 316                      foo_software_key_.c_str(),
 317                      KEY_READ | kRedirectedViewMask));
 318
 319   // Open the redirected view of the parent and try to delete the test key
 320   // from the non-redirected view.
 321   ASSERT_EQ(ERROR_SUCCESS,
 322             key.Open(HKEY_LOCAL_MACHINE,
 323                      L"Software",
 324                      KEY_SET_VALUE | kRedirectedViewMask));
 325   ASSERT_NE(ERROR_SUCCESS, key.DeleteKey(kRootKey));
 326
 327   ASSERT_EQ(ERROR_SUCCESS,
 328             key.Open(HKEY_LOCAL_MACHINE,
 329                      L"Software",
 330                      KEY_SET_VALUE | kNativeViewMask));
 331   ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(kRootKey));
 332 }
 333
 334 TEST_F(RegistryTest, OpenSubKey) {
 335   RegKey key;
 336   ASSERT_EQ(ERROR_SUCCESS,
 337             key.Open(HKEY_CURRENT_USER,
 338                      kRootKey,
 339                      KEY_READ | KEY_CREATE_SUB_KEY));
 340
 341   ASSERT_NE(ERROR_SUCCESS, key.OpenKey(L"foo", KEY_READ));
 342   ASSERT_EQ(ERROR_SUCCESS, key.CreateKey(L"foo", KEY_READ));
 343   ASSERT_EQ(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, kRootKey, KEY_READ));
 344   ASSERT_EQ(ERROR_SUCCESS, key.OpenKey(L"foo", KEY_READ));
 345
 346   std::wstring foo_key(kRootKey);
 347   foo_key += L"\\Foo";
 348   ASSERT_EQ(ERROR_SUCCESS,
 349             key.Open(HKEY_CURRENT_USER, foo_key.c_str(), KEY_READ));
 350
 351   ASSERT_EQ(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, kRootKey, KEY_WRITE));
 352   ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(L"foo"));
 353 }
 354
 355 class TestChangeDelegate {
 356  public:
 357    TestChangeDelegate() : called_(false) {}
 358    ~TestChangeDelegate() {}
 359
 360    void OnKeyChanged() {
 361      MessageLoop::current()->QuitWhenIdle();
 362      called_ = true;
 363    }
 364
 365    bool WasCalled() {
 366      bool was_called = called_;
 367      called_ = false;
 368      return was_called;
 369    }
 370
 371  private:
 372   bool called_;
 373 };
 374
 375 TEST_F(RegistryTest, ChangeCallback) {
 376   RegKey key;
 377   TestChangeDelegate delegate;
 378   MessageLoop message_loop;
 379
 380   std::wstring foo_key(kRootKey);
 381   foo_key += L"\\Foo";
 382   ASSERT_EQ(ERROR_SUCCESS, key.Create(HKEY_CURRENT_USER, foo_key.c_str(),
 383                                       KEY_READ));
 384
 385   ASSERT_TRUE(key.StartWatching(Bind(&TestChangeDelegate::OnKeyChanged,
 386                                      Unretained(&delegate))));
 387   EXPECT_FALSE(delegate.WasCalled());
 388
 389   // Make some change.
 390   RegKey key2;
 391   ASSERT_EQ(ERROR_SUCCESS, key2.Open(HKEY_CURRENT_USER, foo_key.c_str(),
 392                                       KEY_READ | KEY_SET_VALUE));
 393   ASSERT_TRUE(key2.Valid());
 394   EXPECT_EQ(ERROR_SUCCESS, key2.WriteValue(L"name", L"data"));
 395
 396   // Allow delivery of the notification.
 397   EXPECT_FALSE(delegate.WasCalled());
 398   base::RunLoop().Run();
 399
 400   ASSERT_TRUE(delegate.WasCalled());
 401   EXPECT_FALSE(delegate.WasCalled());
 402
 403   ASSERT_TRUE(key.StartWatching(Bind(&TestChangeDelegate::OnKeyChanged,
 404                                      Unretained(&delegate))));
 405
 406   // Change something else.
 407   EXPECT_EQ(ERROR_SUCCESS, key2.WriteValue(L"name2", L"data2"));
 408   base::RunLoop().Run();
 409   ASSERT_TRUE(delegate.WasCalled());
 410
 411   ASSERT_TRUE(key.StartWatching(Bind(&TestChangeDelegate::OnKeyChanged,
 412                                      Unretained(&delegate))));
 413   base::RunLoop().RunUntilIdle();
 414   EXPECT_FALSE(delegate.WasCalled());
 415 }
 416
 417 }  // namespace
 418
 419 }  // namespace win
 420 }  // namespace base