def make_class(cls): # XXX: this is (mostly) wrong: .compile() compiles the code object # using the host python compiler, but then in the tests we load it # with py.py. It works (mostly by chance) because the two functions # are very simple and the bytecodes are compatible enough. co = py.code.Source( """ def get_name(): return __name__ def get_file(): return __file__ """ ).compile() if cls.compression == ZIP_DEFLATED: space = gettestobjspace(usemodules=["zipimport", "zlib", "rctime", "struct"]) else: space = gettestobjspace(usemodules=["zipimport", "rctime", "struct"]) cls.space = space tmpdir = udir.ensure("zipimport_%s" % cls.__name__, dir=1) now = time.time() cls.w_now = space.wrap(now) test_pyc = cls.make_pyc(space, co, now) cls.w_test_pyc = space.wrap(test_pyc) cls.w_compression = space.wrap(cls.compression) cls.w_pathsep = space.wrap(cls.pathsep) # ziptestmodule = tmpdir.ensure('ziptestmodule.zip').write( ziptestmodule = tmpdir.join("somezip.zip") cls.w_tmpzip = space.wrap(str(ziptestmodule)) cls.w_co = space.wrap(co) cls.tmpdir = tmpdir
def test_hash_against_normal_tuple(self): N_space = gettestobjspace(**{"objspace.std.withspecialisedtuple": False}) S_space = gettestobjspace(**{"objspace.std.withspecialisedtuple": True}) def hash_test(values, must_be_specialized=True): N_values_w = [N_space.wrap(value) for value in values] S_values_w = [S_space.wrap(value) for value in values] N_w_tuple = N_space.newtuple(N_values_w) S_w_tuple = S_space.newtuple(S_values_w) if must_be_specialized: assert isinstance(S_w_tuple, W_SpecialisedTupleObject) assert isinstance(N_w_tuple, W_TupleObject) assert S_space.is_true(S_space.eq(N_w_tuple, S_w_tuple)) assert S_space.is_true(S_space.eq(N_space.hash(N_w_tuple), S_space.hash(S_w_tuple))) hash_test([1,2]) hash_test([1.5,2.8]) hash_test([1.0,2.0]) hash_test(['arbitrary','strings']) hash_test([1,(1,2,3,4)]) hash_test([1,(1,2)]) hash_test([1,('a',2)]) hash_test([1,()]) hash_test([1,2,3], must_be_specialized=False)
def setup_class(cls): # This imports support_test_sre as the global "s" try: cls.space = gettestobjspace(usemodules=('_locale', )) except py.test.skip.Exception: cls.space = gettestobjspace(usemodules=('_rawffi', )) init_globals_hack(cls.space)
def setup_class(cls): # This imports support_test_sre as the global "s" try: cls.space = gettestobjspace(usemodules=('_locale',)) except py.test.skip.Exception: cls.space = gettestobjspace(usemodules=('_rawffi',)) init_globals_hack(cls.space)
def setup_module(mod): if os.name != 'nt': mod.space = gettestobjspace(usemodules=['posix', 'fcntl', 'struct']) else: # On windows, os.popen uses the subprocess module mod.space = gettestobjspace( usemodules=['posix', '_rawffi', 'thread', 'struct']) mod.path = udir.join('posixtestfile.txt') mod.path.write("this is a test") mod.path2 = udir.join('test_posix2-') pdir = udir.ensure('posixtestdir', dir=True) pdir.join('file1').write("test1") os.chmod(str(pdir.join('file1')), 0600) pdir.join('file2').write("test2") pdir.join('another_longer_file_name').write("test3") mod.pdir = pdir unicode_dir = udir.ensure('fi\xc5\x9fier.txt', dir=True) unicode_dir.join('somefile').write('who cares?') unicode_dir.join('caf\xe9').write('who knows?') mod.unicode_dir = unicode_dir # in applevel tests, os.stat uses the CPython os.stat. # Be sure to return times with full precision # even when running on top of CPython 2.4. os.stat_float_times(True) # Initialize sys.filesystemencoding space.call_method(space.getbuiltinmodule('sys'), 'getfilesystemencoding')
def setup_module(mod): if os.name != 'nt': mod.space = gettestobjspace(usemodules=['posix', 'fcntl']) else: # On windows, os.popen uses the subprocess module mod.space = gettestobjspace(usemodules=['posix', '_rawffi', 'thread']) mod.path = udir.join('posixtestfile.txt') mod.path.write("this is a test") mod.path2 = udir.join('test_posix2-') pdir = udir.ensure('posixtestdir', dir=True) pdir.join('file1').write("test1") os.chmod(str(pdir.join('file1')), 0600) pdir.join('file2').write("test2") pdir.join('another_longer_file_name').write("test3") mod.pdir = pdir unicode_dir = udir.ensure('fi\xc5\x9fier.txt', dir=True) unicode_dir.join('somefile').write('who cares?') mod.unicode_dir = unicode_dir # in applevel tests, os.stat uses the CPython os.stat. # Be sure to return times with full precision # even when running on top of CPython 2.4. os.stat_float_times(True) # Initialize sys.filesystemencoding space.call_method(space.getbuiltinmodule('sys'), 'getfilesystemencoding')
def make_class(cls): # XXX: this is (mostly) wrong: .compile() compiles the code object # using the host python compiler, but then in the tests we load it # with py.py. It works (mostly by chance) because the two functions # are very simple and the bytecodes are compatible enough. co = py.code.Source(""" def get_name(): return __name__ def get_file(): return __file__ """).compile() if cls.compression == ZIP_DEFLATED: space = gettestobjspace( usemodules=['zipimport', 'zlib', 'rctime', 'struct']) else: space = gettestobjspace( usemodules=['zipimport', 'rctime', 'struct']) cls.space = space tmpdir = udir.ensure('zipimport_%s' % cls.__name__, dir=1) now = time.time() cls.w_now = space.wrap(now) test_pyc = cls.make_pyc(space, co, now) cls.w_test_pyc = space.wrap(test_pyc) cls.w_compression = space.wrap(cls.compression) cls.w_pathsep = space.wrap(cls.pathsep) #ziptestmodule = tmpdir.ensure('ziptestmodule.zip').write( ziptestmodule = tmpdir.join("somezip.zip") cls.w_tmpzip = space.wrap(str(ziptestmodule)) cls.w_co = space.wrap(co) cls.tmpdir = tmpdir
def setup_class(cls): try: cls.space = gettestobjspace(usemodules=('_locale',)) except Skipped: cls.space = gettestobjspace(usemodules=('_rawffi',)) # This imports support_test_sre as the global "s" init_globals_hack(cls.space)
def setup_class(cls): try: cls.space = gettestobjspace(usemodules=('_locale', )) except Skipped: cls.space = gettestobjspace(usemodules=('_rawffi', )) # This imports support_test_sre as the global "s" init_globals_hack(cls.space)
def test_abi_tag(self): space1 = gettestobjspace(soabi='TEST') space2 = gettestobjspace(soabi='') if sys.platform == 'win32': assert importing.get_so_extension(space1) == '.TESTi.pyd' assert importing.get_so_extension(space2) == '.pyd' else: assert importing.get_so_extension(space1) == '.TESTi.so' assert importing.get_so_extension(space2) == '.so'
def test_hash_agains_normal_tuple(self): normalspace = gettestobjspace(**{"objspace.std.withsmalltuple": False}) w_tuple = normalspace.newtuple([self.space.wrap(1), self.space.wrap(2)]) smallspace = gettestobjspace(**{"objspace.std.withsmalltuple": True}) w_smalltuple = smallspace.newtuple([self.space.wrap(1), self.space.wrap(2)]) assert isinstance(w_smalltuple, W_SmallTupleObject) assert isinstance(w_tuple, W_TupleObject) assert not normalspace.is_true(normalspace.eq(w_tuple, w_smalltuple)) assert smallspace.is_true(smallspace.eq(w_tuple, w_smalltuple)) assert smallspace.is_true(smallspace.eq(normalspace.hash(w_tuple), smallspace.hash(w_smalltuple)))
def setup_class(cls): cls.space = gettestobjspace(usemodules=['cpyext', 'thread', '_rawffi']) cls.space.getbuiltinmodule("cpyext") from pypy.module.imp.importing import importhook importhook(cls.space, "os") # warm up reference counts state = cls.space.fromcache(RefcountState) state.non_heaptypes_w[:] = []
def setup_class(cls): space = gettestobjspace() cls.space = space if py.test.config.option.runappdirect: cls.w_file = space.wrap(__file__[:-1]) else: cls.w_file = space.wrap("None<%s" % gateway.__file__[:-1])
def setup_class(cls): cls.space = gettestobjspace(**{"objspace.std.withmapdict": True}) if option.runappdirect: py.test.skip("can only be run on py.py") def has_mapdict(space, w_inst): return space.wrap(w_inst._get_mapdict_map() is not None) cls.w_has_mapdict = cls.space.wrap(gateway.interp2app(has_mapdict))
def setup_class(cls): space = gettestobjspace(usemodules=('_continuation', '_socket')) cls.space = space if option.runappdirect: cls.w_lev = space.wrap(14) else: cls.w_lev = space.wrap(2)
def setup_class(cls): space = gettestobjspace(usemodules=("_stackless",), **cls.OPTIONS) cls.space = space from pypy.rlib import rstack cls.old_resume_state_create = rstack.resume_state_create def tr(prevstate, label, *args): if prevstate is None: prevstate = [] return prevstate + [(label, args)] rstack.resume_state_create = tr w_opmap = space.appexec( [], """(): import opcode return opcode.opmap """, ) opmap = space.unwrap(w_opmap) cls.CALL_FUNCTION = opmap["CALL_FUNCTION"] cls.CALL_FUNCTION_VAR = opmap["CALL_FUNCTION_VAR"] cls.CALL_METHOD = opmap["CALL_METHOD"] cls.callmethod = getattr(cls, cls.callmethod_label)
def setup_class(cls): space = gettestobjspace(usemodules=('_rawffi', 'struct')) cls.space = space cls.w_sizes_and_alignments = space.wrap( dict([(k, (v.c_size, v.c_alignment)) for k, v in TYPEMAP.iteritems()])) Tracker.DO_TRACING = True
def setup_class(cls): space = gettestobjspace(usemodules=("thread", "time")) cls.space = space if option.runappdirect: def plain_waitfor(condition, delay=1): adaptivedelay = 0.04 limit = time.time() + NORMAL_TIMEOUT * delay while time.time() <= limit: time.sleep(adaptivedelay) gc.collect() if condition(): return adaptivedelay *= 1.05 print "*** timed out ***" cls.w_waitfor = plain_waitfor else: cls.w_waitfor = space.wrap(interp2app_temp(waitfor)) cls.w_busywait = space.appexec( [], """(): import time return time.sleep """, )
def setup_class(cls): cls.space = space = gettestobjspace(usemodules=['_locale']) if sys.platform != 'win32': cls.w_language_en = cls.space.wrap("en_US") cls.w_language_utf8 = cls.space.wrap("en_US.UTF-8") cls.w_language_pl = cls.space.wrap("pl_PL.UTF-8") cls.w_encoding_pl = cls.space.wrap("utf-8") else: cls.w_language_en = cls.space.wrap("English_US") cls.w_language_utf8 = cls.space.wrap("English_US.65001") cls.w_language_pl = cls.space.wrap("Polish_Poland.1257") cls.w_encoding_pl = cls.space.wrap("cp1257") import _locale # check whether used locales are installed, otherwise the tests will # fail current = _locale.setlocale(_locale.LC_ALL) try: try: _locale.setlocale(_locale.LC_ALL, space.str_w(cls.w_language_en)) _locale.setlocale(_locale.LC_ALL, space.str_w(cls.w_language_pl)) except _locale.Error: py.test.skip("necessary locales not installed") # Windows forbids the UTF-8 character set since Windows XP. try: _locale.setlocale(_locale.LC_ALL, space.str_w(cls.w_language_utf8)) except _locale.Error: del cls.w_language_utf8 finally: _locale.setlocale(_locale.LC_ALL, current)
def setup_class(cls): if sys.platform == 'win32': py.test.skip("select() doesn't work with pipes on win32") space = gettestobjspace(usemodules=('select', )) cls.space = space # Wraps a file descriptor in an socket-like object space.exec_( '''if 1: import os class FileAsSocket: def __init__(self, fd): self.fd = fd def fileno(self): return self.fd def send(self, data): return os.write(self.fd, data) def recv(self, length): return os.read(self.fd, length) def close(self): return os.close(self.fd) def getpair(): s1, s2 = os.pipe() return FileAsSocket(s1), FileAsSocket(s2)''', space.builtin.w_dict, space.builtin.w_dict)
def setup_class(cls): cls.space = gettestobjspace( **{ "objspace.std.withrope": True, "objspace.std.withprebuiltchar": False, "objspace.std.sharesmallstr": False })
def setup_class(cls): if not option.runappdirect: py.test.skip("likely to deadlock when interpreted by py.py") cls.space = gettestobjspace(usemodules=("_file", "thread")) cls.w_temppath = cls.space.wrap( str(py.test.ensuretemp("fileimpl").join("concurrency.txt"))) cls.w_file = getfile(cls.space)
def setup_class(cls): if sys.platform == "win32": py.test.skip("select() doesn't work with pipes on win32") space = gettestobjspace(usemodules=("select",)) cls.space = space # Wraps a file descriptor in an socket-like object cls.w_getpair = space.appexec( [], """(): import os class FileAsSocket: def __init__(self, fd): self.fd = fd def fileno(self): return self.fd def send(self, data): return os.write(self.fd, data) def recv(self, length): return os.read(self.fd, length) def close(self): return os.close(self.fd) def getpair(): s1, s2 = os.pipe() return FileAsSocket(s1), FileAsSocket(s2) return getpair""", )
def setup_class(cls): cls.space = gettestobjspace( **{ "objspace.std.withmethodcachecounter": True, "objspace.std.withmapdict": True, "objspace.opcodes.CALL_METHOD": True })
def test_hash_agains_normal_tuple(self): normalspace = gettestobjspace(**{"objspace.std.withsmalltuple": False}) w_tuple = normalspace.newtuple( [self.space.wrap(1), self.space.wrap(2)]) smallspace = gettestobjspace(**{"objspace.std.withsmalltuple": True}) w_smalltuple = smallspace.newtuple( [self.space.wrap(1), self.space.wrap(2)]) assert isinstance(w_smalltuple, W_SmallTupleObject) assert isinstance(w_tuple, W_TupleObject) assert not normalspace.is_true(normalspace.eq(w_tuple, w_smalltuple)) assert smallspace.is_true(smallspace.eq(w_tuple, w_smalltuple)) assert smallspace.is_true( smallspace.eq(normalspace.hash(w_tuple), smallspace.hash(w_smalltuple)))
def setup_class(cls): space = gettestobjspace(usemodules=('_rawffi', 'struct')) cls.space = space cls.w_lib_name = space.wrap(cls.prepare_c_example()) cls.w_sizes_and_alignments = space.wrap( dict([(k, (v.c_size, v.c_alignment)) for k, v in TYPEMAP.iteritems()]))
def setup_class(cls): space = gettestobjspace(usemodules=('bz2',)) cls.space = space cls.w_TEXT = space.wrap(TEXT) cls.w_DATA = space.wrap(DATA) cls.w_decompress = space.wrap(decompress) cls.w_HUGE_OK = space.wrap(HUGE_OK)
def setup_class(cls): if option.runappdirect: py.test.skip("Can't run this test with -A") space = gettestobjspace(usemodules=('pypyjit',)) cls.space = space w_f = space.appexec([], """(): def f(): pass return f """) ll_code = cast_instance_to_base_ptr(w_f.code) logger = Logger(MockSD()) oplist = parse(""" [i1, i2] i3 = int_add(i1, i2) guard_true(i3) [] """, namespace={'ptr0': 3}).operations def interp_on_compile(): pypyjitdriver.on_compile(logger, LoopToken(), oplist, 'loop', 0, False, ll_code) def interp_on_compile_bridge(): pypyjitdriver.on_compile_bridge(logger, LoopToken(), oplist, 0) cls.w_on_compile = space.wrap(interp2app(interp_on_compile)) cls.w_on_compile_bridge = space.wrap(interp2app(interp_on_compile_bridge))
def setup_class(cls): cls.space = gettestobjspace(**{"objspace.std.withcelldict": True}) cls.w_impl_used = cls.space.appexec([], """(): import __pypy__ def impl_used(obj): assert "ModuleDictImplementation" in __pypy__.internal_repr(obj) return impl_used """) def is_in_cache(space, w_code, w_globals, w_name): name = space.str_w(w_name) cache = get_global_cache(space, w_code, w_globals) index = [space.str_w(w_n) for w_n in w_code.co_names_w].index(name) return space.wrap(cache[index].w_value is not None) is_in_cache = gateway.interp2app(is_in_cache) cls.w_is_in_cache = cls.space.wrap(is_in_cache) stored_builtins = [] def rescue_builtins(space): w_dict = space.builtin.getdict() content = {} for key, cell in w_dict.implementation.content.iteritems(): newcell = ModuleCell() newcell.w_value = cell.w_value content[key] = newcell stored_builtins.append(content) rescue_builtins = gateway.interp2app(rescue_builtins) cls.w_rescue_builtins = cls.space.wrap(rescue_builtins) def restore_builtins(space): w_dict = space.builtin.getdict() if not isinstance(w_dict.implementation, ModuleDictImplementation): w_dict.implementation = ModuleDictImplementation(space) w_dict.implementation.content = stored_builtins.pop() restore_builtins = gateway.interp2app(restore_builtins) cls.w_restore_builtins = cls.space.wrap(restore_builtins)
def setup_class(cls): space = gettestobjspace(usemodules=('_multiprocessing', 'thread', 'signal')) cls.space = space cls.w_connections = space.newlist([]) def socketpair(space): "A socket.socketpair() that works on Windows" import socket, errno serverSocket = socket.socket() serverSocket.bind(('127.0.0.1', 0)) serverSocket.listen(1) client = socket.socket() client.setblocking(False) try: client.connect(('127.0.0.1', serverSocket.getsockname()[1])) except socket.error, e: assert e.args[0] in (errno.EINPROGRESS, errno.EWOULDBLOCK) server, addr = serverSocket.accept() # keep sockets alive during the test space.call_method(cls.w_connections, "append", space.wrap(server)) space.call_method(cls.w_connections, "append", space.wrap(client)) return space.wrap((server.fileno(), client.fileno()))
def setup_class(cls): cls.space = gettestobjspace(usemodules=['itertools']) if cls.space.is_true( cls.space.appexec([], """(): import sys; return sys.version_info < (2, 7) """)): py.test.skip("Requires Python 2.7")
def setup_class(cls): space = gettestobjspace(usemodules=('_stackless', ), **cls.OPTIONS) cls.space = space from pypy.rlib import rstack cls.old_resume_state_create = rstack.resume_state_create def tr(prevstate, label, *args): if prevstate is None: prevstate = [] return prevstate + [(label, args)] rstack.resume_state_create = tr w_opmap = space.appexec([], """(): import opcode return opcode.opmap """) opmap = space.unwrap(w_opmap) cls.CALL_FUNCTION = opmap['CALL_FUNCTION'] cls.CALL_FUNCTION_VAR = opmap['CALL_FUNCTION_VAR'] cls.CALL_METHOD = opmap['CALL_METHOD'] cls.callmethod = getattr(cls, cls.callmethod_label)
def setup_class(cls): from pypy.interpreter import gateway cls.space = gettestobjspace( **{"objspace.std.withmapdict": True, "objspace.std.withmethodcachecounter": True, "objspace.opcodes.CALL_METHOD": True}) # def check(space, w_func, name): w_code = space.getattr(w_func, space.wrap('func_code')) nameindex = map(space.str_w, w_code.co_names_w).index(name) entry = w_code._mapdict_caches[nameindex] entry.failure_counter = 0 entry.success_counter = 0 INVALID_CACHE_ENTRY.failure_counter = 0 # w_res = space.call_function(w_func) assert space.eq_w(w_res, space.wrap(42)) # entry = w_code._mapdict_caches[nameindex] if entry is INVALID_CACHE_ENTRY: failures = successes = 0 else: failures = entry.failure_counter successes = entry.success_counter globalfailures = INVALID_CACHE_ENTRY.failure_counter return space.wrap((failures, successes, globalfailures)) check.unwrap_spec = [gateway.ObjSpace, gateway.W_Root, str] cls.w_check = cls.space.wrap(gateway.interp2app(check))
def setup_class(cls): space = gettestobjspace(usemodules=('thread', 'time', 'signal')) cls.space = space if option.runappdirect: def plain_waitfor(self, condition, delay=1): adaptivedelay = 0.04 limit = time.time() + NORMAL_TIMEOUT * delay while time.time() <= limit: time.sleep(adaptivedelay) gc.collect() if condition(): return adaptivedelay *= 1.05 print '*** timed out ***' cls.w_waitfor = plain_waitfor else: cls.w_waitfor = space.wrap(lambda self, condition, delay=1: waitfor(space, condition, delay)) cls.w_busywait = space.appexec([], """(): import time return time.sleep """) cls.w_timeout_killer = space.wrap( lambda self, *args, **kwargs: timeout_killer(*args, **kwargs))
def setup_class(cls): space = gettestobjspace(usemodules=('_multiprocessing', 'thread', 'signal', 'struct', 'array')) cls.space = space cls.w_connections = space.newlist([]) def socketpair(space): "A socket.socketpair() that works on Windows" import socket, errno serverSocket = socket.socket() serverSocket.bind(('127.0.0.1', 0)) serverSocket.listen(1) client = socket.socket() client.setblocking(False) try: client.connect(('127.0.0.1', serverSocket.getsockname()[1])) except socket.error, e: assert e.args[0] in (errno.EINPROGRESS, errno.EWOULDBLOCK) server, addr = serverSocket.accept() # keep sockets alive during the test space.call_method(cls.w_connections, "append", space.wrap(server)) space.call_method(cls.w_connections, "append", space.wrap(client)) return space.wrap((server.fileno(), client.fileno()))
def test_direct(): space = gettestobjspace(**{"objspace.std.withsmalllong": True}) w5 = space.wrap(r_longlong(5)) assert isinstance(w5, W_SmallLongObject) wlarge = space.wrap(r_longlong(0x123456789ABCDEFL)) # assert space.int_w(w5) == 5 if sys.maxint < 0x123456789ABCDEFL: py.test.raises(OperationError, space.int_w, wlarge) else: assert space.int_w(wlarge) == 0x123456789ABCDEF # assert space.pos(w5) is w5 assert space.abs(w5) is w5 wm5 = space.wrap(r_longlong(-5)) assert space.int_w(space.abs(wm5)) == 5 assert space.int_w(space.neg(w5)) == -5 assert space.is_true(w5) is True assert space.is_true(wm5) is True w0 = space.wrap(r_longlong(0)) assert space.is_true(w0) is False # w14000000000000 = space.wrap(r_longlong(0x14000000000000L)) assert space.is_true(space.eq( space.lshift(w5, space.wrap(49)), w14000000000000)) is False assert space.is_true(space.eq( space.lshift(w5, space.wrap(50)), w14000000000000)) is True # w_huge = space.sub(space.lshift(w5, space.wrap(150)), space.wrap(1)) wx = space.and_(w14000000000000, w_huge) assert space.is_true(space.eq(wx, w14000000000000))
def setup_class(cls): from pypy.interpreter import gateway cls.space = gettestobjspace( **{ "objspace.std.withmapdict": True, "objspace.std.withmethodcachecounter": True, "objspace.opcodes.CALL_METHOD": True }) # def check(space, w_func, name): w_code = space.getattr(w_func, space.wrap('func_code')) nameindex = map(space.str_w, w_code.co_names_w).index(name) entry = w_code._mapdict_caches[nameindex] entry.failure_counter = 0 entry.success_counter = 0 INVALID_CACHE_ENTRY.failure_counter = 0 # w_res = space.call_function(w_func) assert space.eq_w(w_res, space.wrap(42)) # entry = w_code._mapdict_caches[nameindex] if entry is INVALID_CACHE_ENTRY: failures = successes = 0 else: failures = entry.failure_counter successes = entry.success_counter globalfailures = INVALID_CACHE_ENTRY.failure_counter return space.wrap((failures, successes, globalfailures)) check.unwrap_spec = [gateway.ObjSpace, gateway.W_Root, str] cls.w_check = cls.space.wrap(gateway.interp2app(check))
def setup_class(cls): if not option.runappdirect: py.test.skip("Cannot run this on top of py.py because of PopenGateway") cls.space = gettestobjspace(**{"objspace.std.withtproxy": True, "usemodules":("_stackless",)}) cls.w_remote_side_code = cls.space.appexec([], """(): import sys sys.path.insert(0, '%s') remote_side_code = ''' class A: def __init__(self, x): self.x = x def __len__(self): return self.x + 8 def raising(self): 1/0 def method(self, x): return x() + self.x a = A(3) def count(): x = 10 # naive counting :) result = 1 for i in range(x): result += 1 return result ''' return remote_side_code """ % str(py.path.local(__file__).dirpath().dirpath().dirpath().dirpath()))
def setup_class(cls): space = gettestobjspace(usemodules=('thread', 'time', 'signal')) cls.space = space if option.runappdirect: def plain_waitfor(self, condition, delay=1): adaptivedelay = 0.04 limit = time.time() + NORMAL_TIMEOUT * delay while time.time() <= limit: time.sleep(adaptivedelay) gc.collect() if condition(): return adaptivedelay *= 1.05 print '*** timed out ***' cls.w_waitfor = plain_waitfor else: cls.w_waitfor = space.wrap(lambda self, condition, delay=1: waitfor(space, condition, delay)) cls.w_busywait = space.appexec([], """(): import time return time.sleep """) cls.w_timeout_killer = space.wrap(lambda self, *args, **kwargs: timeout_killer(*args, **kwargs))
def setup_class(cls): space = gettestobjspace(usemodules=('bz2', )) cls.space = space cls.w_TEXT = space.wrap(TEXT) cls.w_DATA = space.wrap(DATA) cls.w_decompress = space.wrap(decompress) cls.w_HUGE_OK = space.wrap(HUGE_OK)
def setup_class(cls): cls.space = gettestobjspace(**{"objspace.std.withstrslice": True}) def not_forced(space, w_s): return space.wrap(isinstance(w_s, W_StringSliceObject) and (w_s.start != 0 or w_s.stop != len(w_s.str))) cls.w_not_forced = cls.space.wrap(gateway.interp2app(not_forced))
def _prepare(self): if hasattr(self, 'name2item'): return self.name2item = {} space = gettestobjspace(usemodules=self.regrtest.usemodules) if self.regrtest.dumbtest or self.regrtest.getoutputpath(): self.name2item['output'] = SimpleRunItem('output', self) return tup = start_intercept(space) self.regrtest.run_file(space) w_namemethods, w_doctestlist = collect_intercept(space, *tup) # setup {name -> wrapped testcase method} for w_item in space.unpackiterable(w_namemethods): w_name, w_method = space.unpacktuple(w_item) name = space.str_w(w_name) testitem = AppTestCaseMethod(name, parent=self, w_method=w_method) self.name2item[name] = testitem # setup {name -> wrapped doctest module} for w_item in space.unpackiterable(w_doctestlist): w_name, w_module = space.unpacktuple(w_item) name = space.str_w(w_name) testitem = AppDocTestModule(name, parent=self, w_module=w_module) self.name2item[name] = testitem
def setup_class(cls): if option.runappdirect: if '__pypy__' not in sys.builtin_module_names: import numpy sys.modules['numpypy'] = numpy sys.modules['_numpypy'] = numpy cls.space = gettestobjspace(usemodules=['micronumpy'])
def test_pyc_magic_changes(self): # test that the pyc files produced by a space are not reimportable # from another, if they differ in what opcodes they support allspaces = [self.space] for opcodename in self.space.config.objspace.opcodes.getpaths(): key = 'objspace.opcodes.' + opcodename space2 = gettestobjspace(**{key: True}) allspaces.append(space2) for space1 in allspaces: for space2 in allspaces: if space1 is space2: continue pathname = "whatever" mtime = 12345 co = compile('x = 42', '?', 'exec') cpathname = _testfile(importing.get_pyc_magic(space1), mtime, co) w_modulename = space2.wrap('somemodule') stream = streamio.open_file_as_stream(cpathname, "rb") try: w_mod = space2.wrap(Module(space2, w_modulename)) magic = importing._r_long(stream) timestamp = importing._r_long(stream) space2.raises_w(space2.w_ImportError, importing.load_compiled_module, space2, w_modulename, w_mod, cpathname, magic, timestamp, stream.readall()) finally: stream.close()
def setup_class(cls): if option.runappdirect: py.test.skip("Can't run this test with -A") space = gettestobjspace(usemodules=('pypyjit',)) cls.space = space w_f = space.appexec([], """(): def function(): pass return function """) cls.w_f = w_f ll_code = cast_instance_to_base_ptr(w_f.code) code_gcref = lltype.cast_opaque_ptr(llmemory.GCREF, ll_code) logger = Logger(MockSD()) oplist = parse(""" [i1, i2, p2] i3 = int_add(i1, i2) debug_merge_point(0, 0, 0, 0, 0, ConstPtr(ptr0)) guard_nonnull(p2) [] guard_true(i3) [] """, namespace={'ptr0': code_gcref}).operations greenkey = [ConstInt(0), ConstInt(0), ConstPtr(code_gcref)] offset = {} for i, op in enumerate(oplist): if i != 1: offset[op] = i di_loop = JitDebugInfo(MockJitDriverSD, logger, JitCellToken(), oplist, 'loop', greenkey) di_loop_optimize = JitDebugInfo(MockJitDriverSD, logger, JitCellToken(), oplist, 'loop', greenkey) di_loop.asminfo = AsmInfo(offset, 0, 0) di_bridge = JitDebugInfo(MockJitDriverSD, logger, JitCellToken(), oplist, 'bridge', fail_descr_no=0) di_bridge.asminfo = AsmInfo(offset, 0, 0) def interp_on_compile(): di_loop.oplist = cls.oplist pypy_hooks.after_compile(di_loop) def interp_on_compile_bridge(): pypy_hooks.after_compile_bridge(di_bridge) def interp_on_optimize(): di_loop_optimize.oplist = cls.oplist pypy_hooks.before_compile(di_loop_optimize) def interp_on_abort(): pypy_hooks.on_abort(ABORT_TOO_LONG, pypyjitdriver, greenkey, 'blah') cls.w_on_compile = space.wrap(interp2app(interp_on_compile)) cls.w_on_compile_bridge = space.wrap(interp2app(interp_on_compile_bridge)) cls.w_on_abort = space.wrap(interp2app(interp_on_abort)) cls.w_int_add_num = space.wrap(rop.INT_ADD) cls.w_dmp_num = space.wrap(rop.DEBUG_MERGE_POINT) cls.w_on_optimize = space.wrap(interp2app(interp_on_optimize)) cls.orig_oplist = oplist
def setup_class(cls): cls.space = gettestobjspace(**{"objspace.std.withcelldict": True}) cls.w_impl_used = cls.space.appexec([], """(): import __pypy__ def impl_used(obj): assert "ModuleDictImplementation" in __pypy__.internal_repr(obj) return impl_used """)
def setup_class(cls): if not option.runappdirect: py.test.skip("meant only for pypy-c") cls.space = gettestobjspace(usemodules=['pypyjit']) cls.tmpdir = udir.join('pypy-jit') cls.tmpdir.ensure(dir=1) cls.counter = 0 cls.pypy_c = sys.executable
def test_trylock(self): space = gettestobjspace(usemodules=["thread"]) lock = interp_bufferedio.TryLock(space) with lock: pass with lock: exc = py.test.raises(OperationError, "with lock: pass") assert exc.value.match(space, space.w_RuntimeError)
def setup_class(cls): cls.space = gettestobjspace(**{ "objspace.usepycfiles": cls.usepycfiles, "objspace.lonepycfiles": cls.lonepycfiles, }) cls.w_usepycfiles = cls.space.wrap(cls.usepycfiles) cls.w_lonepycfiles = cls.space.wrap(cls.lonepycfiles) cls.saved_modules = _setup(cls.space)
def setup_class(cls): cls.space = gettestobjspace(**{"objspace.std.withsmalltuple": True}) cls.w_issmall = cls.space.appexec([], """(): import __pypy__ def issmall(obj): assert "SmallTuple" in __pypy__.internal_repr(obj) return issmall """)