[pypy-commit] pypy sandbox-2: hg merge default

arigo pypy.commits at gmail.com
Fri Aug 9 09:21:29 EDT 2019


Author: Armin Rigo <arigo at tunes.org>
Branch: sandbox-2
Changeset: r97116:3c789662afb2
Date: 2019-08-09 15:11 +0200
http://bitbucket.org/pypy/pypy/changeset/3c789662afb2/

Log:	hg merge default

diff --git a/pypy/interpreter/pyparser/test/unittest_samples.py b/pypy/interpreter/pyparser/test/unittest_samples.py
deleted file mode 100644
--- a/pypy/interpreter/pyparser/test/unittest_samples.py
+++ /dev/null
@@ -1,95 +0,0 @@
-"""test module for CPython / PyPy nested tuples comparison"""
-
-import os, os.path as osp
-import sys
-from pypy.interpreter.pyparser.pythonutil import python_parse, pypy_parse
-from pprint import pprint
-from pypy.interpreter.pyparser import grammar
-grammar.DEBUG = False
-from symbol import sym_name
-
-
-def name(elt):
-    return "%s[%s]"% (sym_name.get(elt,elt),elt)
-
-def read_samples_dir():
-    return [osp.join('samples', fname) for fname in os.listdir('samples') if fname.endswith('.py')]
-
-def print_sym_tuple(nested, level=0, limit=15, names=False, trace=()):
-    buf = []
-    if level <= limit:
-        buf.append("%s(" % (" "*level))
-    else:
-        buf.append("(")
-    for index, elt in enumerate(nested):
-        # Test if debugging and if on last element of error path
-        if trace and not trace[1:] and index == trace[0]:
-            buf.append('\n----> ')
-        if type(elt) is int:
-            if names:
-                buf.append(name(elt))
-            else:
-                buf.append(str(elt))
-            buf.append(', ')
-        elif type(elt) is str:
-            buf.append(repr(elt))
-        else:
-            if level < limit:
-                buf.append('\n')
-            buf.extend(print_sym_tuple(elt, level+1, limit,
-                                       names, trace[1:]))
-    buf.append(')')
-    return buf
-
-def assert_tuples_equal(tup1, tup2, curpos = ()):
-    for index, (elt1, elt2) in enumerate(zip(tup1, tup2)):
-        if elt1 != elt2:
-            if type(elt1) is tuple and type(elt2) is tuple:
-                assert_tuples_equal(elt1, elt2, curpos + (index,))
-            raise AssertionError('Found difference at %s : %s != %s' %
-                                 (curpos, name(elt1), name(elt2) ), curpos)
-
-from time import time, clock
-def test_samples( samples ):
-    time_reports = {}
-    for sample in samples:
-        print "testing", sample
-        tstart1, cstart1 = time(), clock()
-        pypy_tuples = pypy_parse(sample)
-        tstart2, cstart2 = time(), clock()
-        python_tuples = python_parse(sample)
-        time_reports[sample] = (time() - tstart2, tstart2-tstart1, clock() - cstart2, cstart2-cstart1 )
-        #print "-"*10, "PyPy parse results", "-"*10
-        #print ''.join(print_sym_tuple(pypy_tuples, names=True))
-        #print "-"*10, "CPython parse results", "-"*10
-        #print ''.join(print_sym_tuple(python_tuples, names=True))
-        print
-        try:
-            assert_tuples_equal(pypy_tuples, python_tuples)
-        except AssertionError as e:
-            error_path = e.args[-1]
-            print "ERROR PATH =", error_path
-            print "="*80
-            print file(sample).read()
-            print "="*80
-            print "-"*10, "PyPy parse results", "-"*10
-            print ''.join(print_sym_tuple(pypy_tuples, names=True, trace=error_path))
-            print "-"*10, "CPython parse results", "-"*10
-            print ''.join(print_sym_tuple(python_tuples, names=True, trace=error_path))
-            print "Failed on (%s)" % sample
-            # raise
-    pprint(time_reports)
-
-if __name__=="__main__":
-    import getopt
-    opts, args = getopt.getopt( sys.argv[1:], "d:", [] )
-    for opt, val in opts:
-        if opt == "-d":
-            pass
-#            set_debug(int(val))
-    if args:
-        samples = args
-    else:
-        samples = read_samples_dir()
-
-    test_samples( samples )
diff --git a/pypy/module/_socket/interp_socket.py b/pypy/module/_socket/interp_socket.py
--- a/pypy/module/_socket/interp_socket.py
+++ b/pypy/module/_socket/interp_socket.py
@@ -312,7 +312,10 @@
                 raise converted_error(space, e)
         if buflen < 0 or buflen > 1024:
             raise explicit_socket_error(space, "getsockopt buflen out of range")
