Author: Matti Picus <matti.pi...@gmail.com> Branch: py3.5 Changeset: r93633:7b9edeb55281 Date: 2018-01-07 22:29 +0200 http://bitbucket.org/pypy/pypy/changeset/7b9edeb55281/
Log: merge py3-winreg which uses unicode strings in winreg module diff --git a/pypy/interpreter/gateway.py b/pypy/interpreter/gateway.py --- a/pypy/interpreter/gateway.py +++ b/pypy/interpreter/gateway.py @@ -171,6 +171,9 @@ def visit_text0(self, el, app_sig): self.checked_space_method(el, app_sig) + def visit_unicode(self, el, app_sig): + self.checked_space_method(el, app_sig) + def visit_fsencode(self, el, app_sig): self.checked_space_method(el, app_sig) @@ -320,6 +323,9 @@ def visit_text0(self, typ): self.run_args.append("space.text0_w(%s)" % (self.scopenext(),)) + def visit_unicode(self, typ): + self.run_args.append("space.unicode_w(%s)" % (self.scopenext(),)) + def visit_fsencode(self, typ): self.run_args.append("space.fsencode_w(%s)" % (self.scopenext(),)) @@ -485,6 +491,9 @@ def visit_text(self, typ): self.unwrap.append("space.text_w(%s)" % (self.nextarg(),)) + def visit_unicode(self, typ): + self.unwrap.append("space.unicode_w(%s)" % (self.nextarg(),)) + def visit_text0(self, typ): self.unwrap.append("space.text0_w(%s)" % (self.nextarg(),)) diff --git a/pypy/module/_winreg/interp_winreg.py b/pypy/module/_winreg/interp_winreg.py --- a/pypy/module/_winreg/interp_winreg.py +++ b/pypy/module/_winreg/interp_winreg.py @@ -9,9 +9,10 @@ def raiseWindowsError(space, errcode, context): message = rwin32.FormatErrorW(errcode) + w_errcode = space.newint(errcode) raise OperationError(space.w_WindowsError, - space.newtuple([space.newint(errcode), - space.newunicode(message)])) + space.newtuple([w_errcode, space.newunicode(message), + space.w_None, w_errcode])) class W_HKEY(W_Root): def __init__(self, space, hkey): @@ -32,7 +33,7 @@ return space.newint(self.as_int()) def descr_repr(self, space): - return space.newtext("<PyHKEY:0x%x>" % (self.as_int(),)) + return space.newunicode(u"<PyHKEY:0x%x>" % (self.as_int(),)) def descr_int(self, space): return space.newint(self.as_int()) @@ -149,7 +150,7 @@ if ret != 0: raiseWindowsError(space, ret, 'RegFlushKey') -@unwrap_spec(subkey="text", filename="text") +@unwrap_spec(subkey="unicode", filename="unicode") def LoadKey(space, w_hkey, subkey, filename): """LoadKey(key, sub_key, file_name) - Creates a subkey under the specified key and stores registration information from a specified file into that subkey. @@ -170,11 +171,15 @@ The docs imply key must be in the HKEY_USER or HKEY_LOCAL_MACHINE tree""" # XXX should filename use space.fsencode_w? hkey = hkey_w(w_hkey, space) - ret = rwinreg.RegLoadKey(hkey, subkey, filename) - if ret != 0: - raiseWindowsError(space, ret, 'RegLoadKey') + with rffi.scoped_unicode2wcharp(subkey) as wide_subkey: + c_subkey = rffi.cast(rffi.CCHARP, wide_subkey) + with rffi.scoped_unicode2wcharp(filename) as wide_filename: + c_filename = rffi.cast(rffi.CCHARP, wide_filename) + ret = rwinreg.RegLoadKey(hkey, c_subkey, c_filename) + if ret != 0: + raiseWindowsError(space, ret, 'RegLoadKey') -@unwrap_spec(filename="text") +@unwrap_spec(filename="unicode") def SaveKey(space, w_hkey, filename): """SaveKey(key, file_name) - Saves the specified key, and all its subkeys to the specified file. @@ -189,11 +194,13 @@ The caller of this method must possess the SeBackupPrivilege security privilege. This function passes NULL for security_attributes to the API.""" hkey = hkey_w(w_hkey, space) - ret = rwinreg.RegSaveKey(hkey, filename, None) - if ret != 0: - raiseWindowsError(space, ret, 'RegSaveKey') + with rffi.scoped_unicode2wcharp(filename) as wide_filename: + c_filename = rffi.cast(rffi.CCHARP, wide_filename) + ret = rwinreg.RegSaveKey(hkey, c_filename, None) + if ret != 0: + raiseWindowsError(space, ret, 'RegSaveKey') -@unwrap_spec(typ=int, value="text") +@unwrap_spec(typ=int, value="unicode") def SetValue(space, w_hkey, w_subkey, typ, value): """SetValue(key, sub_key, type, value) - Associates a value with a specified key. @@ -215,14 +222,14 @@ if typ != rwinreg.REG_SZ: raise oefmt(space.w_ValueError, "Type must be winreg.REG_SZ") hkey = hkey_w(w_hkey, space) - if space.is_w(w_subkey, space.w_None): - subkey = None - else: - subkey = space.text_w(w_subkey) - with rffi.scoped_str2charp(value) as dataptr: - ret = rwinreg.RegSetValue(hkey, subkey, rwinreg.REG_SZ, dataptr, len(value)) - if ret != 0: - raiseWindowsError(space, ret, 'RegSetValue') + with rffi.scoped_unicode2wcharp(space.unicode_w(w_subkey)) as subkey: + c_subkey = rffi.cast(rffi.CCHARP, subkey) + with rffi.scoped_unicode2wcharp(value) as dataptr: + c_dataptr = rffi.cast(rffi.CCHARP, dataptr) + ret = rwinreg.RegSetValue(hkey, c_subkey, rwinreg.REG_SZ, + c_dataptr, len(value)) + if ret != 0: + raiseWindowsError(space, ret, 'RegSetValue') def QueryValue(space, w_hkey, w_subkey): """string = QueryValue(key, sub_key) - retrieves the unnamed value for a key. @@ -239,30 +246,37 @@ if space.is_w(w_subkey, space.w_None): subkey = None else: - subkey = space.text_w(w_subkey) - with lltype.scoped_alloc(rwin32.PLONG.TO, 1) as bufsize_p: - ret = rwinreg.RegQueryValue(hkey, subkey, None, bufsize_p) - bufSize = intmask(bufsize_p[0]) - if ret == rwinreg.ERROR_MORE_DATA: - bufSize = 256 - elif ret != 0: - raiseWindowsError(space, ret, 'RegQueryValue') + subkey = space.unicode_w(w_subkey) + with rffi.scoped_unicode2wcharp(subkey) as wide_subkey: + c_subkey = rffi.cast(rffi.CCHARP, wide_subkey) + with lltype.scoped_alloc(rwin32.PLONG.TO, 1) as bufsize_p: + ret = rwinreg.RegQueryValue(hkey, c_subkey, None, bufsize_p) + bufSize = intmask(bufsize_p[0]) + if ret == rwinreg.ERROR_MORE_DATA: + bufSize = 256 + elif ret != 0: + raiseWindowsError(space, ret, 'RegQueryValue') - while True: - with lltype.scoped_alloc(rffi.CCHARP.TO, bufSize) as buf: - ret = rwinreg.RegQueryValue(hkey, subkey, buf, bufsize_p) - if ret == rwinreg.ERROR_MORE_DATA: - # Resize and retry - bufSize *= 2 - bufsize_p[0] = bufSize - continue + while True: + with lltype.scoped_alloc(rffi.CCHARP.TO, bufSize) as buf: + ret = rwinreg.RegQueryValue(hkey, c_subkey, buf, bufsize_p) + if ret == rwinreg.ERROR_MORE_DATA: + print 'bufSize was %d, too small' % bufSize + # Resize and retry + bufSize *= 2 + bufsize_p[0] = bufSize + continue - if ret != 0: - raiseWindowsError(space, ret, 'RegQueryValue') - length = intmask(bufsize_p[0] - 1) - return space.newtext(rffi.charp2strn(buf, length)) + if ret != 0: + raiseWindowsError(space, ret, 'RegQueryValue') + length = intmask(bufsize_p[0] - 1) / 2 + wide_buf = rffi.cast(rffi.CWCHARP, buf) + return space.newunicode(rffi.wcharp2unicoden(wide_buf, length)) def convert_to_regdata(space, w_value, typ): + ''' + returns CCHARP, int + ''' buf = None if typ == rwinreg.REG_DWORD: @@ -282,11 +296,9 @@ buf = lltype.malloc(rffi.CCHARP.TO, buflen, flavor='raw') buf[0] = '\0' else: - if space.isinstance_w(w_value, space.w_unicode): - w_value = space.call_method(w_value, 'encode', - space.newtext('mbcs')) - buf = rffi.str2charp(space.text_w(w_value)) - buflen = space.len_w(w_value) + 1 + buf = rffi.unicode2wcharp(space.unicode_w(w_value)) + buf = rffi.cast(rffi.CCHARP, buf) + buflen = (space.len_w(w_value) * 2) + 1 elif typ == rwinreg.REG_MULTI_SZ: if space.is_w(w_value, space.w_None): @@ -302,28 +314,29 @@ while True: try: w_item = space.next(w_iter) - if space.isinstance_w(w_item, space.w_unicode): - w_item = space.call_method(w_item, 'encode', - space.newtext('mbcs')) - item = space.bytes_w(w_item) + item = space.unicode_w(w_item) strings.append(item) - buflen += len(item) + 1 + buflen += 2 * (len(item) + 1) except OperationError as e: if not e.match(space, space.w_StopIteration): raise # re-raise other app-level exceptions break - buflen += 1 + buflen += 2 buf = lltype.malloc(rffi.CCHARP.TO, buflen, flavor='raw') # Now copy data buflen = 0 for string in strings: - for i in range(len(string)): - buf[buflen + i] = string[i] - buflen += len(string) + 1 + with rffi.scoped_unicode2wcharp(string) as wchr: + c_str = rffi.cast(rffi.CCHARP, wchr) + for i in range(len(string) * 2): + buf[buflen + i] = c_str[i] + buflen += (len(string) + 1) * 2 buf[buflen - 1] = '\0' - buflen += 1 + buf[buflen - 2] = '\0' + buflen += 2 buf[buflen - 1] = '\0' + buf[buflen - 2] = '\0' else: # REG_BINARY and ALL unknown data types. if space.is_w(w_value, space.w_None): @@ -357,37 +370,40 @@ elif typ == rwinreg.REG_SZ or typ == rwinreg.REG_EXPAND_SZ: if not buflen: - s = "" + s = u"" else: # may or may not have a trailing NULL in the buffer. - buf = rffi.cast(rffi.CCHARP, buf) + buf = rffi.cast(rffi.CWCHARP, buf) + buflen /= 2 if buf[buflen - 1] == '\x00': buflen -= 1 - s = rffi.charp2strn(buf, buflen) - w_s = space.newbytes(s) - return space.call_method(w_s, 'decode', space.newtext('mbcs')) + s = rffi.wcharp2unicoden(buf, buflen) + w_s = space.newunicode(s) + return w_s elif typ == rwinreg.REG_MULTI_SZ: if not buflen: return space.newlist([]) + buf = rffi.cast(rffi.CWCHARP, buf) + buflen /= 2 i = 0 l = [] while i < buflen and buf[i]: s = [] - while i < buflen and buf[i] != '\0': + while i < buflen and buf[i] != u'\0': s.append(buf[i]) i += 1 if len(s) == 0: break - s = ''.join(s) - l.append(space.newtext(s)) + s = u''.join(s) + l.append(space.newunicode(s)) i += 1 return space.newlist(l) else: # REG_BINARY and all other types return space.newbytes(rffi.charpsize2str(buf, buflen)) -@unwrap_spec(value_name="text", typ=int) +@unwrap_spec(value_name="unicode", typ=int) def SetValueEx(space, w_hkey, value_name, w_reserved, typ, w_value): """SetValueEx(key, value_name, reserved, type, value) - Stores data in the value field of an open registry key. @@ -422,7 +438,9 @@ hkey = hkey_w(w_hkey, space) buf, buflen = convert_to_regdata(space, w_value, typ) try: - ret = rwinreg.RegSetValueEx(hkey, value_name, 0, typ, buf, buflen) + with rffi.scoped_unicode2wcharp(value_name) as wide_vn: + c_vn = rffi.cast(rffi.CCHARP, wide_vn) + ret = rwinreg.RegSetValueEx(hkey, c_vn, 0, typ, buf, buflen) finally: lltype.free(buf, flavor='raw') if ret != 0: @@ -437,38 +455,40 @@ if space.is_w(w_subkey, space.w_None): subkey = None else: - subkey = space.text_w(w_subkey) + subkey = space.unicode_w(w_subkey) null_dword = lltype.nullptr(rwin32.LPDWORD.TO) - with lltype.scoped_alloc(rwin32.LPDWORD.TO, 1) as retDataSize: - ret = rwinreg.RegQueryValueEx(hkey, subkey, null_dword, null_dword, - None, retDataSize) - bufSize = intmask(retDataSize[0]) - if ret == rwinreg.ERROR_MORE_DATA: - bufSize = 256 - elif ret != 0: - raiseWindowsError(space, ret, 'RegQueryValueEx') + with rffi.scoped_unicode2wcharp(subkey) as wide_subkey: + c_subkey = rffi.cast(rffi.CCHARP, wide_subkey) + with lltype.scoped_alloc(rwin32.LPDWORD.TO, 1) as retDataSize: + ret = rwinreg.RegQueryValueEx(hkey, c_subkey, null_dword, null_dword, + None, retDataSize) + bufSize = intmask(retDataSize[0]) + if ret == rwinreg.ERROR_MORE_DATA: + bufSize = 256 + elif ret != 0: + raiseWindowsError(space, ret, 'RegQueryValueEx') - while True: - with lltype.scoped_alloc(rffi.CCHARP.TO, bufSize) as databuf: - with lltype.scoped_alloc(rwin32.LPDWORD.TO, 1) as retType: + while True: + with lltype.scoped_alloc(rffi.CCHARP.TO, bufSize) as databuf: + with lltype.scoped_alloc(rwin32.LPDWORD.TO, 1) as retType: - ret = rwinreg.RegQueryValueEx(hkey, subkey, null_dword, - retType, databuf, retDataSize) - if ret == rwinreg.ERROR_MORE_DATA: - # Resize and retry - bufSize *= 2 - retDataSize[0] = rffi.cast(rwin32.DWORD, bufSize) - continue - if ret != 0: - raiseWindowsError(space, ret, 'RegQueryValueEx') - length = intmask(retDataSize[0]) - return space.newtuple([ - convert_from_regdata(space, databuf, - length, retType[0]), - space.newint(intmask(retType[0])), + ret = rwinreg.RegQueryValueEx(hkey, c_subkey, null_dword, + retType, databuf, retDataSize) + if ret == rwinreg.ERROR_MORE_DATA: + # Resize and retry + bufSize *= 2 + retDataSize[0] = rffi.cast(rwin32.DWORD, bufSize) + continue + if ret != 0: + raiseWindowsError(space, ret, 'RegQueryValueEx') + length = intmask(retDataSize[0]) + return space.newtuple([ + convert_from_regdata(space, databuf, + length, retType[0]), + space.newint(intmask(retType[0])), ]) -@unwrap_spec(subkey="text") +@unwrap_spec(subkey="unicode") def CreateKey(space, w_hkey, subkey): """key = CreateKey(key, sub_key) - Creates or opens the specified key. @@ -482,13 +502,15 @@ The return value is the handle of the opened key. If the function fails, an exception is raised.""" hkey = hkey_w(w_hkey, space) - with lltype.scoped_alloc(rwinreg.PHKEY.TO, 1) as rethkey: - ret = rwinreg.RegCreateKey(hkey, subkey, rethkey) - if ret != 0: - raiseWindowsError(space, ret, 'CreateKey') - return W_HKEY(space, rethkey[0]) + with rffi.scoped_unicode2wcharp(subkey) as wide_subkey: + c_subkey = rffi.cast(rffi.CCHARP, wide_subkey) + with lltype.scoped_alloc(rwinreg.PHKEY.TO, 1) as rethkey: + ret = rwinreg.RegCreateKey(hkey, c_subkey, rethkey) + if ret != 0: + raiseWindowsError(space, ret, 'CreateKey') + return W_HKEY(space, rethkey[0]) -@unwrap_spec(sub_key="text", reserved=int, access=rffi.r_uint) +@unwrap_spec(sub_key="unicode", reserved=int, access=rffi.r_uint) def CreateKeyEx(space, w_key, sub_key, reserved=0, access=rwinreg.KEY_WRITE): """key = CreateKey(key, sub_key) - Creates or opens the specified key. @@ -502,17 +524,19 @@ The return value is the handle of the opened key. If the function fails, an exception is raised.""" hkey = hkey_w(w_key, space) - with lltype.scoped_alloc(rwinreg.PHKEY.TO, 1) as rethkey: - ret = rwinreg.RegCreateKeyEx(hkey, sub_key, reserved, None, 0, - access, None, rethkey, - lltype.nullptr(rwin32.LPDWORD.TO)) - if ret != 0: - raiseWindowsError(space, ret, 'CreateKeyEx') - return W_HKEY(space, rethkey[0]) + with rffi.scoped_unicode2wcharp(sub_key) as wide_sub_key: + c_subkey = rffi.cast(rffi.CCHARP, wide_sub_key) + with lltype.scoped_alloc(rwinreg.PHKEY.TO, 1) as rethkey: + ret = rwinreg.RegCreateKeyEx(hkey, c_subkey, reserved, None, 0, + access, None, rethkey, + lltype.nullptr(rwin32.LPDWORD.TO)) + if ret != 0: + raiseWindowsError(space, ret, 'CreateKeyEx') + return W_HKEY(space, rethkey[0]) -@unwrap_spec(subkey="text") +@unwrap_spec(subkey="unicode") def DeleteKey(space, w_hkey, subkey): - """DeleteKey(key, sub_key) - Deletes the specified key. + """DeleteKey(key, subkey) - Deletes the specified key. key is an already open key, or any one of the predefined HKEY_* constants. sub_key is a string that must be a subkey of the key identified by the key parameter. @@ -523,22 +547,26 @@ If the method succeeds, the entire key, including all of its values, is removed. If the method fails, an EnvironmentError exception is raised.""" hkey = hkey_w(w_hkey, space) - ret = rwinreg.RegDeleteKey(hkey, subkey) - if ret != 0: - raiseWindowsError(space, ret, 'RegDeleteKey') + with rffi.scoped_unicode2wcharp(subkey) as wide_subkey: + c_subkey = rffi.cast(rffi.CCHARP, wide_subkey) + ret = rwinreg.RegDeleteKey(hkey, c_subkey) + if ret != 0: + raiseWindowsError(space, ret, 'RegDeleteKey') -@unwrap_spec(subkey="text") +@unwrap_spec(subkey="unicode") def DeleteValue(space, w_hkey, subkey): """DeleteValue(key, value) - Removes a named value from a registry key. key is an already open key, or any one of the predefined HKEY_* constants. value is a string that identifies the value to remove.""" hkey = hkey_w(w_hkey, space) - ret = rwinreg.RegDeleteValue(hkey, subkey) - if ret != 0: - raiseWindowsError(space, ret, 'RegDeleteValue') + with rffi.scoped_unicode2wcharp(subkey) as wide_subkey: + c_subkey = rffi.cast(rffi.CCHARP, wide_subkey) + ret = rwinreg.RegDeleteValue(hkey, c_subkey) + if ret != 0: + raiseWindowsError(space, ret, 'RegDeleteValue') -@unwrap_spec(sub_key="text", reserved=int, access=rffi.r_uint) +@unwrap_spec(sub_key="unicode", reserved=int, access=rffi.r_uint) def OpenKey(space, w_key, sub_key, reserved=0, access=rwinreg.KEY_READ): """key = OpenKey(key, sub_key, res = 0, sam = KEY_READ) - Opens the specified key. @@ -551,11 +579,13 @@ The result is a new handle to the specified key If the function fails, an EnvironmentError exception is raised.""" hkey = hkey_w(w_key, space) - with lltype.scoped_alloc(rwinreg.PHKEY.TO, 1) as rethkey: - ret = rwinreg.RegOpenKeyEx(hkey, sub_key, reserved, access, rethkey) - if ret != 0: - raiseWindowsError(space, ret, 'RegOpenKeyEx') - return W_HKEY(space, rethkey[0]) + with rffi.scoped_unicode2wcharp(sub_key) as wide_subkey: + c_subkey = rffi.cast(rffi.CCHARP, wide_subkey) + with lltype.scoped_alloc(rwinreg.PHKEY.TO, 1) as rethkey: + ret = rwinreg.RegOpenKeyEx(hkey, c_subkey, reserved, access, rethkey) + if ret != 0: + raiseWindowsError(space, ret, 'RegOpenKeyEx') + return W_HKEY(space, rethkey[0]) @unwrap_spec(index=int) def EnumValue(space, w_hkey, index): @@ -590,15 +620,16 @@ bufDataSize = intmask(retDataSize[0]) bufValueSize = intmask(retValueSize[0]) - with lltype.scoped_alloc(rffi.CCHARP.TO, + with lltype.scoped_alloc(rffi.CWCHARP.TO, intmask(retValueSize[0])) as valuebuf: while True: with lltype.scoped_alloc(rffi.CCHARP.TO, bufDataSize) as databuf: with lltype.scoped_alloc(rwin32.LPDWORD.TO, 1) as retType: + c_valuebuf = rffi.cast(rffi.CCHARP, valuebuf) ret = rwinreg.RegEnumValue( - hkey, index, valuebuf, retValueSize, + hkey, index, c_valuebuf, retValueSize, null_dword, retType, databuf, retDataSize) if ret == rwinreg.ERROR_MORE_DATA: # Resize and retry @@ -614,7 +645,7 @@ length = intmask(retDataSize[0]) return space.newtuple([ - space.newtext(rffi.charp2str(valuebuf)), + space.newunicode(rffi.wcharp2unicode(valuebuf)), convert_from_regdata(space, databuf, length, retType[0]), space.newint(intmask(retType[0])), @@ -647,7 +678,7 @@ lltype.nullptr(rwin32.PFILETIME.TO)) if ret != 0: raiseWindowsError(space, ret, 'RegEnumKeyEx') - return space.newtext(rffi.charp2str(buf)) + return space.newunicode(rffi.wcharp2unicode(rffi.cast(rffi.CWCHARP, buf))) def QueryInfoKey(space, w_hkey): """tuple = QueryInfoKey(key) - Returns information about a key. @@ -726,7 +757,7 @@ raise oefmt(space.w_NotImplementedError, "not implemented on this platform") -@unwrap_spec(sub_key="text", reserved=int, access=rffi.r_uint) +@unwrap_spec(sub_key="unicode", reserved=int, access=rffi.r_uint) def DeleteKeyEx(space, w_key, sub_key, reserved=0, access=rwinreg.KEY_WOW64_64KEY): """DeleteKeyEx(key, sub_key, sam, res) - Deletes the specified key. diff --git a/pypy/module/_winreg/test/test_winreg.py b/pypy/module/_winreg/test/test_winreg.py --- a/pypy/module/_winreg/test/test_winreg.py +++ b/pypy/module/_winreg/test/test_winreg.py @@ -19,7 +19,7 @@ canSaveKey = len(ret) > 0 class AppTestHKey: - #spaceconfig = dict(usemodules=('_winreg',)) + spaceconfig = dict(usemodules=('_winreg',)) def test_repr(self): import winreg @@ -27,12 +27,12 @@ assert str(k) == "<PyHKEY:0x123>" class AppTestFfi: - #spaceconfig = dict(usemodules=('_winreg',)) + spaceconfig = dict(usemodules=('_winreg',)) def setup_class(cls): - import _winreg + import _winreg as winreg space = cls.space - cls.root_key = _winreg.HKEY_CURRENT_USER + cls.root_key = winreg.HKEY_CURRENT_USER cls.test_key_name = "SOFTWARE\\Pypy Registry Test Key - Delete Me" cls.w_root_key = space.wrap(cls.root_key) cls.w_test_key_name = space.wrap(cls.test_key_name) @@ -40,22 +40,22 @@ cls.w_tmpfilename = space.wrap(str(udir.join('winreg-temp'))) test_data = [ - ("Int Value", 0xFEDCBA98, _winreg.REG_DWORD), - ("Str Value", "A string Value", _winreg.REG_SZ), - ("Unicode Value", u"A unicode Value", _winreg.REG_SZ), - ("Str Expand", "The path is %path%", _winreg.REG_EXPAND_SZ), - ("Multi Str", ["Several", "string", u"values"], _winreg.REG_MULTI_SZ), + ("Int Value", 0xFEDCBA98, winreg.REG_DWORD), + ("Str Value", b"A string Value", winreg.REG_SZ), + ("Unicode Value", "A unicode Value", winreg.REG_SZ), + ("Str Expand", "The path is %path%", winreg.REG_EXPAND_SZ), + ("Multi Str", [b"Several", u"string", u"values"], winreg.REG_MULTI_SZ), ] cls.w_test_data = w_test_data = space.wrap(test_data) w_btest = space.newtuple([space.wrap("Raw data"), space.newbytes("binary\x00data"), - space.wrap(_winreg.REG_BINARY)]) + space.wrap(winreg.REG_BINARY)]) w_test_data.append(w_btest) def teardown_class(cls): - import winreg + import _winreg try: - winreg.DeleteKey(cls.root_key, cls.test_key_name) + _winreg.DeleteKey(cls.root_key, cls.test_key_name) except WindowsError: pass @@ -67,14 +67,14 @@ def test_simple_write(self): from winreg import SetValue, QueryValue, REG_SZ - value = "Some Default value" + value = u"Some Default value" SetValue(self.root_key, self.test_key_name, REG_SZ, value) assert QueryValue(self.root_key, self.test_key_name) == value def test_CreateKey(self): from winreg import CreateKey, QueryInfoKey key = CreateKey(self.root_key, self.test_key_name) - sub_key = CreateKey(key, "sub_key") + sub_key = CreateKey(key, u"sub_key") nkeys, nvalues, since_mod = QueryInfoKey(key) assert nkeys == 1 @@ -86,7 +86,7 @@ from winreg import CreateKeyEx, QueryInfoKey from winreg import KEY_ALL_ACCESS, KEY_READ key = CreateKeyEx(self.root_key, self.test_key_name, 0, KEY_ALL_ACCESS) - sub_key = CreateKeyEx(key, "sub_key", 0, KEY_READ) + sub_key = CreateKeyEx(key, u"sub_key", 0, KEY_READ) nkeys, nvalues, since_mod = QueryInfoKey(key) assert nkeys == 1 @@ -97,7 +97,7 @@ def test_close(self): from winreg import OpenKey, CloseKey, FlushKey, QueryInfoKey key = OpenKey(self.root_key, self.test_key_name) - sub_key = OpenKey(key, "sub_key") + sub_key = OpenKey(key, u"sub_key") int_sub_key = int(sub_key) FlushKey(sub_key) @@ -119,7 +119,7 @@ def test_with(self): from winreg import OpenKey with OpenKey(self.root_key, self.test_key_name) as key: - with OpenKey(key, "sub_key") as sub_key: + with OpenKey(key, u"sub_key") as sub_key: assert key.handle != 0 assert sub_key.handle != 0 assert key.handle == 0 @@ -140,17 +140,17 @@ assert 0, "Did not raise" def test_SetValueEx(self): + # this test leaves open keys. If it fails, others will too from winreg import CreateKey, SetValueEx, REG_BINARY, REG_DWORD key = CreateKey(self.root_key, self.test_key_name) - sub_key = CreateKey(key, "sub_key") + sub_key = CreateKey(key, u"sub_key") SetValueEx(sub_key, 'Int Value', 0, REG_DWORD, None) SetValueEx(sub_key, 'Int Value', 0, REG_DWORD, 45) for name, value, type in self.test_data: SetValueEx(sub_key, name, 0, type, value) - exc = raises(TypeError, SetValueEx, sub_key, 'test_name', None, - REG_BINARY, memoryview('abc')) - assert str(exc.value) == ("Objects of type 'memoryview' can not " - "be used as binary registry values") + # cannot wrap a memoryview in setup_class for test_data + SetValueEx(sub_key, u'test_name', None, + REG_BINARY, memoryview(b'abc')) def test_readValues(self): from winreg import OpenKey, EnumValue, QueryValueEx, EnumKey @@ -163,27 +163,31 @@ data = EnumValue(sub_key, index) except EnvironmentError as e: break - assert data in self.test_data + if data[0] != 'test_name': + # cannot wrap a memoryview in setup_class for test_data + assert data in self.test_data index = index + 1 - assert index == len(self.test_data) + assert index == len(self.test_data) + 1 for name, value, type in self.test_data: result = QueryValueEx(sub_key, name) assert result == (value, type) if type == REG_SZ or type == REG_EXPAND_SZ: - assert isinstance(result[0], unicode) # not string + assert not isinstance(result[0], bytes) assert EnumKey(key, 0) == "sub_key" raises(EnvironmentError, EnumKey, key, 1) def test_delete(self): # must be run after test_SetValueEx - from _winreg import OpenKey, KEY_ALL_ACCESS, DeleteValue, DeleteKey + from winreg import OpenKey, KEY_ALL_ACCESS, DeleteValue, DeleteKey key = OpenKey(self.root_key, self.test_key_name, 0, KEY_ALL_ACCESS) sub_key = OpenKey(key, "sub_key", 0, KEY_ALL_ACCESS) for name, value, type in self.test_data: DeleteValue(sub_key, name) + # cannot wrap a memoryview in setup_class for test_data + DeleteValue(sub_key, 'test_name') DeleteKey(key, "sub_key") @@ -242,7 +246,7 @@ skip("access denied to registry key " "(are you running in a non-interactive session?)") raise - QueryValueEx(HKEY_PERFORMANCE_DATA, None) + QueryValueEx(HKEY_PERFORMANCE_DATA, 'Global') def test_reflection_unsupported(self): import sys diff --git a/rpython/rlib/rwinreg.py b/rpython/rlib/rwinreg.py --- a/rpython/rlib/rwinreg.py +++ b/rpython/rlib/rwinreg.py @@ -47,7 +47,7 @@ HKEY = rwin32.HANDLE PHKEY = rffi.CArrayPtr(HKEY) REGSAM = rwin32.DWORD -suffix = 'A' +suffix = 'W' RegSetValue = external( 'RegSetValue' + suffix, _______________________________________________ pypy-commit mailing list pypy-commit@python.org https://mail.python.org/mailman/listinfo/pypy-commit