Home - Summaries: (main) : (py3.11) : Everything - Nightly builds - Benchmarks - RPython - Builders - About

pypy/module/cpyext/test/test_pyerrors.py::AppTestFetch::()::test_SetFromErrnoWithFilename_basic

self = <CallInfo when='call' exception: 'ascii' codec can't encode character u'\u0308' in position 107: ordinal not in range(128)>
func = <function <lambda> at 0x00007fc2fa6abc40>, when = 'call'

    def __init__(self, func, when):
        #: context of invocation: one of "setup", "call",
        #: "teardown", "memocollect"
        self.when = when
        self.start = time()
        try:
>           self.result = func()

../_pytest/runner.py:150: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

>   return CallInfo(lambda: ihook(item=item, **kwds), when=when)

../_pytest/runner.py:138: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <_HookCaller 'pytest_runtest_call'>
kwargs = {'__multicall__': <_MultiCall 0 results, 1 meths, kwargs={'item': <AppTestMethod 'test_SetFromErrnoWithFilename_basic'...all__': <_MultiCall 0 results, 1 meths, kwargs={...}>}>, 'item': <AppTestMethod 'test_SetFromErrnoWithFilename_basic'>}

    def __call__(self, **kwargs):
        assert not self.is_historic()
>       return self._hookexec(self, self._nonwrappers + self._wrappers, kwargs)

../_pytest/vendored_packages/pluggy.py:724: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <_pytest.config.PytestPluginManager object at 0x00007fc2e806c9f8>
hook = <_HookCaller 'pytest_runtest_call'>
methods = [<_pytest.vendored_packages.pluggy.HookImpl instance at 0x00007fc2c8a9e720>]
kwargs = {'__multicall__': <_MultiCall 0 results, 1 meths, kwargs={'item': <AppTestMethod 'test_SetFromErrnoWithFilename_basic'...all__': <_MultiCall 0 results, 1 meths, kwargs={...}>}>, 'item': <AppTestMethod 'test_SetFromErrnoWithFilename_basic'>}

    def _hookexec(self, hook, methods, kwargs):
        # called from all hookcaller instances.
        # enable_tracing will set its own wrapping function at self._inner_hookexec
>       return self._inner_hookexec(hook, methods, kwargs)

../_pytest/vendored_packages/pluggy.py:338: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

hook = <_HookCaller 'pytest_runtest_call'>
methods = [<_pytest.vendored_packages.pluggy.HookImpl instance at 0x00007fc2c8a9e720>]
kwargs = {'__multicall__': <_MultiCall 0 results, 1 meths, kwargs={'item': <AppTestMethod 'test_SetFromErrnoWithFilename_basic'...all__': <_MultiCall 0 results, 1 meths, kwargs={...}>}>, 'item': <AppTestMethod 'test_SetFromErrnoWithFilename_basic'>}

    self._inner_hookexec = lambda hook, methods, kwargs: \
>       _MultiCall(methods, kwargs, hook.spec_opts).execute()

../_pytest/vendored_packages/pluggy.py:333: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <_MultiCall 0 results, 1 meths, kwargs={'item': <AppTestMethod 'test_SetFromErrnoWithFilename_basic'>, '__multicall__': <_MultiCall 0 results, 1 meths, kwargs={...}>}>

    def execute(self):
        all_kwargs = self.kwargs
        self.results = results = []
        firstresult = self.specopts.get("firstresult")
    
        while self.hook_impls:
            hook_impl = self.hook_impls.pop()
            args = [all_kwargs[argname] for argname in hook_impl.argnames]
            if hook_impl.hookwrapper:
>               return _wrapped_call(hook_impl.function(*args), self.execute)

../_pytest/vendored_packages/pluggy.py:595: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

wrap_controller = <generator object pytest_runtest_call at 0x00007fc2ea975240>
func = <bound method _MultiCall.execute of <_MultiCall 0 results, 1 meths, kwargs={'i...name_basic'>, '__multicall__': <_MultiCall 0 results, 1 meths, kwargs={...}>}>>

    def _wrapped_call(wrap_controller, func):
        """ Wrap calling to a function with a generator which needs to yield
        exactly once.  The yield point will trigger calling the wrapped function
        and return its _CallOutcome to the yield point.  The generator then needs
        to finish (raise StopIteration) in order for the wrapped call to complete.
        """
        try:
            next(wrap_controller)   # first yield
        except StopIteration:
            _raise_wrapfail(wrap_controller, "did not yield")
        call_outcome = _CallOutcome(func)
        try:
            wrap_controller.send(call_outcome)
            _raise_wrapfail(wrap_controller, "has second yield")
        except StopIteration:
            pass
>       return call_outcome.get_result()

../_pytest/vendored_packages/pluggy.py:253: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <_pytest.vendored_packages.pluggy._CallOutcome instance at 0x00007fc2c87b61e0>

    def get_result(self):
        if self.excinfo is None:
            return self.result
        else:
            ex = self.excinfo
            if _py3:
                raise ex[1].with_traceback(ex[2])
>           _reraise(*ex)  # noqa

../_pytest/vendored_packages/pluggy.py:279: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <_pytest.vendored_packages.pluggy._CallOutcome instance at 0x00007fc2c87b61e0>
func = <bound method _MultiCall.execute of <_MultiCall 0 results, 1 meths, kwargs={'i...name_basic'>, '__multicall__': <_MultiCall 0 results, 1 meths, kwargs={...}>}>>

    def __init__(self, func):
        try:
>           self.result = func()

../_pytest/vendored_packages/pluggy.py:264: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <_MultiCall 0 results, 1 meths, kwargs={'item': <AppTestMethod 'test_SetFromErrnoWithFilename_basic'>, '__multicall__': <_MultiCall 0 results, 1 meths, kwargs={...}>}>

    def execute(self):
        all_kwargs = self.kwargs
        self.results = results = []
        firstresult = self.specopts.get("firstresult")
    
        while self.hook_impls:
            hook_impl = self.hook_impls.pop()
            args = [all_kwargs[argname] for argname in hook_impl.argnames]
            if hook_impl.hookwrapper:
>               return _wrapped_call(hook_impl.function(*args), self.execute)

../_pytest/vendored_packages/pluggy.py:595: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

wrap_controller = <generator object pytest_runtest_call at 0x00007fc2ea9751f0>
func = <bound method _MultiCall.execute of <_MultiCall 0 results, 1 meths, kwargs={'i...name_basic'>, '__multicall__': <_MultiCall 0 results, 1 meths, kwargs={...}>}>>

    def _wrapped_call(wrap_controller, func):
        """ Wrap calling to a function with a generator which needs to yield
        exactly once.  The yield point will trigger calling the wrapped function
        and return its _CallOutcome to the yield point.  The generator then needs
        to finish (raise StopIteration) in order for the wrapped call to complete.
        """
        try:
            next(wrap_controller)   # first yield
        except StopIteration:
            _raise_wrapfail(wrap_controller, "did not yield")
        call_outcome = _CallOutcome(func)
        try:
            wrap_controller.send(call_outcome)
            _raise_wrapfail(wrap_controller, "has second yield")
        except StopIteration:
            pass
>       return call_outcome.get_result()

../_pytest/vendored_packages/pluggy.py:253: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <_pytest.vendored_packages.pluggy._CallOutcome instance at 0x00007fc2c87b61a0>

    def get_result(self):
        if self.excinfo is None:
            return self.result
        else:
            ex = self.excinfo
            if _py3:
                raise ex[1].with_traceback(ex[2])
>           _reraise(*ex)  # noqa

../_pytest/vendored_packages/pluggy.py:279: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <_pytest.vendored_packages.pluggy._CallOutcome instance at 0x00007fc2c87b61a0>
func = <bound method _MultiCall.execute of <_MultiCall 0 results, 1 meths, kwargs={'i...name_basic'>, '__multicall__': <_MultiCall 0 results, 1 meths, kwargs={...}>}>>

    def __init__(self, func):
        try:
>           self.result = func()

../_pytest/vendored_packages/pluggy.py:264: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <_MultiCall 0 results, 1 meths, kwargs={'item': <AppTestMethod 'test_SetFromErrnoWithFilename_basic'>, '__multicall__': <_MultiCall 0 results, 1 meths, kwargs={...}>}>

    def execute(self):
        all_kwargs = self.kwargs
        self.results = results = []
        firstresult = self.specopts.get("firstresult")
    
        while self.hook_impls:
            hook_impl = self.hook_impls.pop()
            args = [all_kwargs[argname] for argname in hook_impl.argnames]
            if hook_impl.hookwrapper:
                return _wrapped_call(hook_impl.function(*args), self.execute)
>           res = hook_impl.function(*args)

../_pytest/vendored_packages/pluggy.py:596: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

item = <AppTestMethod 'test_SetFromErrnoWithFilename_basic'>

    def pytest_runtest_call(item):
        try:
>           item.runtest()

../_pytest/runner.py:91: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <AppTestMethod 'test_SetFromErrnoWithFilename_basic'>

    def runtest(self):
        target = self.obj
        src = extract_docstring_if_empty_function(target.im_func)
        space = target.im_self.space
        if self.config.option.runappdirect:
            appexec_definitions = self.parent.obj.__dict__
            spaceconfig = getattr(self.parent.obj, 'spaceconfig', None)
            usemodules = spaceconfig.get('usemodules') if spaceconfig else None
            return run_with_python(self.config.option.python, src, usemodules,
                                   **appexec_definitions)
        filename = self._getdynfilename(target)
        func = app2interp_temp(src, filename=filename)
        w_instance = self.parent.w_instance
>       self.execute_appex(space, func, space, w_instance)

tool/pytest/apptest.py:331: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <AppTestMethod 'test_SetFromErrnoWithFilename_basic'>
space = StdObjSpace
target = <function test_SetFromErrnoWithFilename_basic at 0x00007fc2da4db268>
args = (StdObjSpace, <pypy.interpreter.typedef.W_ObjectObjectUserDictWeakrefable object at 0x00007fc2fb9d42c0>)

    def execute_appex(self, space, target, *args):
        self.space = space
        space.getexecutioncontext().set_sys_exc_info(None)
        try:
>           target(*args)

tool/pytest/apptest.py:267: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

space = StdObjSpace
args_w = (<pypy.interpreter.typedef.W_ObjectObjectUserDictWeakrefable object at 0x00007fc2fb9d42c0>,)
w_func = <Function test_SetFromErrnoWithFilename_basic>
args = <pypy.interpreter.typedef.W_ObjectObjectUserDictWeakrefable object at 0x00007fc2fb9d42c0>

    def appcaller(space, *args_w):
        if not isinstance(space, ObjSpace):
            raise TypeError("first argument must be a space instance.")
        # the last argument can be an Arguments
        w_func = self.wget(space, name)
        if not args_w:
            return space.call_function(w_func)
        else:
            args = args_w[-1]
            assert args is not None
            if not isinstance(args, Arguments):
>               return space.call_function(w_func, *args_w)

interpreter/gateway.py:1409: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = StdObjSpace, w_func = <Function test_SetFromErrnoWithFilename_basic>
args_w = (<pypy.interpreter.typedef.W_ObjectObjectUserDictWeakrefable object at 0x00007fc2fb9d42c0>,)
nargs = 1, Function = <class 'pypy.interpreter.function.Function'>
_Method = <class 'pypy.interpreter.function._Method'>

    def call_function(self, w_func, *args_w):
        nargs = len(args_w) # used for pruning funccall versions
        if not self.config.objspace.disable_call_speedhacks and nargs < 5:
            # start of hack for performance
            from pypy.interpreter.function import Function, _Method
            if isinstance(w_func, _Method):
                if nargs < 4:
                    func = w_func.w_function
                    if isinstance(func, Function):
                        return func.funccall(w_func.w_instance, *args_w)
    
            if isinstance(w_func, Function):
>               return w_func.funccall(*args_w)

interpreter/baseobjspace.py:1234: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <Function test_SetFromErrnoWithFilename_basic>
args_w = (<pypy.interpreter.typedef.W_ObjectObjectUserDictWeakrefable object at 0x00007fc2fb9d42c0>,)
gateway = <module 'pypy.interpreter.gateway' from '/Users/matti/build-worker-x86_64/own-macos-x86-64/build/pypy/interpreter/gateway.pyc'>
PyCode = <class 'pypy.interpreter.pycode.PyCode'>
code = <code object test_SetFromErrnoWithFilename_basic, file "[/Users/matti/build-wo.../own-macos-x86-64/build/pypy/module/cpyext/test/test_pyerrors.py:250]", line 1>

    def funccall(self, *args_w): # speed hack
        from pypy.interpreter import gateway
        from pypy.interpreter.pycode import PyCode
    
        code = self.getcode() # hook for the jit
        nargs = len(args_w)
        fast_natural_arity = code.fast_natural_arity
        if nargs == fast_natural_arity:
            if nargs == 0:
                assert isinstance(code, gateway.BuiltinCode0)
                return code.fastcall_0(self.space, self)
            elif nargs == 1:
                assert isinstance(code, gateway.BuiltinCode1)
                return code.fastcall_1(self.space, self, args_w[0])
            elif nargs == 2:
                assert isinstance(code, gateway.BuiltinCode2)
                return code.fastcall_2(self.space, self, args_w[0], args_w[1])
            elif nargs == 3:
                assert isinstance(code, gateway.BuiltinCode3)
                return code.fastcall_3(self.space, self, args_w[0],
                                       args_w[1], args_w[2])
            elif nargs == 4:
                assert isinstance(code, gateway.BuiltinCode4)
                return code.fastcall_4(self.space, self, args_w[0],
                                       args_w[1], args_w[2], args_w[3])
        elif (nargs | PyCode.FLATPYCALL) == fast_natural_arity:
            assert isinstance(code, PyCode)
            if nargs < 5:
                new_frame = self.space.createframe(code, self.w_func_globals,
                                                   self)
                for i in funccallunrolling:
                    if i < nargs:
                        new_frame.locals_cells_stack_w[i] = args_w[i]
>               return new_frame.run(self.name, self.qualname)

interpreter/function.py:131: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <pypy.objspace.std.frame.StdObjSpaceFrame executing <code object test_SetFromE...x86-64/build/pypy/module/cpyext/test/test_pyerrors.py:250]", line 1> at line 56
name = 'test_SetFromErrnoWithFilename_basic'
qualname = 'test_SetFromErrnoWithFilename_basic'

    def run(self, name=None, qualname=None):
        """Start this frame's execution."""
        if self._is_generator_or_coroutine():
            return self.initialize_as_generator(name, qualname)
        else:
>           return self.execute_frame()

interpreter/pyframe.py:256: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <pypy.objspace.std.frame.StdObjSpaceFrame executing <code object test_SetFromE...x86-64/build/pypy/module/cpyext/test/test_pyerrors.py:250]", line 1> at line 56
w_arg_or_err = None

    def execute_frame(self, w_arg_or_err=None):
        """Execute this frame.  Main entry point to the interpreter.
            'w_arg_or_err' is non-None iff we are starting or resuming
            a generator or coroutine frame; in that case, w_arg_or_err
            is the input argument -or- an SApplicationException instance.
            """
        from pypy.interpreter import pyopcode as pyopcode
        # the following 'assert' is an annotation hint: it hides from
        # the annotator all methods that are defined in PyFrame but
        # overridden in the {,Host}FrameClass subclasses of PyFrame.
        assert (isinstance(self, self.space.FrameClass) or
                not self.space.config.translating)
        executioncontext = self.space.getexecutioncontext()
        executioncontext.enter(self)
        got_exception = True
        w_exitvalue = self.space.w_None
        try:
            executioncontext.call_trace(self)
            #
            # Execution starts just after the last_instr.  Initially,
            # last_instr is -1.  After a generator suspends it points to
            # the YIELD_VALUE/YIELD_FROM instruction.
            try:
                try:
                    if w_arg_or_err is None:
                        assert self.last_instr == -1
                        next_instr = r_uint(0)
                    else:
                        next_instr = self.resume_execute_frame(w_arg_or_err)
                except pyopcode.Yield:
                    w_exitvalue = self.popvalue()
                else:
                    w_exitvalue = self.dispatch(self.pycode, next_instr,
                                                executioncontext)
            except OperationError:
                raise
            except Exception as e:      # general fall-back
>               raise self._convert_unexpected_exception(e)

interpreter/pyframe.py:353: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <pypy.objspace.std.frame.StdObjSpaceFrame executing <code object test_SetFromE...x86-64/build/pypy/module/cpyext/test/test_pyerrors.py:250]", line 1> at line 56
e = UnicodeEncodeError('ascii', u'\n                 errno = EBADF;\n             ...       return NULL;\n                 ', 107, 108, 'ordinal not in range(128)')

    def _convert_unexpected_exception(self, e):
        from pypy.interpreter import error
    
>       operr = error.get_converted_unexpected_exception(self.space, e)

interpreter/pyframe.py:844: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <pypy.objspace.std.frame.StdObjSpaceFrame executing <code object test_SetFromE...x86-64/build/pypy/module/cpyext/test/test_pyerrors.py:250]", line 1> at line 56
w_arg_or_err = None

    def execute_frame(self, w_arg_or_err=None):
        """Execute this frame.  Main entry point to the interpreter.
            'w_arg_or_err' is non-None iff we are starting or resuming
            a generator or coroutine frame; in that case, w_arg_or_err
            is the input argument -or- an SApplicationException instance.
            """
        from pypy.interpreter import pyopcode as pyopcode
        # the following 'assert' is an annotation hint: it hides from
        # the annotator all methods that are defined in PyFrame but
        # overridden in the {,Host}FrameClass subclasses of PyFrame.
        assert (isinstance(self, self.space.FrameClass) or
                not self.space.config.translating)
        executioncontext = self.space.getexecutioncontext()
        executioncontext.enter(self)
        got_exception = True
        w_exitvalue = self.space.w_None
        try:
            executioncontext.call_trace(self)
            #
            # Execution starts just after the last_instr.  Initially,
            # last_instr is -1.  After a generator suspends it points to
            # the YIELD_VALUE/YIELD_FROM instruction.
            try:
                try:
                    if w_arg_or_err is None:
                        assert self.last_instr == -1
                        next_instr = r_uint(0)
                    else:
                        next_instr = self.resume_execute_frame(w_arg_or_err)
                except pyopcode.Yield:
                    w_exitvalue = self.popvalue()
                else:
                    w_exitvalue = self.dispatch(self.pycode, next_instr,
>                                               executioncontext)

interpreter/pyframe.py:349: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <pypy.objspace.std.frame.StdObjSpaceFrame executing <code object test_SetFromE...x86-64/build/pypy/module/cpyext/test/test_pyerrors.py:250]", line 1> at line 56
pycode = <code object test_SetFromErrnoWithFilename_basic, file "[/Users/matti/build-wo.../own-macos-x86-64/build/pypy/module/cpyext/test/test_pyerrors.py:250]", line 1>
next_instr = 88
ec = <pypy.interpreter.executioncontext.ExecutionContext object at 0x00007fc2c8919600>

    def dispatch(self, pycode, next_instr, ec):
        # For the sequel, force 'next_instr' to be unsigned for performance
        next_instr = r_uint(next_instr)
        co_code = pycode.co_code
        try:
            while True:
                assert next_instr & 1 == 0
>               next_instr = self.handle_bytecode(co_code, next_instr, ec)

interpreter/pyopcode.py:67: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <pypy.objspace.std.frame.StdObjSpaceFrame executing <code object test_SetFromE...x86-64/build/pypy/module/cpyext/test/test_pyerrors.py:250]", line 1> at line 56
co_code = '|\x00j\x00}\x01|\x01d\x00u\x00r\td\x01}\x01d\x02d\x00l\x01}\x02d\x02d\x00l\x02}\x03d\x02d\x00l\x03}\x04d\x03d\x04d\x0...01|\x07j\tj\nd\x13k\x02\x90\x01s\x0cJ\x00\x82\x01|\x07j\tj\x14d\x14k\x02\x90\x01s\x15J\x00\x82\x01d\x00S\x00d\x00S\x00'
next_instr = 88
ec = <pypy.interpreter.executioncontext.ExecutionContext object at 0x00007fc2c8919600>

    def handle_bytecode(self, co_code, next_instr, ec):
        try:
>           next_instr = self.dispatch_bytecode(co_code, next_instr, ec)

interpreter/pyopcode.py:73: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <pypy.objspace.std.frame.StdObjSpaceFrame executing <code object test_SetFromE...x86-64/build/pypy/module/cpyext/test/test_pyerrors.py:250]", line 1> at line 56
co_code = '|\x00j\x00}\x01|\x01d\x00u\x00r\td\x01}\x01d\x02d\x00l\x01}\x02d\x02d\x00l\x02}\x03d\x02d\x00l\x03}\x04d\x03d\x04d\x0...01|\x07j\tj\nd\x13k\x02\x90\x01s\x0cJ\x00\x82\x01|\x07j\tj\x14d\x14k\x02\x90\x01s\x15J\x00\x82\x01d\x00S\x00d\x00S\x00'
next_instr = 102L
ec = <pypy.interpreter.executioncontext.ExecutionContext object at 0x00007fc2c8919600>

    @jit.unroll_safe
    def dispatch_bytecode(self, co_code, next_instr, ec):
        while True:
            assert next_instr & 1 == 0
            self.last_instr = intmask(next_instr)
            if jit.we_are_jitted():
                ec.bytecode_only_trace(self)
            else:
                ec.bytecode_trace(self)
            next_instr = r_uint(self.last_instr)
            assert next_instr & 1 == 0
            opcode = ord(co_code[next_instr])
            oparg = ord(co_code[next_instr + 1])
            next_instr += 2
    
            # note: the structure of the code here is such that it makes
            # (after translation) a big "if/elif" chain, which is then
            # turned into a switch().
    
            while opcode == opcodedesc.EXTENDED_ARG.index:
                opcode = ord(co_code[next_instr])
                arg = ord(co_code[next_instr + 1])
                if opcode < HAVE_ARGUMENT:
                    raise BytecodeCorruption
                next_instr += 2
                oparg = (oparg * 256) | arg
    
            if opcode == opcodedesc.RETURN_VALUE.index:
                self.frame_finished_execution = True  # for generators
                raise Return
            elif opcode == opcodedesc.JUMP_ABSOLUTE.index:
                return self.jump_absolute(oparg, next_instr, ec)
            elif opcode == opcodedesc.RERAISE.index:
                return self.RERAISE(oparg, next_instr)
            elif opcode == opcodedesc.FOR_ITER.index:
                next_instr = self.FOR_ITER(oparg, next_instr)
            elif opcode == opcodedesc.JUMP_FORWARD.index:
                next_instr = self.JUMP_FORWARD(oparg, next_instr)
            elif opcode == opcodedesc.JUMP_IF_FALSE_OR_POP.index:
                return self.JUMP_IF_FALSE_OR_POP(oparg, next_instr, ec)
            elif opcode == opcodedesc.JUMP_IF_TRUE_OR_POP.index:
                return self.JUMP_IF_TRUE_OR_POP(oparg, next_instr, ec)
            elif opcode == opcodedesc.POP_JUMP_IF_FALSE.index:
                return self.POP_JUMP_IF_FALSE(oparg, next_instr, ec)
            elif opcode == opcodedesc.POP_JUMP_IF_TRUE.index:
                return self.POP_JUMP_IF_TRUE(oparg, next_instr, ec)
            elif opcode == opcodedesc.POP_JUMP_FORWARD_IF_NONE.index:
                next_instr = self.POP_JUMP_FORWARD_IF_NONE(oparg, next_instr)
            elif opcode == opcodedesc.POP_JUMP_FORWARD_IF_NOT_NONE.index:
                next_instr = self.POP_JUMP_FORWARD_IF_NOT_NONE(oparg, next_instr)
            elif opcode == opcodedesc.JUMP_IF_NOT_EXC_MATCH.index:
                next_instr = self.JUMP_IF_NOT_EXC_MATCH(oparg, next_instr)
            elif opcode == opcodedesc.BINARY_ADD.index:
                self.BINARY_ADD(oparg, next_instr)
            elif opcode == opcodedesc.BINARY_AND.index:
                self.BINARY_AND(oparg, next_instr)
            elif opcode == opcodedesc.BINARY_FLOOR_DIVIDE.index:
                self.BINARY_FLOOR_DIVIDE(oparg, next_instr)
            elif opcode == opcodedesc.BINARY_MATRIX_MULTIPLY.index:
                self.BINARY_MATRIX_MULTIPLY(oparg, next_instr)
            elif opcode == opcodedesc.BINARY_LSHIFT.index:
                self.BINARY_LSHIFT(oparg, next_instr)
            elif opcode == opcodedesc.BINARY_MODULO.index:
                self.BINARY_MODULO(oparg, next_instr)
            elif opcode == opcodedesc.BINARY_MULTIPLY.index:
                self.BINARY_MULTIPLY(oparg, next_instr)
            elif opcode == opcodedesc.BINARY_OR.index:
                self.BINARY_OR(oparg, next_instr)
            elif opcode == opcodedesc.BINARY_POWER.index:
                self.BINARY_POWER(oparg, next_instr)
            elif opcode == opcodedesc.BINARY_RSHIFT.index:
                self.BINARY_RSHIFT(oparg, next_instr)
            elif opcode == opcodedesc.BINARY_SUBSCR.index:
                self.BINARY_SUBSCR(oparg, next_instr)
            elif opcode == opcodedesc.BINARY_SUBTRACT.index:
                self.BINARY_SUBTRACT(oparg, next_instr)
            elif opcode == opcodedesc.BINARY_TRUE_DIVIDE.index:
                self.BINARY_TRUE_DIVIDE(oparg, next_instr)
            elif opcode == opcodedesc.BINARY_XOR.index:
                self.BINARY_XOR(oparg, next_instr)
            elif opcode == opcodedesc.BUILD_CONST_KEY_MAP.index:
                self.BUILD_CONST_KEY_MAP(oparg, next_instr)
            elif opcode == opcodedesc.BUILD_LIST.index:
                self.BUILD_LIST(oparg, next_instr)
            elif opcode == opcodedesc.BUILD_LIST_FROM_ARG.index:
                self.BUILD_LIST_FROM_ARG(oparg, next_instr)
            elif opcode == opcodedesc.BUILD_MAP.index:
                self.BUILD_MAP(oparg, next_instr)
            elif opcode == opcodedesc.BUILD_SET.index:
                self.BUILD_SET(oparg, next_instr)
            elif opcode == opcodedesc.BUILD_SLICE.index:
                self.BUILD_SLICE(oparg, next_instr)
            elif opcode == opcodedesc.BUILD_TUPLE.index:
                self.BUILD_TUPLE(oparg, next_instr)
            elif opcode == opcodedesc.CALL_FUNCTION.index:
                self.CALL_FUNCTION(oparg, next_instr)
            elif opcode == opcodedesc.CALL_FUNCTION_KW.index:
                self.CALL_FUNCTION_KW(oparg, next_instr)
            elif opcode == opcodedesc.CALL_FUNCTION_EX.index:
                self.CALL_FUNCTION_EX(oparg, next_instr)
            elif opcode == opcodedesc.CALL_METHOD.index:
                self.CALL_METHOD(oparg, next_instr)
            elif opcode == opcodedesc.CALL_METHOD_KW.index:
>               self.CALL_METHOD_KW(oparg, next_instr)

interpreter/pyopcode.py:298: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

f = <pypy.objspace.std.frame.StdObjSpaceFrame executing <code object test_SetFromE...x86-64/build/pypy/module/cpyext/test/test_pyerrors.py:250]", line 1> at line 56
n_arguments = 2, ignored = (102L,)
W_AbstractTupleObject = <class 'pypy.objspace.std.tupleobject.W_AbstractTupleObject'>
w_self = None, space = StdObjSpace

    @jit.unroll_safe
    def CALL_METHOD_KW(f, n_arguments, *ignored):
        from pypy.objspace.std.tupleobject import W_AbstractTupleObject
        # opargs contains the arg + kwarg count, excluding the implicit 'self'
        w_self = f.peekvalue_maybe_none(n_arguments + 1)
    
        space = f.space
        # like in BUILD_CONST_KEY_MAP we can't use space.fixedview because then
        # the immutability of the tuple is lost
        w_tup_varnames = space.interp_w(W_AbstractTupleObject, f.popvalue())
        n_keywords = space.len_w(w_tup_varnames)
        keyword_names_w = [None] * n_keywords
        keywords_w = [None] * n_keywords
        for i in range(n_keywords):
            keyword_names_w[i] = w_tup_varnames.getitem(space, i)
            w_value = f.peekvalue(n_keywords - 1 - i)
            keywords_w[i] = w_value
        f.dropvalues(n_keywords)
        n_arguments -= n_keywords
        n = n_arguments + (w_self is not None)
        arguments = f.popvalues(n)    # includes w_self if it is not None
        if w_self is None:
            f.popvalue_maybe_none()    # removes w_self, which is None
        w_callable = f.popvalue()
        args = f.argument_factory(
                arguments, keyword_names_w, keywords_w, None, None,
                methodcall=w_self is not None, w_function=w_callable)
        if f.get_is_being_profiled() and function.is_builtin_code(w_callable):
            w_result = f.space.call_args_and_c_profile(f, w_callable, args)
        else:
>           w_result = f.space.call_args(w_callable, args)

objspace/std/callmethod.py:126: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

space = StdObjSpace, w_obj = <FunctionWithFixedCode import_extension>
args = Arguments([W_UnicodeObject('foo'), W_ListObject(<pypy.objspace.std.listobject....                 '))])], ['prologue'], [W_UnicodeObject('#include <errno.h>')])

    def call_args(space, w_obj, args):
        # two special cases for performance
        if isinstance(w_obj, Function):
>           return w_obj.call_args(args)

objspace/descroperation.py:192: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <FunctionWithFixedCode import_extension>
args = Arguments([W_UnicodeObject('foo'), W_ListObject(<pypy.objspace.std.listobject....                 '))])], ['prologue'], [W_UnicodeObject('#include <errno.h>')])

    def call_args(self, args):
        # delegate activation to code
>       w_res = self.getcode().funcrun(self, args)

interpreter/function.py:81: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <pypy.interpreter.gateway.BuiltinCode object at 0x00007fc2db044d08>
func = <FunctionWithFixedCode import_extension>
args = Arguments([W_UnicodeObject('foo'), W_ListObject(<pypy.objspace.std.listobject....                 '))])], ['prologue'], [W_UnicodeObject('#include <errno.h>')])

    def funcrun(self, func, args):
>       return BuiltinCode.funcrun_obj(self, func, None, args)

interpreter/gateway.py:869: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <pypy.interpreter.gateway.BuiltinCode object at 0x00007fc2db044d08>
func = <FunctionWithFixedCode import_extension>, w_obj = None
args = Arguments([W_UnicodeObject('foo'), W_ListObject(<pypy.objspace.std.listobject....                 '))])], ['prologue'], [W_UnicodeObject('#include <errno.h>')])

    def funcrun_obj(self, func, w_obj, args):
        space = func.space
        activation = self.activation
    
        scope_w = args.parse_obj(w_obj, func.qualname, self.sig,
                                 func.defs_w, func.w_kw_defs, self.minargs)
        try:
            w_result = activation._run(space, scope_w)
        except DescrMismatch:
            if w_obj is not None:
                args = args.prepend(w_obj)
            return self._type_unwrap_mismatch(space, args)
        except Exception as e:
>           self.handle_exception(space, e)

interpreter/gateway.py:884: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <pypy.interpreter.gateway.BuiltinCode object at 0x00007fc2db044d08>
space = StdObjSpace
e = UnicodeEncodeError('ascii', u'\n                 errno = EBADF;\n             ...       return NULL;\n                 ', 107, 108, 'ordinal not in range(128)')

    def handle_exception(self, space, e):
        try:
            if not we_are_translated():
                raise
            raise e
        except OperationError:
            raise
        except Exception as e:      # general fall-back
            from pypy.interpreter import error
>           raise error.get_converted_unexpected_exception(space, e)

interpreter/gateway.py:908: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <pypy.interpreter.gateway.BuiltinCode object at 0x00007fc2db044d08>
func = <FunctionWithFixedCode import_extension>, w_obj = None
args = Arguments([W_UnicodeObject('foo'), W_ListObject(<pypy.objspace.std.listobject....                 '))])], ['prologue'], [W_UnicodeObject('#include <errno.h>')])

    def funcrun_obj(self, func, w_obj, args):
        space = func.space
        activation = self.activation
    
        scope_w = args.parse_obj(w_obj, func.qualname, self.sig,
                                 func.defs_w, func.w_kw_defs, self.minargs)
        try:
>           w_result = activation._run(space, scope_w)

interpreter/gateway.py:878: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <pypy.interpreter.gateway.BuiltinActivation_UwS_ObjSpace_text_W_Root_text_W_Root_text_bool object at 0x00007fc2db044de8>
space = StdObjSpace
scope_w = [W_UnicodeObject('foo'), W_ListObject(<pypy.objspace.std.listobject.ObjectListStrategy object at 0x0000..., "/path/to/...n NULL;\n                 '))]), W_UnicodeObject('#include <errno.h>'), None, W_UnicodeObject(''), W_BoolObject(False)]

    def _run(self, space, scope_w):
>       return self.behavior(space, space.text_w(scope_w[0]), scope_w[1], space.text_w(scope_w[2]), scope_w[3], space.text_w(scope_w[4]), space.is_true(scope_w[5]))

<3100-codegen /Users/matti/build-worker-x86_64/own-macos-x86-64/build/rpython/tool/sourcetools.py:174>:3: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

space = StdObjSpace, modname = 'foo'
w_functions = W_ListObject(<pypy.objspace.std.listobject.ObjectListStrategy object at 0x0000..., "/path/to/a\xcc\x88");\n                 return NULL;\n                 '))])
prologue = '#include <errno.h>', w_include_dirs = None, more_init = ''
PY_SSIZE_T_CLEAN = False

    @unwrap_spec(modname='text', prologue='text',
                         more_init='text', PY_SSIZE_T_CLEAN=bool)
    def import_extension(space, modname, w_functions, prologue="",
                         w_include_dirs=None, more_init="", PY_SSIZE_T_CLEAN=False):
        functions = space.unwrap(w_functions)
        include_dirs = _unwrap_include_dirs(space, w_include_dirs)
        # If there's already a module under this name (file-based or a
        # previous inline extension), save it in _module_keepalive before
        # it's displaced.  This prevents its raw allocations (method-name
        # strings, type dicts, etc.) from being freed during a later
        # test's leakfinder tracking window.
        self._file_module_cache.pop(modname, None)
        w_modules = space.sys.get('modules')
        try:
            w_old = space.getitem(w_modules, space.newtext(modname))
            self._module_keepalive.append(w_old)
        except OperationError:
            pass
        w_result = self.sys_info.import_extension(
            modname, functions, prologue, include_dirs, more_init,
>           PY_SSIZE_T_CLEAN)

module/cpyext/test/test_cpyext.py:415: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <pypy.module.cpyext.test.test_cpyext.SpaceCompiler object at 0x00007fc2fa68a0c8>
modname = 'foo'
functions = [(u'set_from_errno', u'METH_NOARGS', u'\n                 errno = EBADF;\n                 PyErr_SetFromErrnoWithFilen...PyErr_SetFromErrnoWithFilename(PyExc_OSError, "/path/to/a\u0308");\n                 return NULL;\n                 ')]
prologue = '#include <errno.h>', include_dirs = None, more_init = ''
PY_SSIZE_T_CLEAN = False

    def import_extension(self, modname, functions, prologue="",
            include_dirs=None, more_init="", PY_SSIZE_T_CLEAN=False):
>       body = prologue + make_methods(functions, modname)

tool/cpyext/extbuild.py:88: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

functions = [(u'set_from_errno', u'METH_NOARGS', u'\n                 errno = EBADF;\n                 PyErr_SetFromErrnoWithFilen...PyErr_SetFromErrnoWithFilename(PyExc_OSError, "/path/to/a\u0308");\n                 return NULL;\n                 ')]
modname = 'foo'

    def make_methods(functions, modname):
        methods_table = []
        codes = []
        for funcname, flags, code in functions:
            cfuncname = "%s_%s" % (modname, funcname)
            if 'METH_FASTCALL' in flags and 'METH_KEYWORDS' in flags:
                signature = ('(PyObject *self, PyObject *const *args, '
                             'Py_ssize_t len_args, PyObject *kwnames)')
            elif 'METH_KEYWORDS' in flags:
                signature = '(PyObject *self, PyObject *args, PyObject *kwargs)'
            elif 'METH_FASTCALL' in flags:
                signature = ('(PyObject *self, PyObject *const *args, '
                             'Py_ssize_t len_args)')
            else:
                signature = '(PyObject *self, PyObject *args)'
            methods_table.append(
                "{\"%s\", (PyCFunction)%s, %s}," % (funcname, cfuncname, flags))
            func_code = """
            static PyObject* {cfuncname}{signature}
            {{
            {code}
            }}
>           """.format(cfuncname=cfuncname, signature=signature, code=code)
E           UnicodeEncodeError: 'ascii' codec can't encode character u'\u0308' in position 107: ordinal not in range(128)

tool/cpyext/extbuild.py:139: UnicodeEncodeError
builder: own-macos-x86-64 build #1209
test: pypy/module/cpyext/test/test_pyerrors/py/AppTestFetch/()/test_SetFromErrnoWithFilename_basic