-        return space.newbytes(self.sock.getsockopt(level, optname, buflen))
+        try:
+            return space.newbytes(self.sock.getsockopt(level, optname, buflen))
+        except SocketError as e:
+            raise converted_error(space, e)
 
     def gettimeout_w(self, space):
         """gettimeout() -> timeout
@@ -438,7 +441,10 @@
         setblocking(True) is equivalent to settimeout(None);
         setblocking(False) is equivalent to settimeout(0.0).
         """
-        self.sock.setblocking(flag)
+        try:
+            self.sock.setblocking(flag)
+        except SocketError as e:
+            pass    # CPython 2 only: never raise anything here
 
     @unwrap_spec(level=int, optname=int)
     def setsockopt_w(self, space, level, optname, w_optval):
@@ -477,7 +483,10 @@
             timeout = space.float_w(w_timeout)
             if timeout < 0.0:
                 raise oefmt(space.w_ValueError, "Timeout value out of range")
-        self.sock.settimeout(timeout)
+        try:
+            self.sock.settimeout(timeout)
+        except SocketError as e:
+            pass    # CPython 2 only: never raise anything here
 
     @unwrap_spec(nbytes=int, flags=int)
     def recv_into_w(self, space, w_buffer, nbytes=0, flags=0):
diff --git a/pypy/module/_socket/test/test_sock_app.py b/pypy/module/_socket/test/test_sock_app.py
--- a/pypy/module/_socket/test/test_sock_app.py
+++ b/pypy/module/_socket/test/test_sock_app.py
@@ -872,6 +872,14 @@
         cli = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         assert cli.family == socket.AF_INET
 
+    def test_missing_error_catching(self):
+        from _socket import socket, error
+        s = socket()
+        s.close()
+        s.settimeout(1)          # EBADF, but ignored on Python 2
+        s.setblocking(True)      # EBADF, but ignored on Python 2
+        raises(error, s.getsockopt, 42, 84, 8)    # EBADF
+
 
 class AppTestErrno:
     spaceconfig = {'usemodules': ['_socket']}
diff --git a/pypy/module/imp/importing.py b/pypy/module/imp/importing.py
--- a/pypy/module/imp/importing.py
+++ b/pypy/module/imp/importing.py
@@ -11,6 +11,7 @@
 from pypy.interpreter.baseobjspace import W_Root, CannotHaveLock
 from pypy.interpreter.eval import Code
 from pypy.interpreter.pycode import PyCode
+from pypy.interpreter.streamutil import wrap_streamerror
 from rpython.rlib import streamio, jit
 from rpython.rlib.streamio import StreamErrors
 from rpython.rlib.objectmodel import we_are_translated, specialize
@@ -659,13 +660,14 @@
             if find_info.modtype == PY_SOURCE:
                 return load_source_module(
                     space, w_modulename, w_mod,
-                    find_info.filename, find_info.stream.readall(),
+                    find_info.filename, _wrap_readall(space, find_info.stream),
                     find_info.stream.try_to_find_file_descriptor())
             elif find_info.modtype == PY_COMPILED:
-                magic = _r_long(find_info.stream)
-                timestamp = _r_long(find_info.stream)
+                magic = _wrap_r_long(space, find_info.stream)
+                timestamp = _wrap_r_long(space, find_info.stream)
                 return load_compiled_module(space, w_modulename, w_mod, find_info.filename,
-                                     magic, timestamp, find_info.stream.readall())
+                                     magic, timestamp,
+                                     _wrap_readall(space, find_info.stream))
             elif find_info.modtype == PKG_DIRECTORY:
                 w_path = space.newlist([space.newtext(find_info.filename)])
                 space.setattr(w_mod, space.newtext('__path__'), w_path)
@@ -677,10 +679,7 @@
                     w_mod = load_module(space, w_modulename, find_info,
                                         reuse=True)
                 finally:
-                    try:
-                        find_info.stream.close()
-                    except StreamErrors:
-                        pass
+                    _close_ignore(find_info.stream)
                 return w_mod
             elif find_info.modtype == C_EXTENSION and has_so_extension(space):
                 return load_c_extension(space, find_info.filename,
@@ -712,10 +711,7 @@
             if find_info:
                 stream = find_info.stream
                 if stream:
-                    try:
-                        stream.close()
-                    except StreamErrors:
-                        pass
+                    _close_ignore(stream)
 
     if tentative:
         return None
@@ -770,7 +766,7 @@
                 return load_module(space, w_modulename, find_info, reuse=True)
             finally:
                 if find_info.stream:
-                    find_info.stream.close()
+                    _wrap_close(space, find_info.stream)
         except:
             # load_module probably removed name from modules because of
             # the error.  Put back the original module object.
@@ -936,12 +932,10 @@
     if stream:
         # existing and up-to-date .pyc file
         try:
-            code_w = read_compiled_module(space, cpathname, stream.readall())
+            code_w = read_compiled_module(space, cpathname,
+                                          _wrap_readall(space, stream))
         finally:
-            try:
-                stream.close()
-            except StreamErrors:
-                pass
+            _close_ignore(stream)
         space.setattr(w_mod, space.newtext('__file__'), space.newtext(cpathname))
     else:
         code_w = parse_source_module(space, pathname, source)
@@ -1007,6 +1001,35 @@
     d = x & 0xff
     stream.write(chr(a) + chr(b) + chr(c) + chr(d))
 
+def _wrap_r_long(space, stream):
+    """like _r_long(), but raising app-level exceptions"""
+    try:
+        return _r_long(stream)
+    except StreamErrors as e:
+        raise wrap_streamerror(space, e)
+
+def _wrap_readall(space, stream):
+    """stream.readall(), but raising app-level exceptions"""
+    try:
+        return stream.readall()
+    except StreamErrors as e:
+        raise wrap_streamerror(space, e)
+
+def _wrap_close(space, stream):
+    """stream.close(), but raising app-level exceptions"""
+    try:
+        stream.close()
+    except StreamErrors as e:
+        raise wrap_streamerror(space, e)
+
+def _close_ignore(stream):
+    """stream.close(), but ignoring any stream exception"""
+    try:
+        stream.close()
+    except StreamErrors as e:
+        pass
+
+
 def check_compiled_module(space, pycfilename, expected_mtime):
     """
     Check if a pyc file's magic number and mtime match.
@@ -1025,10 +1048,7 @@
         return stream
     except StreamErrors:
         if stream:
-            try:
-                stream.close()
-            except StreamErrors:
-                pass
+            _close_ignore(stream)
         return None    # XXX! must not eat all exceptions, e.g.
                        # Out of file descriptors.
 
diff --git a/pypy/module/imp/interp_imp.py b/pypy/module/imp/interp_imp.py
--- a/pypy/module/imp/interp_imp.py
+++ b/pypy/module/imp/interp_imp.py
@@ -104,9 +104,10 @@
 
     w_mod = importing.load_source_module(
         space, w_modulename, w_mod,
-        filename, stream.readall(), stream.try_to_find_file_descriptor())
+        filename, importing._wrap_readall(space, stream),
+        stream.try_to_find_file_descriptor())
     if space.is_none(w_file):
-        stream.close()
+        importing._wrap_close(space, stream)
     return w_mod
 
 @unwrap_spec(filename='fsencode', check_afterwards=int)
@@ -115,14 +116,15 @@
     # the function 'imp._run_compiled_module' is a pypy-only extension
     stream = get_file(space, w_file, filename, 'rb')
 
-    magic = importing._r_long(stream)
-    timestamp = importing._r_long(stream)
+    magic = importing._wrap_r_long(space, stream)
+    timestamp = importing._wrap_r_long(space, stream)
 
     w_mod = importing.load_compiled_module(
         space, w_modulename, w_module, filename, magic, timestamp,
-        stream.readall(), check_afterwards=check_afterwards)
+        importing._wrap_readall(space, stream),
+        check_afterwards=check_afterwards)
     if space.is_none(w_file):
-        stream.close()
+        importing._wrap_close(space, stream)
     return w_mod
 
 @unwrap_spec(filename='fsencode')


More information about the pypy-commit mailing list