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; | |
grt (UTC plus 2)
2014/05/20 15:28:52
i think you still need definitions of these at nam
Will Harris
2014/05/20 17:03:34
Okay I read the standard and I think I am now comp
grt (UTC plus 2)
2014/05/20 17:46:56
You could keep the initializers up here in the cla
| |
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"; | |
40 foo_software_wow64_key_ = L"Software\\Wow6432Node\\"; | |
41 foo_software_wow64_key_ += kRootKey; | |
42 foo_software_wow64_key_ += L"\\Foo"; | |
32 } | 43 } |
33 | 44 |
34 virtual void TearDown() OVERRIDE { | 45 virtual void TearDown() OVERRIDE { |
35 // Clean up the temporary key. | 46 // Clean up the temporary key. |
36 RegKey key(HKEY_CURRENT_USER, L"", KEY_SET_VALUE); | 47 RegKey key(HKEY_CURRENT_USER, L"", KEY_SET_VALUE); |
37 ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(kRootKey)); | 48 ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(kRootKey)); |
49 ASSERT_NE(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, kRootKey, KEY_READ)); | |
38 } | 50 } |
39 | 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 std::wstring foo_software_wow64_key_; | |
63 | |
40 private: | 64 private: |
41 DISALLOW_COPY_AND_ASSIGN(RegistryTest); | 65 DISALLOW_COPY_AND_ASSIGN(RegistryTest); |
42 }; | 66 }; |
43 | 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(), |
(...skipping 101 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 | |
189 // \->Foo | |
190 // \->Moo | |
191 // \->Foo | |
192 // and delete kRootKey->Foo | |
193 std::wstring foo_key(kRootKey); | |
194 foo_key += L"\\Foo"; | |
195 ASSERT_EQ(ERROR_SUCCESS, | |
196 key.Create(HKEY_CURRENT_USER, foo_key.c_str(), KEY_WRITE)); | |
197 ASSERT_EQ(ERROR_SUCCESS, key.CreateKey(L"Bar", KEY_WRITE)); | |
198 ASSERT_EQ(ERROR_SUCCESS, | |
199 key.Create(HKEY_CURRENT_USER, foo_key.c_str(), KEY_WRITE)); | |
200 ASSERT_EQ(ERROR_SUCCESS, key.CreateKey(L"Moo", KEY_WRITE)); | |
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"Foo", KEY_WRITE)); | |
204 foo_key += L"\\Bar"; | |
205 ASSERT_EQ(ERROR_SUCCESS, | |
206 key.Open(HKEY_CURRENT_USER, foo_key.c_str(), KEY_WRITE)); | |
207 foo_key += L"\\Foo"; | |
208 ASSERT_EQ(ERROR_SUCCESS, key.CreateKey(L"Foo", KEY_WRITE)); | |
209 ASSERT_EQ(ERROR_SUCCESS, | |
210 key.Open(HKEY_CURRENT_USER, foo_key.c_str(), KEY_READ)); | |
211 | |
212 ASSERT_EQ(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, kRootKey, KEY_WRITE)); | |
213 ASSERT_NE(ERROR_SUCCESS, key.DeleteKey(L"Bar")); | |
214 ASSERT_NE(ERROR_SUCCESS, key.DeleteEmptyKey(L"Foo")); | |
215 ASSERT_NE(ERROR_SUCCESS, key.DeleteEmptyKey(L"Foo\\Bar")); | |
216 ASSERT_EQ(ERROR_SUCCESS, key.DeleteEmptyKey(L"Foo\\Foo")); | |
217 ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(L"Foo")); | |
218 ASSERT_NE(ERROR_SUCCESS, key.DeleteKey(L"Foo")); | |
219 ASSERT_NE(ERROR_SUCCESS, | |
220 key.Open(HKEY_CURRENT_USER, foo_key.c_str(), KEY_READ)); | |
221 } | |
222 | |
223 // This test requires running as an Administrator as it tests redirected | |
224 // registry writes to HKLM\Software | |
225 // http://msdn.microsoft.com/en-us/library/windows/desktop/aa384253.aspx | |
226 TEST_F(RegistryTest, Wow64RedirectedFromNative) { | |
227 if (!IsRedirectorPresent()) | |
228 return; | |
229 | |
230 RegKey key; | |
231 | |
232 // Test redirected key access from non-redirected. | |
233 ASSERT_EQ(ERROR_SUCCESS, | |
234 key.Create(HKEY_LOCAL_MACHINE, | |
235 foo_software_key_.c_str(), | |
236 KEY_WRITE | kRedirectedViewMask)); | |
237 ASSERT_NE(ERROR_SUCCESS, | |
238 key.Open(HKEY_LOCAL_MACHINE, foo_software_key_.c_str(), KEY_READ)); | |
239 ASSERT_NE(ERROR_SUCCESS, | |
240 key.Open(HKEY_LOCAL_MACHINE, | |
241 foo_software_key_.c_str(), | |
242 KEY_READ | kNativeViewMask)); | |
243 | |
244 // Open the non-redirected view of the parent and try to delete the test key. | |
245 ASSERT_EQ(ERROR_SUCCESS, | |
246 key.Open(HKEY_LOCAL_MACHINE, L"Software", KEY_SET_VALUE)); | |
247 ASSERT_NE(ERROR_SUCCESS, key.DeleteKey(kRootKey)); | |
248 ASSERT_EQ(ERROR_SUCCESS, | |
249 key.Open(HKEY_LOCAL_MACHINE, | |
250 L"Software", | |
251 KEY_SET_VALUE | kNativeViewMask)); | |
252 ASSERT_NE(ERROR_SUCCESS, key.DeleteKey(kRootKey)); | |
253 | |
254 // Open the redirected view and delete the key created above. | |
255 ASSERT_EQ(ERROR_SUCCESS, | |
256 key.Open(HKEY_LOCAL_MACHINE, | |
257 L"Software", | |
258 KEY_SET_VALUE | kRedirectedViewMask)); | |
259 ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(kRootKey)); | |
260 } | |
261 | |
262 TEST_F(RegistryTest, Wow64NativeFromRedirected) { | |
263 if (!IsRedirectorPresent()) | |
264 return; | |
265 RegKey key; | |
266 | |
267 // Test non-redirected key access from redirected. | |
268 ASSERT_EQ(ERROR_SUCCESS, | |
269 key.Create(HKEY_LOCAL_MACHINE, | |
270 foo_software_key_.c_str(), | |
271 KEY_WRITE | kNativeViewMask)); | |
272 ASSERT_EQ(ERROR_SUCCESS, | |
273 key.Open(HKEY_LOCAL_MACHINE, foo_software_key_.c_str(), KEY_READ)); | |
274 ASSERT_NE(ERROR_SUCCESS, | |
275 key.Open(HKEY_LOCAL_MACHINE, | |
276 foo_software_key_.c_str(), | |
277 KEY_READ | kRedirectedViewMask)); | |
278 | |
279 // Open the redirected view of the parent and try to delete the test key | |
280 // from the non-redirected view. | |
281 ASSERT_EQ(ERROR_SUCCESS, | |
282 key.Open(HKEY_LOCAL_MACHINE, | |
283 L"Software", | |
284 KEY_SET_VALUE | kRedirectedViewMask)); | |
285 ASSERT_NE(ERROR_SUCCESS, key.DeleteKey(kRootKey)); | |
286 | |
287 ASSERT_EQ(ERROR_SUCCESS, | |
288 key.Open(HKEY_LOCAL_MACHINE, | |
289 L"Software", | |
290 KEY_SET_VALUE | kNativeViewMask)); | |
291 ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(kRootKey)); | |
292 } | |
293 | |
294 TEST_F(RegistryTest, Wow6432NodeFromRedirected) { | |
295 if (!IsRedirectorPresent()) | |
296 return; | |
297 | |
298 RegKey key; | |
299 // Test access to 32-bit values on 64-bit via the Wow6432Node key. | |
300 ASSERT_EQ(ERROR_SUCCESS, | |
301 key.Create(HKEY_LOCAL_MACHINE, | |
302 foo_software_key_.c_str(), | |
303 KEY_WRITE | KEY_WOW64_32KEY)); | |
304 ASSERT_EQ(ERROR_SUCCESS, | |
305 key.Open(HKEY_LOCAL_MACHINE, | |
306 foo_software_wow64_key_.c_str(), | |
307 KEY_READ)); | |
308 ASSERT_EQ(ERROR_SUCCESS, | |
309 key.Open(HKEY_LOCAL_MACHINE, | |
310 foo_software_wow64_key_.c_str(), | |
311 KEY_READ | KEY_WOW64_64KEY)); | |
312 ASSERT_EQ(ERROR_SUCCESS, | |
313 key.Open(HKEY_LOCAL_MACHINE, | |
314 foo_software_wow64_key_.c_str(), | |
315 KEY_READ | KEY_WOW64_32KEY)); | |
316 ASSERT_EQ(ERROR_SUCCESS, | |
317 key.Open(HKEY_LOCAL_MACHINE, | |
318 L"Software", | |
319 KEY_SET_VALUE | KEY_WOW64_32KEY)); | |
320 ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(kRootKey)); | |
321 } | |
322 | |
323 TEST_F(RegistryTest, Wow64ConflictingViews) { | |
324 RegKey key; | |
325 // Test that conflicting WOW64 access flags are always rejected. | |
326 ASSERT_EQ(ERROR_SUCCESS, | |
327 key.Create(HKEY_LOCAL_MACHINE, | |
328 foo_software_key_.c_str(), | |
329 KEY_WRITE | KEY_WOW64_32KEY)); | |
330 ASSERT_NE(ERROR_SUCCESS, key.CreateKey(L"Foo", KEY_READ | KEY_WOW64_64KEY)); | |
331 ASSERT_NE(ERROR_SUCCESS, key.CreateKey(L"Foo", KEY_READ)); | |
332 ASSERT_EQ(ERROR_SUCCESS, key.CreateKey(L"Foo", KEY_READ | KEY_WOW64_32KEY)); | |
333 ASSERT_EQ(ERROR_SUCCESS, | |
334 key.Open(HKEY_LOCAL_MACHINE, | |
335 L"Software", | |
336 KEY_WRITE | KEY_WOW64_32KEY)); | |
337 ASSERT_NE(ERROR_SUCCESS, key.OpenKey(L"Foo", KEY_READ | KEY_WOW64_64KEY)); | |
338 ASSERT_NE(ERROR_SUCCESS, key.OpenKey(L"Foo", KEY_READ)); | |
339 ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(kRootKey)); | |
340 } | |
341 | |
342 TEST_F(RegistryTest, OpenSubKey) { | |
343 RegKey key; | |
344 ASSERT_EQ(ERROR_SUCCESS, | |
345 key.Open(HKEY_CURRENT_USER, | |
346 kRootKey, | |
347 KEY_READ | KEY_CREATE_SUB_KEY)); | |
348 | |
349 ASSERT_NE(ERROR_SUCCESS, key.OpenKey(L"foo", KEY_READ)); | |
350 ASSERT_EQ(ERROR_SUCCESS, key.CreateKey(L"foo", KEY_READ)); | |
351 ASSERT_EQ(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, kRootKey, KEY_READ)); | |
352 ASSERT_EQ(ERROR_SUCCESS, key.OpenKey(L"foo", KEY_READ)); | |
353 | |
354 std::wstring foo_key(kRootKey); | |
355 foo_key += L"\\Foo"; | |
356 ASSERT_EQ(ERROR_SUCCESS, | |
357 key.Open(HKEY_CURRENT_USER, foo_key.c_str(), KEY_READ)); | |
358 | |
359 ASSERT_EQ(ERROR_SUCCESS, key.Open(HKEY_CURRENT_USER, kRootKey, KEY_WRITE)); | |
360 ASSERT_EQ(ERROR_SUCCESS, key.DeleteKey(L"foo")); | |
361 } | |
362 | |
161 } // namespace | 363 } // namespace |
162 | 364 |
163 } // namespace win | 365 } // namespace win |
164 } // namespace base | 366 } // namespace base |
OLD | NEW |