def test_rename(self): def f(): return rposix.rename(self.path, self.path2) interpret(f, []) assert not os.path.exists(self.ufilename) assert os.path.exists(self.ufilename + '.new')
def test_set_item(self): f = open(self.tmpname + "s", "w+") f.write("foobar") f.flush() def func(no): m = mmap.mmap(no, 6, access=mmap.ACCESS_WRITE) # def f(m): m[1:3] = u'xx' # py.test.raises(IndexError, f, m) # def f(m): m[1:4] = "zz" # py.test.raises(IndexError, f, m) # def f(m): m[1:6] = "z" * 6 # py.test.raises(IndexError, f, m) # def f(m): m[:2] = "z" * 5 # m[1:3] = 'xx' # assert m.read(6) == "fxxbar" # m.seek(0) m.setitem(0, 'x') assert m.getitem(0) == 'x' m.setitem(-6, 'y') data = m.read(6) assert data == "yoobar" # yxxbar with slice's stuff m.close() interpret(func, [f.fileno()]) f.close()
def test_mix_class_record_instance(): I = Instance("test", ROOT, {"a": Signed}) R = Record({"x": Signed}) L = List(Signed) c1 = runtimeClass(I) c2 = runtimeClass(R) c3 = runtimeClass(L) c4 = runtimeClass(Class) def fn(flag): if flag == 0: return c1 elif flag == 1: return c2 elif flag == 2: return c3 else: return c4 res = interpret(fn, [0], type_system='ootype') assert res is c1 res = interpret(fn, [1], type_system='ootype') assert res is c2 res = interpret(fn, [2], type_system='ootype') assert res is c3 res = interpret(fn, [3], type_system='ootype') assert res is c4
def test_posixpath(): import posixpath def f(): assert posixpath.join("/foo", "bar") == "/foo/bar" assert posixpath.join("/foo", "spam/egg") == "/foo/spam/egg" assert posixpath.join("/foo", "/bar") == "/bar" interpret(f, [])
def test_ntpath(): import ntpath def f(): assert ntpath.join("\\foo", "bar") == "\\foo\\bar" assert ntpath.join("c:\\foo", "spam\\egg") == "c:\\foo\\spam\\egg" assert ntpath.join("c:\\foo", "d:\\bar") == "d:\\bar" interpret(f, [])
def test_rpython_merge_RWeakValueDictionary2(): class A(object): def __init__(self): self.d = RWeakValueDictionary(str, A) def f(self, key): a = A() self.d.set(key, a) return a empty = A() def f(x): a = A() if x: a = empty a2 = a.f("a") assert a.d.get("a") is a2 f(0) interpret(f, [0]) f(1) interpret(f, [1]) def g(x): if x: d = RWeakValueDictionary(str, X) else: d = RWeakValueDictionary(str, Y) d.set("x", X()) py.test.raises(Exception, interpret, g, [1])
def test_find(self): f = open(self.tmpname + "g", "w+") f.write("foobarfoobar\0") f.flush() def func(no): m = mmap.mmap(no, 12) assert m.find("\0", 0, 13) == -1 # no searching past the stop assert m.find("\0", 0, 13, True) == -1 m.close() # m = mmap.mmap(no, 13) assert m.find("b", 0, 7) == 3 assert m.find("z", 0, 7) == -1 assert m.find("o", 11, 13) == -1 assert m.find("ob", 0, 7) == 2 assert m.find("\0", 0, 13) == 12 assert m.find("o", 1, 4) == 1 assert m.find("o", 2, 4) == 2 assert m.find("o", 2, -4) == 2 assert m.find("o", 8, -5) == -1 m.close() func(f.fileno()) interpret(func, [f.fileno()]) f.close()
def test_prebuilt(): c = C(111) b = B(939393) def makeint(n): if n < 0: x = c elif n > 0: x = C(n) else: x = b return x def fn(n): x = makeint(n) if isinstance(x, B): return 'B', x.normalint elif isinstance(x, C): return 'C', x.smallint else: return 'A', 0 res = interpret(fn, [12], taggedpointers=True) assert res.item0 == 'C' assert res.item1 == 12 res = interpret(fn, [-1], taggedpointers=True) assert res.item0 == 'C' assert res.item1 == 111 res = interpret(fn, [0], taggedpointers=True) assert res.item0 == 'B' assert res.item1 == 939393
def test_around_extcall(self): if sys.platform == "win32": py.test.skip('No pipes on windows') import os from rpython.annotator import model as annmodel from rpython.rlib.objectmodel import invoke_around_extcall from rpython.rtyper.extfuncregistry import register_external read_fd, write_fd = os.pipe() try: # we need an external function that is not going to get wrapped around # before()/after() calls, in order to call it from before()/after()... def mywrite(s): os.write(write_fd, s) def llimpl(s): s = ''.join(s.chars) os.write(write_fd, s) register_external(mywrite, [str], annmodel.s_None, 'll_mywrite', llfakeimpl=llimpl, sandboxsafe=True) def before(): mywrite("B") def after(): mywrite("A") def f(): os.write(write_fd, "-") invoke_around_extcall(before, after) os.write(write_fd, "E") interpret(f, []) data = os.read(read_fd, 99) assert data == "-BEA" finally: os.close(write_fd) os.close(read_fd)
def test_key_instance(): class K(object): pass keys = [K(), K(), K()] def g(d): assert d.get(keys[3]) is None x1 = X(); x2 = X(); x3 = X() d.set(keys[0], x1) d.set(keys[1], x2) d.set(keys[2], x3) assert d.get(keys[0]) is x1 assert d.get(keys[1]) is x2 assert d.get(keys[2]) is x3 assert d.get(keys[3]) is None return x1, x3 # x2 dies def f(): keys.append(K()) d = RWeakValueDictionary(K, X) x1, x3 = g(d) rgc.collect(); rgc.collect() assert d.get(keys[0]) is x1 assert d.get(keys[1]) is None assert d.get(keys[2]) is x3 assert d.get(keys[3]) is None d.set(keys[0], None) assert d.get(keys[0]) is None assert d.get(keys[1]) is None assert d.get(keys[2]) is x3 assert d.get(keys[3]) is None f() interpret(f, [])
def test_overflow_bug(): CASE = [ (144, 248), # \ cycle (248, 144), # / (488, 416), # \ two usages of -488 (488, 480), # / (488, 488), # - one self-application of -488 ] class FakeAssembler: def regalloc_mov(self, src, dst): print "mov", src, dst def regalloc_push(self, x): print "push", x def regalloc_pop(self, x): print "pop", x def regalloc_immedmem2mem(self, x, y): print "?????????????????????????" def main(): srclocs = [FrameLoc(9999, x, 'i') for x,y in CASE] dstlocs = [FrameLoc(9999, y, 'i') for x,y in CASE] remap_frame_layout(FakeAssembler(), srclocs, dstlocs, eax) # it works when run directly main() # but it used to crash when translated, # because of a -sys.maxint-2 overflowing to sys.maxint from rpython.rtyper.test.test_llinterp import interpret interpret(main, [])
def test_make_sure_not_resized_annorder(): def f(n): if n > 5: result = None else: result = [1,2,3] make_sure_not_resized(result) interpret(f, [10])
def test_bogus_makekey(): class X: pass class Y: pass def g(): X(); Y() RWeakValueDictionary(str, X).get("foobar") RWeakValueDictionary(int, Y).get(42) interpret(g, [])
def test_operation_with_float(): def f(x): assert r_longlong(x) + 0.5 == 43.5 assert r_longlong(x) - 0.5 == 42.5 assert r_longlong(x) * 0.5 == 21.5 assert r_longlong(x) / 0.8 == 53.75 f(43) interpret(f, [43])
def test_string_annotation(): def oof(lst): return lst.ll_strlen() s = new(String) assert interpret(oof, [s], type_system='ootype') == 0 s = make_string('foo') assert interpret(oof, [s], type_system='ootype') == 3
def test_stat(self): def f(): return rposix_stat.stat(self.path).st_mtime if sys.platform == 'win32': # double vs. float, be satisfied with sub-millisec resolution assert abs(interpret(f, []) - os.stat(self.ufilename).st_mtime) < 1e-4 else: assert interpret(f, []) == os.stat(self.ufilename).st_mtime
def test_check_nonneg(): def f(x): assert x >= 5 check_nonneg(x) interpret(f, [9]) def g(x): check_nonneg(x-1) py.test.raises(IntegerCanBeNegative, interpret, g, [9])
def test_putenv(self): from rpython.rlib import rposix_environ def f(): rposix.putenv(self.path, self.path) rposix.unsetenv(self.path) interpret(f, [], # does not crash malloc_check=rposix_environ.REAL_UNSETENV)
def test_fchmodat(self): def f(dirfd): return rposix.fchmodat('test_open_ascii', 0777, dirfd) dirfd = os.open(os.path.dirname(self.ufilename), os.O_RDONLY) try: interpret(f, [dirfd]) # does not crash finally: os.close(dirfd)
def test_cast_gcref_to_int(): A = lltype.GcArray(Address) def f(): ptr = lltype.malloc(A, 10) gcref = lltype.cast_opaque_ptr(GCREF, ptr) adr = lltype.cast_ptr_to_int(gcref) assert adr == lltype.cast_ptr_to_int(ptr) f() interpret(f, [])
def test_contains_with_hash(): def f(i): d = {i + .5: 5} assert contains_with_hash(d, i + .5, compute_hash(i + .5)) assert not contains_with_hash(d, i + .3, compute_hash(i + .3)) return 0 f(29) interpret(f, [29])
def test_rpython_merge_RWeakKeyDictionary4(): def g(x): if x: d = RWeakKeyDictionary(KX, VX) else: d = RWeakKeyDictionary(KX, VY) d.set(KX(), VX()) with py.test.raises(UnionError): interpret(g, [1])
def test_has_weakref_support(): assert has_weakref_support() res = interpret(lambda: has_weakref_support(), [], **{'translation.rweakref': True}) assert res == True res = interpret(lambda: has_weakref_support(), [], **{'translation.rweakref': False}) assert res == False
def test_unlinkat(self): def f(dirfd): return rposix.unlinkat('test_open_ascii', dir_fd=dirfd) dirfd = os.open(os.path.dirname(self.ufilename), os.O_RDONLY) try: interpret(f, [dirfd]) finally: os.close(dirfd) assert not os.path.exists(self.ufilename)
def test_utimensat(self): def f(dirfd): return rposix.utimensat('test_open_ascii', 0, rposix.UTIME_NOW, 0, rposix.UTIME_NOW, dir_fd=dirfd) dirfd = os.open(os.path.dirname(self.ufilename), os.O_RDONLY) try: interpret(f, [dirfd]) # does not crash finally: os.close(dirfd)
def test_rpython_merge_RWeakValueDictionary3(): def g(x): if x: d = RWeakValueDictionary(str, X) else: d = RWeakValueDictionary(str, Y) d.set("x", X()) with py.test.raises(UnionError): interpret(g, [1])
def test_format(): def fn(n): if n > 0: x = B(n) else: x = C(n) return '%r' % (x,) res = interpret(fn, [-832], taggedpointers=True) assert ''.join(res.chars) == '<unboxed -832>' res = interpret(fn, [1], taggedpointers=True) assert ''.join(res.chars).startswith('<B object')
def test_method(): def fn(n): if n > 0: x = B(n) else: x = C(n) return x.meth(100) res = interpret(fn, [1000], taggedpointers=True) assert res == 1102 res = interpret(fn, [-1000], taggedpointers=True) assert res == -897
def test_select_timeout(): if os.name == 'nt': py.test.skip('cannot select on file handles on windows') from time import time def f(): # once there was a bug where the sleeping time was doubled a = time() iwtd, owtd, ewtd = select([], [], [], 5.0) diff = time() - a assert 4.8 < diff < 9.0 interpret(f, [])
def test_hash_equal_whatever_lltype(): s1 = rstr.mallocstr(2) s2 = rstr.mallocstr(2) s1.chars[0] = 'x'; s1.chars[1] = 'y' s2.chars[0] = 'x'; s2.chars[1] = 'y' def fn(x): assert hash_whatever(lltype.typeOf(x), x) == 42 assert (hash_whatever(lltype.typeOf(s1), s1) == hash_whatever(lltype.typeOf(s2), s2)) assert equal_whatever(lltype.typeOf(s1), s1, s2) fn(42) interpret(fn, [42], type_system='lltype')
def test_get_untagged_value(): def fn1(n): return C(n).get_untagged_value() res = interpret(fn1, [42], taggedpointers=True) assert res == 42
def test_ptradd_interpret(): interpret(test_ptradd, [])
def test_rpython_RWeakValueDictionary(): interpret(make_test(loop=12), [])
def inner(arg0=-1, arg1=-1): return interpret(f, [i, arg0, arg1])
def test_simple(): def dummyfn(x): return x + 1 res = interpret(dummyfn, [7]) assert res == 8
def test_page_size(self): def f(): assert mmap.PAGESIZE > 0 assert isinstance(mmap.PAGESIZE, int) interpret(f, [])
def run(self, func, args): return interpret(func, args)
def test_rpython_RWeakValueDictionary_int(): interpret(make_test(loop=12, keyclass=int), [])
def test_unlink(self): def f(): return rposix.unlink(self.path) interpret(f, []) assert not os.path.exists(self.ufilename)
def test_annotation(): diff = interpret(timer, []) assert diff > 1000
def test_putenv(self): def f(): rposix.putenv(self.path, self.path) rposix.unsetenv(self.path) interpret(f, []) # does not crash
def test_byteswap_interpret(): interpret(test_byteswap, [])
def test_attribute(): def fn1(n): return C(n).smallint res = interpret(fn1, [42], taggedpointers=True) assert res == 42
def test_access(self): def f(): return rposix.access(self.path, os.R_OK) assert interpret(f, []) == 1
def interpret(self, f, args): return interpret(f, args, type_system='lltype')
def test_chmod(self): def f(): return rposix.chmod(self.path, 0777) interpret(f, []) # does not crash
def test_utime(self): def f(): return rposix.utime(self.path, None) interpret(f, []) # does not crash