def teardown_method(self, meth):

assert annmodel.s_Bool == annmodel.SomeBool()

class RPythonAnnotator(_RPythonAnnotator):

def build_types(self, *args):

s = _RPythonAnnotator.build_types(self, *args)

self.validate()

if option.view:

self.translator.view()

return s

def test_simple_func(self):

"""

x = Variable("x")

oper = op.add(x, Constant(1))

block = Block([x])

fun = FunctionGraph("f", block)

block.operations.append(oper)

block.closeblock(Link([oper.result], fun.returnblock))

a = self.RPythonAnnotator()

a.addpendingblock(fun, fun.startblock, [annmodel.SomeInteger()])

a.complete()

assert a.gettype(fun.getreturnvar()) == int

def test_while(self):

"""

i1 = Variable("i1")

i2 = Variable("i2")

conditionop = op.gt(i1, Constant(0))

decop = op.add(i2, Constant(-1))

headerblock = Block([i1])

whileblock = Block([i2])

fun = FunctionGraph("f", headerblock)

headerblock.operations.append(conditionop)

headerblock.exitswitch = conditionop.result

headerblock.closeblock(Link([i1], fun.returnblock, False),

Link([i1], whileblock, True))

whileblock.operations.append(decop)

whileblock.closeblock(Link([decop.result], headerblock))

a = self.RPythonAnnotator()

a.addpendingblock(fun, fun.startblock, [annmodel.SomeInteger()])

a.complete()

assert a.gettype(fun.getreturnvar()) == int

def test_while_sum(self):

