sources for test_model.py [rev. 38799]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
""" test_model - our (very simple) type system
model tests
"""
from py.__.apigen.tracer.model import *
import types
import py
def check_guess(val, t):
    assert isinstance(guess_type(val), t)
def test_basic():
    """ This tests checks every object that we might want
    to track
    """
    check_guess(3, SomeInt)
    check_guess(3., SomeFloat)
    check_guess(True, SomeBoolean)
    check_guess(lambda x: None, SomeFunction)
    class A:
        pass
    check_guess(A, SomeClass)
    check_guess(A(), SomeInstance)
    class B(object):
        def meth(self):
            pass
    
    class C(object):
        def __call__(self):
            pass
    check_guess(B, SomeClass)
    check_guess(B.meth, SomeFunction)
    check_guess(B(), SomeInstance)
    check_guess(B().meth, SomeMethod)
    check_guess([1], SomeList)
    check_guess(None, SomeNone)
    check_guess((1,), SomeTuple)
    check_guess(C(), SomeInstance)
    import sys
    check_guess(sys, SomeModule)
    check_guess({}, SomeDict)
    check_guess(sys.exc_info, SomeBuiltinFunction)
def test_anyof():
    def check_lst(lst):
        a = guess_type(lst[0])
        for i in lst[1:]:
            a = unionof(a, guess_type(i))
        d = dict([(i, True) for i in a.possibilities])
        assert len(a.possibilities) == len(d)
        for i in a.possibilities:
            assert not isinstance(i, SomeUnion)
        return a
        
    class C(object):
        pass
    
    ret = check_lst([3, 4, 3., "aa"])
    assert len(ret.possibilities) == 3
    ret = check_lst([3, 4, 3.])
    ret2 = check_lst([1, "aa"])
    ret3 = unionof(ret, ret2)
    assert len(ret3.possibilities) == 3
    ret = check_lst([3, 1.])
    ret = unionof(ret, guess_type("aa"))
    ret = unionof(guess_type("aa"), ret)
    ret = unionof(guess_type(C()), ret)
    ret = unionof(ret, guess_type("aa"))
    ret = unionof(ret, guess_type(C()))
    assert len(ret.possibilities) == 4
def test_union():
    class A(object):
        pass
    
    class B(object):
        pass
    
    f = guess_type(A).unionof(guess_type(A))
    assert isinstance(f, SomeClass)
    assert f.cls is A
    f = guess_type(A).unionof(guess_type(B)).unionof(guess_type(A))
    assert isinstance(f, SomeUnion)
    assert len(f.possibilities) == 2
    f = guess_type(A()).unionof(guess_type(A()))
    assert isinstance(f, SomeInstance)
    assert isinstance(f.classdef, SomeClass)
    assert f.classdef.cls is A
    f = guess_type(B()).unionof(guess_type(A())).unionof(guess_type(B()))
    assert isinstance(f, SomeInstance)
    assert isinstance(f.classdef, SomeUnion)
    assert len(f.classdef.possibilities) == 2
    
def test_striter():
    class A(object):
        pass
    
    class B(object):
        pass
    
    g = guess_type(A).unionof(guess_type(A()))
    l = py.builtin.sorted(list(g.striter()))
    assert l[4] == "AnyOf("
    assert isinstance(l[0], SomeClass)
    assert l[3] == ", "
    assert isinstance(l[1], SomeInstance)