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