"""

i1 = Variable("i1")

i2 = Variable("i2")

i3 = Variable("i3")

sum2 = Variable("sum2")

sum3 = Variable("sum3")

conditionop = op.gt(i2, Constant(0))

decop = op.add(i3, Constant(-1))

addop = op.add(i3, sum3)

startblock = Block([i1])

headerblock = Block([i2, sum2])

whileblock = Block([i3, sum3])

fun = FunctionGraph("f", startblock)

startblock.closeblock(Link([i1, Constant(0)], headerblock))

headerblock.operations.append(conditionop)

headerblock.exitswitch = conditionop.result

headerblock.closeblock(Link([sum2], fun.returnblock, False),

Link([i2, sum2], whileblock, True))

whileblock.operations.append(addop)

whileblock.operations.append(decop)

whileblock.closeblock(Link([decop.result, addop.result], headerblock))

a = self.RPythonAnnotator()

a.addpendingblock(fun, fun.startblock, [annmodel.SomeInteger()])

a.complete()

assert a.gettype(fun.getreturnvar()) == int

def test_f_calls_g(self):

a = self.RPythonAnnotator()

s = a.build_types(f_calls_g, [int])

# result should be an integer

assert s.knowntype == int

def test_not_rpython(self):

def g(x):

""" NOT_RPYTHON """

return eval(x)

def f(x):

return g(str(x))

a = self.RPythonAnnotator()

with py.test.raises(ValueError):

a.build_types(f, [int])

def test_not_rpython_decorator(self):

from rpython.rlib.objectmodel import not_rpython

@not_rpython

def g(x):

return eval(x)

def f(x):

return g(str(x))

a = self.RPythonAnnotator()

with py.test.raises(ValueError):

a.build_types(f, [int])

def test_lists(self):

a = self.RPythonAnnotator()

end_cell = a.build_types(snippet.poor_man_rev_range, [int])

# result should be a list of integers

assert listitem(end_cell).knowntype == int

def test_factorial(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.factorial, [int])

# result should be an integer

assert s.knowntype == int

def test_factorial2(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.factorial2, [int])

# result should be an integer

assert s.knowntype == int

def test_build_instance(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.build_instance, [])

# result should be a snippet.C instance

assert isinstance(s, annmodel.SomeInstance)

assert s.classdef == a.bookkeeper.getuniqueclassdef(snippet.C)

def test_set_attr(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.set_attr, [])

# result should be an integer

assert s.knowntype == int

def test_merge_setattr(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.merge_setattr, [int])

# result should be an integer

assert s.knowntype == int

def test_inheritance1(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.inheritance1, [])

# result should be exactly:

assert s == annmodel.SomeTuple([

a.bookkeeper.immutablevalue(()),

annmodel.SomeInteger()

])

def test_poor_man_range(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.poor_man_range, [int])

# result should be a list of integers

assert listitem(s).knowntype == int

def test_staticmethod(self):

class X(object):

@staticmethod

def stat(value):

return value + 4

def f(v):

return X().stat(v)

a = self.RPythonAnnotator()

s = a.build_types(f, [int])

assert isinstance(s, annmodel.SomeInteger)

def test_classmethod(self):

class X(object):

@classmethod

def meth(cls):

return None

def f():

return X().meth()

a = self.RPythonAnnotator()

py.test.raises(AnnotatorError, a.build_types, f, [])

def test_methodcall1(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet._methodcall1, [int])

# result should be a tuple of (C, positive_int)

assert s.knowntype == tuple

assert len(s.items) == 2

s0 = s.items[0]

assert isinstance(s0, annmodel.SomeInstance)

assert s0.classdef == a.bookkeeper.getuniqueclassdef(snippet.C)

assert s.items[1].knowntype == int

assert s.items[1].nonneg == True

def test_classes_methodcall1(self):

a = self.RPythonAnnotator()

a.build_types(snippet._methodcall1, [int])

# the user classes should have the following attributes:

getcdef = a.bookkeeper.getuniqueclassdef

assert getcdef(snippet.F).attrs.keys() == ['m']

assert getcdef(snippet.G).attrs.keys() == ['m2']

assert getcdef(snippet.H).attrs.keys() == ['attr']

assert getcdef(snippet.H).about_attribute('attr') == (

a.bookkeeper.immutablevalue(1))

def test_generaldict(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.generaldict, [str, int, str, int])

# result should be an integer

assert s.knowntype == int

def test_somebug1(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet._somebug1, [int])

# result should be a built-in method

assert isinstance(s, annmodel.SomeBuiltin)

def test_with_init(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.with_init, [int])

# result should be an integer

assert s.knowntype == int

def test_with_more_init(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.with_more_init, [int, bool])

# the user classes should have the following attributes:

getcdef = a.bookkeeper.getuniqueclassdef

# XXX on which class should the attribute 'a' appear? We only

# ever flow WithInit.__init__ with a self which is an instance

# of WithMoreInit, so currently it appears on WithMoreInit.

assert getcdef(snippet.WithMoreInit).about_attribute('a') == (

annmodel.SomeInteger())

assert getcdef(snippet.WithMoreInit).about_attribute('b') == (

annmodel.SomeBool())

def test_global_instance(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.global_instance, [])

# currently this returns the constant 42.

# XXX not sure this is the best behavior...

assert s == a.bookkeeper.immutablevalue(42)

def test_call_five(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.call_five, [])

# returns should be a list of constants (= 5)

assert listitem(s) == a.bookkeeper.immutablevalue(5)

def test_call_five_six(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.call_five_six, [])

# returns should be a list of positive integers

assert listitem(s) == annmodel.SomeInteger(nonneg=True)

def test_constant_result(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.constant_result, [])

#a.translator.simplify()

# must return "yadda"

assert s == a.bookkeeper.immutablevalue("yadda")

graphs = a.translator.graphs

assert len(graphs) == 2

assert graphs[0].func is snippet.constant_result

assert graphs[1].func is snippet.forty_two

a.simplify()

#a.translator.view()

def test_flow_type_info(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.flow_type_info, [int])

a.simplify()

assert s.knowntype == int

a = self.RPythonAnnotator()

s = a.build_types(snippet.flow_type_info, [str])

a.simplify()

assert s.knowntype == int

def test_flow_type_info_2(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.flow_type_info,

[annmodel.SomeInteger(nonneg=True)])

# this checks that isinstance(i, int) didn't lose the

# actually more precise information that i is non-negative

assert s == annmodel.SomeInteger(nonneg=True)

def test_flow_usertype_info(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.flow_usertype_info, [snippet.WithInit])

#a.translator.view()

assert isinstance(s, annmodel.SomeInstance)

assert s.classdef == a.bookkeeper.getuniqueclassdef(snippet.WithInit)

def test_flow_usertype_info2(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.flow_usertype_info, [snippet.WithMoreInit])

#a.translator.view()

assert isinstance(s, annmodel.SomeInstance)

assert s.classdef == a.bookkeeper.getuniqueclassdef(snippet.WithMoreInit)

def test_mergefunctions(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.mergefunctions, [int])

# the test is mostly that the above line hasn't blown up

# but let's at least check *something*

assert isinstance(s, annmodel.SomePBC)

def test_func_calls_func_which_just_raises(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.funccallsex, [])

# the test is mostly that the above line hasn't blown up

# but let's at least check *something*

#self.assert_(isinstance(s, SomeCallable))

def test_tuple_unpack_from_const_tuple_with_different_types(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.func_arg_unpack, [])

assert isinstance(s, annmodel.SomeInteger)

assert s.const == 3

def test_star_unpack_list(self):

def g():

pass

def f(l):

return g(*l)

a = self.RPythonAnnotator()

with py.test.raises(AnnotatorError):

a.build_types(f, [[int]])

def test_star_unpack_and_keywords(self):

def g(a, b, c=0, d=0):

return a + b + c + d

def f(a, b):

return g(a, *(b,), d=5)

a = self.RPythonAnnotator()

s_result = a.build_types(f, [int, int])

assert isinstance(s_result, annmodel.SomeInteger)

def test_pbc_attr_preserved_on_instance(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.preserve_pbc_attr_on_instance, [bool])

#a.simplify()

#a.translator.view()

assert s == annmodel.SomeInteger(nonneg=True)

#self.assertEquals(s.__class__, annmodel.SomeInteger)

def test_pbc_attr_preserved_on_instance_with_slots(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.preserve_pbc_attr_on_instance_with_slots,

[bool])

assert s == annmodel.SomeInteger(nonneg=True)

def test_is_and_knowntype_data(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.is_and_knowntype, [str])

#a.simplify()

#a.translator.view()

assert s == a.bookkeeper.immutablevalue(None)

def test_isinstance_and_knowntype_data(self):

a = self.RPythonAnnotator()

x = a.bookkeeper.immutablevalue(snippet.apbc)

s = a.build_types(snippet.isinstance_and_knowntype, [x])

#a.simplify()

#a.translator.view()

assert s == x

def test_somepbc_simplify(self):

a = self.RPythonAnnotator()

# this example used to trigger an AssertionError

a.build_types(snippet.somepbc_simplify, [])

def test_builtin_methods(self):

a = self.RPythonAnnotator()

iv = a.bookkeeper.immutablevalue

# this checks that some built-in methods are really supported by

# the annotator (it doesn't check that they operate property, though)

for example, methname, s_example in [

('', 'join', annmodel.SomeString()),

([], 'append', somelist(annmodel.s_Int)),

([], 'extend', somelist(annmodel.s_Int)),

([], 'reverse', somelist(annmodel.s_Int)),

([], 'insert', somelist(annmodel.s_Int)),

([], 'pop', somelist(annmodel.s_Int)),

]:

constmeth = getattr(example, methname)

s_constmeth = iv(constmeth)

assert isinstance(s_constmeth, annmodel.SomeBuiltin)

s_meth = s_example.getattr(iv(methname))

assert isinstance(s_constmeth, annmodel.SomeBuiltin)

def test_str_join(self):

a = self.RPythonAnnotator()

def g(n):

if n:

return ["foo", "bar"]

def f(n):

g(0)

return ''.join(g(n))

s = a.build_types(f, [int])

assert s.knowntype == str

assert s.no_nul

def test_unicode_join(self):

a = self.RPythonAnnotator()

def g(n):

if n:

return [u"foo", u"bar"]

def f(n):

g(0)

return u''.join(g(n))

s = a.build_types(f, [int])

assert s.knowntype == unicode

assert s.no_nul

def test_str_split(self):

a = self.RPythonAnnotator()

def g(n):

if n:

return "test string"

def f(n):

if n:

return g(n).split(' ')

s = a.build_types(f, [int])

assert isinstance(s, annmodel.SomeList)

s_item = s.listdef.listitem.s_value

assert s_item.no_nul

def test_unicode_split(self):

a = self.RPythonAnnotator()

def g(n):

if n:

return u"test string"

def f(n):

if n:

return g(n).split(u' ')

s = a.build_types(f, [int])

assert isinstance(s, annmodel.SomeList)

s_item = s.listdef.listitem.s_value

assert s_item.no_nul

def test_str_split_nul(self):

def f(n):

return n.split('\0')[0]

a = self.RPythonAnnotator()

a.translator.config.translation.check_str_without_nul = True

s = a.build_types(f, [annmodel.SomeString(no_nul=False, can_be_None=False)])

assert isinstance(s, annmodel.SomeString)

assert not s.can_be_None

assert s.no_nul

def g(n):

return n.split('\0', 1)[0]

a = self.RPythonAnnotator()

a.translator.config.translation.check_str_without_nul = True

s = a.build_types(g, [annmodel.SomeString(no_nul=False, can_be_None=False)])

assert isinstance(s, annmodel.SomeString)

assert not s.can_be_None

assert not s.no_nul

def test_unicode_split_nul(self):

def f(n):

return n.split(u'\0')[0]

a = self.RPythonAnnotator()

a.translator.config.translation.check_str_without_nul = True

s = a.build_types(f, [annmodel.SomeUnicodeString(

no_nul=False, can_be_None=False)])

assert isinstance(s, annmodel.SomeUnicodeString)

assert not s.can_be_None

assert s.no_nul

def g(n):

return n.split(u'\0', 1)[0]

a = self.RPythonAnnotator()

a.translator.config.translation.check_str_without_nul = True

s = a.build_types(g, [annmodel.SomeUnicodeString(

no_nul=False, can_be_None=False)])

assert isinstance(s, annmodel.SomeUnicodeString)

assert not s.can_be_None

assert not s.no_nul

def test_str_splitlines(self):

a = self.RPythonAnnotator()

def f(a_str):

return a_str.splitlines()

s = a.build_types(f, [str])

assert isinstance(s, annmodel.SomeList)

assert s.listdef.listitem.resized

def test_str_strip(self):

a = self.RPythonAnnotator()

def f(n, a_str):

if n == 0:

return a_str.strip(' ')

elif n == 1:

return a_str.rstrip(' ')

else:

return a_str.lstrip(' ')

s = a.build_types(f, [int, annmodel.SomeString(no_nul=True)])

assert s.no_nul

def test_unicode_strip(self):

a = self.RPythonAnnotator()

def f(n, a_str):

if n == 0:

return a_str.strip(u' ')

elif n == 1:

return a_str.rstrip(u' ')

else:

return a_str.lstrip(u' ')

s = a.build_types(f, [int, annmodel.SomeUnicodeString(no_nul=True)])

assert s.no_nul

def test_str_mul(self):

a = self.RPythonAnnotator()

def f(a_str):

return a_str * 3

s = a.build_types(f, [str])

assert isinstance(s, annmodel.SomeString)

def test_str_isalpha(self):

def f(s):

return s.isalpha()

a = self.RPythonAnnotator()

s = a.build_types(f, [str])

assert isinstance(s, annmodel.SomeBool)

def test_simple_slicing(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.simple_slice, [somelist(annmodel.s_Int)])

assert isinstance(s, annmodel.SomeList)

def test_simple_iter_list(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.simple_iter, [somelist(annmodel.s_Int)])

assert isinstance(s, annmodel.SomeIterator)

def test_simple_iter_next(self):

def f(x):

i = iter(range(x))

return i.next()

a = self.RPythonAnnotator()

s = a.build_types(f, [int])

assert isinstance(s, annmodel.SomeInteger)

def test_simple_iter_dict(self):

a = self.RPythonAnnotator()

t = somedict(a, annmodel.SomeInteger(), annmodel.SomeInteger())

s = a.build_types(snippet.simple_iter, [t])

assert isinstance(s, annmodel.SomeIterator)

def test_simple_zip(self):

a = self.RPythonAnnotator()

x = somelist(annmodel.SomeInteger())

y = somelist(annmodel.SomeString())

s = a.build_types(snippet.simple_zip, [x,y])

assert s.knowntype == list

assert listitem(s).knowntype == tuple

assert listitem(s).items[0].knowntype == int

assert listitem(s).items[1].knowntype == str

def test_dict_copy(self):

a = self.RPythonAnnotator()

t = somedict(a, annmodel.SomeInteger(), annmodel.SomeInteger())

s = a.build_types(snippet.dict_copy, [t])

assert isinstance(dictkey(s), annmodel.SomeInteger)

assert isinstance(dictvalue(s), annmodel.SomeInteger)

def test_dict_update(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.dict_update, [int])

assert isinstance(dictkey(s), annmodel.SomeInteger)

assert isinstance(dictvalue(s), annmodel.SomeInteger)

def test_dict_update_2(self):

a = self.RPythonAnnotator()

def g(n):

if n:

return {3: 4}

def f(n):

g(0)

d = {}

d.update(g(n))

return d

s = a.build_types(f, [int])

assert dictkey(s).knowntype == int

def test_dict_keys(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.dict_keys, [])

assert isinstance(listitem(s), annmodel.SomeString)

def test_dict_keys2(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.dict_keys2, [])

assert type(listitem(s)) is annmodel.SomeString

def test_dict_values(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.dict_values, [])

assert isinstance(listitem(s), annmodel.SomeString)

def test_dict_values2(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.dict_values2, [])

assert type(listitem(s)) is annmodel.SomeString

def test_dict_items(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.dict_items, [])

assert isinstance(listitem(s), annmodel.SomeTuple)

s_key, s_value = listitem(s).items

assert isinstance(s_key, annmodel.SomeString)

assert isinstance(s_value, annmodel.SomeInteger)

def test_dict_setdefault(self):

a = self.RPythonAnnotator()

def f():

d = {}

d.setdefault('a', 2)

d.setdefault('a', -3)

return d

s = a.build_types(f, [])

assert isinstance(s, annmodel.SomeDict)

assert isinstance(dictkey(s), annmodel.SomeString)

assert isinstance(dictvalue(s), annmodel.SomeInteger)

assert not dictvalue(s).nonneg

def test_dict_get(self):

def f1(i, j):

d = {i: ''}

return d.get(j)

a = self.RPythonAnnotator()

s = a.build_types(f1, [int, int])

assert isinstance(s, annmodel.SomeString)

assert s.can_be_None

def test_exception_deduction(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.exception_deduction, [])

assert isinstance(s, annmodel.SomeInstance)

assert s.classdef is a.bookkeeper.getuniqueclassdef(snippet.Exc)

def test_exception_deduction_we_are_dumb(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.exception_deduction_we_are_dumb, [])

assert isinstance(s, annmodel.SomeInstance)

assert s.classdef is a.bookkeeper.getuniqueclassdef(snippet.Exc)

def test_nested_exception_deduction(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.nested_exception_deduction, [])

assert isinstance(s, annmodel.SomeTuple)

assert isinstance(s.items[0], annmodel.SomeInstance)

assert isinstance(s.items[1], annmodel.SomeInstance)

assert s.items[0].classdef is a.bookkeeper.getuniqueclassdef(snippet.Exc)

assert s.items[1].classdef is a.bookkeeper.getuniqueclassdef(snippet.Exc2)

def test_exc_deduction_our_exc_plus_others(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.exc_deduction_our_exc_plus_others, [])

assert isinstance(s, annmodel.SomeInteger)

def test_exc_deduction_our_excs_plus_others(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.exc_deduction_our_excs_plus_others, [])

assert isinstance(s, annmodel.SomeInteger)

def test_complex_exception_deduction(self):

class InternalError(Exception):

def __init__(self, msg):

self.msg = msg

class AppError(Exception):

def __init__(self, msg):

self.msg = msg

def apperror(msg):

return AppError(msg)

def f(string):

if not string:

raise InternalError('Empty string')

return string, None

def cleanup():

pass

def g(string):

try:

try:

string, _ = f(string)

except ZeroDivisionError:

raise apperror('ZeroDivisionError')

try:

result, _ = f(string)

finally:

cleanup()

except InternalError as e:

raise apperror(e.msg)

return result

a = self.RPythonAnnotator()

s_result = a.build_types(g, [str])

assert isinstance(s_result, annmodel.SomeString)

def test_method_exception_specialization(self):

def f(l):

try:

return l.pop()

except Exception:

raise

a = self.RPythonAnnotator()

s = a.build_types(f, [[int]])

graph = graphof(a, f)

etype, evalue = graph.exceptblock.inputargs

assert evalue.annotation.classdefs == {

a.bookkeeper.getuniqueclassdef(IndexError)}

assert etype.annotation.const == IndexError

def test_operation_always_raising(self):

def operation_always_raising(n):

lst = []

try:

return lst[n]

except IndexError:

return 24

a = self.RPythonAnnotator()

s = a.build_types(operation_always_raising, [int])

assert s == a.bookkeeper.immutablevalue(24)

def test_propagation_of_fresh_instances_through_attrs(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.propagation_of_fresh_instances_through_attrs, [int])

assert s is not None

def test_propagation_of_fresh_instances_through_attrs_rec_0(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.make_r, [int])

Rdef = a.bookkeeper.getuniqueclassdef(snippet.R)

assert s.classdef == Rdef

assert Rdef.attrs['r'].s_value.classdef == Rdef

assert Rdef.attrs['n'].s_value.knowntype == int

assert Rdef.attrs['m'].s_value.knowntype == int

def test_propagation_of_fresh_instances_through_attrs_rec_eo(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.make_eo, [int])

assert s.classdef == a.bookkeeper.getuniqueclassdef(snippet.B)

Even_def = a.bookkeeper.getuniqueclassdef(snippet.Even)

Odd_def = a.bookkeeper.getuniqueclassdef(snippet.Odd)

assert listitem(Even_def.attrs['x'].s_value).classdef == Odd_def

assert listitem(Even_def.attrs['y'].s_value).classdef == Even_def

assert listitem(Odd_def.attrs['x'].s_value).classdef == Even_def

assert listitem(Odd_def.attrs['y'].s_value).classdef == Odd_def

def test_flow_rev_numbers(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.flow_rev_numbers, [int])

assert s.knowntype == int

assert not s.is_constant() # !

def test_methodcall_is_precise(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.methodcall_is_precise, [bool])

getcdef = a.bookkeeper.getuniqueclassdef

assert 'x' not in getcdef(snippet.CBase).attrs

assert (getcdef(snippet.CSub1).attrs['x'].s_value ==

a.bookkeeper.immutablevalue(42))

assert (getcdef(snippet.CSub2).attrs['x'].s_value ==

a.bookkeeper.immutablevalue('world'))

assert s == a.bookkeeper.immutablevalue(42)

def test_call_star_args(self):

a = self.RPythonAnnotator(policy=AnnotatorPolicy())

s = a.build_types(snippet.call_star_args, [int])

assert s.knowntype == int

def test_call_star_args_multiple(self):

a = self.RPythonAnnotator(policy=AnnotatorPolicy())

s = a.build_types(snippet.call_star_args_multiple, [int])

assert s.knowntype == int

def test_exception_deduction_with_raise1(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.exception_deduction_with_raise1, [bool])

assert isinstance(s, annmodel.SomeInstance)

assert s.classdef is a.bookkeeper.getuniqueclassdef(snippet.Exc)

def test_exception_deduction_with_raise2(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.exception_deduction_with_raise2, [bool])

assert isinstance(s, annmodel.SomeInstance)

assert s.classdef is a.bookkeeper.getuniqueclassdef(snippet.Exc)

def test_exception_deduction_with_raise3(self):

a = self.RPythonAnnotator()

s = a.build_types(snippet.exception_deduction_with_raise3, [bool])

assert isinstance(s, annmodel.SomeInstance)

assert s.classdef is a.bookkeeper.getuniqueclassdef(snippet.Exc)

def test_type_is(self):

class B(object):

pass

class C(B):

pass

def f(x):

assert type(x) is C

return x

a = self.RPythonAnnotator()

s = a.build_types(f, [B])

assert s.classdef is a.bookkeeper.getuniqueclassdef(C)

@py.test.mark.xfail

def test_union_type_some_pbc(self):

class A(object):

name = "A"

def f(self):

return type(self)

class B(A):

name = "B"

def f(tp):

return tp

def main(n):

if n:

if n == 1:

inst = A()

else:

inst = B()

arg = inst.f()

else:

arg = B

return f(arg).name

a = self.RPythonAnnotator()

s = a.build_types(main, [int])

assert isinstance(s, annmodel.SomeString)

def test_ann_assert(self):

def assert_(x):

assert x,"XXX"

a = self.RPythonAnnotator()

s = a.build_types(assert_, [int])

assert s.const is None

def test_string_and_none(self):

def f(n):

if n:

return 'y'

else:

return 'n'

def g(n):

if n:

return 'y'

else:

return None

a = self.RPythonAnnotator()

s = a.build_types(f, [bool])

assert s.knowntype == str

assert not s.can_be_None

s = a.build_types(g, [bool])

assert s.knowntype == str

assert s.can_be_None

def test_implicit_exc(self):

def f(l):

try:

l[0]

except (KeyError, IndexError) as e:

return e

return None

a = self.RPythonAnnotator()

s = a.build_types(f, [somelist(annmodel.s_Int)])

assert s.classdef is a.bookkeeper.getuniqueclassdef(IndexError) # KeyError ignored because l is a list

def test_freeze_protocol(self):

class Stuff: