mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-10-21 14:12:27 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 8

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

652
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') def istest(self, predicate, exp):
tree = inspect.getclasstree(map(lambda x: x[1], classes), 1) obj = eval(exp)
test(tree == self.failUnless(predicate(obj), '%s(%s)' % (predicate.__name__, exp))
[(mod.ParrotDroppings, ()),
(mod.StupidGit, ()), for other in self.predicates - set([predicate]):
[(mod.MalodorousPervert, (mod.StupidGit,)), self.failIf(other(obj), 'not %s(%s)' % (other.__name__, exp))
[(mod.FesteringGob, (mod.MalodorousPervert, mod.ParrotDroppings))
]
]
], 'class tree')
functions = inspect.getmembers(mod, inspect.isfunction) class TestPredicates(IsTestBase):
test(functions == [('eggs', mod.eggs), ('spam', mod.spam)], 'function list') def test_eleven(self):
# 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)
def test_excluding_predicates(self):
self.istest(inspect.isbuiltin, 'sys.exit')
self.istest(inspect.isbuiltin, '[].append')
self.istest(inspect.isclass, 'mod.StupidGit')
self.istest(inspect.iscode, 'mod.spam.func_code')
self.istest(inspect.isframe, 'tb.tb_frame')
self.istest(inspect.isfunction, 'mod.spam')
self.istest(inspect.ismethod, 'mod.StupidGit.abuse')
self.istest(inspect.ismethod, 'git.argue')
self.istest(inspect.ismodule, 'mod')
self.istest(inspect.istraceback, 'tb')
self.istest(inspect.isdatadescriptor, '__builtin__.file.closed')
self.istest(inspect.isdatadescriptor, '__builtin__.file.softspace')
test(inspect.getdoc(mod) == 'A module docstring.', 'getdoc(mod)') def test_isroutine(self):
test(inspect.getcomments(mod) == '# line 1\n', 'getcomments(mod)') self.assert_(inspect.isroutine(mod.spam))
test(inspect.getmodule(mod.StupidGit) == mod, 'getmodule(mod.StupidGit)') self.assert_(inspect.isroutine([].count))
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 TestInterpreterStack(IsTestBase):
lines = string.split(source, '\n') def __init__(self, *args, **kwargs):
return string.join(lines[top-1:bottom], '\n') + '\n' unittest.TestCase.__init__(self, *args, **kwargs)
git.abuse(7, 8, 9)
test(inspect.getsource(git.abuse) == sourcerange(29, 39), def test_abuse_done(self):
'getsource(git.abuse)') self.istest(inspect.istraceback, 'git.ex[2]')
test(inspect.getsource(mod.StupidGit) == sourcerange(21, 46), self.istest(inspect.isframe, 'mod.fr')
'getsource(mod.StupidGit)')
test(inspect.getdoc(mod.StupidGit) ==
'A longer,\n\nindented\n\ndocstring.', 'getdoc(mod.StupidGit)')
test(inspect.getdoc(git.abuse) ==
'Another\n\ndocstring\n\ncontaining\n\ntabs', 'getdoc(git.abuse)')
test(inspect.getcomments(mod.StupidGit) == '# line 20\n',
'getcomments(mod.StupidGit)')
git.abuse(7, 8, 9) def test_stack(self):
self.assert_(len(mod.st) >= 5)
self.assertEqual(mod.st[0][1:],
(modfile, 16, 'eggs', [' st = inspect.stack()\n'], 0))
self.assertEqual(mod.st[1][1:],
(modfile, 9, 'spam', [' eggs(b + d, c + f)\n'], 0))
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))
istest(inspect.istraceback, 'git.ex[2]') def test_trace(self):
istest(inspect.isframe, 'mod.fr') self.assertEqual(len(git.tr), 3)
self.assertEqual(git.tr[0][1:], (modfile, 43, 'argue',
[' spam(a, b, c)\n'], 0))
self.assertEqual(git.tr[1][1:], (modfile, 9, 'spam',
[' eggs(b + d, c + f)\n'], 0))
self.assertEqual(git.tr[2][1:], (modfile, 18, 'eggs',
[' q = y / 0\n'], 0))
test(len(git.tr) == 3, 'trace() length') def test_frame(self):
test(git.tr[0][1:] == (TESTFN, 43, 'argue', args, varargs, varkw, locals = inspect.getargvalues(mod.fr)
[' spam(a, b, c)\n'], 0), self.assertEqual(args, ['x', 'y'])
'trace() row 2') self.assertEqual(varargs, None)
test(git.tr[1][1:] == (TESTFN, 9, 'spam', [' eggs(b + d, c + f)\n'], 0), self.assertEqual(varkw, None)
'trace() row 2') self.assertEqual(locals, {'x': 11, 'p': 11, 'y': 14})
test(git.tr[2][1:] == (TESTFN, 18, 'eggs', [' q = y / 0\n'], 0), self.assertEqual(inspect.formatargvalues(args, varargs, varkw, locals),
'trace() row 3') '(x=11, y=14)')
test(len(mod.st) >= 5, 'stack() length') def test_previous_frame(self):
test(mod.st[0][1:] == args, varargs, varkw, locals = inspect.getargvalues(mod.fr.f_back)
(TESTFN, 16, 'eggs', [' st = inspect.stack()\n'], 0), self.assertEqual(args, ['a', 'b', 'c', 'd', ['e', ['f']]])
'stack() row 1') self.assertEqual(varargs, 'g')
test(mod.st[1][1:] == self.assertEqual(varkw, 'h')
(TESTFN, 9, 'spam', [' eggs(b + d, c + f)\n'], 0), self.assertEqual(inspect.formatargvalues(args, varargs, varkw, locals),
'stack() row 2') '(a=7, b=8, c=9, d=3, (e=4, (f=5,)), *g=(), **h={})')
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) class GetSourceBase(unittest.TestCase):
test(args == ['x', 'y'], 'mod.fr args') # Subclasses must override.
test(varargs == None, 'mod.fr varargs') fodderFile = None
test(varkw == None, 'mod.fr varkw')
test(locals == {'x': 11, 'p': 11, 'y': 14}, 'mod.fr locals') def __init__(self, *args, **kwargs):
test(inspect.formatargvalues(args, varargs, varkw, locals) == unittest.TestCase.__init__(self, *args, **kwargs)
'(x=11, y=14)', 'mod.fr formatted argvalues')
args, varargs, varkw, locals = inspect.getargvalues(mod.fr.f_back) self.source = file(inspect.getsourcefile(self.fodderFile)).read()
test(args == ['a', 'b', 'c', 'd', ['e', ['f']]], 'mod.fr.f_back args')
test(varargs == 'g', 'mod.fr.f_back varargs')
test(varkw == 'h', 'mod.fr.f_back varkw')
test(inspect.formatargvalues(args, varargs, varkw, locals) ==
'(a=7, b=8, c=9, d=3, (e=4, (f=5,)), *g=(), **h={})',
'mod.fr.f_back formatted argvalues')
for fname in files_to_clean_up: def sourcerange(self, top, bottom):
try: lines = self.source.split("\n")
os.unlink(fname) return "\n".join(lines[top-1:bottom]) + "\n"
except:
pass
# Test for decorators as well. def assertSourceEqual(self, obj, top, bottom):
self.assertEqual(inspect.getsource(obj),
self.sourcerange(top, bottom))
class TestRetrievingSourceCode(GetSourceBase):
fodderFile = mod
def test_getclasses(self):
classes = inspect.getmembers(mod, inspect.isclass)
self.assertEqual(classes,
[('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))
]
]
])
def test_getfunctions(self):
functions = inspect.getmembers(mod, inspect.isfunction)
self.assertEqual(functions, [('eggs', mod.eggs),
('spam', mod.spam)])
source = r""" def test_getdoc(self):
def wrap(foo=None): self.assertEqual(inspect.getdoc(mod), 'A module docstring.')
def wrapper(func): self.assertEqual(inspect.getdoc(mod.StupidGit),
return func 'A longer,\n\nindented\n\ndocstring.')
return wrapper self.assertEqual(inspect.getdoc(git.abuse),
'Another\n\ndocstring\n\ncontaining\n\ntabs')
def replace(func): def test_getcomments(self):
def insteadfunc(): self.assertEqual(inspect.getcomments(mod), '# line 1\n')
print 'hello' self.assertEqual(inspect.getcomments(mod.StupidGit), '# line 20\n')
return insteadfunc
# two decorators, one with argument def test_getmodule(self):
@wrap() self.assertEqual(inspect.getmodule(mod.StupidGit), mod)
@wrap(wrap)
def wrapped():
pass
@replace def test_getsource(self):
def gone(): self.assertSourceEqual(git.abuse, 29, 39)
pass""" self.assertSourceEqual(mod.StupidGit, 21, 46)
file = open(TESTFN + "2", "w") def test_getsourcefile(self):
file.write(source) self.assertEqual(inspect.getsourcefile(mod.spam), modfile)
file.close() self.assertEqual(inspect.getsourcefile(git.abuse), modfile)
files_to_clean_up = [TESTFN + "2", TESTFN + '2c', TESTFN + '2o']
mod2 = imp.load_source("testmod3", TESTFN + "2") def test_getfile(self):
self.assertEqual(inspect.getfile(mod.StupidGit), mod.__file__)
test(inspect.getsource(mod2.wrapped) == sourcerange(13, 16), class TestDecorators(GetSourceBase):
"inspect.getsource(mod.wrapped)") fodderFile = mod2
test(inspect.getsource(mod2.gone) == sourcerange(8, 9),
"inspect.getsource(mod.gone)")
for fname in files_to_clean_up: def test_wrapped_decorator(self):
try: self.assertSourceEqual(mod2.wrapped, 14, 17)
os.unlink(fname)
except:
pass
# Test classic-class method resolution order. def test_replacing_decorator(self):
class A: pass self.assertSourceEqual(mod2.gone, 9, 10)
class B(A): pass
class C(A): pass
class D(B, C): pass
expected = (D, B, A, C) # Helper for testing classify_class_attrs.
got = inspect.getmro(D)
test(expected == got, "expected %r mro, got %r", expected, got)
# The same w/ new-class MRO.
class A(object): pass
class B(A): pass
class C(A): pass
class D(B, C): pass
expected = (D, B, C, A, object)
got = inspect.getmro(D)
test(expected == got, "expected %r mro, got %r", expected, got)
# Test 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')