← Back to branch summary

~ubuntu-branches/ubuntu/maverick/python3.1/maverick

« back to all changes in this revision

Viewing changes to Lib/test/test_symtable.py

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2009-03-23 00:01:27 UTC
  • Revision ID: james.westby@ubuntu.com-20090323000127-5fstfxju4ufrhthq
Tags: upstream-3.1~a1+20090322
Import upstream version 3.1~a1+20090322

Show diffs side-by-side

added added

removed removed

Lines of Context:
Lib/test/test_symtable.py
 
1
"""
 
2
Test the API of the symtable module.
 
3
"""
 
4
import symtable
 
5
import unittest
 
6
 
 
7
from test import support
 
8
 
 
9
 
 
10
TEST_CODE = """
 
11
import sys
 
12
 
 
13
glob = 42
 
14
 
 
15
class Mine:
 
16
    instance_var = 24
 
17
    def a_method(p1, p2):
 
18
        pass
 
19
 
 
20
def spam(a, b, *var, **kw):
 
21
    global bar
 
22
    bar = 47
 
23
    x = 23
 
24
    glob
 
25
    def internal():
 
26
        return x
 
27
    return internal
 
28
 
 
29
def foo():
 
30
    pass
 
31
 
 
32
def namespace_test(): pass
 
33
def namespace_test(): pass
 
34
"""
 
35
 
 
36
 
 
37
def find_block(block, name):
 
38
    for ch in block.get_children():
 
39
        if ch.get_name() == name:
 
40
            return ch
 
41
 
 
42
 
 
43
class SymtableTest(unittest.TestCase):
 
44
 
 
45
    top = symtable.symtable(TEST_CODE, "?", "exec")
 
46
    # These correspond to scopes in TEST_CODE
 
47
    Mine = find_block(top, "Mine")
 
48
    a_method = find_block(Mine, "a_method")
 
49
    spam = find_block(top, "spam")
 
50
    internal = find_block(spam, "internal")
 
51
    foo = find_block(top, "foo")
 
52
 
 
53
    def test_type(self):
 
54
        self.assertEqual(self.top.get_type(), "module")
 
55
        self.assertEqual(self.Mine.get_type(), "class")
 
56
        self.assertEqual(self.a_method.get_type(), "function")
 
57
        self.assertEqual(self.spam.get_type(), "function")
 
58
        self.assertEqual(self.internal.get_type(), "function")
 
59
 
 
60
    def test_optimized(self):
 
61
        self.assertFalse(self.top.is_optimized())
 
62
        self.assertFalse(self.top.has_exec())
 
63
 
 
64
        self.assertTrue(self.spam.is_optimized())
 
65
 
 
66
    def test_nested(self):
 
67
        self.assertFalse(self.top.is_nested())
 
68
        self.assertFalse(self.Mine.is_nested())
 
69
        self.assertFalse(self.spam.is_nested())
 
70
        self.assertTrue(self.internal.is_nested())
 
71
 
 
72
    def test_children(self):
 
73
        self.assertTrue(self.top.has_children())
 
74
        self.assertTrue(self.Mine.has_children())
 
75
        self.assertFalse(self.foo.has_children())
 
76
 
 
77
    def test_lineno(self):
 
78
        self.assertEqual(self.top.get_lineno(), 0)
 
79
        self.assertEqual(self.spam.get_lineno(), 11)
 
80
 
 
81
    def test_function_info(self):
 
82
        func = self.spam
 
83
        self.assertEqual(func.get_parameters(), ("a", "b", "kw", "var"))
 
84
        self.assertEqual(func.get_locals(),
 
85
                         ("a", "b", "bar", "glob", "internal", "kw", "var", "x"))
 
86
        self.assertEqual(func.get_globals(), ("bar", "glob"))
 
87
        self.assertEqual(self.internal.get_frees(), ("x",))
 
88
 
 
89
    def test_globals(self):
 
90
        self.assertTrue(self.spam.lookup("glob").is_global())
 
91
        self.assertTrue(self.spam.lookup("bar").is_global())
 
92
        self.assertFalse(self.internal.lookup("x").is_global())
 
93
        self.assertFalse(self.Mine.lookup("instance_var").is_global())
 
