def test_pack_float(self):
def pack(x, size):
result = []
ieee.pack_float(result, x, size, False)
l = []
for x in result:
for c in x:
l.append(str(ord(c)))
return ','.join(l)
c_pack = compile(pack, [float, int])
def unpack(s):
l = s.split(',')
s = ''.join([chr(int(x)) for x in l])
return ieee.unpack_float(s, False)
c_unpack = compile(unpack, [str])
def check_roundtrip(x, size):
s = c_pack(x, size)
if not isnan(x):
# pack uses copysign which is ambiguous for NAN
assert s == pack(x, size)
assert unpack(s) == x
assert c_unpack(s) == x
else:
assert isnan(unpack(s))
assert isnan(c_unpack(s))
for size in [2, 4, 8]:
check_roundtrip(123.4375, size)
check_roundtrip(-123.4375, size)
check_roundtrip(INFINITY, size)
check_roundtrip(NAN, size)
def test_translated(self):
from rpython.translator.c.test.test_genc import compile
def func(no):
m = mmap.mmap(no, 1)
r = m.read_byte()
m.close()
return r
compile(func, [int], gcpolicy='boehm')
def test_utime_negative_fraction(self):
def f(fname, t1):
os.utime(fname, (t1, t1))
fname = udir.join('test_utime_negative_fraction.txt')
fname.ensure()
t1 = -123.75
compile(f, (str, float))(str(fname), t1)
got = os.stat(str(fname)).st_mtime
assert got == -123 or got == -123.75
def test_os_path_isdir():
directory = "./."
def fn():
return os.path.isdir(directory)
f = compile(fn, [])
assert f() == True
directory = "some/random/name"
def fn():
return os.path.isdir(directory)
f = compile(fn, [])
assert f() == False
def test_utimes():
if os.name != 'nt':
py.test.skip('Windows specific feature')
# Windows support centiseconds
def f(fname, t1):
os.utime(fname, (t1, t1))
fname = udir.join('test_utimes.txt')
fname.ensure()
t1 = 1159195039.25
compile(f, (str, float))(str(fname), t1)
assert t1 == os.stat(str(fname)).st_mtime
def test_utimes(self):
# Windows support centiseconds
def f(fname, t1):
os.utime(fname, (t1, t1))
fname = udir.join('test_utimes.txt')
fname.ensure()
t1 = 1159195039.25
compile(f, (str, float))(str(fname), t1)
assert t1 == os.stat(str(fname)).st_mtime
t1 = 5000000000.0
compile(f, (str, float))(str(fname), t1)
assert t1 == os.stat(str(fname)).st_mtime
def test_translate_pypackrat():
from rpython.rlib.parsing.pypackrat import PackratParser
class parser(PackratParser):
"""
expr:
additive;
additive:
a = additive
'-'
b = multitive
return {'(%s - %s)' % (a, b)}
| multitive;
multitive:
a = multitive
'*'
b = simple
return {'(%s * %s)' % (a, b)}
| simple;
simple:
('0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9');
"""
print parser._code
def parse(s):
p = parser(s)
return p.expr()
res = parse("5-5-5")
assert res == '((5 - 5) - 5)'
func = compile(parse, [str])
res = func("5-5-5")
assert res == '((5 - 5) - 5)'
def test_translate_netdb_lock_thread():
def f():
rsocket_startup()
gethostbyaddr("localhost")
return 0
fc = compile(f, [], thread=True)
assert fc() == 0
class TestLLTermios(object):
def run(self, arg, expected):
import pexpect
child = pexpect.spawn(str(arg.builder.executable_name))
child.expect(re.escape(expected))
assert child.status is None
def test_tcgetattr(self):
from rpython.translator.c.test.test_genc import compile
from rpython.rlib import rtermios
def runs_tcgetattr():
tpl = list(rtermios.tcgetattr(2)[:-1])
return str(tpl)
fn = compile(runs_tcgetattr, [], backendopt=False)
self.run(fn, TCGETATTR)
def test_tcgetattr2(self):
from rpython.translator.c.test.test_genc import compile
from rpython.rlib import rtermios
import os, errno
def runs_tcgetattr():
fd = os.open('.', 0, 0777)
try:
rtermios.tcgetattr(fd)
except OSError, e:
assert e.errno == errno.ENOTTY
print "ok"
fn = compile(runs_tcgetattr, [], backendopt=False)
self.run(fn, "ok")
def test_getcwd():
def does_stuff():
return os.getcwd()
f1 = compile(does_stuff, [])
res = f1()
assert res == os.getcwd()
def test_translate_netdb_lock_thread():
def f():
rsocket_startup()
gethostbyaddr("localhost")
return 0
fc = compile(f, [], thread=True)
assert fc() == 0
def test_high_precision_stat_time():
def f():
st = os.stat('.')
# should be supported on all platforms, but give a result whose
# precision might be lower than full nanosecond
highprec = rposix_stat.get_stat_ns_as_bigint(st, "ctime")
return '%s;%s' % (st.st_ctime, highprec.str())
fc = compile(f, [])
as_string = fc()
asfloat, highprec = as_string.split(';')
asfloat = float(asfloat)
highprec = int(highprec)
st = os.stat('.')
assert abs(asfloat - st.st_ctime) < 500e-9
assert abs(highprec - int(st.st_ctime * 1e9)) < 500
assert abs(rposix_stat.get_stat_ns_as_bigint(st, "ctime").tolong()
- st.st_ctime * 1e9) < 3
if rposix_stat.TIMESPEC is not None:
with lltype.scoped_alloc(rposix_stat.STAT_STRUCT.TO) as stresult:
rposix_stat.c_stat(".", stresult)
if sys.platform == "darwin":
assert 0 <= stresult.c_st_ctimespec.c_tv_nsec <= 999999999
assert highprec == (int(stresult.c_st_ctimespec.c_tv_sec) * 1000000000
+ int(stresult.c_st_ctimespec.c_tv_nsec))
else:
assert 0 <= stresult.c_st_ctim.c_tv_nsec <= 999999999
assert highprec == (int(stresult.c_st_ctim.c_tv_sec) * 1000000000
+ int(stresult.c_st_ctim.c_tv_nsec))
def test_math():
f = compile(fn, [])
res = f()
if res >= 0:
py.test.fail(repr(MathTests.TESTCASES[res]))
else:
assert res == -42
def test_os_setpgrp():
def does_stuff():
return os.setpgrp()
f1 = compile(does_stuff, [])
res = f1()
assert res == os.setpgrp()
def test_dictlike_environ_delitem():
def fn(s1, s2, s3, s4, s5):
for n in range(10):
os.environ[s1] = "t1"
os.environ[s2] = "t2"
os.environ[s3] = "t3"
os.environ[s4] = "t4"
os.environ[s5] = "t5"
del os.environ[s3]
del os.environ[s1]
del os.environ[s2]
del os.environ[s4]
try:
del os.environ[s2]
except KeyError:
pass
else:
raise Exception("should have raised!")
# os.environ[s5] stays
func = compile(fn, [str] * 5)
func(
"PYPY_TEST_DICTLIKE_ENVDEL1",
"PYPY_TEST_DICTLIKE_ENVDEL_X",
"PYPY_TEST_DICTLIKE_ENVDELFOO",
"PYPY_TEST_DICTLIKE_ENVDELBAR",
"PYPY_TEST_DICTLIKE_ENVDEL5",
)
def test_os_getpid():
def does_stuff():
return os.getpid()
f1 = compile(does_stuff, [])
res = f1()
assert res != os.getpid()
def test_float_to_str():
def fn(f):
return str(f)
f = compile(fn, [float])
res = f(1.5)
assert eval(res) == 1.5
def test_system():
def does_stuff(cmd):
return os.system(cmd)
f1 = compile(does_stuff, [str])
res = f1("echo hello")
assert res == 0
def test_translate_simple(self):
digits = RangeExpression("0", "9")
lower = RangeExpression("a", "z")
upper = RangeExpression("A", "Z")
keywords = StringExpression("if") | StringExpression("else") | StringExpression("def") | StringExpression("class")
underscore = StringExpression("_")
atoms = lower + (upper | lower | digits | underscore).kleene()
vars = underscore | (upper + (upper | lower | underscore | digits).kleene())
integers = StringExpression("0") | (RangeExpression("1", "9") + digits.kleene())
white = StringExpression(" ")
l1 = self.get_lexer([keywords, atoms, vars, integers, white], ["KEYWORD", "ATOM", "VAR", "INT", "WHITE"])
l2 = self.get_lexer([keywords, atoms, vars, integers, white], ["KEYWORD", "ATOM", "VAR", "INT", "WHITE"], ["WHITE"])
def lex(s, ignore=False):
if ignore:
tokens = l2.tokenize(s)
else:
tokens = l1.tokenize(s)
return "-%-".join([t.name for t in tokens])
res = lex("if A a 12341 0 else").split("-%-")
assert res == ("KEYWORD WHITE VAR WHITE ATOM WHITE INT WHITE "
"INT WHITE KEYWORD").split()
res = lex("if A a 12341 0 else", True).split("-%-")
assert res == "KEYWORD VAR ATOM INT INT KEYWORD".split()
func = compile(lex, [str, bool])
res = lex("if A a 12341 0 else", False).split("-%-")
assert res == ("KEYWORD WHITE VAR WHITE ATOM WHITE INT WHITE "
"INT WHITE KEYWORD").split()
res = lex("if A a 12341 0 else", True).split("-%-")
assert res == "KEYWORD VAR ATOM INT INT KEYWORD".split()
def test_unset_error():
import sys
def foo(x):
if x:
os.environ['TEST'] = 'STRING'
assert os.environ['TEST'] == 'STRING'
del os.environ['TEST']
try:
del os.environ['key=']
except (KeyError, OSError):
return 1
return 2
else:
return 0
f = compile(foo, [int], backendopt=False)
if sys.platform.startswith('win'):
# Do not open error dialog box
import ctypes
SEM_NOGPFAULTERRORBOX = 0x0002 # From MSDN
old_err_mode = ctypes.windll.kernel32.GetErrorMode()
new_err_mode = old_err_mode | SEM_NOGPFAULTERRORBOX
ctypes.windll.kernel32.SetErrorMode(new_err_mode)
assert f(1) == 1
if sys.platform.startswith('win'):
ctypes.windll.kernel32.SetErrorMode(old_err_mode)
def test_math():
f = compile(fn, [])
res = f()
if res >= 0:
py.test.fail(repr(MathTests.TESTCASES[res]))
else:
assert res == -42
def test_os_stat():
filename = str(py.path.local(__file__))
has_blksize = hasattr(os.stat_result, "st_blksize")
has_blocks = hasattr(os.stat_result, "st_blocks")
def call_stat():
st = os.stat(filename)
res = (st[0], st.st_ino, st.st_ctime)
if has_blksize:
res += (st.st_blksize,)
if has_blocks:
res += (st.st_blocks,)
return str(res)
f = compile(call_stat, [])
res = eval(f())
assert res[0] == os.stat(filename).st_mode
assert res[1] == os.stat(filename).st_ino
st_ctime = res[2]
if isinstance(st_ctime, float):
assert (st_ctime - os.stat(filename).st_ctime) < 0.1
else:
assert st_ctime == int(os.stat(filename).st_ctime)
if has_blksize:
assert res[3] == os.stat(filename).st_blksize
if has_blocks:
assert res[4] == os.stat(filename).st_blocks
def test_gcref():
if sys.platform == "darwin":
py.test.skip("'boehm' may crash")
S = lltype.GcStruct("S", ("x", lltype.Signed))
s = lltype.malloc(S)
s.x = 123
g1 = lltype.cast_opaque_ptr(GCREF, s)
g2 = lltype.cast_opaque_ptr(GCREF, lltype.nullptr(S))
def f2(x):
if x > 0:
return g1
else:
return g2
def f(x):
gref = f2(x)
g = lltype.cast_opaque_ptr(lltype.Ptr(S), gref)
if g:
return g.x
else:
return -42
fn = compile(f, [int], gcpolicy="boehm")
assert fn(3) == 123
assert fn(-3) == -42
def test_vmprof_execute_code_2():
class MyCode:
pass
try:
rvmprof.register_code_object_class(MyCode, lambda code: 'some code')
except rvmprof.VMProfPlatformUnsupported:
pass
class A:
pass
@rvmprof.vmprof_execute_code("xcode2", lambda num, code: code,
result_class=A)
def main(num, code):
print num
return A()
def f():
a = main(7, MyCode())
assert isinstance(a, A)
return 0
assert f() == 0
fn = compile(f, [])
assert fn() == 0
def test_os_stat():
filename = str(py.path.local(__file__))
has_blksize = hasattr(os.stat_result, 'st_blksize')
has_blocks = hasattr(os.stat_result, 'st_blocks')
def call_stat():
st = os.stat(filename)
res = (st[0], st.st_ino, st.st_ctime)
if has_blksize: res += (st.st_blksize, )
if has_blocks: res += (st.st_blocks, )
return str(res)
f = compile(call_stat, [])
res = eval(f())
assert res[0] == os.stat(filename).st_mode
# windows zeros out st_ino in the app-level os.stat
if sys.platform != 'win32':
assert res[1] == os.stat(filename).st_ino
st_ctime = res[2]
if isinstance(st_ctime, float):
assert (st_ctime - os.stat(filename).st_ctime) < 0.1
else:
assert st_ctime == int(os.stat(filename).st_ctime)
if has_blksize:
assert res[3] == os.stat(filename).st_blksize
if has_blocks:
assert res[4] == os.stat(filename).st_blocks
def test_translate_netdb_lock():
def f():
gethostbyaddr("localhost")
return 0
fc = compile(f, [])
assert fc() == 0
def test_strerror():
def does_stuff(n):
return os.strerror(n)
f1 = compile(does_stuff, [int])
for i in range(4):
res = f1(i)
assert res == os.strerror(i)
def test_pipe_dup_dup2():
def does_stuff():
a, b = os.pipe()
c = os.dup(a)
d = os.dup(b)
assert a != b
assert a != c
assert a != d
assert b != c
assert b != d
assert c != d
os.close(c)
os.dup2(d, c)
e, f = os.pipe()
assert e != a
assert e != b
assert e != c
assert e != d
assert f != a
assert f != b
assert f != c
assert f != d
assert f != e
os.close(a)
os.close(b)
os.close(c)
os.close(d)
os.close(e)
os.close(f)
return 42
f1 = compile(does_stuff, [])
res = f1()
assert res == 42
def test_debug_print_traceback():
from rpython.translator.c.test.test_genc import compile
from rpython.rtyper.lltypesystem import lltype
from rpython.rtyper.lltypesystem.lloperation import llop
def ggg(n):
if n < 10:
ggg(n + 1)
else:
raise ValueError
def recovery():
llop.debug_print_traceback(lltype.Void)
recovery._dont_inline_ = True
def fff():
try:
ggg(0)
except:
recovery()
fn = compile(fff, [], return_stderr=True)
stderr = fn()
assert 'RPython traceback:\n' in stderr
assert stderr.count('entry_point') == 1
assert stderr.count('ggg') == 11
assert stderr.count('recovery') == 0
def test_chdir():
def does_stuff(path):
os.chdir(path)
return os.getcwd()
f1 = compile(does_stuff, [str])
# different on windows please
assert f1('/tmp') == os.path.realpath('/tmp')
def test_os_access():
filename = str(py.path.local(__file__))
def call_access(path, mode):
return os.access(path, mode)
f = compile(call_access, [str, int])
for mode in os.R_OK, os.W_OK, os.X_OK, (os.R_OK | os.W_OK | os.X_OK):
assert f(filename, mode) == os.access(filename, mode)
def test_os_isatty():
def call_isatty(fd):
return os.isatty(fd)
f = compile(call_isatty, [int])
assert f(0) == os.isatty(0)
assert f(1) == os.isatty(1)
assert f(2) == os.isatty(2)
def test_unset_error():
import sys
def foo(x):
if x:
os.environ['TEST'] = 'STRING'
assert os.environ['TEST'] == 'STRING'
del os.environ['TEST']
try:
del os.environ['key=']
except OSError:
return 1
return 2
else:
return 0
f = compile(foo, [int], backendopt=False)
if sys.platform.startswith('win'):
# Do not open error dialog box
import ctypes
SEM_NOGPFAULTERRORBOX = 0x0002 # From MSDN
old_err_mode = ctypes.windll.kernel32.GetErrorMode()
new_err_mode = old_err_mode | SEM_NOGPFAULTERRORBOX
ctypes.windll.kernel32.SetErrorMode(new_err_mode)
assert f(1) == 1
if sys.platform.startswith('win'):
ctypes.windll.kernel32.SetErrorMode(old_err_mode)
def test_largefile():
if not hasattr(os, 'ftruncate'):
py.test.skip("this os has no ftruncate :-(")
need_sparse_files()
filename = str(udir.join('test_largefile'))
r4800000000 = r_longlong(4800000000L)
r4900000000 = r_longlong(4900000000L)
r5000000000 = r_longlong(5000000000L)
r5200000000 = r_longlong(5200000000L)
r9900000000 = r_longlong(9900000000L)
r10000000000 = r_longlong(10000000000L)
def does_stuff():
fd = os.open(filename, os.O_RDWR | os.O_CREAT, 0666)
os.ftruncate(fd, r10000000000)
res = os.lseek(fd, r9900000000, 0)
assert res == r9900000000
res = os.lseek(fd, -r5000000000, 1)
assert res == r4900000000
res = os.lseek(fd, -r5200000000, 2)
assert res == r4800000000
os.close(fd)
try:
os.lseek(fd, 0, 0)
except OSError:
pass
else:
print "DID NOT RAISE"
raise AssertionError
st = os.stat(filename)
assert st.st_size == r10000000000
does_stuff()
os.unlink(filename)
f1 = compile(does_stuff, [])
f1()
os.unlink(filename)
def get_interp(self):
def f(testfile):
interp = Interpreter({'no-exception-jseval': True})
shell_src = load_file(str(shellpath))
interp.run_src(shell_src)
test_src = load_file(testfile)
interp.run_src(test_src)
global_object = interp.global_object
testcases = global_object.get(u'testcases')
testcount = testcases.get(u'length').ToInt32()
run_test_func = global_object.get(u'run_test')
test_results = []
for number in xrange(testcount):
w_test_number = _w(number)
result_obj = run_test_func.Call(args=[w_test_number])
result_passed = result_obj.get(u'passed').to_boolean()
result_reason = str(result_obj.get(u'reason').to_string())
test_results.append({'number': number, 'passed': result_passed, 'reason': result_reason})
return test_results
if self.do_compile:
if self.compiled_interpreter is None:
from rpython.translator.c.test.test_genc import compile
self.compiled_interpreter = compile(f, [str])
return self.compiled_interpreter
else:
return f
def test_stat_result():
import os
from rpython.translator.c.test.test_genc import compile
from rpython.rtyper.module.ll_os_stat import s_StatResult
marshal_stat_result = get_marshaller(s_StatResult)
unmarshal_stat_result = get_unmarshaller(s_StatResult)
def f(path):
st = os.stat(path)
buf = []
marshal_stat_result(buf, st)
buf = ''.join(buf)
st2 = unmarshal_stat_result(buf)
assert st2.st_mode == st.st_mode
assert st2[9] == st[9]
return buf
fn = compile(f, [str])
res = fn('.')
st = os.stat('.')
sttuple = marshal.loads(res)
assert sttuple[0] == st[0]
assert sttuple[1] == st[1]
assert sttuple[2] == st[2]
assert sttuple[3] == st[3]
assert sttuple[4] == st[4]
assert sttuple[5] == st[5]
assert len(sttuple) == 10
def test_translate_compiled_parser():
r0 = Rule("expression", [["additive", "EOF"]])
r1 = Rule("additive", [["multitive", "+", "additive"], ["multitive"]])
r2 = Rule("multitive", [["primary", "*", "multitive"], ["primary"]])
r3 = Rule("primary", [["(", "additive", ")"], ["decimal"]])
r4 = Rule("decimal", [[symb] for symb in "0123456789"])
p = PackratParser([r0, r1, r2, r3, r4], "expression")
compiler = ParserCompiler(p)
kls = compiler.compile()
p = kls()
tree = p.parse([
Token(c, i, SourcePos(i, 0, i))
for i, c in enumerate(list("2*(3+4)") + ["EOF"])
])
data = [
Token(c, i, SourcePos(i, 0, i))
for i, c in enumerate(list("2*(3+4)") + ["EOF"])
]
print tree
p = kls()
def parse(choose):
tree = p.parse(data)
return tree.symbol + " " + "-%-".join(
[c.symbol for c in tree.children])
func = compile(parse, [bool])
res1 = parse(True)
res2 = func(True)
assert res1 == res2
def test_links():
import stat
tmpfile1 = str(udir.join('test_links_1.txt'))
tmpfile2 = str(udir.join('test_links_2.txt'))
tmpfile3 = str(udir.join('test_links_3.txt'))
f = open(tmpfile1, 'w')
f.close()
def does_stuff():
os.symlink(tmpfile1, tmpfile2)
os.link(tmpfile1, tmpfile3)
assert os.readlink(tmpfile2) == tmpfile1
flag= 0
st = os.lstat(tmpfile1)
flag = flag*10 + stat.S_ISREG(st[0])
flag = flag*10 + stat.S_ISLNK(st[0])
st = os.lstat(tmpfile2)
flag = flag*10 + stat.S_ISREG(st[0])
flag = flag*10 + stat.S_ISLNK(st[0])
st = os.lstat(tmpfile3)
flag = flag*10 + stat.S_ISREG(st[0])
flag = flag*10 + stat.S_ISLNK(st[0])
return flag
f1 = compile(does_stuff, [])
res = f1()
assert res == 100110
assert os.path.islink(tmpfile2)
assert not os.path.islink(tmpfile3)
def test_dictlike_environ_delitem():
def fn(s1, s2, s3, s4, s5):
for n in range(10):
os.environ[s1] = 't1'
os.environ[s2] = 't2'
os.environ[s3] = 't3'
os.environ[s4] = 't4'
os.environ[s5] = 't5'
del os.environ[s3]
del os.environ[s1]
del os.environ[s2]
del os.environ[s4]
try:
del os.environ[s2]
except KeyError:
pass
else:
raise Exception("should have raised!")
# os.environ[s5] stays
func = compile(fn, [str] * 5)
func('PYPY_TEST_DICTLIKE_ENVDEL1',
'PYPY_TEST_DICTLIKE_ENVDEL_X',
'PYPY_TEST_DICTLIKE_ENVDELFOO',
'PYPY_TEST_DICTLIKE_ENVDELBAR',
'PYPY_TEST_DICTLIKE_ENVDEL5')
def test_vmprof_execute_code_2():
class MyCode:
pass
try:
rvmprof.register_code_object_class(MyCode, lambda code: 'some code')
except rvmprof.VMProfPlatformUnsupported:
pass
class A:
pass
@rvmprof.vmprof_execute_code("xcode2", lambda num, code: code,
result_class=A)
def main(num, code):
print num
return A()
def f():
a = main(7, MyCode())
assert isinstance(a, A)
return 0
assert f() == 0
fn = compile(f, [])
assert fn() == 0
def test_getcwd():
def does_stuff():
return os.getcwd()
f1 = compile(does_stuff, [])
res = f1()
assert res == os.getcwd()
def test_gcref():
if sys.platform == 'darwin':
py.test.skip("'boehm' may crash")
S = lltype.GcStruct("S", ("x", lltype.Signed))
s = lltype.malloc(S)
s.x = 123
g1 = lltype.cast_opaque_ptr(GCREF, s)
g2 = lltype.cast_opaque_ptr(GCREF, lltype.nullptr(S))
def f2(x):
if x > 0:
return g1
else:
return g2
def f(x):
gref = f2(x)
g = lltype.cast_opaque_ptr(lltype.Ptr(S), gref)
if g:
return g.x
else:
return -42
fn = compile(f, [int], gcpolicy='boehm')
assert fn(3) == 123
assert fn(-3) == -42
def test_debug_print_traceback():
from rpython.translator.c.test.test_genc import compile
from rpython.rtyper.lltypesystem import lltype
from rpython.rtyper.lltypesystem.lloperation import llop
def ggg(n):
if n < 10:
ggg(n + 1)
else:
raise ValueError
def recovery():
llop.debug_print_traceback(lltype.Void)
recovery._dont_inline_ = True
def fff():
try:
ggg(0)
except:
recovery()
fn = compile(fff, [], return_stderr=True)
stderr = fn()
assert 'RPython traceback:\n' in stderr
assert stderr.count('entry_point') == 1
assert stderr.count('ggg') == 11
assert stderr.count('recovery') == 0
def test_os_setpgrp():
def does_stuff():
return os.setpgrp()
f1 = compile(does_stuff, [])
res = f1()
assert res == os.setpgrp()
def test_links():
import stat
tmpfile1 = str(udir.join('test_links_1.txt'))
tmpfile2 = str(udir.join('test_links_2.txt'))
tmpfile3 = str(udir.join('test_links_3.txt'))
f = open(tmpfile1, 'w')
f.close()
def does_stuff():
os.symlink(tmpfile1, tmpfile2)
os.link(tmpfile1, tmpfile3)
assert os.readlink(tmpfile2) == tmpfile1
flag = 0
st = os.lstat(tmpfile1)
flag = flag * 10 + stat.S_ISREG(st[0])
flag = flag * 10 + stat.S_ISLNK(st[0])
st = os.lstat(tmpfile2)
flag = flag * 10 + stat.S_ISREG(st[0])
flag = flag * 10 + stat.S_ISLNK(st[0])
st = os.lstat(tmpfile3)
flag = flag * 10 + stat.S_ISREG(st[0])
flag = flag * 10 + stat.S_ISLNK(st[0])
return flag
f1 = compile(does_stuff, [])
res = f1()
assert res == 100110
assert os.path.islink(tmpfile2)
assert not os.path.islink(tmpfile3)
def test_pipe_dup_dup2():
def does_stuff():
a, b = os.pipe()
c = os.dup(a)
d = os.dup(b)
assert a != b
assert a != c
assert a != d
assert b != c
assert b != d
assert c != d
os.close(c)
os.dup2(d, c)
e, f = os.pipe()
assert e != a
assert e != b
assert e != c
assert e != d
assert f != a
assert f != b
assert f != c
assert f != d
assert f != e
os.close(a)
os.close(b)
os.close(c)
os.close(d)
os.close(e)
os.close(f)
return 42
f1 = compile(does_stuff, [])
res = f1()
assert res == 42
def test_os_getpid():
def does_stuff():
return os.getpid()
f1 = compile(does_stuff, [])
res = f1()
assert res != os.getpid()
def test_float_to_str():
def fn(f):
return str(f)
f = compile(fn, [float])
res = f(1.5)
assert eval(res) == 1.5
def test_system():
def does_stuff(cmd):
return os.system(cmd)
f1 = compile(does_stuff, [str])
res = f1("echo hello")
assert res == 0
def test_translate_pypackrat():
from rpython.rlib.parsing.pypackrat import PackratParser
class parser(PackratParser):
"""
expr:
additive;
additive:
a = additive
'-'
b = multitive
return {'(%s - %s)' % (a, b)}
| multitive;
multitive:
a = multitive
'*'
b = simple
return {'(%s * %s)' % (a, b)}
| simple;
simple:
('0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9');
"""
print parser._code
def parse(s):
p = parser(s)
return p.expr()
res = parse("5-5-5")
assert res == '((5 - 5) - 5)'
func = compile(parse, [str])
res = func("5-5-5")
assert res == '((5 - 5) - 5)'
def test_stat_result():
import os
from rpython.translator.c.test.test_genc import compile
from rpython.rlib.rposix_stat import s_StatResult
marshal_stat_result = get_marshaller(s_StatResult)
unmarshal_stat_result = get_unmarshaller(s_StatResult)
def f(path):
st = os.stat(path)
buf = []
marshal_stat_result(buf, st)
buf = ''.join(buf)
st2 = unmarshal_stat_result(buf)
assert st2.st_mode == st.st_mode
assert st2[9] == st[9]
return buf
fn = compile(f, [str])
res = fn('.')
st = os.stat('.')
sttuple = marshal.loads(res)
assert sttuple[0] == st[0]
assert sttuple[1] == st[1]
assert sttuple[2] == st[2]
assert sttuple[3] == st[3]
assert sttuple[4] == st[4]
assert sttuple[5] == st[5]
assert len(sttuple) == 10
def test_strerror():
def does_stuff(n):
return os.strerror(n)
f1 = compile(does_stuff, [int])
for i in range(4):
res = f1(i)
assert res == os.strerror(i)
def test_os_isatty():
def call_isatty(fd):
return os.isatty(fd)
f = compile(call_isatty, [int])
assert f(0) == os.isatty(0)
assert f(1) == os.isatty(1)
assert f(2) == os.isatty(2)
def test_utimes():
if os.name != 'nt':
py.test.skip('Windows specific feature')
# Windows support centiseconds
def f(fname, t1):
os.utime(fname, (t1, t1))
fname = udir.join('test_utimes.txt')
fname.ensure()
t1 = 1159195039.25
compile(f, (str, float))(str(fname), t1)
assert t1 == os.stat(str(fname)).st_mtime
if sys.version_info < (2, 7):
py.test.skip('requires Python 2.7')
t1 = 5000000000.0
compile(f, (str, float))(str(fname), t1)
assert t1 == os.stat(str(fname)).st_mtime
def test_compile_c(self):
function = compile(self.get_unit, [])
unit = function()
if platform.processor() in ('x86', 'x86_64'):
assert unit == rtimer.UNIT_TSC
else:
assert unit in (rtimer.UNIT_TSC, rtimer.UNIT_NS,
rtimer.UNIT_QUERY_PERFORMANCE_COUNTER)
def test_csetupterm(self):
from rpython.translator.c.test.test_genc import compile
from pypy.module._minimal_curses import interp_curses
def runs_setupterm():
interp_curses._curses_setupterm_null(1)
fn = compile(runs_setupterm, [])
fn()
def test_translate_and_large_input():
from rpython.translator.c.test.test_genc import compile
def f(i, check):
bytes = "s" * i
if check == 1:
for j in range(3):
stream = rminiz_oxide.deflateInit()
bytes = rminiz_oxide.compress(stream, bytes,
rminiz_oxide.Z_FINISH)
rminiz_oxide.deflateEnd(stream)
return bytes
if check == 2:
return str(rminiz_oxide.adler32(bytes))
if check == 3:
return str(rminiz_oxide.crc32(bytes))
return '?'
fc = compile(f, [int, int])
test_list = [
1, 2, 3, 5, 8, 87, 876, 8765, 87654, 876543, 8765432, 127329129
] # up to ~128MB
if sys.maxint > 2**32:
test_list.append(4305704715) # 4.01GB
# XXX should we have a way to say "I don't have enough RAM,
# don't run this"?
for a in test_list:
print 'Testing compression of "s" * %d' % a
z = zlib.compressobj()
count = a
pieces = []
while count > 1024 * 1024:
pieces.append(z.compress("s" * (1024 * 1024)))
count -= 1024 * 1024
pieces.append(z.compress("s" * count))
pieces.append(z.flush(zlib.Z_FINISH))
expected = ''.join(pieces)
del pieces
expected = zlib.compress(expected)
expected = zlib.compress(expected)
assert fc(a, 1) == expected
print 'Testing adler32 and crc32 of "s" * %d' % a
def compute(function, start):
count = a
while count > 0:
count1 = min(count, 1024 * 1024)
start = function("s" * count1, start)
count -= count1
return start
expected_adler32 = compute(zlib.adler32, 1) & (2**32 - 1)
expected_crc32 = compute(zlib.crc32, 0) & (2**32 - 1)
assert fc(a, 2) == str(expected_adler32)
assert fc(a, 3) == str(expected_crc32)
def test_large_dict(self):
d = {}
d_small = {1: 2}
fixlist = [x for x in range(100)]
dynlist = [x for x in range(100)]
test_dict = dict(map(lambda x: (x, hex(x)), range(256, 4096)))
reverse_dict = dict(map(lambda (x, y): (y, x), test_dict.items()))
class wrap:
pass
for x in xrange(100):
i = wrap()
i.x = x
d[x] = i
def f(x):
if x > 42:
dynlist.append(x)
return d[x].x + fixlist[x] + d_small[x] + reverse_dict[
test_dict[x]]
func = compile(f, [int])
db = func.builder.db
gcontainers = list(db.globalcontainers())
t = db.translator
rtyper = t.rtyper
get_container = lambda x: rtyper.getrepr(
t.annotator.bookkeeper.immutablevalue(x)).convert_const(x)._obj
dictvalnode = db.getcontainernode(get_container(d))
dictvalnode2 = db.getcontainernode(get_container(d_small))
fixarrayvalnode = db.getcontainernode(get_container(fixlist))
dynarrayvalnode = db.getcontainernode(get_container(dynlist))
test_dictnode = db.getcontainernode(get_container(test_dict))
reverse_dictnode = db.getcontainernode(get_container(reverse_dict))
S = rffi.sizeof(lltype.Signed)
P = rffi.sizeof(rffi.VOIDP)
B = 1 # bool
assert guess_size(func.builder.db, dictvalnode, set()) > 100
assert guess_size(func.builder.db, dictvalnode2, set()) == (
(4 * S + 2 * P) + # struct dicttable
# (S + 16) + # indexes, length 16, but is absent here
(S + S + S)) # entries, length 1
r_set = set()
dictnode_size = guess_size(db, test_dictnode, r_set)
assert dictnode_size == (
(4 * S + 2 * P) + # struct dicttable
# (S + 2 * 8192) + # indexes, length 8192, rffi.USHORT,
# but is absent here during translation
(S + (S + S) * 3840) + # entries, length 3840
(S + S + 6) * 3840) # 3840 strings with 5 chars each (+1 final)
assert guess_size(func.builder.db, fixarrayvalnode, set(
)) == 100 * rffi.sizeof(lltype.Signed) + 1 * rffi.sizeof(lltype.Signed)
assert guess_size(
func.builder.db, dynarrayvalnode,
set()) == 100 * rffi.sizeof(lltype.Signed) + 2 * rffi.sizeof(
lltype.Signed) + 1 * rffi.sizeof(rffi.VOIDP)
def test_code_to_unichr():
def f(c):
return ord(code_to_unichr(c)[0])
f1 = compile(f, [int])
got = f1(0x12346)
if MAXUNICODE == 65535:
assert got == 0xd808 # first char of a pair
else:
assert got == 0x12346
def test_compiled_encode_nan():
fn2 = compile(fn_encode_nan, [float, int])
ints = [int(-2**31), int(2**31 - 1), 42]
for x in enum_floats():
y = ints.pop()
ints.insert(0, y)
fn_encode_nan(x, y)
res = fn2(x, y)
assert res == 42
