Debian Codegraph @

Lib/test/test_winreg.py

raw
1 # Test the windows specific win32reg module.
2 # Only win32reg functions not hit here: FlushKey, LoadKey and SaveKey
3
4 import gc
5 import os, sys, errno
6 import itertools
7 import threading
8 import unittest
9 from platform import machine, win32_edition
10 from test.support import cpython_only, import_helper
11
12 # Do this first so test will be skipped if module doesn't exist
13 import_helper.import_module('winreg', required_on=['win'])
14 # Now import everything
15 from winreg import *
16
17 try:
18 REMOTE_NAME = sys.argv[sys.argv.index("--remote")+1]
19 except (IndexError, ValueError):
20 REMOTE_NAME = None
21
22 # tuple of (major, minor)
23 WIN_VER = sys.getwindowsversion()[:2]
24 # Some tests should only run on 64-bit architectures where WOW64 will be.
25 WIN64_MACHINE = True if machine() == "AMD64" else False
26
27 # Starting with Windows 7 and Windows Server 2008 R2, WOW64 no longer uses
28 # registry reflection and formerly reflected keys are shared instead.
29 # Windows 7 and Windows Server 2008 R2 are version 6.1. Due to this, some
30 # tests are only valid up until 6.1
31 HAS_REFLECTION = True if WIN_VER < (6, 1) else False
32
33 # Use a per-process key to prevent concurrent test runs (buildbot!) from
34 # stomping on each other.
35 test_key_base = "Python Test Key [%d] - Delete Me" % (os.getpid(),)
36 test_key_name = "SOFTWARE\\" + test_key_base
37 # On OS'es that support reflection we should test with a reflected key
38 test_reflect_key_name = "SOFTWARE\\Classes\\" + test_key_base
39
40 test_data = [
41 ("Int Value", 45, REG_DWORD),
42 ("Qword Value", 0x1122334455667788, REG_QWORD),
43 ("String Val", "A string value", REG_SZ),
44 ("StringExpand", "The path is %path%", REG_EXPAND_SZ),
45 ("Multi-string", ["Lots", "of", "string", "values"], REG_MULTI_SZ),
46 ("Multi-nul", ["", "", "", ""], REG_MULTI_SZ),
47 ("Raw Data", b"binary\x00data", REG_BINARY),
48 ("Big String", "x"*(2**14-1), REG_SZ),
49 ("Big Binary", b"x"*(2**14), REG_BINARY),
50 # Two and three kanjis, meaning: "Japan" and "Japanese".
51 ("Japanese 日本", "日本語", REG_SZ),
52 ]
53
54
55 @cpython_only
56 class HeapTypeTests(unittest.TestCase):
57 def test_have_gc(self):
58 self.assertTrue(gc.is_tracked(HKEYType))
59
60 def test_immutable(self):
61 with self.assertRaisesRegex(TypeError, "immutable"):
62 HKEYType.foo = "bar"
63
64
65 class BaseWinregTests(unittest.TestCase):
66
67 def setUp(self):
68 # Make sure that the test key is absent when the test
69 # starts.
70 self.delete_tree(HKEY_CURRENT_USER, test_key_name)
71
72 def delete_tree(self, root, subkey):
73 try:
74 hkey = OpenKey(root, subkey, 0, KEY_ALL_ACCESS)
75 except OSError:
76 # subkey does not exist
77 return
78 while True:
79 try:
80 subsubkey = EnumKey(hkey, 0)
81 except OSError:
82 # no more subkeys
83 break
84 self.delete_tree(hkey, subsubkey)
85 CloseKey(hkey)
86 DeleteKey(root, subkey)
87
88 def _write_test_data(self, root_key, subkeystr="sub_key",
89 CreateKey=CreateKey):
90 # Set the default value for this key.
91 SetValue(root_key, test_key_name, REG_SZ, "Default value")
92 key = CreateKey(root_key, test_key_name)
93 self.assertTrue(key.handle != 0)
94 # Create a sub-key
95 sub_key = CreateKey(key, subkeystr)
96 # Give the sub-key some named values
97
98 for value_name, value_data, value_type in test_data:
99 SetValueEx(sub_key, value_name, 0, value_type, value_data)
100
101 # Check we wrote as many items as we thought.
102 nkeys, nvalues, since_mod = QueryInfoKey(key)
103 self.assertEqual(nkeys, 1, "Not the correct number of sub keys")
104 self.assertEqual(nvalues, 1, "Not the correct number of values")
105 nkeys, nvalues, since_mod = QueryInfoKey(sub_key)
106 self.assertEqual(nkeys, 0, "Not the correct number of sub keys")
107 self.assertEqual(nvalues, len(test_data),
108 "Not the correct number of values")
109 # Close this key this way...
110 # (but before we do, copy the key as an integer - this allows
111 # us to test that the key really gets closed).
112 int_sub_key = int(sub_key)
113 CloseKey(sub_key)
114 try:
115 QueryInfoKey(int_sub_key)
116 self.fail("It appears the CloseKey() function does "
117 "not close the actual key!")
118 except OSError:
119 pass
120 # ... and close that key that way :-)
121 int_key = int(key)
122 key.Close()
123 try:
124 QueryInfoKey(int_key)
125 self.fail("It appears the key.Close() function "
126 "does not close the actual key!")
127 except OSError:
128 pass
129 def _read_test_data(self, root_key, subkeystr="sub_key", OpenKey=OpenKey):
130 # Check we can get default value for this key.
131 val = QueryValue(root_key, test_key_name)
132 self.assertEqual(val, "Default value",
133 "Registry didn't give back the correct value")
134
135 key = OpenKey(root_key, test_key_name)
136 # Read the sub-keys
137 with OpenKey(key, subkeystr) as sub_key:
138 # Check I can enumerate over the values.
139 index = 0
140 while 1:
141 try:
142 data = EnumValue(sub_key, index)
143 except OSError:
144 break
145 self.assertEqual(data in test_data, True,
146 "Didn't read back the correct test data")
147 index = index + 1
148 self.assertEqual(index, len(test_data),
149 "Didn't read the correct number of items")
150 # Check I can directly access each item
151 for value_name, value_data, value_type in test_data:
152 read_val, read_typ = QueryValueEx(sub_key, value_name)
153 self.assertEqual(read_val, value_data,
154 "Could not directly read the value")
155 self.assertEqual(read_typ, value_type,
156 "Could not directly read the value")
157 sub_key.Close()
158 # Enumerate our main key.
159 read_val = EnumKey(key, 0)
160 self.assertEqual(read_val, subkeystr, "Read subkey value wrong")
161 try:
162 EnumKey(key, 1)
163 self.fail("Was able to get a second key when I only have one!")
164 except OSError:
165 pass
166
167 key.Close()
168
169 def _delete_test_data(self, root_key, subkeystr="sub_key"):
170 key = OpenKey(root_key, test_key_name, 0, KEY_ALL_ACCESS)
171 sub_key = OpenKey(key, subkeystr, 0, KEY_ALL_ACCESS)
172 # It is not necessary to delete the values before deleting
173 # the key (although subkeys must not exist). We delete them
174 # manually just to prove we can :-)
175 for value_name, value_data, value_type in test_data:
176 DeleteValue(sub_key, value_name)
177
178 nkeys, nvalues, since_mod = QueryInfoKey(sub_key)
179 self.assertEqual(nkeys, 0, "subkey not empty before delete")
180 self.assertEqual(nvalues, 0, "subkey not empty before delete")
181 sub_key.Close()
182 DeleteKey(key, subkeystr)
183
184 try:
185 # Shouldn't be able to delete it twice!
186 DeleteKey(key, subkeystr)
187 self.fail("Deleting the key twice succeeded")
188 except OSError:
189 pass
190 key.Close()
191 DeleteKey(root_key, test_key_name)
192 # Opening should now fail!
193 try:
194 key = OpenKey(root_key, test_key_name)
195 self.fail("Could open the non-existent key")
196 except OSError: # Use this error name this time
197 pass
198
199 def _test_all(self, root_key, subkeystr="sub_key"):
200 self._write_test_data(root_key, subkeystr)
201 self._read_test_data(root_key, subkeystr)
202 self._delete_test_data(root_key, subkeystr)
203
204 def _test_named_args(self, key, sub_key):
205 with CreateKeyEx(key=key, sub_key=sub_key, reserved=0,
206 access=KEY_ALL_ACCESS) as ckey:
207 self.assertTrue(ckey.handle != 0)
208
209 with OpenKeyEx(key=key, sub_key=sub_key, reserved=0,
210 access=KEY_ALL_ACCESS) as okey:
211 self.assertTrue(okey.handle != 0)
212
213
214 class LocalWinregTests(BaseWinregTests):
215
216 def test_registry_works(self):
217 self._test_all(HKEY_CURRENT_USER)
218 self._test_all(HKEY_CURRENT_USER, "日本-subkey")
219
220 def test_registry_works_extended_functions(self):
221 # Substitute the regular CreateKey and OpenKey calls with their
222 # extended counterparts.
223 # Note: DeleteKeyEx is not used here because it is platform dependent
224 cke = lambda key, sub_key: CreateKeyEx(key, sub_key, 0, KEY_ALL_ACCESS)
225 self._write_test_data(HKEY_CURRENT_USER, CreateKey=cke)
226
227 oke = lambda key, sub_key: OpenKeyEx(key, sub_key, 0, KEY_READ)
228 self._read_test_data(HKEY_CURRENT_USER, OpenKey=oke)
229
230 self._delete_test_data(HKEY_CURRENT_USER)
231
232 def test_named_arguments(self):
233 self._test_named_args(HKEY_CURRENT_USER, test_key_name)
234 # Use the regular DeleteKey to clean up
235 # DeleteKeyEx takes named args and is tested separately
236 DeleteKey(HKEY_CURRENT_USER, test_key_name)
237
238 def test_connect_registry_to_local_machine_works(self):
239 # perform minimal ConnectRegistry test which just invokes it
240 h = ConnectRegistry(None, HKEY_LOCAL_MACHINE)
241 self.assertNotEqual(h.handle, 0)
242 h.Close()
243 self.assertEqual(h.handle, 0)
244
245 def test_nonexistent_remote_registry(self):
246 connect = lambda: ConnectRegistry("abcdefghijkl", HKEY_CURRENT_USER)
247 self.assertRaises(OSError, connect)
248
249 def testExpandEnvironmentStrings(self):
250 r = ExpandEnvironmentStrings("%windir%\\test")
251 self.assertEqual(type(r), str)
252 self.assertEqual(r, os.environ["windir"] + "\\test")
253
254 def test_context_manager(self):
255 # ensure that the handle is closed if an exception occurs
256 try:
257 with ConnectRegistry(None, HKEY_LOCAL_MACHINE) as h:
258 self.assertNotEqual(h.handle, 0)
259 raise OSError
260 except OSError:
261 self.assertEqual(h.handle, 0)
262
263 def test_changing_value(self):
264 # Issue2810: A race condition in 2.6 and 3.1 may cause
265 # EnumValue or QueryValue to raise "WindowsError: More data is
266 # available"
267 done = False
268
269 class VeryActiveThread(threading.Thread):
270 def run(self):
271 with CreateKey(HKEY_CURRENT_USER, test_key_name) as key:
272 use_short = True
273 long_string = 'x'*2000
274 while not done:
275 s = 'x' if use_short else long_string
276 use_short = not use_short
277 SetValue(key, 'changing_value', REG_SZ, s)
278
279 thread = VeryActiveThread()
280 thread.start()
281 try:
282 with CreateKey(HKEY_CURRENT_USER,
283 test_key_name+'\\changing_value') as key:
284 for _ in range(1000):
285 num_subkeys, num_values, t = QueryInfoKey(key)
286 for i in range(num_values):
287 name = EnumValue(key, i)
288 QueryValue(key, name[0])
289 finally:
290 done = True
291 thread.join()
292 DeleteKey(HKEY_CURRENT_USER, test_key_name+'\\changing_value')
293 DeleteKey(HKEY_CURRENT_USER, test_key_name)
294
295 def test_queryvalueex_race_condition(self):
296 # gh-142282: QueryValueEx could read garbage buffer under race
297 # condition when another thread changes the value size
298 done = False
299 ready = threading.Event()
300 values = [b'ham', b'spam']
301
302 class WriterThread(threading.Thread):
303 def run(self):
304 with CreateKey(HKEY_CURRENT_USER, test_key_name) as key:
305 values_iter = itertools.cycle(values)
306 while not done:
307 val = next(values_iter)
308 SetValueEx(key, 'test_value', 0, REG_BINARY, val)
309 ready.set()
310
311 thread = WriterThread()
312 thread.start()
313 try:
314 ready.wait()
315 with CreateKey(HKEY_CURRENT_USER, test_key_name) as key:
316 for _ in range(1000):
317 result, typ = QueryValueEx(key, 'test_value')
318 # The result must be one of the written values,
319 # not garbage data from uninitialized buffer
320 self.assertIn(result, values)
321 finally:
322 done = True
323 thread.join()
324 DeleteKey(HKEY_CURRENT_USER, test_key_name)
325
326 def test_long_key(self):
327 # Issue2810, in 2.6 and 3.1 when the key name was exactly 256
328 # characters, EnumKey raised "WindowsError: More data is
329 # available"
330 name = 'x'*256
331 try:
332 with CreateKey(HKEY_CURRENT_USER, test_key_name) as key:
333 SetValue(key, name, REG_SZ, 'x')
334 num_subkeys, num_values, t = QueryInfoKey(key)
335 EnumKey(key, 0)
336 finally:
337 DeleteKey(HKEY_CURRENT_USER, '\\'.join((test_key_name, name)))
338 DeleteKey(HKEY_CURRENT_USER, test_key_name)
339
340 def test_dynamic_key(self):
341 # Issue2810, when the value is dynamically generated, these
342 # raise "WindowsError: More data is available" in 2.6 and 3.1
343 try:
344 EnumValue(HKEY_PERFORMANCE_DATA, 0)
345 except OSError as e:
346 if e.errno in (errno.EPERM, errno.EACCES):
347 self.skipTest("access denied to registry key "
348 "(are you running in a non-interactive session?)")
349 raise
350 QueryValueEx(HKEY_PERFORMANCE_DATA, "")
351
352 # Reflection requires XP x64/Vista at a minimum. XP doesn't have this stuff
353 # or DeleteKeyEx so make sure their use raises NotImplementedError
354 @unittest.skipUnless(WIN_VER < (5, 2), "Requires Windows XP")
355 def test_reflection_unsupported(self):
356 try:
357 with CreateKey(HKEY_CURRENT_USER, test_key_name) as ck:
358 self.assertNotEqual(ck.handle, 0)
359
360 key = OpenKey(HKEY_CURRENT_USER, test_key_name)
361 self.assertNotEqual(key.handle, 0)
362
363 with self.assertRaises(NotImplementedError):
364 DisableReflectionKey(key)
365 with self.assertRaises(NotImplementedError):
366 EnableReflectionKey(key)
367 with self.assertRaises(NotImplementedError):
368 QueryReflectionKey(key)
369 with self.assertRaises(NotImplementedError):
370 DeleteKeyEx(HKEY_CURRENT_USER, test_key_name)
371 finally:
372 DeleteKey(HKEY_CURRENT_USER, test_key_name)
373
374 def test_setvalueex_value_range(self):
375 # Test for Issue #14420, accept proper ranges for SetValueEx.
376 # Py2Reg, which gets called by SetValueEx, was using PyLong_AsLong,
377 # thus raising OverflowError. The implementation now uses
378 # PyLong_AsUnsignedLong to match DWORD's size.
379 try:
380 with CreateKey(HKEY_CURRENT_USER, test_key_name) as ck:
381 self.assertNotEqual(ck.handle, 0)
382 SetValueEx(ck, "test_name", None, REG_DWORD, 0x80000000)
383 finally:
384 DeleteKey(HKEY_CURRENT_USER, test_key_name)
385
386 def test_setvalueex_negative_one_check(self):
387 # Test for Issue #43984, check -1 was not set by SetValueEx.
388 # Py2Reg, which gets called by SetValueEx, wasn't checking return
389 # value by PyLong_AsUnsignedLong, thus setting -1 as value in the registry.
390 # The implementation now checks PyLong_AsUnsignedLong return value to assure
391 # the value set was not -1.
392 try:
393 with CreateKey(HKEY_CURRENT_USER, test_key_name) as ck:
394 with self.assertRaises(OverflowError):
395 SetValueEx(ck, "test_name_dword", None, REG_DWORD, -1)
396 SetValueEx(ck, "test_name_qword", None, REG_QWORD, -1)
397 self.assertRaises(FileNotFoundError, QueryValueEx, ck, "test_name_dword")
398 self.assertRaises(FileNotFoundError, QueryValueEx, ck, "test_name_qword")
399
400 finally:
401 DeleteKey(HKEY_CURRENT_USER, test_key_name)
402
403 def test_queryvalueex_return_value(self):
404 # Test for Issue #16759, return unsigned int from QueryValueEx.
405 # Reg2Py, which gets called by QueryValueEx, was returning a value
406 # generated by PyLong_FromLong. The implementation now uses
407 # PyLong_FromUnsignedLong to match DWORD's size.
408 try:
409 with CreateKey(HKEY_CURRENT_USER, test_key_name) as ck:
410 self.assertNotEqual(ck.handle, 0)
411 test_val = 0x80000000
412 SetValueEx(ck, "test_name", None, REG_DWORD, test_val)
413 ret_val, ret_type = QueryValueEx(ck, "test_name")
414 self.assertEqual(ret_type, REG_DWORD)
415 self.assertEqual(ret_val, test_val)
416 finally:
417 DeleteKey(HKEY_CURRENT_USER, test_key_name)
418
419 def test_setvalueex_crash_with_none_arg(self):
420 # Test for Issue #21151, segfault when None is passed to SetValueEx
421 try:
422 with CreateKey(HKEY_CURRENT_USER, test_key_name) as ck:
423 self.assertNotEqual(ck.handle, 0)
424 test_val = None
425 SetValueEx(ck, "test_name", 0, REG_BINARY, test_val)
426 ret_val, ret_type = QueryValueEx(ck, "test_name")
427 self.assertEqual(ret_type, REG_BINARY)
428 self.assertEqual(ret_val, test_val)
429 finally:
430 DeleteKey(HKEY_CURRENT_USER, test_key_name)
431
432 def test_read_string_containing_null(self):
433 # Test for issue 25778: REG_SZ should not contain null characters
434 try:
435 with CreateKey(HKEY_CURRENT_USER, test_key_name) as ck:
436 self.assertNotEqual(ck.handle, 0)
437 test_val = "A string\x00 with a null"
438 SetValueEx(ck, "test_name", 0, REG_SZ, test_val)
439 ret_val, ret_type = QueryValueEx(ck, "test_name")
440 self.assertEqual(ret_type, REG_SZ)
441 self.assertEqual(ret_val, "A string")
442 finally:
443 DeleteKey(HKEY_CURRENT_USER, test_key_name)
444
445
446 @unittest.skipUnless(REMOTE_NAME, "Skipping remote registry tests")
447 class RemoteWinregTests(BaseWinregTests):
448
449 def test_remote_registry_works(self):
450 remote_key = ConnectRegistry(REMOTE_NAME, HKEY_CURRENT_USER)
451 self._test_all(remote_key)
452
453
454 @unittest.skipUnless(WIN64_MACHINE, "x64 specific registry tests")
455 class Win64WinregTests(BaseWinregTests):
456
457 def test_named_arguments(self):
458 self._test_named_args(HKEY_CURRENT_USER, test_key_name)
459 # Clean up and also exercise the named arguments
460 DeleteKeyEx(key=HKEY_CURRENT_USER, sub_key=test_key_name,
461 access=KEY_ALL_ACCESS, reserved=0)
462
463 @unittest.skipIf(win32_edition() in ('WindowsCoreHeadless', 'IoTEdgeOS'), "APIs not available on WindowsCoreHeadless")
464 def test_reflection_functions(self):
465 # Test that we can call the query, enable, and disable functions
466 # on a key which isn't on the reflection list with no consequences.
467 with OpenKey(HKEY_LOCAL_MACHINE, "Software") as key:
468 # HKLM\Software is redirected but not reflected in all OSes
469 self.assertTrue(QueryReflectionKey(key))
470 self.assertIsNone(EnableReflectionKey(key))
471 self.assertIsNone(DisableReflectionKey(key))
472 self.assertTrue(QueryReflectionKey(key))
473
474 @unittest.skipUnless(HAS_REFLECTION, "OS doesn't support reflection")
475 def test_reflection(self):
476 # Test that we can create, open, and delete keys in the 32-bit
477 # area. Because we are doing this in a key which gets reflected,
478 # test the differences of 32 and 64-bit keys before and after the
479 # reflection occurs (ie. when the created key is closed).
480 try:
481 with CreateKeyEx(HKEY_CURRENT_USER, test_reflect_key_name, 0,
482 KEY_ALL_ACCESS | KEY_WOW64_32KEY) as created_key:
483 self.assertNotEqual(created_key.handle, 0)
484
485 # The key should now be available in the 32-bit area
486 with OpenKey(HKEY_CURRENT_USER, test_reflect_key_name, 0,
487 KEY_ALL_ACCESS | KEY_WOW64_32KEY) as key:
488 self.assertNotEqual(key.handle, 0)
489
490 # Write a value to what currently is only in the 32-bit area
491 SetValueEx(created_key, "", 0, REG_SZ, "32KEY")
492
493 # The key is not reflected until created_key is closed.
494 # The 64-bit version of the key should not be available yet.
495 open_fail = lambda: OpenKey(HKEY_CURRENT_USER,
496 test_reflect_key_name, 0,
497 KEY_READ | KEY_WOW64_64KEY)
498 self.assertRaises(OSError, open_fail)
499
500 # Now explicitly open the 64-bit version of the key
501 with OpenKey(HKEY_CURRENT_USER, test_reflect_key_name, 0,
502 KEY_ALL_ACCESS | KEY_WOW64_64KEY) as key:
503 self.assertNotEqual(key.handle, 0)
504 # Make sure the original value we set is there
505 self.assertEqual("32KEY", QueryValue(key, ""))
506 # Set a new value, which will get reflected to 32-bit
507 SetValueEx(key, "", 0, REG_SZ, "64KEY")
508
509 # Reflection uses a "last-writer wins policy, so the value we set
510 # on the 64-bit key should be the same on 32-bit
511 with OpenKey(HKEY_CURRENT_USER, test_reflect_key_name, 0,
512 KEY_READ | KEY_WOW64_32KEY) as key:
513 self.assertEqual("64KEY", QueryValue(key, ""))
514 finally:
515 DeleteKeyEx(HKEY_CURRENT_USER, test_reflect_key_name,
516 KEY_WOW64_32KEY, 0)
517
518 @unittest.skipUnless(HAS_REFLECTION, "OS doesn't support reflection")
519 def test_disable_reflection(self):
520 # Make use of a key which gets redirected and reflected
521 try:
522 with CreateKeyEx(HKEY_CURRENT_USER, test_reflect_key_name, 0,
523 KEY_ALL_ACCESS | KEY_WOW64_32KEY) as created_key:
524 # QueryReflectionKey returns whether or not the key is disabled
525 disabled = QueryReflectionKey(created_key)
526 self.assertEqual(type(disabled), bool)
527 # HKCU\Software\Classes is reflected by default
528 self.assertFalse(disabled)
529
530 DisableReflectionKey(created_key)
531 self.assertTrue(QueryReflectionKey(created_key))
532
533 # The key is now closed and would normally be reflected to the
534 # 64-bit area, but let's make sure that didn't happen.
535 open_fail = lambda: OpenKeyEx(HKEY_CURRENT_USER,
536 test_reflect_key_name, 0,
537 KEY_READ | KEY_WOW64_64KEY)
538 self.assertRaises(OSError, open_fail)
539
540 # Make sure the 32-bit key is actually there
541 with OpenKeyEx(HKEY_CURRENT_USER, test_reflect_key_name, 0,
542 KEY_READ | KEY_WOW64_32KEY) as key:
543 self.assertNotEqual(key.handle, 0)
544 finally:
545 DeleteKeyEx(HKEY_CURRENT_USER, test_reflect_key_name,
546 KEY_WOW64_32KEY, 0)
547
548 def test_exception_numbers(self):
549 with self.assertRaises(FileNotFoundError) as ctx:
550 QueryValue(HKEY_CLASSES_ROOT, 'some_value_that_does_not_exist')
551
552
553 if __name__ == "__main__":
554 if not REMOTE_NAME:
555 print("Remote registry calls can be tested using",
556 "'test_winreg.py --remote \\\\machine_name'")
557 unittest.main()