94
 
 
95
    def test_local(self):
 
96
        self.assertTrue(self.spam.lookup("x").is_local())
 
97
        self.assertFalse(self.internal.lookup("x").is_local())
 
98
 
 
99
    def test_referenced(self):
 
100
        self.assertTrue(self.internal.lookup("x").is_referenced())
 
101
        self.assertTrue(self.spam.lookup("internal").is_referenced())
 
102
        self.assertFalse(self.spam.lookup("x").is_referenced())
 
103
 
 
104
    def test_parameters(self):
 
105
        for sym in ("a", "var", "kw"):
 
106
            self.assertTrue(self.spam.lookup(sym).is_parameter())
 
107
        self.assertFalse(self.spam.lookup("x").is_parameter())
 
108
 
 
109
    def test_symbol_lookup(self):
 
110
        self.assertEqual(len(self.top.get_identifiers()),
 
111
                         len(self.top.get_symbols()))
 
112
 
 
113
        self.assertRaises(KeyError, self.top.lookup, "not_here")
 
114
 
 
115
    def test_namespaces(self):
 
116
        self.assertTrue(self.top.lookup("Mine").is_namespace())
 
117
        self.assertTrue(self.Mine.lookup("a_method").is_namespace())
 
118
        self.assertTrue(self.top.lookup("spam").is_namespace())
 
119
        self.assertTrue(self.spam.lookup("internal").is_namespace())
 
120
        self.assertTrue(self.top.lookup("namespace_test").is_namespace())
 
121
        self.assertFalse(self.spam.lookup("x").is_namespace())
 
122
 
 
123
        self.assert_(self.top.lookup("spam").get_namespace() is self.spam)
 
124
        ns_test = self.top.lookup("namespace_test")
 
125
        self.assertEqual(len(ns_test.get_namespaces()), 2)
 
126
        self.assertRaises(ValueError, ns_test.get_namespace)
 
127
 
 
128
    def test_assigned(self):
 
129
        self.assertTrue(self.spam.lookup("x").is_assigned())
 
130
        self.assertTrue(self.spam.lookup("bar").is_assigned())
 
131
        self.assertTrue(self.top.lookup("spam").is_assigned())
 
132
        self.assertTrue(self.Mine.lookup("a_method").is_assigned())
 
133
        self.assertFalse(self.internal.lookup("x").is_assigned())
 
134
 
 
135
    def test_imported(self):
 
136
        self.assertTrue(self.top.lookup("sys").is_imported())
 
137
 
 
138
    def test_name(self):
 
139
        self.assertEqual(self.top.get_name(), "top")
 
140
        self.assertEqual(self.spam.get_name(), "spam")
 
141
        self.assertEqual(self.spam.lookup("x").get_name(), "x")
 
142
        self.assertEqual(self.Mine.get_name(), "Mine")
 
143
 
 
144
    def test_class_info(self):
 
145
        self.assertEqual(self.Mine.get_methods(), ('a_method',))
 
146
 
 
147
    def test_filename_correct(self):
 
148
        ### Bug tickler: SyntaxError file name correct whether error raised
 
149
        ### while parsing or building symbol table.
 
150
        def checkfilename(brokencode):
 
151
            try:
 
152
                symtable.symtable(brokencode, "spam", "exec")
 
153
            except SyntaxError as e:
 
154
                self.assertEqual(e.filename, "spam")
 
155
            else:
 
156
                self.fail("no SyntaxError for %r" % (brokencode,))
 
157
        checkfilename("def f(x): foo)(")  # parse-time
 
158
        checkfilename("def f(x): global x")  # symtable-build-time
 
159
 
 
160
    def test_eval(self):
 
161
        symbols = symtable.symtable("42", "?", "eval")
 
162
 
 
163
    def test_single(self):
 
164
        symbols = symtable.symtable("42", "?", "single")
 
165
 
 
166
    def test_exec(self):
 
167
        symbols = symtable.symtable("def f(x): return x", "?", "exec")
 
168
 
 
169
 
 
170
def test_main():
 
171
    support.run_unittest(SymtableTest)
 
172
 
 
173
if __name__ == '__main__':
 
174
    test_main()