def test_check_compiled_module(self):
space = self.space
mtime = 12345
cpathname = _testfile(importing.get_pyc_magic(space), mtime)
ret = importing.check_compiled_module(space, cpathname, mtime)
assert ret is not None
ret.close()
# check for wrong mtime
ret = importing.check_compiled_module(space, cpathname, mtime + 1)
assert ret is None
# also check with expected mtime==0 (nothing special any more about 0)
ret = importing.check_compiled_module(space, cpathname, 0)
assert ret is None
os.remove(cpathname)
# check for wrong version
cpathname = _testfile(importing.get_pyc_magic(space) + 1, mtime)
ret = importing.check_compiled_module(space, cpathname, mtime)
assert ret is None
# check for empty .pyc file
f = open(cpathname, "wb")
f.close()
ret = importing.check_compiled_module(space, cpathname, mtime)
assert ret is None
os.remove(cpathname)
def test_check_compiled_module(self):
space = self.space
mtime = 12345
cpathname = _testfile(importing.get_pyc_magic(space), mtime)
ret = importing.check_compiled_module(space,
cpathname,
mtime)
assert ret is not None
ret.close()
# check for wrong mtime
ret = importing.check_compiled_module(space,
cpathname,
mtime+1)
assert ret is None
os.remove(cpathname)
# check for wrong version
cpathname = _testfile(importing.get_pyc_magic(space)+1, mtime)
ret = importing.check_compiled_module(space,
cpathname,
mtime)
assert ret is None
# check for empty .pyc file
f = open(cpathname, 'wb')
f.close()
ret = importing.check_compiled_module(space,
cpathname,
mtime)
assert ret is None
os.remove(cpathname)
def test_check_compiled_module(self):
space = self.space
mtime = 12345
cpathname = _testfile(importing.get_pyc_magic(space), mtime)
ret = importing.check_compiled_module(space, cpathname, mtime)
assert ret is not None
ret.close()
# check for wrong mtime
ret = importing.check_compiled_module(space, cpathname, mtime + 1)
assert ret is None
# also check with expected mtime==0 (nothing special any more about 0)
ret = importing.check_compiled_module(space, cpathname, 0)
assert ret is None
os.remove(cpathname)
# check for wrong version
cpathname = _testfile(importing.get_pyc_magic(space) + 1, mtime)
ret = importing.check_compiled_module(space, cpathname, mtime)
assert ret is None
# check for empty .pyc file
f = open(cpathname, 'wb')
f.close()
ret = importing.check_compiled_module(space, cpathname, mtime)
assert ret is None
os.remove(cpathname)
def test_pyc_magic_changes(self):
py.test.skip("For now, PyPy generates only one kind of .pyc files")
# 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 = maketestobjspace(make_config(None, **{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_after_space_initialization(self):
"""NOT_RPYTHON"""
if not self.space.config.translating:
self.extra_interpdef('interp_pdb', 'interp_magic.interp_pdb')
if self.space.config.objspace.std.withmethodcachecounter:
self.extra_interpdef('method_cache_counter',
'interp_magic.method_cache_counter')
self.extra_interpdef('reset_method_cache_counter',
'interp_magic.reset_method_cache_counter')
if self.space.config.objspace.std.withmapdict:
self.extra_interpdef('mapdict_cache_counter',
'interp_magic.mapdict_cache_counter')
PYC_MAGIC = get_pyc_magic(self.space)
self.extra_interpdef('PYC_MAGIC', 'space.wrap(%d)' % PYC_MAGIC)
#
try:
from rpython.jit.backend import detect_cpu
model = detect_cpu.autodetect()
self.extra_interpdef('cpumodel', 'space.wrap(%r)' % model)
except Exception:
if self.space.config.translation.jit:
raise
else:
pass # ok fine to ignore in this case
#
if self.space.config.translation.jit:
features = detect_cpu.getcpufeatures(model)
self.extra_interpdef('jit_backend_features',
'space.wrap(%r)' % features)
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_after_space_initialization(self):
"""NOT_RPYTHON"""
if self.space.config.objspace.std.withmethodcachecounter:
self.extra_interpdef('method_cache_counter',
'interp_magic.method_cache_counter')
self.extra_interpdef('reset_method_cache_counter',
'interp_magic.reset_method_cache_counter')
self.extra_interpdef('mapdict_cache_counter',
'interp_magic.mapdict_cache_counter')
PYC_MAGIC = get_pyc_magic(self.space)
self.extra_interpdef('PYC_MAGIC', 'space.wrap(%d)' % PYC_MAGIC)
try:
from rpython.jit.backend import detect_cpu
model = detect_cpu.autodetect()
self.extra_interpdef('cpumodel', 'space.wrap(%r)' % model)
except Exception:
if self.space.config.translation.jit:
raise
else:
pass # ok fine to ignore in this case
if self.space.config.translation.jit:
features = detect_cpu.getcpufeatures(model)
self.extra_interpdef('jit_backend_features',
'space.wrap(%r)' % features)
if self.space.config.translation.reverse_debugger:
self.extra_interpdef('revdb_stop', 'interp_magic.revdb_stop')
else:
self.extra_interpdef('revdb_stop', 'space.w_None')
def test_pyc_magic_changes(self):
# skipped: for now, PyPy generates only one kind of .pyc file
# per version. Different versions should differ in
# sys.implementation.cache_tag, which means that they'll look up
# different .pyc files anyway. See test_get_tag() in test_app.py.
py.test.skip("For now, PyPy generates only one kind of .pyc files")
# 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 = maketestobjspace(make_config(None, **{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(space1, 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 = _r_long(stream)
timestamp = _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 can_use_pyc(self, space, filename, magic, timestamp):
if magic != importing.get_pyc_magic(space):
return False
if self.check_newer_pyfile(space, filename[:-1], timestamp):
return False
if not self.check_compatible_mtime(space, filename, timestamp):
return False
return True
def can_use_pyc(self, space, filename, magic, timestamp):
if magic != importing.get_pyc_magic(space):
return False
if self.check_newer_pyfile(space, filename[:-1], timestamp):
return False
if not self.check_compatible_mtime(space, filename, timestamp):
return False
return True
def get_magic(space):
x = importing.get_pyc_magic(space)
a = x & 0xff
x >>= 8
b = x & 0xff
x >>= 8
c = x & 0xff
x >>= 8
d = x & 0xff
return space.newbytes(chr(a) + chr(b) + chr(c) + chr(d))
def get_magic(space):
x = importing.get_pyc_magic(space)
a = x & 0xff
x >>= 8
b = x & 0xff
x >>= 8
c = x & 0xff
x >>= 8
d = x & 0xff
return space.wrap(chr(a) + chr(b) + chr(c) + chr(d))
def setup_after_space_initialization(self):
"""NOT_RPYTHON"""
if not self.space.config.translating:
self.extra_interpdef('isfake', 'interp_magic.isfake')
self.extra_interpdef('interp_pdb', 'interp_magic.interp_pdb')
if self.space.config.objspace.std.withmethodcachecounter:
self.extra_interpdef('method_cache_counter',
'interp_magic.method_cache_counter')
self.extra_interpdef('reset_method_cache_counter',
'interp_magic.reset_method_cache_counter')
PYC_MAGIC = get_pyc_magic(self.space)
self.extra_interpdef('PYC_MAGIC', 'space.wrap(%d)' % PYC_MAGIC)
def setup_after_space_initialization(self):
"""NOT_RPYTHON"""
if not self.space.config.translating:
self.extra_interpdef('isfake', 'interp_magic.isfake')
self.extra_interpdef('interp_pdb', 'interp_magic.interp_pdb')
if self.space.config.objspace.std.withmethodcachecounter:
self.extra_interpdef('method_cache_counter',
'interp_magic.method_cache_counter')
self.extra_interpdef('reset_method_cache_counter',
'interp_magic.reset_method_cache_counter')
PYC_MAGIC = get_pyc_magic(self.space)
self.extra_interpdef('PYC_MAGIC', 'space.wrap(%d)' % PYC_MAGIC)
def make_pyc(cls, space, co, mtime):
data = marshal.dumps(co)
if type(mtime) is type(0.0):
# Mac mtimes need a bit of special casing
if mtime < 0x7fffffff:
mtime = int(mtime)
else:
mtime = int(-0x100000000L + long(mtime))
s = StringIO()
try:
_w_long(s, get_pyc_magic(space))
except AttributeError:
import imp
s.write(imp.get_magic())
pyc = s.getvalue() + struct.pack("<i", int(mtime)) + data
return pyc
def make_pyc(cls, space, co, mtime):
data = marshal.dumps(co)
if type(mtime) is type(0.0):
# Mac mtimes need a bit of special casing
if mtime < 0x7fffffff:
mtime = int(mtime)
else:
mtime = int(-0x100000000L + long(mtime))
s = StringIO()
try:
_w_long(s, get_pyc_magic(space))
except AttributeError:
import imp
s.write(imp.get_magic())
pyc = s.getvalue() + struct.pack("<i", int(mtime)) + data
return pyc
def setup_after_space_initialization(self):
"""NOT_RPYTHON"""
if not self.space.config.translating:
self.extra_interpdef("isfake", "interp_magic.isfake")
self.extra_interpdef("interp_pdb", "interp_magic.interp_pdb")
if self.space.config.objspace.std.withmethodcachecounter:
self.extra_interpdef("method_cache_counter", "interp_magic.method_cache_counter")
self.extra_interpdef("reset_method_cache_counter", "interp_magic.reset_method_cache_counter")
if self.space.config.objspace.std.withmapdict:
self.extra_interpdef("mapdict_cache_counter", "interp_magic.mapdict_cache_counter")
PYC_MAGIC = get_pyc_magic(self.space)
self.extra_interpdef("PYC_MAGIC", "space.wrap(%d)" % PYC_MAGIC)
#
from pypy.jit.backend import detect_cpu
model = detect_cpu.autodetect_main_model_and_size()
self.extra_interpdef("cpumodel", "space.wrap(%r)" % model)
def test_read_compiled_module(self):
space = self.space
mtime = 12345
co = compile("x = 42", "?", "exec")
cpathname = _testfile(importing.get_pyc_magic(space), mtime, co)
stream = streamio.open_file_as_stream(cpathname, "rb")
try:
stream.seek(8, 0)
w_code = importing.read_compiled_module(space, cpathname, stream.readall())
pycode = w_code
finally:
stream.close()
assert type(pycode) is pypy.interpreter.pycode.PyCode
w_dic = space.newdict()
pycode.exec_code(space, w_dic, w_dic)
w_ret = space.getitem(w_dic, space.wrap("x"))
ret = space.int_w(w_ret)
assert ret == 42
def test_load_compiled_module_nopathname(self):
space = self.space
mtime = 12345
co = compile('x = 42', '?', 'exec')
cpathname = _testfile(space, importing.get_pyc_magic(space), mtime, co)
w_modulename = space.wrap('somemodule')
stream = streamio.open_file_as_stream(cpathname, "rb")
try:
w_mod = space.wrap(Module(space, w_modulename))
magic = _r_long(stream)
timestamp = _r_long(stream)
w_ret = importing.load_compiled_module(space, w_modulename, w_mod,
None, magic, timestamp,
stream.readall())
finally:
stream.close()
filename = space.getattr(w_ret, space.wrap('__file__'))
assert space.str_w(filename) == u'?'
def test_load_compiled_module(self):
space = self.space
mtime = 12345
co = compile("x = 42", "?", "exec")
cpathname = _testfile(importing.get_pyc_magic(space), mtime, co)
w_modulename = space.wrap("somemodule")
stream = streamio.open_file_as_stream(cpathname, "rb")
try:
w_mod = space.wrap(Module(space, w_modulename))
magic = importing._r_long(stream)
timestamp = importing._r_long(stream)
w_ret = _load_compiled_module(space, w_modulename, w_mod, cpathname, magic, timestamp, stream.readall())
finally:
stream.close()
assert w_mod is w_ret
w_ret = space.getattr(w_mod, space.wrap("x"))
ret = space.int_w(w_ret)
assert ret == 42
def setup_after_space_initialization(self):
"""NOT_RPYTHON"""
if not self.space.config.translating:
self.extra_interpdef('isfake', 'interp_magic.isfake')
self.extra_interpdef('interp_pdb', 'interp_magic.interp_pdb')
if self.space.config.objspace.std.withmethodcachecounter:
self.extra_interpdef('method_cache_counter',
'interp_magic.method_cache_counter')
self.extra_interpdef('reset_method_cache_counter',
'interp_magic.reset_method_cache_counter')
if self.space.config.objspace.std.withmapdict:
self.extra_interpdef('mapdict_cache_counter',
'interp_magic.mapdict_cache_counter')
PYC_MAGIC = get_pyc_magic(self.space)
self.extra_interpdef('PYC_MAGIC', 'space.wrap(%d)' % PYC_MAGIC)
#
from pypy.jit.backend import detect_cpu
model = detect_cpu.autodetect_main_model_and_size()
self.extra_interpdef('cpumodel', 'space.wrap(%r)' % model)
def test_read_compiled_module(self):
space = self.space
mtime = 12345
co = compile('x = 42', '?', 'exec')
cpathname = _testfile(space, importing.get_pyc_magic(space), mtime, co)
stream = streamio.open_file_as_stream(cpathname, "rb")
try:
stream.seek(8, 0)
w_code = importing.read_compiled_module(space, cpathname,
stream.readall())
pycode = w_code
finally:
stream.close()
assert type(pycode) is PyCode
w_dic = space.newdict()
pycode.exec_code(space, w_dic, w_dic)
w_ret = space.getitem(w_dic, space.wrap('x'))
ret = space.int_w(w_ret)
assert ret == 42
def setup_after_space_initialization(self):
"""NOT_RPYTHON"""
if not self.space.config.translating:
self.extra_interpdef('isfake', 'interp_magic.isfake')
self.extra_interpdef('interp_pdb', 'interp_magic.interp_pdb')
if self.space.config.objspace.std.withmethodcachecounter:
self.extra_interpdef('method_cache_counter',
'interp_magic.method_cache_counter')
self.extra_interpdef('reset_method_cache_counter',
'interp_magic.reset_method_cache_counter')
if self.space.config.objspace.std.withmapdict:
self.extra_interpdef('mapdict_cache_counter',
'interp_magic.mapdict_cache_counter')
PYC_MAGIC = get_pyc_magic(self.space)
self.extra_interpdef('PYC_MAGIC', 'space.wrap(%d)' % PYC_MAGIC)
#
from pypy.jit.backend import detect_cpu
model = detect_cpu.autodetect_main_model_and_size()
self.extra_interpdef('cpumodel', 'space.wrap(%r)' % model)
def test_load_compiled_module(self):
space = self.space
mtime = 12345
co = compile('x = 42', '?', 'exec')
cpathname = _testfile(importing.get_pyc_magic(space), mtime, co)
w_modulename = space.wrap('somemodule')
stream = streamio.open_file_as_stream(cpathname, "rb")
try:
w_mod = space.wrap(Module(space, w_modulename))
magic = importing._r_long(stream)
timestamp = importing._r_long(stream)
w_ret = importing.load_compiled_module(space, w_modulename, w_mod,
cpathname, magic, timestamp,
stream.readall())
finally:
stream.close()
assert w_mod is w_ret
w_ret = space.getattr(w_mod, space.wrap('x'))
ret = space.int_w(w_ret)
assert ret == 42
def can_use_pyc(self, space, filename, magic, buf):
if magic != importing.get_pyc_magic(space):
return False
bitfield = importing._get_long(buf[4:8])
if bitfield != 0:
# Hash-based pyc. CPython (and we) currently refuse to handle
# checked hash-based pycs in zips. We could validate hash-based
# pycs against the source, but it seems likely that most people
# putting hash-based pycs in a zipfile will use unchecked ones.
w_imp = space.getbuiltinmodule("_imp")
w_mode = space.getattr(w_imp,
space.newtext("check_hash_based_pycs"))
mode = space.text_w(w_mode)
if mode == "always":
return False
if mode == "default" and bitfield & 0b10:
return False
return True
timestamp = importing._get_long(buf[8:12])
if self.check_newer_pyfile(space, filename[:-1], timestamp):
return False
return True
