OLD | NEW |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/win/registry.h" | 5 #include "base/win/registry.h" |
6 | 6 |
7 #include <cstring> | 7 #include <cstring> |
8 #include <vector> | 8 #include <vector> |
9 | 9 |
10 #include "base/compiler_specific.h" | 10 #include "base/compiler_specific.h" |
11 #include "base/stl_util.h" | 11 #include "base/stl_util.h" |
| 12 #include "base/win/windows_version.h" |
12 #include "testing/gtest/include/gtest/gtest.h" | 13 #include "testing/gtest/include/gtest/gtest.h" |
13 | 14 |
14 namespace base { | 15 namespace base { |
15 namespace win { | 16 namespace win { |
16 | 17 |
17 namespace { | 18 namespace { |
18 | 19 |
19 const wchar_t kRootKey[] = L"Base_Registry_Unittest"; | 20 class RegistryTest : public testing::Test { |
| 21 protected: |
| 22 #if defined(_WIN64) |
| 23 static const REGSAM kNativeViewMask = KEY_WOW64_64KEY; |
| 24 static const REGSAM kRedirectedViewMask = KEY_WOW64_32KEY; |
| 25 #else |
| 26 static const REGSAM kNativeViewMask = KEY_WOW64_32KEY; |
| 27 static const REGSAM kRedirectedViewMask = KEY_WOW64_64KEY; |
| 28 #endif // _WIN64 |
20 | 29 |
21 class RegistryTest : public testing::Test { | |
22 public: | |
23 RegistryTest() {} | 30 RegistryTest() {} |
24 | |
25 protected: | |
26 virtual void SetUp() OVERRIDE { | 31 virtual void SetUp() OVERRIDE { |
27 // Create a temporary key. | 32 // Create a temporary key. |
28 RegKey key(HKEY_CURRENT_USER, L"", KEY_ALL_ACCESS); | 33 RegKey key(HKEY_CURRENT_USER, L"", KEY_ALL_ACCESS); |
29 key.DeleteKey(kRootKey); | 34 key.DeleteKey(kRootKey); |
30 ASSERT_NE(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, kRootKey, KEY_READ)); | 35 ASSERT_NE(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, kRootKey, KEY_READ)); |
31 ASSERT_EQ(ERROR_SUCCESS, key.Create(HKEY_CURRENT_USER, kRootKey, KEY_READ)); | 36 ASSERT_EQ(ERROR_SUCCESS, key.Create(HKEY_CURRENT_USER, kRootKey, KEY_READ)); |
| 37 foo_software_key_ = L"Software\\"; |
| 38 foo_software_key_ += kRootKey; |
| 39 foo_software_key_ += L"\\Foo"; |
32 } | 40 } |
33 | 41 |
34 virtual void TearDown() OVERRIDE { | 42 virtual void TearDown() OVERRIDE { |
35 // Clean up the temporary key. | 43 // Clean up the temporary key. |
36 RegKey key(HKEY_CURRENT_USER, L"", KEY_SET_VALUE); | 44 RegKey key(HKEY_CURRENT_USER, L"", KEY_SET_VALUE); |
37 ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(kRootKey)); | 45 ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(kRootKey)); |
| 46 ASSERT_NE(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, kRootKey, KEY_READ)); |
38 } | 47 } |
39 | 48 |
| 49 static bool IsRedirectorPresent() { |
| 50 #if defined(_WIN64) |
| 51 return true; |
| 52 #else |
| 53 return OSInfo::GetInstance()->wow64_status() == OSInfo::WOW64_ENABLED; |
| 54 #endif |
| 55 } |
| 56 |
| 57 const wchar_t* const kRootKey = L"Base_Registry_Unittest"; |
| 58 std::wstring foo_software_key_; |
| 59 |
40 private: | 60 private: |
41 DISALLOW_COPY_AND_ASSIGN(RegistryTest); | 61 DISALLOW_COPY_AND_ASSIGN(RegistryTest); |
42 }; | 62 }; |
43 | 63 |
| 64 // static |
| 65 const REGSAM RegistryTest::kNativeViewMask; |
| 66 const REGSAM RegistryTest::kRedirectedViewMask; |
| 67 |
44 TEST_F(RegistryTest, ValueTest) { | 68 TEST_F(RegistryTest, ValueTest) { |
45 RegKey key; | 69 RegKey key; |
46 | 70 |
47 std::wstring foo_key(kRootKey); | 71 std::wstring foo_key(kRootKey); |
48 foo_key += L"\\Foo"; | 72 foo_key += L"\\Foo"; |
49 ASSERT_EQ(ERROR_SUCCESS, key.Create(HKEY_CURRENT_USER, foo_key.c_str(), | 73 ASSERT_EQ(ERROR_SUCCESS, key.Create(HKEY_CURRENT_USER, foo_key.c_str(), |
50 KEY_READ)); | 74 KEY_READ)); |
51 | 75 |
52 { | 76 { |
53 ASSERT_EQ(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, foo_key.c_str(), | 77 ASSERT_EQ(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, foo_key.c_str(), |
(...skipping 97 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
151 ASSERT_EQ(arraysize(kData), iterator.ValueSize()); | 175 ASSERT_EQ(arraysize(kData), iterator.ValueSize()); |
152 // Value() is NUL terminated. | 176 // Value() is NUL terminated. |
153 int end = (iterator.ValueSize() + sizeof(wchar_t) - 1) / sizeof(wchar_t); | 177 int end = (iterator.ValueSize() + sizeof(wchar_t) - 1) / sizeof(wchar_t); |
154 EXPECT_NE(L'\0', iterator.Value()[end-1]); | 178 EXPECT_NE(L'\0', iterator.Value()[end-1]); |
155 EXPECT_EQ(L'\0', iterator.Value()[end]); | 179 EXPECT_EQ(L'\0', iterator.Value()[end]); |
156 EXPECT_EQ(0, std::memcmp(kData, iterator.Value(), arraysize(kData))); | 180 EXPECT_EQ(0, std::memcmp(kData, iterator.Value(), arraysize(kData))); |
157 ++iterator; | 181 ++iterator; |
158 EXPECT_FALSE(iterator.Valid()); | 182 EXPECT_FALSE(iterator.Valid()); |
159 } | 183 } |
160 | 184 |
| 185 TEST_F(RegistryTest, RecursiveDelete) { |
| 186 RegKey key; |
| 187 // Create kRootKey->Foo |
| 188 // \->Bar (TestValue) |
| 189 // \->Foo (TestValue) |
| 190 // \->Bar |
| 191 // \->Foo |
| 192 // \->Moo |
| 193 // \->Foo |
| 194 // and delete kRootKey->Foo |
| 195 std::wstring foo_key(kRootKey); |
| 196 foo_key += L"\\Foo"; |
| 197 ASSERT_EQ(ERROR_SUCCESS, |
| 198 key.Create(HKEY_CURRENT_USER, foo_key.c_str(), KEY_WRITE)); |
| 199 ASSERT_EQ(ERROR_SUCCESS, key.CreateKey(L"Bar", KEY_WRITE)); |
| 200 ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(L"TestValue", L"TestData")); |
| 201 ASSERT_EQ(ERROR_SUCCESS, |
| 202 key.Create(HKEY_CURRENT_USER, foo_key.c_str(), KEY_WRITE)); |
| 203 ASSERT_EQ(ERROR_SUCCESS, key.CreateKey(L"Moo", KEY_WRITE)); |
| 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"Foo", KEY_WRITE)); |
| 207 foo_key += L"\\Bar"; |
| 208 ASSERT_EQ(ERROR_SUCCESS, |
| 209 key.Open(HKEY_CURRENT_USER, foo_key.c_str(), KEY_WRITE)); |
| 210 foo_key += L"\\Foo"; |
| 211 ASSERT_EQ(ERROR_SUCCESS, key.CreateKey(L"Foo", KEY_WRITE)); |
| 212 ASSERT_EQ(ERROR_SUCCESS, key.WriteValue(L"TestValue", L"TestData")); |
| 213 ASSERT_EQ(ERROR_SUCCESS, |
| 214 key.Open(HKEY_CURRENT_USER, foo_key.c_str(), KEY_READ)); |
| 215 |
| 216 ASSERT_EQ(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, kRootKey, KEY_WRITE)); |
| 217 ASSERT_NE(ERROR_SUCCESS, key.DeleteKey(L"Bar")); |
| 218 ASSERT_NE(ERROR_SUCCESS, key.DeleteEmptyKey(L"Foo")); |
| 219 ASSERT_NE(ERROR_SUCCESS, key.DeleteEmptyKey(L"Foo\\Bar\\Foo")); |
| 220 ASSERT_NE(ERROR_SUCCESS, key.DeleteEmptyKey(L"Foo\\Bar")); |
| 221 ASSERT_EQ(ERROR_SUCCESS, key.DeleteEmptyKey(L"Foo\\Foo")); |
| 222 |
| 223 ASSERT_EQ(ERROR_SUCCESS, |
| 224 key.Open(HKEY_CURRENT_USER, foo_key.c_str(), KEY_WRITE)); |
| 225 ASSERT_EQ(ERROR_SUCCESS, key.CreateKey(L"Bar", KEY_WRITE)); |
| 226 ASSERT_EQ(ERROR_SUCCESS, key.CreateKey(L"Foo", KEY_WRITE)); |
| 227 ASSERT_EQ(ERROR_SUCCESS, |
| 228 key.Open(HKEY_CURRENT_USER, foo_key.c_str(), KEY_WRITE)); |
| 229 ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(L"")); |
| 230 ASSERT_NE(ERROR_SUCCESS, |
| 231 key.Open(HKEY_CURRENT_USER, foo_key.c_str(), KEY_READ)); |
| 232 |
| 233 ASSERT_EQ(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, kRootKey, KEY_WRITE)); |
| 234 ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(L"Foo")); |
| 235 ASSERT_NE(ERROR_SUCCESS, key.DeleteKey(L"Foo")); |
| 236 ASSERT_NE(ERROR_SUCCESS, |
| 237 key.Open(HKEY_CURRENT_USER, foo_key.c_str(), KEY_READ)); |
| 238 } |
| 239 |
| 240 // This test requires running as an Administrator as it tests redirected |
| 241 // registry writes to HKLM\Software |
| 242 // http://msdn.microsoft.com/en-us/library/windows/desktop/aa384253.aspx |
| 243 TEST_F(RegistryTest, Wow64RedirectedFromNative) { |
| 244 if (!IsRedirectorPresent()) |
| 245 return; |
| 246 |
| 247 RegKey key; |
| 248 |
| 249 // Test redirected key access from non-redirected. |
| 250 ASSERT_EQ(ERROR_SUCCESS, |
| 251 key.Create(HKEY_LOCAL_MACHINE, |
| 252 foo_software_key_.c_str(), |
| 253 KEY_WRITE | kRedirectedViewMask)); |
| 254 ASSERT_NE(ERROR_SUCCESS, |
| 255 key.Open(HKEY_LOCAL_MACHINE, foo_software_key_.c_str(), KEY_READ)); |
| 256 ASSERT_NE(ERROR_SUCCESS, |
| 257 key.Open(HKEY_LOCAL_MACHINE, |
| 258 foo_software_key_.c_str(), |
| 259 KEY_READ | kNativeViewMask)); |
| 260 |
| 261 // Open the non-redirected view of the parent and try to delete the test key. |
| 262 ASSERT_EQ(ERROR_SUCCESS, |
| 263 key.Open(HKEY_LOCAL_MACHINE, L"Software", KEY_SET_VALUE)); |
| 264 ASSERT_NE(ERROR_SUCCESS, key.DeleteKey(kRootKey)); |
| 265 ASSERT_EQ(ERROR_SUCCESS, |
| 266 key.Open(HKEY_LOCAL_MACHINE, |
| 267 L"Software", |
| 268 KEY_SET_VALUE | kNativeViewMask)); |
| 269 ASSERT_NE(ERROR_SUCCESS, key.DeleteKey(kRootKey)); |
| 270 |
| 271 // Open the redirected view and delete the key created above. |
| 272 ASSERT_EQ(ERROR_SUCCESS, |
| 273 key.Open(HKEY_LOCAL_MACHINE, |
| 274 L"Software", |
| 275 KEY_SET_VALUE | kRedirectedViewMask)); |
| 276 ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(kRootKey)); |
| 277 } |
| 278 |
| 279 TEST_F(RegistryTest, Wow64NativeFromRedirected) { |
| 280 if (!IsRedirectorPresent()) |
| 281 return; |
| 282 RegKey key; |
| 283 |
| 284 // Test non-redirected key access from redirected. |
| 285 ASSERT_EQ(ERROR_SUCCESS, |
| 286 key.Create(HKEY_LOCAL_MACHINE, |
| 287 foo_software_key_.c_str(), |
| 288 KEY_WRITE | kNativeViewMask)); |
| 289 ASSERT_EQ(ERROR_SUCCESS, |
| 290 key.Open(HKEY_LOCAL_MACHINE, foo_software_key_.c_str(), KEY_READ)); |
| 291 ASSERT_NE(ERROR_SUCCESS, |
| 292 key.Open(HKEY_LOCAL_MACHINE, |
| 293 foo_software_key_.c_str(), |
| 294 KEY_READ | kRedirectedViewMask)); |
| 295 |
| 296 // Open the redirected view of the parent and try to delete the test key |
| 297 // from the non-redirected view. |
| 298 ASSERT_EQ(ERROR_SUCCESS, |
| 299 key.Open(HKEY_LOCAL_MACHINE, |
| 300 L"Software", |
| 301 KEY_SET_VALUE | kRedirectedViewMask)); |
| 302 ASSERT_NE(ERROR_SUCCESS, key.DeleteKey(kRootKey)); |
| 303 |
| 304 ASSERT_EQ(ERROR_SUCCESS, |
| 305 key.Open(HKEY_LOCAL_MACHINE, |
| 306 L"Software", |
| 307 KEY_SET_VALUE | kNativeViewMask)); |
| 308 ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(kRootKey)); |
| 309 } |
| 310 |
| 311 TEST_F(RegistryTest, OpenSubKey) { |
| 312 RegKey key; |
| 313 ASSERT_EQ(ERROR_SUCCESS, |
| 314 key.Open(HKEY_CURRENT_USER, |
| 315 kRootKey, |
| 316 KEY_READ | KEY_CREATE_SUB_KEY)); |
| 317 |
| 318 ASSERT_NE(ERROR_SUCCESS, key.OpenKey(L"foo", KEY_READ)); |
| 319 ASSERT_EQ(ERROR_SUCCESS, key.CreateKey(L"foo", KEY_READ)); |
| 320 ASSERT_EQ(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, kRootKey, KEY_READ)); |
| 321 ASSERT_EQ(ERROR_SUCCESS, key.OpenKey(L"foo", KEY_READ)); |
| 322 |
| 323 std::wstring foo_key(kRootKey); |
| 324 foo_key += L"\\Foo"; |
| 325 ASSERT_EQ(ERROR_SUCCESS, |
| 326 key.Open(HKEY_CURRENT_USER, foo_key.c_str(), KEY_READ)); |
| 327 |
| 328 ASSERT_EQ(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, kRootKey, KEY_WRITE)); |
| 329 ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(L"foo")); |
| 330 } |
| 331 |
161 } // namespace | 332 } // namespace |
162 | 333 |
163 } // namespace win | 334 } // namespace win |
164 } // namespace base | 335 } // namespace base |
OLD | NEW |