Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 1 | import sys |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 2 | import types |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 3 | import unittest |
| 4 | import inspect |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 5 | import datetime |
Guido van Rossum | 813b0e5 | 2007-05-21 18:11:34 +0000 | [diff] [blame] | 6 | import collections |
Christian Heimes | a3538eb | 2007-11-06 11:44:48 +0000 | [diff] [blame] | 7 | from os.path import normcase |
Ka-Ping Yee | 6397c7c | 2001-02-27 14:43:21 +0000 | [diff] [blame] | 8 | |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 9 | from test.support import TESTFN, run_unittest |
Ka-Ping Yee | 6397c7c | 2001-02-27 14:43:21 +0000 | [diff] [blame] | 10 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 11 | from test import inspect_fodder as mod |
| 12 | from test import inspect_fodder2 as mod2 |
Ka-Ping Yee | 6397c7c | 2001-02-27 14:43:21 +0000 | [diff] [blame] | 13 | |
| 14 | # Functions tested in this suite: |
| 15 | # ismodule, isclass, ismethod, isfunction, istraceback, isframe, iscode, |
Christian Heimes | 7131fd9 | 2008-02-19 14:21:46 +0000 | [diff] [blame] | 16 | # isbuiltin, isroutine, isgenerator, isgeneratorfunction, getmembers, |
| 17 | # getdoc, getfile, getmodule, getsourcefile, getcomments, getsource, |
| 18 | # getclasstree, getargspec, getargvalues, formatargspec, formatargvalues, |
| 19 | # currentframe, stack, trace, isdatadescriptor |
Ka-Ping Yee | 6397c7c | 2001-02-27 14:43:21 +0000 | [diff] [blame] | 20 | |
Nick Coghlan | f088e5e | 2008-12-14 11:50:48 +0000 | [diff] [blame] | 21 | # NOTE: There are some additional tests relating to interaction with |
| 22 | # zipimport in the test_zipimport_support test module. |
| 23 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 24 | modfile = mod.__file__ |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 25 | if modfile.endswith(('c', 'o')): |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 26 | modfile = modfile[:-1] |
Ka-Ping Yee | 6397c7c | 2001-02-27 14:43:21 +0000 | [diff] [blame] | 27 | |
Christian Heimes | a3538eb | 2007-11-06 11:44:48 +0000 | [diff] [blame] | 28 | # Normalize file names: on Windows, the case of file names of compiled |
| 29 | # modules depends on the path used to start the python executable. |
| 30 | modfile = normcase(modfile) |
| 31 | |
| 32 | def revise(filename, *args): |
| 33 | return (normcase(filename),) + args |
| 34 | |
Georg Brandl | 1a3284e | 2007-12-02 09:40:06 +0000 | [diff] [blame] | 35 | import builtins |
Ka-Ping Yee | 6397c7c | 2001-02-27 14:43:21 +0000 | [diff] [blame] | 36 | |
Ka-Ping Yee | 6397c7c | 2001-02-27 14:43:21 +0000 | [diff] [blame] | 37 | try: |
| 38 | 1/0 |
| 39 | except: |
Guido van Rossum | e7ba495 | 2007-06-06 23:52:48 +0000 | [diff] [blame] | 40 | tb = sys.exc_info()[2] |
Ka-Ping Yee | 6397c7c | 2001-02-27 14:43:21 +0000 | [diff] [blame] | 41 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 42 | git = mod.StupidGit() |
Ka-Ping Yee | 6397c7c | 2001-02-27 14:43:21 +0000 | [diff] [blame] | 43 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 44 | class IsTestBase(unittest.TestCase): |
| 45 | predicates = set([inspect.isbuiltin, inspect.isclass, inspect.iscode, |
| 46 | inspect.isframe, inspect.isfunction, inspect.ismethod, |
Christian Heimes | 7131fd9 | 2008-02-19 14:21:46 +0000 | [diff] [blame] | 47 | inspect.ismodule, inspect.istraceback, |
| 48 | inspect.isgenerator, inspect.isgeneratorfunction]) |
Tim Peters | 5a9fb3c | 2005-01-07 16:01:32 +0000 | [diff] [blame] | 49 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 50 | def istest(self, predicate, exp): |
| 51 | obj = eval(exp) |
| 52 | self.failUnless(predicate(obj), '%s(%s)' % (predicate.__name__, exp)) |
Tim Peters | 5a9fb3c | 2005-01-07 16:01:32 +0000 | [diff] [blame] | 53 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 54 | for other in self.predicates - set([predicate]): |
Christian Heimes | 7131fd9 | 2008-02-19 14:21:46 +0000 | [diff] [blame] | 55 | if predicate == inspect.isgeneratorfunction and\ |
| 56 | other == inspect.isfunction: |
| 57 | continue |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 58 | self.failIf(other(obj), 'not %s(%s)' % (other.__name__, exp)) |
Ka-Ping Yee | 6397c7c | 2001-02-27 14:43:21 +0000 | [diff] [blame] | 59 | |
Christian Heimes | 7131fd9 | 2008-02-19 14:21:46 +0000 | [diff] [blame] | 60 | def generator_function_example(self): |
| 61 | for i in range(2): |
| 62 | yield i |
| 63 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 64 | class TestPredicates(IsTestBase): |
Christian Heimes | 227c800 | 2008-03-03 20:34:40 +0000 | [diff] [blame] | 65 | def test_sixteen(self): |
Guido van Rossum | c1f779c | 2007-07-03 08:25:58 +0000 | [diff] [blame] | 66 | count = len([x for x in dir(inspect) if x.startswith('is')]) |
Christian Heimes | 7131fd9 | 2008-02-19 14:21:46 +0000 | [diff] [blame] | 67 | # This test is here for remember you to update Doc/library/inspect.rst |
Christian Heimes | 7864476 | 2008-03-04 23:39:23 +0000 | [diff] [blame] | 68 | # which claims there are 16 such functions |
Christian Heimes | 227c800 | 2008-03-03 20:34:40 +0000 | [diff] [blame] | 69 | expected = 16 |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 70 | err_msg = "There are %d (not %d) is* functions" % (count, expected) |
| 71 | self.assertEqual(count, expected, err_msg) |
Tim Peters | 5a9fb3c | 2005-01-07 16:01:32 +0000 | [diff] [blame] | 72 | |
Christian Heimes | 7131fd9 | 2008-02-19 14:21:46 +0000 | [diff] [blame] | 73 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 74 | def test_excluding_predicates(self): |
| 75 | self.istest(inspect.isbuiltin, 'sys.exit') |
| 76 | self.istest(inspect.isbuiltin, '[].append') |
| 77 | self.istest(inspect.isclass, 'mod.StupidGit') |
Neal Norwitz | 221085d | 2007-02-25 20:55:47 +0000 | [diff] [blame] | 78 | self.istest(inspect.iscode, 'mod.spam.__code__') |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 79 | self.istest(inspect.isframe, 'tb.tb_frame') |
| 80 | self.istest(inspect.isfunction, 'mod.spam') |
Christian Heimes | 4a22b5d | 2007-11-25 09:39:14 +0000 | [diff] [blame] | 81 | self.istest(inspect.isfunction, 'mod.StupidGit.abuse') |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 82 | self.istest(inspect.ismethod, 'git.argue') |
| 83 | self.istest(inspect.ismodule, 'mod') |
| 84 | self.istest(inspect.istraceback, 'tb') |
Guido van Rossum | 813b0e5 | 2007-05-21 18:11:34 +0000 | [diff] [blame] | 85 | self.istest(inspect.isdatadescriptor, 'collections.defaultdict.default_factory') |
Christian Heimes | 7131fd9 | 2008-02-19 14:21:46 +0000 | [diff] [blame] | 86 | self.istest(inspect.isgenerator, '(x for x in range(2))') |
| 87 | self.istest(inspect.isgeneratorfunction, 'generator_function_example') |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 88 | if hasattr(types, 'GetSetDescriptorType'): |
| 89 | self.istest(inspect.isgetsetdescriptor, |
| 90 | 'type(tb.tb_frame).f_locals') |
| 91 | else: |
| 92 | self.failIf(inspect.isgetsetdescriptor(type(tb.tb_frame).f_locals)) |
| 93 | if hasattr(types, 'MemberDescriptorType'): |
| 94 | self.istest(inspect.ismemberdescriptor, 'datetime.timedelta.days') |
| 95 | else: |
| 96 | self.failIf(inspect.ismemberdescriptor(datetime.timedelta.days)) |
Ka-Ping Yee | 6397c7c | 2001-02-27 14:43:21 +0000 | [diff] [blame] | 97 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 98 | def test_isroutine(self): |
| 99 | self.assert_(inspect.isroutine(mod.spam)) |
| 100 | self.assert_(inspect.isroutine([].count)) |
Ka-Ping Yee | 6397c7c | 2001-02-27 14:43:21 +0000 | [diff] [blame] | 101 | |
Benjamin Peterson | 058e31e | 2009-01-16 03:54:08 +0000 | [diff] [blame] | 102 | def test_get_slot_members(self): |
| 103 | class C(object): |
| 104 | __slots__ = ("a", "b") |
| 105 | |
| 106 | x = C() |
| 107 | x.a = 42 |
| 108 | members = dict(inspect.getmembers(x)) |
| 109 | self.assert_('a' in members) |
| 110 | self.assert_('b' not in members) |
| 111 | |
| 112 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 113 | class TestInterpreterStack(IsTestBase): |
| 114 | def __init__(self, *args, **kwargs): |
| 115 | unittest.TestCase.__init__(self, *args, **kwargs) |
Tim Peters | 5a9fb3c | 2005-01-07 16:01:32 +0000 | [diff] [blame] | 116 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 117 | git.abuse(7, 8, 9) |
Ka-Ping Yee | 6397c7c | 2001-02-27 14:43:21 +0000 | [diff] [blame] | 118 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 119 | def test_abuse_done(self): |
| 120 | self.istest(inspect.istraceback, 'git.ex[2]') |
| 121 | self.istest(inspect.isframe, 'mod.fr') |
Ka-Ping Yee | 6397c7c | 2001-02-27 14:43:21 +0000 | [diff] [blame] | 122 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 123 | def test_stack(self): |
| 124 | self.assert_(len(mod.st) >= 5) |
Christian Heimes | a3538eb | 2007-11-06 11:44:48 +0000 | [diff] [blame] | 125 | self.assertEqual(revise(*mod.st[0][1:]), |
Tim Peters | 5a9fb3c | 2005-01-07 16:01:32 +0000 | [diff] [blame] | 126 | (modfile, 16, 'eggs', [' st = inspect.stack()\n'], 0)) |
Christian Heimes | a3538eb | 2007-11-06 11:44:48 +0000 | [diff] [blame] | 127 | self.assertEqual(revise(*mod.st[1][1:]), |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 128 | (modfile, 9, 'spam', [' eggs(b + d, c + f)\n'], 0)) |
Christian Heimes | a3538eb | 2007-11-06 11:44:48 +0000 | [diff] [blame] | 129 | self.assertEqual(revise(*mod.st[2][1:]), |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 130 | (modfile, 43, 'argue', [' spam(a, b, c)\n'], 0)) |
Christian Heimes | a3538eb | 2007-11-06 11:44:48 +0000 | [diff] [blame] | 131 | self.assertEqual(revise(*mod.st[3][1:]), |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 132 | (modfile, 39, 'abuse', [' self.argue(a, b, c)\n'], 0)) |
Ka-Ping Yee | 6397c7c | 2001-02-27 14:43:21 +0000 | [diff] [blame] | 133 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 134 | def test_trace(self): |
| 135 | self.assertEqual(len(git.tr), 3) |
Christian Heimes | a3538eb | 2007-11-06 11:44:48 +0000 | [diff] [blame] | 136 | self.assertEqual(revise(*git.tr[0][1:]), |
| 137 | (modfile, 43, 'argue', [' spam(a, b, c)\n'], 0)) |
| 138 | self.assertEqual(revise(*git.tr[1][1:]), |
| 139 | (modfile, 9, 'spam', [' eggs(b + d, c + f)\n'], 0)) |
| 140 | self.assertEqual(revise(*git.tr[2][1:]), |
| 141 | (modfile, 18, 'eggs', [' q = y / 0\n'], 0)) |
Ka-Ping Yee | 6397c7c | 2001-02-27 14:43:21 +0000 | [diff] [blame] | 142 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 143 | def test_frame(self): |
| 144 | args, varargs, varkw, locals = inspect.getargvalues(mod.fr) |
| 145 | self.assertEqual(args, ['x', 'y']) |
| 146 | self.assertEqual(varargs, None) |
| 147 | self.assertEqual(varkw, None) |
| 148 | self.assertEqual(locals, {'x': 11, 'p': 11, 'y': 14}) |
| 149 | self.assertEqual(inspect.formatargvalues(args, varargs, varkw, locals), |
| 150 | '(x=11, y=14)') |
Ka-Ping Yee | 6397c7c | 2001-02-27 14:43:21 +0000 | [diff] [blame] | 151 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 152 | def test_previous_frame(self): |
| 153 | args, varargs, varkw, locals = inspect.getargvalues(mod.fr.f_back) |
Guido van Rossum | 1bc535d | 2007-05-15 18:46:22 +0000 | [diff] [blame] | 154 | self.assertEqual(args, ['a', 'b', 'c', 'd', 'e', 'f']) |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 155 | self.assertEqual(varargs, 'g') |
| 156 | self.assertEqual(varkw, 'h') |
| 157 | self.assertEqual(inspect.formatargvalues(args, varargs, varkw, locals), |
Guido van Rossum | 1bc535d | 2007-05-15 18:46:22 +0000 | [diff] [blame] | 158 | '(a=7, b=8, c=9, d=3, e=4, f=5, *g=(), **h={})') |
Ka-Ping Yee | 6397c7c | 2001-02-27 14:43:21 +0000 | [diff] [blame] | 159 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 160 | class GetSourceBase(unittest.TestCase): |
| 161 | # Subclasses must override. |
| 162 | fodderFile = None |
Tim Peters | 5a9fb3c | 2005-01-07 16:01:32 +0000 | [diff] [blame] | 163 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 164 | def __init__(self, *args, **kwargs): |
| 165 | unittest.TestCase.__init__(self, *args, **kwargs) |
Ka-Ping Yee | 6397c7c | 2001-02-27 14:43:21 +0000 | [diff] [blame] | 166 | |
Alex Martelli | 01c77c6 | 2006-08-24 02:58:11 +0000 | [diff] [blame] | 167 | self.source = open(inspect.getsourcefile(self.fodderFile)).read() |
Ka-Ping Yee | 6397c7c | 2001-02-27 14:43:21 +0000 | [diff] [blame] | 168 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 169 | def sourcerange(self, top, bottom): |
| 170 | lines = self.source.split("\n") |
| 171 | return "\n".join(lines[top-1:bottom]) + "\n" |
Tim Peters | e0b2d7a | 2001-09-22 06:10:55 +0000 | [diff] [blame] | 172 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 173 | def assertSourceEqual(self, obj, top, bottom): |
| 174 | self.assertEqual(inspect.getsource(obj), |
| 175 | self.sourcerange(top, bottom)) |
Tim Peters | 5a9fb3c | 2005-01-07 16:01:32 +0000 | [diff] [blame] | 176 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 177 | class TestRetrievingSourceCode(GetSourceBase): |
| 178 | fodderFile = mod |
Tim Peters | 5a9fb3c | 2005-01-07 16:01:32 +0000 | [diff] [blame] | 179 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 180 | def test_getclasses(self): |
| 181 | classes = inspect.getmembers(mod, inspect.isclass) |
| 182 | self.assertEqual(classes, |
| 183 | [('FesteringGob', mod.FesteringGob), |
| 184 | ('MalodorousPervert', mod.MalodorousPervert), |
| 185 | ('ParrotDroppings', mod.ParrotDroppings), |
| 186 | ('StupidGit', mod.StupidGit)]) |
| 187 | tree = inspect.getclasstree([cls[1] for cls in classes], 1) |
| 188 | self.assertEqual(tree, |
Thomas Wouters | 725af87 | 2006-04-15 09:13:19 +0000 | [diff] [blame] | 189 | [(object, ()), |
| 190 | [(mod.ParrotDroppings, (object,)), |
| 191 | (mod.StupidGit, (object,)), |
| 192 | [(mod.MalodorousPervert, (mod.StupidGit,)), |
| 193 | [(mod.FesteringGob, (mod.MalodorousPervert, |
| 194 | mod.ParrotDroppings)) |
| 195 | ] |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 196 | ] |
| 197 | ] |
| 198 | ]) |
Tim Peters | 5a9fb3c | 2005-01-07 16:01:32 +0000 | [diff] [blame] | 199 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 200 | def test_getfunctions(self): |
| 201 | functions = inspect.getmembers(mod, inspect.isfunction) |
| 202 | self.assertEqual(functions, [('eggs', mod.eggs), |
| 203 | ('spam', mod.spam)]) |
Johannes Gijsbers | c473c99 | 2004-08-18 12:40:31 +0000 | [diff] [blame] | 204 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 205 | def test_getdoc(self): |
| 206 | self.assertEqual(inspect.getdoc(mod), 'A module docstring.') |
| 207 | self.assertEqual(inspect.getdoc(mod.StupidGit), |
| 208 | 'A longer,\n\nindented\n\ndocstring.') |
| 209 | self.assertEqual(inspect.getdoc(git.abuse), |
| 210 | 'Another\n\ndocstring\n\ncontaining\n\ntabs') |
Johannes Gijsbers | c473c99 | 2004-08-18 12:40:31 +0000 | [diff] [blame] | 211 | |
Georg Brandl | 0c77a82 | 2008-06-10 16:37:50 +0000 | [diff] [blame] | 212 | def test_cleandoc(self): |
| 213 | self.assertEqual(inspect.cleandoc('An\n indented\n docstring.'), |
| 214 | 'An\nindented\ndocstring.') |
| 215 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 216 | def test_getcomments(self): |
| 217 | self.assertEqual(inspect.getcomments(mod), '# line 1\n') |
| 218 | self.assertEqual(inspect.getcomments(mod.StupidGit), '# line 20\n') |
Johannes Gijsbers | c473c99 | 2004-08-18 12:40:31 +0000 | [diff] [blame] | 219 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 220 | def test_getmodule(self): |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 221 | # Check actual module |
| 222 | self.assertEqual(inspect.getmodule(mod), mod) |
| 223 | # Check class (uses __module__ attribute) |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 224 | self.assertEqual(inspect.getmodule(mod.StupidGit), mod) |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 225 | # Check a method (no __module__ attribute, falls back to filename) |
| 226 | self.assertEqual(inspect.getmodule(mod.StupidGit.abuse), mod) |
| 227 | # Do it again (check the caching isn't broken) |
| 228 | self.assertEqual(inspect.getmodule(mod.StupidGit.abuse), mod) |
| 229 | # Check a builtin |
Georg Brandl | 1a3284e | 2007-12-02 09:40:06 +0000 | [diff] [blame] | 230 | self.assertEqual(inspect.getmodule(str), sys.modules["builtins"]) |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 231 | # Check filename override |
| 232 | self.assertEqual(inspect.getmodule(None, modfile), mod) |
Johannes Gijsbers | c473c99 | 2004-08-18 12:40:31 +0000 | [diff] [blame] | 233 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 234 | def test_getsource(self): |
| 235 | self.assertSourceEqual(git.abuse, 29, 39) |
| 236 | self.assertSourceEqual(mod.StupidGit, 21, 46) |
Johannes Gijsbers | c473c99 | 2004-08-18 12:40:31 +0000 | [diff] [blame] | 237 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 238 | def test_getsourcefile(self): |
Christian Heimes | a3538eb | 2007-11-06 11:44:48 +0000 | [diff] [blame] | 239 | self.assertEqual(normcase(inspect.getsourcefile(mod.spam)), modfile) |
| 240 | self.assertEqual(normcase(inspect.getsourcefile(git.abuse)), modfile) |
Johannes Gijsbers | c473c99 | 2004-08-18 12:40:31 +0000 | [diff] [blame] | 241 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 242 | def test_getfile(self): |
| 243 | self.assertEqual(inspect.getfile(mod.StupidGit), mod.__file__) |
Johannes Gijsbers | c473c99 | 2004-08-18 12:40:31 +0000 | [diff] [blame] | 244 | |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 245 | def test_getmodule_recursion(self): |
Christian Heimes | 45f9af3 | 2007-11-27 21:50:00 +0000 | [diff] [blame] | 246 | from types import ModuleType |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 247 | name = '__inspect_dummy' |
Christian Heimes | 45f9af3 | 2007-11-27 21:50:00 +0000 | [diff] [blame] | 248 | m = sys.modules[name] = ModuleType(name) |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 249 | m.__file__ = "<string>" # hopefully not a real filename... |
| 250 | m.__loader__ = "dummy" # pretend the filename is understood by a loader |
Georg Brandl | 7cae87c | 2006-09-06 06:51:57 +0000 | [diff] [blame] | 251 | exec("def x(): pass", m.__dict__) |
Neal Norwitz | 221085d | 2007-02-25 20:55:47 +0000 | [diff] [blame] | 252 | self.assertEqual(inspect.getsourcefile(m.x.__code__), '<string>') |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 253 | del sys.modules[name] |
| 254 | inspect.getmodule(compile('a=10','','single')) |
| 255 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 256 | class TestDecorators(GetSourceBase): |
| 257 | fodderFile = mod2 |
Johannes Gijsbers | c473c99 | 2004-08-18 12:40:31 +0000 | [diff] [blame] | 258 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 259 | def test_wrapped_decorator(self): |
Christian Heimes | 09aaa88 | 2008-02-23 15:01:06 +0000 | [diff] [blame] | 260 | self.assertSourceEqual(mod2.wrapped, 14, 17) |
Johannes Gijsbers | c473c99 | 2004-08-18 12:40:31 +0000 | [diff] [blame] | 261 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 262 | def test_replacing_decorator(self): |
| 263 | self.assertSourceEqual(mod2.gone, 9, 10) |
Tim Peters | e0b2d7a | 2001-09-22 06:10:55 +0000 | [diff] [blame] | 264 | |
Johannes Gijsbers | 1542f34 | 2004-12-12 16:46:28 +0000 | [diff] [blame] | 265 | class TestOneliners(GetSourceBase): |
| 266 | fodderFile = mod2 |
| 267 | def test_oneline_lambda(self): |
| 268 | # Test inspect.getsource with a one-line lambda function. |
| 269 | self.assertSourceEqual(mod2.oll, 25, 25) |
Tim Peters | 5a9fb3c | 2005-01-07 16:01:32 +0000 | [diff] [blame] | 270 | |
Johannes Gijsbers | 1542f34 | 2004-12-12 16:46:28 +0000 | [diff] [blame] | 271 | def test_threeline_lambda(self): |
| 272 | # Test inspect.getsource with a three-line lambda function, |
| 273 | # where the second and third lines are _not_ indented. |
Tim Peters | 5a9fb3c | 2005-01-07 16:01:32 +0000 | [diff] [blame] | 274 | self.assertSourceEqual(mod2.tll, 28, 30) |
| 275 | |
Johannes Gijsbers | 1542f34 | 2004-12-12 16:46:28 +0000 | [diff] [blame] | 276 | def test_twoline_indented_lambda(self): |
| 277 | # Test inspect.getsource with a two-line lambda function, |
| 278 | # where the second line _is_ indented. |
| 279 | self.assertSourceEqual(mod2.tlli, 33, 34) |
Tim Peters | 5a9fb3c | 2005-01-07 16:01:32 +0000 | [diff] [blame] | 280 | |
Johannes Gijsbers | 1542f34 | 2004-12-12 16:46:28 +0000 | [diff] [blame] | 281 | def test_onelinefunc(self): |
| 282 | # Test inspect.getsource with a regular one-line function. |
| 283 | self.assertSourceEqual(mod2.onelinefunc, 37, 37) |
Tim Peters | 5a9fb3c | 2005-01-07 16:01:32 +0000 | [diff] [blame] | 284 | |
Johannes Gijsbers | 1542f34 | 2004-12-12 16:46:28 +0000 | [diff] [blame] | 285 | def test_manyargs(self): |
| 286 | # Test inspect.getsource with a regular function where |
| 287 | # the arguments are on two lines and _not_ indented and |
| 288 | # the body on the second line with the last arguments. |
| 289 | self.assertSourceEqual(mod2.manyargs, 40, 41) |
Tim Peters | 5a9fb3c | 2005-01-07 16:01:32 +0000 | [diff] [blame] | 290 | |
Johannes Gijsbers | 1542f34 | 2004-12-12 16:46:28 +0000 | [diff] [blame] | 291 | def test_twolinefunc(self): |
| 292 | # Test inspect.getsource with a regular function where |
| 293 | # the body is on two lines, following the argument list and |
| 294 | # continued on the next line by a \\. |
| 295 | self.assertSourceEqual(mod2.twolinefunc, 44, 45) |
Tim Peters | 5a9fb3c | 2005-01-07 16:01:32 +0000 | [diff] [blame] | 296 | |
Johannes Gijsbers | 1542f34 | 2004-12-12 16:46:28 +0000 | [diff] [blame] | 297 | def test_lambda_in_list(self): |
| 298 | # Test inspect.getsource with a one-line lambda function |
| 299 | # defined in a list, indented. |
| 300 | self.assertSourceEqual(mod2.a[1], 49, 49) |
Tim Peters | 5a9fb3c | 2005-01-07 16:01:32 +0000 | [diff] [blame] | 301 | |
Johannes Gijsbers | 1542f34 | 2004-12-12 16:46:28 +0000 | [diff] [blame] | 302 | def test_anonymous(self): |
| 303 | # Test inspect.getsource with a lambda function defined |
| 304 | # as argument to another function. |
| 305 | self.assertSourceEqual(mod2.anonymous, 55, 55) |
| 306 | |
Johannes Gijsbers | a5855d5 | 2005-03-12 16:37:11 +0000 | [diff] [blame] | 307 | class TestBuggyCases(GetSourceBase): |
| 308 | fodderFile = mod2 |
| 309 | |
| 310 | def test_with_comment(self): |
| 311 | self.assertSourceEqual(mod2.with_comment, 58, 59) |
| 312 | |
| 313 | def test_multiline_sig(self): |
| 314 | self.assertSourceEqual(mod2.multiline_sig[0], 63, 64) |
| 315 | |
Armin Rigo | dd5c023 | 2005-09-25 11:45:45 +0000 | [diff] [blame] | 316 | def test_nested_class(self): |
| 317 | self.assertSourceEqual(mod2.func69().func71, 71, 72) |
| 318 | |
| 319 | def test_one_liner_followed_by_non_name(self): |
| 320 | self.assertSourceEqual(mod2.func77, 77, 77) |
| 321 | |
| 322 | def test_one_liner_dedent_non_name(self): |
| 323 | self.assertSourceEqual(mod2.cls82.func83, 83, 83) |
| 324 | |
| 325 | def test_with_comment_instead_of_docstring(self): |
| 326 | self.assertSourceEqual(mod2.func88, 88, 90) |
| 327 | |
Thomas Wouters | 00ee7ba | 2006-08-21 19:07:27 +0000 | [diff] [blame] | 328 | def test_method_in_dynamic_class(self): |
| 329 | self.assertSourceEqual(mod2.method_in_dynamic_class, 95, 97) |
| 330 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 331 | # Helper for testing classify_class_attrs. |
Tim Peters | 13b49d3 | 2001-09-23 02:00:29 +0000 | [diff] [blame] | 332 | def attrs_wo_objs(cls): |
| 333 | return [t[:3] for t in inspect.classify_class_attrs(cls)] |
| 334 | |
Tim Peters | 5a9fb3c | 2005-01-07 16:01:32 +0000 | [diff] [blame] | 335 | class TestClassesAndFunctions(unittest.TestCase): |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 336 | def test_newstyle_mro(self): |
| 337 | # The same w/ new-class MRO. |
| 338 | class A(object): pass |
| 339 | class B(A): pass |
| 340 | class C(A): pass |
| 341 | class D(B, C): pass |
Tim Peters | 13b49d3 | 2001-09-23 02:00:29 +0000 | [diff] [blame] | 342 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 343 | expected = (D, B, C, A, object) |
| 344 | got = inspect.getmro(D) |
| 345 | self.assertEqual(expected, got) |
Tim Peters | 13b49d3 | 2001-09-23 02:00:29 +0000 | [diff] [blame] | 346 | |
Christian Heimes | 3795b53 | 2007-11-08 13:48:53 +0000 | [diff] [blame] | 347 | def assertArgSpecEquals(self, routine, args_e, varargs_e=None, |
| 348 | varkw_e=None, defaults_e=None, formatted=None): |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 349 | args, varargs, varkw, defaults = inspect.getargspec(routine) |
| 350 | self.assertEqual(args, args_e) |
| 351 | self.assertEqual(varargs, varargs_e) |
| 352 | self.assertEqual(varkw, varkw_e) |
| 353 | self.assertEqual(defaults, defaults_e) |
| 354 | if formatted is not None: |
| 355 | self.assertEqual(inspect.formatargspec(args, varargs, varkw, defaults), |
| 356 | formatted) |
Tim Peters | 13b49d3 | 2001-09-23 02:00:29 +0000 | [diff] [blame] | 357 | |
Christian Heimes | 3795b53 | 2007-11-08 13:48:53 +0000 | [diff] [blame] | 358 | def assertFullArgSpecEquals(self, routine, args_e, varargs_e=None, |
| 359 | varkw_e=None, defaults_e=None, |
| 360 | kwonlyargs_e=[], kwonlydefaults_e=None, |
| 361 | ann_e={}, formatted=None): |
| 362 | args, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, ann = \ |
| 363 | inspect.getfullargspec(routine) |
| 364 | self.assertEqual(args, args_e) |
| 365 | self.assertEqual(varargs, varargs_e) |
| 366 | self.assertEqual(varkw, varkw_e) |
| 367 | self.assertEqual(defaults, defaults_e) |
| 368 | self.assertEqual(kwonlyargs, kwonlyargs_e) |
| 369 | self.assertEqual(kwonlydefaults, kwonlydefaults_e) |
| 370 | self.assertEqual(ann, ann_e) |
| 371 | if formatted is not None: |
| 372 | self.assertEqual(inspect.formatargspec(args, varargs, varkw, defaults, |
| 373 | kwonlyargs, kwonlydefaults, ann), |
| 374 | formatted) |
| 375 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 376 | def test_getargspec(self): |
Christian Heimes | 3795b53 | 2007-11-08 13:48:53 +0000 | [diff] [blame] | 377 | self.assertArgSpecEquals(mod.eggs, ['x', 'y'], formatted='(x, y)') |
Tim Peters | 13b49d3 | 2001-09-23 02:00:29 +0000 | [diff] [blame] | 378 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 379 | self.assertArgSpecEquals(mod.spam, |
Guido van Rossum | 1bc535d | 2007-05-15 18:46:22 +0000 | [diff] [blame] | 380 | ['a', 'b', 'c', 'd', 'e', 'f'], |
| 381 | 'g', 'h', (3, 4, 5), |
| 382 | '(a, b, c, d=3, e=4, f=5, *g, **h)') |
Tim Peters | 13b49d3 | 2001-09-23 02:00:29 +0000 | [diff] [blame] | 383 | |
Christian Heimes | 3795b53 | 2007-11-08 13:48:53 +0000 | [diff] [blame] | 384 | self.assertRaises(ValueError, self.assertArgSpecEquals, |
| 385 | mod2.keyworded, []) |
| 386 | |
| 387 | self.assertRaises(ValueError, self.assertArgSpecEquals, |
| 388 | mod2.annotated, []) |
| 389 | |
| 390 | def test_getfullargspec(self): |
| 391 | self.assertFullArgSpecEquals(mod2.keyworded, [], varargs_e='arg1', |
| 392 | kwonlyargs_e=['arg2'], |
| 393 | kwonlydefaults_e={'arg2':1}, |
| 394 | formatted='(*arg1, arg2=1)') |
| 395 | |
| 396 | self.assertFullArgSpecEquals(mod2.annotated, ['arg1'], |
Christian Heimes | c9543e4 | 2007-11-28 08:28:28 +0000 | [diff] [blame] | 397 | ann_e={'arg1' : list}, |
Christian Heimes | 3795b53 | 2007-11-08 13:48:53 +0000 | [diff] [blame] | 398 | formatted='(arg1: list)') |
| 399 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 400 | def test_getargspec_method(self): |
| 401 | class A(object): |
| 402 | def m(self): |
| 403 | pass |
| 404 | self.assertArgSpecEquals(A.m, ['self']) |
Tim Peters | 13b49d3 | 2001-09-23 02:00:29 +0000 | [diff] [blame] | 405 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 406 | def test_classify_newstyle(self): |
| 407 | class A(object): |
Tim Peters | 13b49d3 | 2001-09-23 02:00:29 +0000 | [diff] [blame] | 408 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 409 | def s(): pass |
| 410 | s = staticmethod(s) |
Tim Peters | 13b49d3 | 2001-09-23 02:00:29 +0000 | [diff] [blame] | 411 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 412 | def c(cls): pass |
| 413 | c = classmethod(c) |
Tim Peters | 13b49d3 | 2001-09-23 02:00:29 +0000 | [diff] [blame] | 414 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 415 | def getp(self): pass |
| 416 | p = property(getp) |
Tim Peters | 13b49d3 | 2001-09-23 02:00:29 +0000 | [diff] [blame] | 417 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 418 | def m(self): pass |
Tim Peters | 13b49d3 | 2001-09-23 02:00:29 +0000 | [diff] [blame] | 419 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 420 | def m1(self): pass |
Tim Peters | 13b49d3 | 2001-09-23 02:00:29 +0000 | [diff] [blame] | 421 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 422 | datablob = '1' |
Tim Peters | 13b49d3 | 2001-09-23 02:00:29 +0000 | [diff] [blame] | 423 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 424 | attrs = attrs_wo_objs(A) |
| 425 | self.assert_(('s', 'static method', A) in attrs, 'missing static method') |
| 426 | self.assert_(('c', 'class method', A) in attrs, 'missing class method') |
| 427 | self.assert_(('p', 'property', A) in attrs, 'missing property') |
Christian Heimes | 4a22b5d | 2007-11-25 09:39:14 +0000 | [diff] [blame] | 428 | self.assert_(('m', 'method', A) in attrs, |
| 429 | 'missing plain method: %r' % attrs) |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 430 | self.assert_(('m1', 'method', A) in attrs, 'missing plain method') |
| 431 | self.assert_(('datablob', 'data', A) in attrs, 'missing data') |
Tim Peters | 13b49d3 | 2001-09-23 02:00:29 +0000 | [diff] [blame] | 432 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 433 | class B(A): |
Tim Peters | 13b49d3 | 2001-09-23 02:00:29 +0000 | [diff] [blame] | 434 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 435 | def m(self): pass |
Tim Peters | 13b49d3 | 2001-09-23 02:00:29 +0000 | [diff] [blame] | 436 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 437 | attrs = attrs_wo_objs(B) |
| 438 | self.assert_(('s', 'static method', A) in attrs, 'missing static method') |
| 439 | self.assert_(('c', 'class method', A) in attrs, 'missing class method') |
| 440 | self.assert_(('p', 'property', A) in attrs, 'missing property') |
| 441 | self.assert_(('m', 'method', B) in attrs, 'missing plain method') |
| 442 | self.assert_(('m1', 'method', A) in attrs, 'missing plain method') |
| 443 | self.assert_(('datablob', 'data', A) in attrs, 'missing data') |
Tim Peters | 13b49d3 | 2001-09-23 02:00:29 +0000 | [diff] [blame] | 444 | |
| 445 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 446 | class C(A): |
Tim Peters | 13b49d3 | 2001-09-23 02:00:29 +0000 | [diff] [blame] | 447 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 448 | def m(self): pass |
| 449 | def c(self): pass |
Tim Peters | 13b49d3 | 2001-09-23 02:00:29 +0000 | [diff] [blame] | 450 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 451 | attrs = attrs_wo_objs(C) |
| 452 | self.assert_(('s', 'static method', A) in attrs, 'missing static method') |
| 453 | self.assert_(('c', 'method', C) in attrs, 'missing plain method') |
| 454 | self.assert_(('p', 'property', A) in attrs, 'missing property') |
| 455 | self.assert_(('m', 'method', C) in attrs, 'missing plain method') |
| 456 | self.assert_(('m1', 'method', A) in attrs, 'missing plain method') |
| 457 | self.assert_(('datablob', 'data', A) in attrs, 'missing data') |
Tim Peters | 13b49d3 | 2001-09-23 02:00:29 +0000 | [diff] [blame] | 458 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 459 | class D(B, C): |
Tim Peters | 13b49d3 | 2001-09-23 02:00:29 +0000 | [diff] [blame] | 460 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 461 | def m1(self): pass |
Tim Peters | 13b49d3 | 2001-09-23 02:00:29 +0000 | [diff] [blame] | 462 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 463 | attrs = attrs_wo_objs(D) |
| 464 | self.assert_(('s', 'static method', A) in attrs, 'missing static method') |
| 465 | self.assert_(('c', 'method', C) in attrs, 'missing plain method') |
| 466 | self.assert_(('p', 'property', A) in attrs, 'missing property') |
| 467 | self.assert_(('m', 'method', B) in attrs, 'missing plain method') |
| 468 | self.assert_(('m1', 'method', D) in attrs, 'missing plain method') |
| 469 | self.assert_(('datablob', 'data', A) in attrs, 'missing data') |
Jeremy Hylton | c4bf5ed | 2003-06-27 18:43:12 +0000 | [diff] [blame] | 470 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 471 | def test_main(): |
Johannes Gijsbers | 1542f34 | 2004-12-12 16:46:28 +0000 | [diff] [blame] | 472 | run_unittest(TestDecorators, TestRetrievingSourceCode, TestOneliners, |
Johannes Gijsbers | a5855d5 | 2005-03-12 16:37:11 +0000 | [diff] [blame] | 473 | TestBuggyCases, |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 474 | TestInterpreterStack, TestClassesAndFunctions, TestPredicates) |
Martin v. Löwis | 893ffa4 | 2003-10-31 15:35:53 +0000 | [diff] [blame] | 475 | |
Johannes Gijsbers | cb9015d | 2004-12-12 16:20:22 +0000 | [diff] [blame] | 476 | if __name__ == "__main__": |
| 477 | test_main() |