mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-10-24 15:36:26 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 9

Patch #736962: port test_inspect to unittest. As part of this, move out

Browse source 
the fodder modules to separate files to get rid of the imp.load_source()
trickery.
This commit is contained in:
Johannes Gijsbers 2004-12-12 16:20:22 +00:00
parent 6b220b0355
commit cb9015dc08
3 changed files with 381 additions and 349 deletions
Download patch file Download diff file Expand all files Collapse all files

56
Lib/test/inspect_fodder.py Normal file
View file

@ -0,0 +1,56 @@
# line 1
'A module docstring.'
import sys, inspect
# line 5
# line 7
def spam(a, b, c, d=3, (e, (f,))=(4, (5,)), *g, **h):
eggs(b + d, c + f)
# line 11
def eggs(x, y):
"A docstring."
global fr, st
fr = inspect.currentframe()
st = inspect.stack()
p = x
q = y / 0
# line 20
class StupidGit:
"""A longer,
indented
docstring."""
# line 27
def abuse(self, a, b, c):
"""Another
\tdocstring
containing
\ttabs
\t
"""
self.argue(a, b, c)
# line 40
def argue(self, a, b, c):
try:
spam(a, b, c)
except:
self.ex = sys.exc_info()
self.tr = inspect.trace()
# line 48
class MalodorousPervert(StupidGit):
pass
class ParrotDroppings:
pass
class FesteringGob(MalodorousPervert, ParrotDroppings):
pass

22
Lib/test/inspect_fodder2.py Normal file
View file

@ -0,0 +1,22 @@
# line 1
def wrap(foo=None):
def wrapper(func):
return func
return wrapper
# line 7
def replace(func):
def insteadfunc():
print 'hello'
return insteadfunc
# line 13
@wrap()
@wrap(wrap)
def wrapped():
pass
# line 19
@replace
def gone():
pass

644
Lib/test/test_inspect.py
View file

