Index: Lib/test/test_winreg.py =================================================================== --- Lib/test/test_winreg.py (revision 61589) +++ Lib/test/test_winreg.py (working copy) @@ -1,32 +1,33 @@ # Test the windows specific win32reg module. # Only win32reg functions not hit here: FlushKey, LoadKey and SaveKey -from _winreg import * +import _winreg import os, sys import unittest from test import test_support +from exceptions import WindowsError test_key_name = "SOFTWARE\\Python Registry Test Key - Delete Me" test_data = [ - ("Int Value", 45, REG_DWORD), - ("String Val", "A string value", REG_SZ), - ("StringExpand", "The path is %path%", REG_EXPAND_SZ), - ("Multi-string", ["Lots", "of", "string", "values"], REG_MULTI_SZ), - ("Raw Data", ("binary"+chr(0)+"data"), REG_BINARY), - ("Big String", "x"*(2**14-1), REG_SZ), - ("Big Binary", "x"*(2**14), REG_BINARY), + ("Int Value", 45, _winreg.REG_DWORD), + ("String Val", "A string value", _winreg.REG_SZ), + ("StringExpand", "The path is %path%", _winreg.REG_EXPAND_SZ), + ("Multi-string", ["Lots", "of", "string", "values"], _winreg.REG_MULTI_SZ), + ("Raw Data", ("binary"+chr(0)+"data"), _winreg.REG_BINARY), + ("Big String", "x"*(2**14-1), _winreg.REG_SZ), + ("Big Binary", "x"*(2**14), _winreg.REG_BINARY), ] if test_support.have_unicode: test_data += [ - (unicode("Unicode Val"), unicode("A Unicode value"), REG_SZ,), - ("UnicodeExpand", unicode("The path is %path%"), REG_EXPAND_SZ), + (unicode("Unicode Val"), unicode("A Unicode value"), _winreg.REG_SZ,), + ("UnicodeExpand", unicode("The path is %path%"), _winreg.REG_EXPAND_SZ), ("Multi-unicode", [unicode("Lots"), unicode("of"), unicode("unicode"), - unicode("values")], REG_MULTI_SZ), + unicode("values")], _winreg.REG_MULTI_SZ), ("Multi-mixed", [unicode("Unicode"), unicode("and"), "string", - "values"], REG_MULTI_SZ), + "values"], _winreg.REG_MULTI_SZ), ] class WinregTests(unittest.TestCase): @@ -34,20 +35,20 @@ def WriteTestData(self, root_key): # Set the default value for this key. - SetValue(root_key, test_key_name, REG_SZ, "Default value") - key = CreateKey(root_key, test_key_name) + _winreg.SetValue(root_key, test_key_name, _winreg.REG_SZ, "Default value") + key = _winreg.CreateKey(root_key, test_key_name) # Create a sub-key - sub_key = CreateKey(key, "sub_key") + sub_key = _winreg.CreateKey(key, "sub_key") # Give the sub-key some named values for value_name, value_data, value_type in test_data: - SetValueEx(sub_key, value_name, 0, value_type, value_data) + _winreg.SetValueEx(sub_key, value_name, 0, value_type, value_data) # Check we wrote as many items as we thought. - nkeys, nvalues, since_mod = QueryInfoKey(key) + nkeys, nvalues, since_mod = _winreg.QueryInfoKey(key) self.assertEquals(nkeys, 1, "Not the correct number of sub keys") self.assertEquals(nvalues, 1, "Not the correct number of values") - nkeys, nvalues, since_mod = QueryInfoKey(sub_key) + nkeys, nvalues, since_mod = _winreg.QueryInfoKey(sub_key) self.assertEquals(nkeys, 0, "Not the correct number of sub keys") self.assertEquals(nvalues, len(test_data), "Not the correct number of values") @@ -55,9 +56,9 @@ # (but before we do, copy the key as an integer - this allows # us to test that the key really gets closed). int_sub_key = int(sub_key) - CloseKey(sub_key) + _winreg.CloseKey(sub_key) try: - QueryInfoKey(int_sub_key) + _winreg.QueryInfoKey(int_sub_key) self.fail("It appears the CloseKey() function does " "not close the actual key!") except EnvironmentError: @@ -66,7 +67,7 @@ int_key = int(key) key.Close() try: - QueryInfoKey(int_key) + _winreg.QueryInfoKey(int_key) self.fail("It appears the key.Close() function " "does not close the actual key!") except EnvironmentError: @@ -74,18 +75,18 @@ def ReadTestData(self, root_key): # Check we can get default value for this key. - val = QueryValue(root_key, test_key_name) + val = _winreg.QueryValue(root_key, test_key_name) self.assertEquals(val, "Default value", "Registry didn't give back the correct value") - key = OpenKey(root_key, test_key_name) + key = _winreg.OpenKey(root_key, test_key_name) # Read the sub-keys - with OpenKey(key, "sub_key") as sub_key: + with _winreg.OpenKey(key, "sub_key") as sub_key: # Check I can enumerate over the values. index = 0 while 1: try: - data = EnumValue(sub_key, index) + data = _winreg.EnumValue(sub_key, index) except EnvironmentError: break self.assertEquals(data in test_data, True, @@ -95,17 +96,17 @@ "Didn't read the correct number of items") # Check I can directly access each item for value_name, value_data, value_type in test_data: - read_val, read_typ = QueryValueEx(sub_key, value_name) + read_val, read_typ = _winreg.QueryValueEx(sub_key, value_name) self.assertEquals(read_val, value_data, "Could not directly read the value") self.assertEquals(read_typ, value_type, "Could not directly read the value") sub_key.Close() # Enumerate our main key. - read_val = EnumKey(key, 0) + read_val = _winreg.EnumKey(key, 0) self.assertEquals(read_val, "sub_key", "Read subkey value wrong") try: - EnumKey(key, 1) + _winreg.EnumKey(key, 1) self.fail("Was able to get a second key when I only have one!") except EnvironmentError: pass @@ -113,31 +114,31 @@ key.Close() def DeleteTestData(self, root_key): - key = OpenKey(root_key, test_key_name, 0, KEY_ALL_ACCESS) - sub_key = OpenKey(key, "sub_key", 0, KEY_ALL_ACCESS) + key = _winreg.OpenKey(root_key, test_key_name, 0, _winreg.KEY_ALL_ACCESS) + sub_key = _winreg.OpenKey(key, "sub_key", 0, _winreg.KEY_ALL_ACCESS) # It is not necessary to delete the values before deleting # the key (although subkeys must not exist). We delete them # manually just to prove we can :-) for value_name, value_data, value_type in test_data: - DeleteValue(sub_key, value_name) + _winreg.DeleteValue(sub_key, value_name) - nkeys, nvalues, since_mod = QueryInfoKey(sub_key) + nkeys, nvalues, since_mod = _winreg.QueryInfoKey(sub_key) self.assertEquals(nkeys, 0, "subkey not empty before delete") self.assertEquals(nvalues, 0, "subkey not empty before delete") sub_key.Close() - DeleteKey(key, "sub_key") + _winreg.DeleteKey(key, "sub_key") try: # Shouldnt be able to delete it twice! - DeleteKey(key, "sub_key") + _winreg.DeleteKey(key, "sub_key") self.fail("Deleting the key twice succeeded") except EnvironmentError: pass key.Close() - DeleteKey(root_key, test_key_name) + _winreg.DeleteKey(root_key, test_key_name) # Opening should now fail! try: - key = OpenKey(root_key, test_key_name) + key = _winreg.OpenKey(root_key, test_key_name) self.fail("Could open the non-existent key") except WindowsError: # Use this error name this time pass @@ -148,21 +149,21 @@ self.DeleteTestData(root_key) def testLocalMachineRegistryWorks(self): - self.TestAll(HKEY_CURRENT_USER) + self.TestAll(_winreg.HKEY_CURRENT_USER) def testConnectRegistryToLocalMachineWorks(self): # perform minimal ConnectRegistry test which just invokes it - h = ConnectRegistry(None, HKEY_LOCAL_MACHINE) + h = _winreg.ConnectRegistry(None, _winreg.HKEY_LOCAL_MACHINE) h.Close() def testRemoteMachineRegistryWorks(self): if not self.remote_name: return # remote machine name not specified - remote_key = ConnectRegistry(self.remote_name, HKEY_CURRENT_USER) + remote_key = _winreg.ConnectRegistry(self.remote_name, _winreg.HKEY_CURRENT_USER) self.TestAll(remote_key) def testExpandEnvironmentStrings(self): - r = ExpandEnvironmentStrings(u"%windir%\\test") + r = _winreg.ExpandEnvironmentStrings(u"%windir%\\test") self.assertEqual(type(r), unicode) self.assertEqual(r, os.environ["windir"] + "\\test")