pypy / pypy / tool / pytest /

The branch 'remove-globals-in-jit' does not exist.
Amaury Forgeot d… 607b9ab 
Armin Rigo 3a8541d 
Amaury Forgeot d… 607b9ab 

Alex Gaynor 1646d57 
Amaury Forgeot d… 607b9ab 

Alex Gaynor 1646d57 
Amaury Forgeot d… 607b9ab 

Amaury Forgeot d… a69f63c 

Armin Rigo cc03c3f 

Amaury Forgeot d… a69f63c 

mattip fb71ab1 

Amaury Forgeot d… a69f63c 
mattip 68d481e 

Amaury Forgeot d… a69f63c 

import py
import sys
from pypy.config.config import ConflictConfigError
from pypy.tool.option import make_config, make_objspace
from pypy.tool.pytest import appsupport
from pypy.conftest import option

def gettestobjspace(**kwds):
    """ helper for instantiating and caching space's for testing.
        config = make_config(option,**kwds)
    except ConflictConfigError, e:
        # this exception is typically only raised if a module is not available.
        # in this case the test should be skipped
    key = config.getkey()
        return _SPACECACHE[key]
    except KeyError:
        if getattr(option, 'runappdirect', None):
            return TinyObjSpace(**kwds)
        space = maketestobjspace(config)
        _SPACECACHE[key] = space
        return space

def maketestobjspace(config=None):
    if config is None:
        config = make_config(option)
    space = make_objspace(config)
    space.startup() # Initialize all builtin modules
    space.setitem(space.builtin.w_dict, space.wrap('AssertionError'),
    space.setitem(space.builtin.w_dict, space.wrap('raises'),
    space.setitem(space.builtin.w_dict, space.wrap('skip'),
    space.raises_w = appsupport.raises_w.__get__(space)
    space.eq_w = appsupport.eq_w.__get__(space)
    return space

class TinyObjSpace(object):
    """An object space that delegates everything to the hosting Python."""
    def __init__(self, **kwds):
        info = getattr(sys, 'pypy_translation_info', None)
        for key, value in kwds.iteritems():
            if key == 'usemodules':
                if info is not None:
                    for modname in value:
                        if modname == 'time':
                            continue   # always either 'time' or 'rctime',
                                       # and any is fine
                        ok = info.get('objspace.usemodules.%s' % modname,
                        if not ok:
                            py.test.skip("cannot runappdirect test: "
                                         "module %r required" % (modname,))
                    if '__pypy__' in value:
                        py.test.skip("no module __pypy__ on top of CPython")
            if info is None:
                py.test.skip("cannot runappdirect this test on top of CPython")
            has = info.get(key, None)
            if has != value:
                #print sys.pypy_translation_info
                py.test.skip("cannot runappdirect test: space needs %s = %s, "\
                    "while pypy-c was built with %s" % (key, value, has))

        for name in ('int', 'long', 'str', 'unicode', 'None', 'ValueError',
            setattr(self, 'w_' + name, eval(name))
        import __builtin__ as __builtin__
        self.builtin = __builtin__

    def appexec(self, args, body):
        body = body.lstrip()
        assert body.startswith('(')
        src = py.code.Source("def anonymous" + body)
        d = {}
        exec src.compile() in d
        return d['anonymous'](*args)

    def wrap(self, obj):
        return obj

    def unpackiterable(self, itr):
        return list(itr)

    def is_true(self, obj):
        return bool(obj)

    def str_w(self, w_str):
        return w_str

    def newdict(self, module=None):
        return {}

    def newtuple(self, iterable):
        return tuple(iterable)

    def newlist(self, iterable):
        return list(iterable)

    def call_function(self, func, *args, **kwds):
        return func(*args, **kwds)

    def call_method(self, obj, name, *args, **kwds):
        return getattr(obj, name)(*args, **kwds)

    def getattr(self, obj, name):
        return getattr(obj, name)

    def setattr(self, obj, name, value):
        setattr(obj, name, value)

    def getbuiltinmodule(self, name):
        return __import__(name)

    def delslice(self, obj, *args):

    def is_w(self, obj1, obj2):
        return obj1 is obj2