@ -1,60 +1,11 @@
source = '''# line 1 import sys
'A module docstring.' import unittest
import inspect
import sys, inspect from test.test_support import TESTFN, run_unittest
# line 5
# line 7 from test import inspect_fodder as mod
def spam(a, b, c, d=3, (e, (f,))=(4, (5,)), *g, **h): from test import inspect_fodder2 as mod2
eggs(b + d, c + f)
# line 11
def eggs(x, y):
"A docstring."
global fr, st
fr = inspect.currentframe()
st = inspect.stack()
p = x
q = y / 0
# line 20
class StupidGit:
"""A longer,
indented
docstring."""
# line 27
def abuse(self, a, b, c):
"""Another
\tdocstring
containing
\ttabs
\t
"""
self.argue(a, b, c)
# line 40
def argue(self, a, b, c):
try:
spam(a, b, c)
except:
self.ex = sys.exc_info()
self.tr = inspect.trace()
# line 48
class MalodorousPervert(StupidGit):
pass
class ParrotDroppings:
pass
class FesteringGob(MalodorousPervert, ParrotDroppings):
pass
'''
# Functions tested in this suite: # Functions tested in this suite:
# ismodule, isclass, ismethod, isfunction, istraceback, isframe, iscode, # ismodule, isclass, ismethod, isfunction, istraceback, isframe, iscode,
@ -63,363 +14,366 @@ class FesteringGob(MalodorousPervert, ParrotDroppings):
# getargvalues, formatargspec, formatargvalues, currentframe, stack, trace # getargvalues, formatargspec, formatargvalues, currentframe, stack, trace
# isdatadescriptor # isdatadescriptor
from test.test_support import TestFailed, TESTFN modfile = mod.__file__
import sys, imp, os, string if modfile.endswith('c') or modfile.endswith('o'):
modfile = modfile[:-1]
def test(assertion, message, *args): import __builtin__
if not assertion:
raise TestFailed, message % args
import inspect
file = open(TESTFN, 'w')
file.write(source)
file.close()
# Note that load_source creates file TESTFN+'c' or TESTFN+'o'.
mod = imp.load_source('testmod', TESTFN)
files_to_clean_up = [TESTFN, TESTFN + 'c', TESTFN + 'o']
def istest(func, exp):
obj = eval(exp)
test(func(obj), '%s(%s)' % (func.__name__, exp))
for other in [inspect.isbuiltin, inspect.isclass, inspect.iscode,
inspect.isframe, inspect.isfunction, inspect.ismethod,
inspect.ismodule, inspect.istraceback]:
if other is not func:
test(not other(obj), 'not %s(%s)' % (other.__name__, exp))
git = mod.StupidGit()
try: try:
1/0 1/0
except: except:
tb = sys.exc_traceback tb = sys.exc_traceback
istest(inspect.isbuiltin, 'sys.exit') git = mod.StupidGit()
istest(inspect.isbuiltin, '[].append')
istest(inspect.isclass, 'mod.StupidGit')
istest(inspect.iscode, 'mod.spam.func_code')
istest(inspect.isframe, 'tb.tb_frame')
istest(inspect.isfunction, 'mod.spam')
istest(inspect.ismethod, 'mod.StupidGit.abuse')
istest(inspect.ismethod, 'git.argue')
istest(inspect.ismodule, 'mod')
istest(inspect.istraceback, 'tb')
import __builtin__
istest(inspect.isdatadescriptor, '__builtin__.file.closed')
istest(inspect.isdatadescriptor, '__builtin__.file.softspace')
test(inspect.isroutine(mod.spam), 'isroutine(mod.spam)')
test(inspect.isroutine([].count), 'isroutine([].count)')
classes = inspect.getmembers(mod, inspect.isclass) class IsTestBase(unittest.TestCase):
test(classes == predicates = set([inspect.isbuiltin, inspect.isclass, inspect.iscode,
[('FesteringGob', mod.FesteringGob), inspect.isframe, inspect.isfunction, inspect.ismethod,
('MalodorousPervert', mod.MalodorousPervert), inspect.ismodule, inspect.istraceback])
('ParrotDroppings', mod.ParrotDroppings),
('StupidGit', mod.StupidGit)], 'class list')
tree = inspect.getclasstree(map(lambda x: x[1], classes), 1)
test(tree ==
[(mod.ParrotDroppings, ()),
(mod.StupidGit, ()),
[(mod.MalodorousPervert, (mod.StupidGit,)),
[(mod.FesteringGob, (mod.MalodorousPervert, mod.ParrotDroppings))
]
]
], 'class tree')
functions = inspect.getmembers(mod, inspect.isfunction) def istest(self, predicate, exp):
test(functions == [('eggs', mod.eggs), ('spam', mod.spam)], 'function list') obj = eval(exp)
self.failUnless(predicate(obj), '%s(%s)' % (predicate.__name__, exp))
test(inspect.getdoc(mod) == 'A module docstring.', 'getdoc(mod)') for other in self.predicates - set([predicate]):
test(inspect.getcomments(mod) == '# line 1\n', 'getcomments(mod)') self.failIf(other(obj), 'not %s(%s)' % (other.__name__, exp))
test(inspect.getmodule(mod.StupidGit) == mod, 'getmodule(mod.StupidGit)')
test(inspect.getfile(mod.StupidGit) == TESTFN, 'getfile(mod.StupidGit)')
test(inspect.getsourcefile(mod.spam) == TESTFN, 'getsourcefile(mod.spam)')
test(inspect.getsourcefile(git.abuse) == TESTFN, 'getsourcefile(git.abuse)')
def sourcerange(top, bottom): class TestPredicates(IsTestBase):
lines = string.split(source, '\n') def test_eleven(self):
return string.join(lines[top-1:bottom], '\n') + '\n' # Doc/lib/libinspect.tex claims there are 11 such functions
count = len(filter(lambda x:x.startswith('is'), dir(inspect)))
self.assertEqual(count, 11, "There are %d (not 11) is* functions" % count)
test(inspect.getsource(git.abuse) == sourcerange(29, 39), def test_excluding_predicates(self):
'getsource(git.abuse)') self.istest(inspect.isbuiltin, 'sys.exit')
test(inspect.getsource(mod.StupidGit) == sourcerange(21, 46), self.istest(inspect.isbuiltin, '[].append')
'getsource(mod.StupidGit)') self.istest(inspect.isclass, 'mod.StupidGit')
test(inspect.getdoc(mod.StupidGit) == self.istest(inspect.iscode, 'mod.spam.func_code')
'A longer,\n\nindented\n\ndocstring.', 'getdoc(mod.StupidGit)') self.istest(inspect.isframe, 'tb.tb_frame')
test(inspect.getdoc(git.abuse) == self.istest(inspect.isfunction, 'mod.spam')
'Another\n\ndocstring\n\ncontaining\n\ntabs', 'getdoc(git.abuse)') self.istest(inspect.ismethod, 'mod.StupidGit.abuse')
test(inspect.getcomments(mod.StupidGit) == '# line 20\n', self.istest(inspect.ismethod, 'git.argue')
'getcomments(mod.StupidGit)') self.istest(inspect.ismodule, 'mod')
self.istest(inspect.istraceback, 'tb')
self.istest(inspect.isdatadescriptor, '__builtin__.file.closed')
self.istest(inspect.isdatadescriptor, '__builtin__.file.softspace')
git.abuse(7, 8, 9) def test_isroutine(self):
self.assert_(inspect.isroutine(mod.spam))
self.assert_(inspect.isroutine([].count))
istest(inspect.istraceback, 'git.ex[2]') class TestInterpreterStack(IsTestBase):
istest(inspect.isframe, 'mod.fr') def __init__(self, *args, **kwargs):
unittest.TestCase.__init__(self, *args, **kwargs)
test(len(git.tr) == 3, 'trace() length') git.abuse(7, 8, 9)
test(git.tr[0][1:] == (TESTFN, 43, 'argue',
[' spam(a, b, c)\n'], 0),
'trace() row 2')
test(git.tr[1][1:] == (TESTFN, 9, 'spam', [' eggs(b + d, c + f)\n'], 0),
'trace() row 2')
test(git.tr[2][1:] == (TESTFN, 18, 'eggs', [' q = y / 0\n'], 0),
'trace() row 3')
test(len(mod.st) >= 5, 'stack() length') def test_abuse_done(self):
test(mod.st[0][1:] == self.istest(inspect.istraceback, 'git.ex[2]')
(TESTFN, 16, 'eggs', [' st = inspect.stack()\n'], 0), self.istest(inspect.isframe, 'mod.fr')
'stack() row 1')
test(mod.st[1][1:] ==
(TESTFN, 9, 'spam', [' eggs(b + d, c + f)\n'], 0),
'stack() row 2')
test(mod.st[2][1:] ==
(TESTFN, 43, 'argue', [' spam(a, b, c)\n'], 0),
'stack() row 3')
test(mod.st[3][1:] ==
(TESTFN, 39, 'abuse', [' self.argue(a, b, c)\n'], 0),
'stack() row 4')
args, varargs, varkw, locals = inspect.getargvalues(mod.fr) def test_stack(self):
test(args == ['x', 'y'], 'mod.fr args') self.assert_(len(mod.st) >= 5)
test(varargs == None, 'mod.fr varargs') self.assertEqual(mod.st[0][1:],
test(varkw == None, 'mod.fr varkw') (modfile, 16, 'eggs', [' st = inspect.stack()\n'], 0))
test(locals == {'x': 11, 'p': 11, 'y': 14}, 'mod.fr locals') self.assertEqual(mod.st[1][1:],
test(inspect.formatargvalues(args, varargs, varkw, locals) == (modfile, 9, 'spam', [' eggs(b + d, c + f)\n'], 0))
'(x=11, y=14)', 'mod.fr formatted argvalues') self.assertEqual(mod.st[2][1:],
(modfile, 43, 'argue', [' spam(a, b, c)\n'], 0))
self.assertEqual(mod.st[3][1:],
(modfile, 39, 'abuse', [' self.argue(a, b, c)\n'], 0))
args, varargs, varkw, locals = inspect.getargvalues(mod.fr.f_back) def test_trace(self):
test(args == ['a', 'b', 'c', 'd', ['e', ['f']]], 'mod.fr.f_back args') self.assertEqual(len(git.tr), 3)
test(varargs == 'g', 'mod.fr.f_back varargs') self.assertEqual(git.tr[0][1:], (modfile, 43, 'argue',
test(varkw == 'h', 'mod.fr.f_back varkw') [' spam(a, b, c)\n'], 0))
test(inspect.formatargvalues(args, varargs, varkw, locals) == self.assertEqual(git.tr[1][1:], (modfile, 9, 'spam',
'(a=7, b=8, c=9, d=3, (e=4, (f=5,)), *g=(), **h={})', [' eggs(b + d, c + f)\n'], 0))
'mod.fr.f_back formatted argvalues') self.assertEqual(git.tr[2][1:], (modfile, 18, 'eggs',
[' q = y / 0\n'], 0))
for fname in files_to_clean_up: def test_frame(self):
try: args, varargs, varkw, locals = inspect.getargvalues(mod.fr)
os.unlink(fname) self.assertEqual(args, ['x', 'y'])
except: self.assertEqual(varargs, None)
pass self.assertEqual(varkw, None)
self.assertEqual(locals, {'x': 11, 'p': 11, 'y': 14})
self.assertEqual(inspect.formatargvalues(args, varargs, varkw, locals),
'(x=11, y=14)')
# Test for decorators as well. def test_previous_frame(self):
args, varargs, varkw, locals = inspect.getargvalues(mod.fr.f_back)
self.assertEqual(args, ['a', 'b', 'c', 'd', ['e', ['f']]])
self.assertEqual(varargs, 'g')
self.assertEqual(varkw, 'h')
self.assertEqual(inspect.formatargvalues(args, varargs, varkw, locals),
'(a=7, b=8, c=9, d=3, (e=4, (f=5,)), *g=(), **h={})')
source = r""" class GetSourceBase(unittest.TestCase):
def wrap(foo=None): # Subclasses must override.
def wrapper(func): fodderFile = None
return func
return wrapper
def replace(func): def __init__(self, *args, **kwargs):
def insteadfunc(): unittest.TestCase.__init__(self, *args, **kwargs)
print 'hello'
return insteadfunc
# two decorators, one with argument self.source = file(inspect.getsourcefile(self.fodderFile)).read()
@wrap()
@wrap(wrap)
def wrapped():
pass
@replace def sourcerange(self, top, bottom):
def gone(): lines = self.source.split("\n")
pass""" return "\n".join(lines[top-1:bottom]) + "\n"
file = open(TESTFN + "2", "w") def assertSourceEqual(self, obj, top, bottom):
file.write(source) self.assertEqual(inspect.getsource(obj),
file.close() self.sourcerange(top, bottom))
files_to_clean_up = [TESTFN + "2", TESTFN + '2c', TESTFN + '2o']
mod2 = imp.load_source("testmod3", TESTFN + "2") class TestRetrievingSourceCode(GetSourceBase):
fodderFile = mod
test(inspect.getsource(mod2.wrapped) == sourcerange(13, 16), def test_getclasses(self):
"inspect.getsource(mod.wrapped)") classes = inspect.getmembers(mod, inspect.isclass)
test(inspect.getsource(mod2.gone) == sourcerange(8, 9), self.assertEqual(classes,
"inspect.getsource(mod.gone)") [('FesteringGob', mod.FesteringGob),
('MalodorousPervert', mod.MalodorousPervert),
('ParrotDroppings', mod.ParrotDroppings),
('StupidGit', mod.StupidGit)])
tree = inspect.getclasstree([cls[1] for cls in classes], 1)
self.assertEqual(tree,
[(mod.ParrotDroppings, ()),
(mod.StupidGit, ()),
[(mod.MalodorousPervert, (mod.StupidGit,)),
[(mod.FesteringGob, (mod.MalodorousPervert,
mod.ParrotDroppings))
]
]
])
for fname in files_to_clean_up: def test_getfunctions(self):
try: functions = inspect.getmembers(mod, inspect.isfunction)
os.unlink(fname) self.assertEqual(functions, [('eggs', mod.eggs),
except: ('spam', mod.spam)])
pass
# Test classic-class method resolution order. def test_getdoc(self):
class A: pass self.assertEqual(inspect.getdoc(mod), 'A module docstring.')
class B(A): pass self.assertEqual(inspect.getdoc(mod.StupidGit),
class C(A): pass 'A longer,\n\nindented\n\ndocstring.')
class D(B, C): pass self.assertEqual(inspect.getdoc(git.abuse),
'Another\n\ndocstring\n\ncontaining\n\ntabs')
expected = (D, B, A, C) def test_getcomments(self):
got = inspect.getmro(D) self.assertEqual(inspect.getcomments(mod), '# line 1\n')
test(expected == got, "expected %r mro, got %r", expected, got) self.assertEqual(inspect.getcomments(mod.StupidGit), '# line 20\n')
# The same w/ new-class MRO. def test_getmodule(self):
class A(object): pass self.assertEqual(inspect.getmodule(mod.StupidGit), mod)
class B(A): pass
class C(A): pass
class D(B, C): pass
expected = (D, B, C, A, object) def test_getsource(self):
got = inspect.getmro(D) self.assertSourceEqual(git.abuse, 29, 39)
test(expected == got, "expected %r mro, got %r", expected, got) self.assertSourceEqual(mod.StupidGit, 21, 46)
# Test classify_class_attrs. def test_getsourcefile(self):
self.assertEqual(inspect.getsourcefile(mod.spam), modfile)
self.assertEqual(inspect.getsourcefile(git.abuse), modfile)
def test_getfile(self):
self.assertEqual(inspect.getfile(mod.StupidGit), mod.__file__)
class TestDecorators(GetSourceBase):
fodderFile = mod2
def test_wrapped_decorator(self):
self.assertSourceEqual(mod2.wrapped, 14, 17)
def test_replacing_decorator(self):
self.assertSourceEqual(mod2.gone, 9, 10)
# Helper for testing classify_class_attrs.
def attrs_wo_objs(cls): def attrs_wo_objs(cls):
return [t[:3] for t in inspect.classify_class_attrs(cls)] return [t[:3] for t in inspect.classify_class_attrs(cls)]
class A: class TestClassesAndFunctions(unittest.TestCase):
def s(): pass def test_classic_mro(self):
s = staticmethod(s) # Test classic-class method resolution order.
class A: pass
class B(A): pass
class C(A): pass
class D(B, C): pass
def c(cls): pass expected = (D, B, A, C)
c = classmethod(c) got = inspect.getmro(D)
self.assertEqual(expected, got)
def getp(self): pass def test_newstyle_mro(self):
p = property(getp) # The same w/ new-class MRO.
class A(object): pass
class B(A): pass
class C(A): pass
class D(B, C): pass
def m(self): pass expected = (D, B, C, A, object)
got = inspect.getmro(D)
self.assertEqual(expected, got)
def m1(self): pass def assertArgSpecEquals(self, routine, args_e, varargs_e = None,
varkw_e = None, defaults_e = None,
formatted = None):
args, varargs, varkw, defaults = inspect.getargspec(routine)
self.assertEqual(args, args_e)
self.assertEqual(varargs, varargs_e)
self.assertEqual(varkw, varkw_e)
self.assertEqual(defaults, defaults_e)
if formatted is not None:
self.assertEqual(inspect.formatargspec(args, varargs, varkw, defaults),
formatted)
datablob = '1' def test_getargspec(self):
self.assertArgSpecEquals(mod.eggs, ['x', 'y'], formatted = '(x, y)')
attrs = attrs_wo_objs(A) self.assertArgSpecEquals(mod.spam,
test(('s', 'static method', A) in attrs, 'missing static method') ['a', 'b', 'c', 'd', ['e', ['f']]],
test(('c', 'class method', A) in attrs, 'missing class method') 'g', 'h', (3, (4, (5,))),
test(('p', 'property', A) in attrs, 'missing property') '(a, b, c, d=3, (e, (f,))=(4, (5,)), *g, **h)')
test(('m', 'method', A) in attrs, 'missing plain method')
test(('m1', 'method', A) in attrs, 'missing plain method')
test(('datablob', 'data', A) in attrs, 'missing data')
class B(A): def test_getargspec_method(self):
def m(self): pass class A(object):
def m(self):
pass
self.assertArgSpecEquals(A.m, ['self'])
attrs = attrs_wo_objs(B) def test_getargspec_sublistofone(self):
test(('s', 'static method', A) in attrs, 'missing static method') def sublistOfOne((foo)): return 1
test(('c', 'class method', A) in attrs, 'missing class method')
test(('p', 'property', A) in attrs, 'missing property') self.assertArgSpecEquals(sublistOfOne, [['foo']])
test(('m', 'method', B) in attrs, 'missing plain method')
test(('m1', 'method', A) in attrs, 'missing plain method') def test_classify_oldstyle(self):
test(('datablob', 'data', A) in attrs, 'missing data') class A:
def s(): pass
s = staticmethod(s)
def c(cls): pass
c = classmethod(c)
def getp(self): pass
p = property(getp)
def m(self): pass
def m1(self): pass
datablob = '1'
attrs = attrs_wo_objs(A)
self.assert_(('s', 'static method', A) in attrs, 'missing static method')
self.assert_(('c', 'class method', A) in attrs, 'missing class method')
self.assert_(('p', 'property', A) in attrs, 'missing property')
self.assert_(('m', 'method', A) in attrs, 'missing plain method')
self.assert_(('m1', 'method', A) in attrs, 'missing plain method')
self.assert_(('datablob', 'data', A) in attrs, 'missing data')
class B(A):
def m(self): pass
attrs = attrs_wo_objs(B)
self.assert_(('s', 'static method', A) in attrs, 'missing static method')
self.assert_(('c', 'class method', A) in attrs, 'missing class method')
self.assert_(('p', 'property', A) in attrs, 'missing property')
self.assert_(('m', 'method', B) in attrs, 'missing plain method')
self.assert_(('m1', 'method', A) in attrs, 'missing plain method')
self.assert_(('datablob', 'data', A) in attrs, 'missing data')
class C(A): class C(A):
def m(self): pass def m(self): pass
def c(self): pass def c(self): pass
attrs = attrs_wo_objs(C) attrs = attrs_wo_objs(C)
test(('s', 'static method', A) in attrs, 'missing static method') self.assert_(('s', 'static method', A) in attrs, 'missing static method')
test(('c', 'method', C) in attrs, 'missing plain method') self.assert_(('c', 'method', C) in attrs, 'missing plain method')
test(('p', 'property', A) in attrs, 'missing property') self.assert_(('p', 'property', A) in attrs, 'missing property')
test(('m', 'method', C) in attrs, 'missing plain method') self.assert_(('m', 'method', C) in attrs, 'missing plain method')
test(('m1', 'method', A) in attrs, 'missing plain method') self.assert_(('m1', 'method', A) in attrs, 'missing plain method')
test(('datablob', 'data', A) in attrs, 'missing data') self.assert_(('datablob', 'data', A) in attrs, 'missing data')
class D(B, C): class D(B, C):
def m1(self): pass def m1(self): pass
attrs = attrs_wo_objs(D) attrs = attrs_wo_objs(D)
test(('s', 'static method', A) in attrs, 'missing static method') self.assert_(('s', 'static method', A) in attrs, 'missing static method')
test(('c', 'class method', A) in attrs, 'missing class method') self.assert_(('c', 'class method', A) in attrs, 'missing class method')
test(('p', 'property', A) in attrs, 'missing property') self.assert_(('p', 'property', A) in attrs, 'missing property')
test(('m', 'method', B) in attrs, 'missing plain method') self.assert_(('m', 'method', B) in attrs, 'missing plain method')
test(('m1', 'method', D) in attrs, 'missing plain method') self.assert_(('m1', 'method', D) in attrs, 'missing plain method')
test(('datablob', 'data', A) in attrs, 'missing data') self.assert_(('datablob', 'data', A) in attrs, 'missing data')
# Repeat all that, but w/ new-style classes. # Repeat all that, but w/ new-style classes.
def test_classify_newstyle(self):
class A(object):
class A(object): def s(): pass
s = staticmethod(s)
def s(): pass def c(cls): pass
s = staticmethod(s) c = classmethod(c)
def c(cls): pass def getp(self): pass
c = classmethod(c) p = property(getp)
def getp(self): pass def m(self): pass
p = property(getp)
def m(self): pass def m1(self): pass
def m1(self): pass datablob = '1'
datablob = '1' attrs = attrs_wo_objs(A)
self.assert_(('s', 'static method', A) in attrs, 'missing static method')
self.assert_(('c', 'class method', A) in attrs, 'missing class method')
self.assert_(('p', 'property', A) in attrs, 'missing property')
self.assert_(('m', 'method', A) in attrs, 'missing plain method')
self.assert_(('m1', 'method', A) in attrs, 'missing plain method')
self.assert_(('datablob', 'data', A) in attrs, 'missing data')
attrs = attrs_wo_objs(A) class B(A):
test(('s', 'static method', A) in attrs, 'missing static method')
test(('c', 'class method', A) in attrs, 'missing class method')
test(('p', 'property', A) in attrs, 'missing property')
test(('m', 'method', A) in attrs, 'missing plain method')
test(('m1', 'method', A) in attrs, 'missing plain method')
test(('datablob', 'data', A) in attrs, 'missing data')
class B(A): def m(self): pass
def m(self): pass attrs = attrs_wo_objs(B)
self.assert_(('s', 'static method', A) in attrs, 'missing static method')
attrs = attrs_wo_objs(B) self.assert_(('c', 'class method', A) in attrs, 'missing class method')
test(('s', 'static method', A) in attrs, 'missing static method') self.assert_(('p', 'property', A) in attrs, 'missing property')
test(('c', 'class method', A) in attrs, 'missing class method') self.assert_(('m', 'method', B) in attrs, 'missing plain method')
test(('p', 'property', A) in attrs, 'missing property') self.assert_(('m1', 'method', A) in attrs, 'missing plain method')
test(('m', 'method', B) in attrs, 'missing plain method') self.assert_(('datablob', 'data', A) in attrs, 'missing data')
test(('m1', 'method', A) in attrs, 'missing plain method')
test(('datablob', 'data', A) in attrs, 'missing data')
class C(A): class C(A):
def m(self): pass def m(self): pass
def c(self): pass def c(self): pass
attrs = attrs_wo_objs(C) attrs = attrs_wo_objs(C)
test(('s', 'static method', A) in attrs, 'missing static method') self.assert_(('s', 'static method', A) in attrs, 'missing static method')
test(('c', 'method', C) in attrs, 'missing plain method') self.assert_(('c', 'method', C) in attrs, 'missing plain method')
test(('p', 'property', A) in attrs, 'missing property') self.assert_(('p', 'property', A) in attrs, 'missing property')
test(('m', 'method', C) in attrs, 'missing plain method') self.assert_(('m', 'method', C) in attrs, 'missing plain method')
test(('m1', 'method', A) in attrs, 'missing plain method') self.assert_(('m1', 'method', A) in attrs, 'missing plain method')
test(('datablob', 'data', A) in attrs, 'missing data') self.assert_(('datablob', 'data', A) in attrs, 'missing data')
class D(B, C): class D(B, C):
def m1(self): pass def m1(self): pass
attrs = attrs_wo_objs(D) attrs = attrs_wo_objs(D)
test(('s', 'static method', A) in attrs, 'missing static method') self.assert_(('s', 'static method', A) in attrs, 'missing static method')
test(('c', 'method', C) in attrs, 'missing plain method') self.assert_(('c', 'method', C) in attrs, 'missing plain method')
test(('p', 'property', A) in attrs, 'missing property') self.assert_(('p', 'property', A) in attrs, 'missing property')
test(('m', 'method', B) in attrs, 'missing plain method') self.assert_(('m', 'method', B) in attrs, 'missing plain method')
test(('m1', 'method', D) in attrs, 'missing plain method') self.assert_(('m1', 'method', D) in attrs, 'missing plain method')
test(('datablob', 'data', A) in attrs, 'missing data') self.assert_(('datablob', 'data', A) in attrs, 'missing data')
args, varargs, varkw, defaults = inspect.getargspec(mod.eggs) def test_main():
test(args == ['x', 'y'], 'mod.eggs args') run_unittest(TestDecorators, TestRetrievingSourceCode,
test(varargs == None, 'mod.eggs varargs') TestInterpreterStack, TestClassesAndFunctions, TestPredicates)
test(varkw == None, 'mod.eggs varkw')
test(defaults == None, 'mod.eggs defaults')
test(inspect.formatargspec(args, varargs, varkw, defaults) ==
'(x, y)', 'mod.eggs formatted argspec')
args, varargs, varkw, defaults = inspect.getargspec(mod.spam)
test(args == ['a', 'b', 'c', 'd', ['e', ['f']]], 'mod.spam args')
test(varargs == 'g', 'mod.spam varargs')
test(varkw == 'h', 'mod.spam varkw')
test(defaults == (3, (4, (5,))), 'mod.spam defaults')
test(inspect.formatargspec(args, varargs, varkw, defaults) ==
'(a, b, c, d=3, (e, (f,))=(4, (5,)), *g, **h)',
'mod.spam formatted argspec')
args, varargs, varkw, defaults = inspect.getargspec(A.m)
test(args == ['self'], 'A.m args')
test(varargs is None, 'A.m varargs')
test(varkw is None, 'A.m varkw')
test(defaults is None, 'A.m defaults')
# Doc/lib/libinspect.tex claims there are 11 such functions if __name__ == "__main__":
count = len(filter(lambda x:x.startswith('is'), dir(inspect))) test_main()
test(count == 11, "There are %d (not 11) is* functions", count)
def sublistOfOne((foo)): return 1
args, varargs, varkw, defaults = inspect.getargspec(sublistOfOne)
test(args == [['foo']], 'sublistOfOne args')
test(varargs is None, 'sublistOfOne varargs')
test(varkw is None, 'sublistOfOne varkw')
test(defaults is None, 'sublistOfOn defaults')