mirror of
https://github.com/python/cpython.git
synced 2025-11-03 19:34:08 +00:00
1070 lines
40 KiB
Python
1070 lines
40 KiB
Python
import re
|
|
import sys
|
|
import types
|
|
import unittest
|
|
import inspect
|
|
import linecache
|
|
import datetime
|
|
import collections
|
|
import os
|
|
import shutil
|
|
from os.path import normcase
|
|
|
|
from test.support import run_unittest, TESTFN, DirsOnSysPath
|
|
|
|
from test import inspect_fodder as mod
|
|
from test import inspect_fodder2 as mod2
|
|
|
|
# C module for test_findsource_binary
|
|
import unicodedata
|
|
|
|
# Functions tested in this suite:
|
|
# ismodule, isclass, ismethod, isfunction, istraceback, isframe, iscode,
|
|
# isbuiltin, isroutine, isgenerator, isgeneratorfunction, getmembers,
|
|
# getdoc, getfile, getmodule, getsourcefile, getcomments, getsource,
|
|
# getclasstree, getargspec, getargvalues, formatargspec, formatargvalues,
|
|
# currentframe, stack, trace, isdatadescriptor
|
|
|
|
# NOTE: There are some additional tests relating to interaction with
|
|
# zipimport in the test_zipimport_support test module.
|
|
|
|
modfile = mod.__file__
|
|
if modfile.endswith(('c', 'o')):
|
|
modfile = modfile[:-1]
|
|
|
|
# Normalize file names: on Windows, the case of file names of compiled
|
|
# modules depends on the path used to start the python executable.
|
|
modfile = normcase(modfile)
|
|
|
|
def revise(filename, *args):
|
|
return (normcase(filename),) + args
|
|
|
|
import builtins
|
|
|
|
try:
|
|
1/0
|
|
except:
|
|
tb = sys.exc_info()[2]
|
|
|
|
git = mod.StupidGit()
|
|
|
|
class IsTestBase(unittest.TestCase):
|
|
predicates = set([inspect.isbuiltin, inspect.isclass, inspect.iscode,
|
|
inspect.isframe, inspect.isfunction, inspect.ismethod,
|
|
inspect.ismodule, inspect.istraceback,
|
|
inspect.isgenerator, inspect.isgeneratorfunction])
|
|
|
|
def istest(self, predicate, exp):
|
|
obj = eval(exp)
|
|
self.assertTrue(predicate(obj), '%s(%s)' % (predicate.__name__, exp))
|
|
|
|
for other in self.predicates - set([predicate]):
|
|
if predicate == inspect.isgeneratorfunction and\
|
|
other == inspect.isfunction:
|
|
continue
|
|
self.assertFalse(other(obj), 'not %s(%s)' % (other.__name__, exp))
|
|
|
|
def generator_function_example(self):
|
|
for i in range(2):
|
|
yield i
|
|
|
|
class TestPredicates(IsTestBase):
|
|
def test_sixteen(self):
|
|
count = len([x for x in dir(inspect) if x.startswith('is')])
|
|
# This test is here for remember you to update Doc/library/inspect.rst
|
|
# which claims there are 16 such functions
|
|
expected = 16
|
|
err_msg = "There are %d (not %d) is* functions" % (count, expected)
|
|
self.assertEqual(count, expected, err_msg)
|
|
|
|
|
|
def test_excluding_predicates(self):
|
|
self.istest(inspect.isbuiltin, 'sys.exit')
|
|
self.istest(inspect.isbuiltin, '[].append')
|
|
self.istest(inspect.iscode, 'mod.spam.__code__')
|
|
self.istest(inspect.isframe, 'tb.tb_frame')
|
|
self.istest(inspect.isfunction, 'mod.spam')
|
|
self.istest(inspect.isfunction, 'mod.StupidGit.abuse')
|
|
self.istest(inspect.ismethod, 'git.argue')
|
|
self.istest(inspect.ismodule, 'mod')
|
|
self.istest(inspect.istraceback, 'tb')
|
|
self.istest(inspect.isdatadescriptor, 'collections.defaultdict.default_factory')
|
|
self.istest(inspect.isgenerator, '(x for x in range(2))')
|
|
self.istest(inspect.isgeneratorfunction, 'generator_function_example')
|
|
if hasattr(types, 'GetSetDescriptorType'):
|
|
self.istest(inspect.isgetsetdescriptor,
|
|
'type(tb.tb_frame).f_locals')
|
|
else:
|
|
self.assertFalse(inspect.isgetsetdescriptor(type(tb.tb_frame).f_locals))
|
|
if hasattr(types, 'MemberDescriptorType'):
|
|
self.istest(inspect.ismemberdescriptor, 'datetime.timedelta.days')
|
|
else:
|
|
self.assertFalse(inspect.ismemberdescriptor(datetime.timedelta.days))
|
|
|
|
def test_isroutine(self):
|
|
self.assertTrue(inspect.isroutine(mod.spam))
|
|
self.assertTrue(inspect.isroutine([].count))
|
|
|
|
def test_isclass(self):
|
|
self.istest(inspect.isclass, 'mod.StupidGit')
|
|
self.assertTrue(inspect.isclass(list))
|
|
|
|
class CustomGetattr(object):
|
|
def __getattr__(self, attr):
|
|
return None
|
|
self.assertFalse(inspect.isclass(CustomGetattr()))
|
|
|
|
def test_get_slot_members(self):
|
|
class C(object):
|
|
__slots__ = ("a", "b")
|
|
|
|
x = C()
|
|
x.a = 42
|
|
members = dict(inspect.getmembers(x))
|
|
self.assertIn('a', members)
|
|
self.assertNotIn('b', members)
|
|
|
|
def test_isabstract(self):
|
|
from abc import ABCMeta, abstractmethod
|
|
|
|
class AbstractClassExample(metaclass=ABCMeta):
|
|
|
|
@abstractmethod
|
|
def foo(self):
|
|
pass
|
|
|
|
class ClassExample(AbstractClassExample):
|
|
def foo(self):
|
|
pass
|
|
|
|
a = ClassExample()
|
|
|
|
# Test general behaviour.
|
|
self.assertTrue(inspect.isabstract(AbstractClassExample))
|
|
self.assertFalse(inspect.isabstract(ClassExample))
|
|
self.assertFalse(inspect.isabstract(a))
|
|
self.assertFalse(inspect.isabstract(int))
|
|
self.assertFalse(inspect.isabstract(5))
|
|
|
|
|
|
class TestInterpreterStack(IsTestBase):
|
|
def __init__(self, *args, **kwargs):
|
|
unittest.TestCase.__init__(self, *args, **kwargs)
|
|
|
|
git.abuse(7, 8, 9)
|
|
|
|
def test_abuse_done(self):
|
|
self.istest(inspect.istraceback, 'git.ex[2]')
|
|
self.istest(inspect.isframe, 'mod.fr')
|
|
|
|
def test_stack(self):
|
|
self.assertTrue(len(mod.st) >= 5)
|
|
self.assertEqual(revise(*mod.st[0][1:]),
|
|
(modfile, 16, 'eggs', [' st = inspect.stack()\n'], 0))
|
|
self.assertEqual(revise(*mod.st[1][1:]),
|
|
(modfile, 9, 'spam', [' eggs(b + d, c + f)\n'], 0))
|
|
self.assertEqual(revise(*mod.st[2][1:]),
|
|
(modfile, 43, 'argue', [' spam(a, b, c)\n'], 0))
|
|
self.assertEqual(revise(*mod.st[3][1:]),
|
|
(modfile, 39, 'abuse', [' self.argue(a, b, c)\n'], 0))
|
|
|
|
def test_trace(self):
|
|
self.assertEqual(len(git.tr), 3)
|
|
self.assertEqual(revise(*git.tr[0][1:]),
|
|
(modfile, 43, 'argue', [' spam(a, b, c)\n'], 0))
|
|
self.assertEqual(revise(*git.tr[1][1:]),
|
|
(modfile, 9, 'spam', [' eggs(b + d, c + f)\n'], 0))
|
|
self.assertEqual(revise(*git.tr[2][1:]),
|
|
(modfile, 18, 'eggs', [' q = y / 0\n'], 0))
|
|
|
|
def test_frame(self):
|
|
args, varargs, varkw, locals = inspect.getargvalues(mod.fr)
|
|
self.assertEqual(args, ['x', 'y'])
|
|
self.assertEqual(varargs, None)
|
|
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)')
|
|
|
|
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={})')
|
|
|
|
class GetSourceBase(unittest.TestCase):
|
|
# Subclasses must override.
|
|
fodderModule = None
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
unittest.TestCase.__init__(self, *args, **kwargs)
|
|
|
|
with open(inspect.getsourcefile(self.fodderModule)) as fp:
|
|
self.source = fp.read()
|
|
|
|
def sourcerange(self, top, bottom):
|
|
lines = self.source.split("\n")
|
|
return "\n".join(lines[top-1:bottom]) + "\n"
|
|
|
|
def assertSourceEqual(self, obj, top, bottom):
|
|
self.assertEqual(inspect.getsource(obj),
|
|
self.sourcerange(top, bottom))
|
|
|
|
class TestRetrievingSourceCode(GetSourceBase):
|
|
fodderModule = 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,
|
|
[(object, ()),
|
|
[(mod.ParrotDroppings, (object,)),
|
|
(mod.StupidGit, (object,)),
|
|
[(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)])
|
|
|
|
@unittest.skipIf(sys.flags.optimize >= 2,
|
|
"Docstrings are omitted with -O2 and above")
|
|
def test_getdoc(self):
|
|
self.assertEqual(inspect.getdoc(mod), 'A module docstring.')
|
|
self.assertEqual(inspect.getdoc(mod.StupidGit),
|
|
'A longer,\n\nindented\n\ndocstring.')
|
|
self.assertEqual(inspect.getdoc(git.abuse),
|
|
'Another\n\ndocstring\n\ncontaining\n\ntabs')
|
|
|
|
def test_cleandoc(self):
|
|
self.assertEqual(inspect.cleandoc('An\n indented\n docstring.'),
|
|
'An\nindented\ndocstring.')
|
|
|
|
def test_getcomments(self):
|
|
self.assertEqual(inspect.getcomments(mod), '# line 1\n')
|
|
self.assertEqual(inspect.getcomments(mod.StupidGit), '# line 20\n')
|
|
|
|
def test_getmodule(self):
|
|
# Check actual module
|
|
self.assertEqual(inspect.getmodule(mod), mod)
|
|
# Check class (uses __module__ attribute)
|
|
self.assertEqual(inspect.getmodule(mod.StupidGit), mod)
|
|
# Check a method (no __module__ attribute, falls back to filename)
|
|
self.assertEqual(inspect.getmodule(mod.StupidGit.abuse), mod)
|
|
# Do it again (check the caching isn't broken)
|
|
self.assertEqual(inspect.getmodule(mod.StupidGit.abuse), mod)
|
|
# Check a builtin
|
|
self.assertEqual(inspect.getmodule(str), sys.modules["builtins"])
|
|
# Check filename override
|
|
self.assertEqual(inspect.getmodule(None, modfile), mod)
|
|
|
|
def test_getsource(self):
|
|
self.assertSourceEqual(git.abuse, 29, 39)
|
|
self.assertSourceEqual(mod.StupidGit, 21, 46)
|
|
|
|
def test_getsourcefile(self):
|
|
self.assertEqual(normcase(inspect.getsourcefile(mod.spam)), modfile)
|
|
self.assertEqual(normcase(inspect.getsourcefile(git.abuse)), modfile)
|
|
fn = "_non_existing_filename_used_for_sourcefile_test.py"
|
|
co = compile("None", fn, "exec")
|
|
self.assertEqual(inspect.getsourcefile(co), None)
|
|
linecache.cache[co.co_filename] = (1, None, "None", co.co_filename)
|
|
self.assertEqual(normcase(inspect.getsourcefile(co)), fn)
|
|
|
|
def test_getfile(self):
|
|
self.assertEqual(inspect.getfile(mod.StupidGit), mod.__file__)
|
|
|
|
def test_getmodule_recursion(self):
|
|
from types import ModuleType
|
|
name = '__inspect_dummy'
|
|
m = sys.modules[name] = ModuleType(name)
|
|
m.__file__ = "<string>" # hopefully not a real filename...
|
|
m.__loader__ = "dummy" # pretend the filename is understood by a loader
|
|
exec("def x(): pass", m.__dict__)
|
|
self.assertEqual(inspect.getsourcefile(m.x.__code__), '<string>')
|
|
del sys.modules[name]
|
|
inspect.getmodule(compile('a=10','','single'))
|
|
|
|
def test_proceed_with_fake_filename(self):
|
|
'''doctest monkeypatches linecache to enable inspection'''
|
|
fn, source = '<test>', 'def x(): pass\n'
|
|
getlines = linecache.getlines
|
|
def monkey(filename, module_globals=None):
|
|
if filename == fn:
|
|
return source.splitlines(True)
|
|
else:
|
|
return getlines(filename, module_globals)
|
|
linecache.getlines = monkey
|
|
try:
|
|
ns = {}
|
|
exec(compile(source, fn, 'single'), ns)
|
|
inspect.getsource(ns["x"])
|
|
finally:
|
|
linecache.getlines = getlines
|
|
|
|
class TestDecorators(GetSourceBase):
|
|
fodderModule = mod2
|
|
|
|
def test_wrapped_decorator(self):
|
|
self.assertSourceEqual(mod2.wrapped, 14, 17)
|
|
|
|
def test_replacing_decorator(self):
|
|
self.assertSourceEqual(mod2.gone, 9, 10)
|
|
|
|
class TestOneliners(GetSourceBase):
|
|
fodderModule = mod2
|
|
def test_oneline_lambda(self):
|
|
# Test inspect.getsource with a one-line lambda function.
|
|
self.assertSourceEqual(mod2.oll, 25, 25)
|
|
|
|
def test_threeline_lambda(self):
|
|
# Test inspect.getsource with a three-line lambda function,
|
|
# where the second and third lines are _not_ indented.
|
|
self.assertSourceEqual(mod2.tll, 28, 30)
|
|
|
|
def test_twoline_indented_lambda(self):
|
|
# Test inspect.getsource with a two-line lambda function,
|
|
# where the second line _is_ indented.
|
|
self.assertSourceEqual(mod2.tlli, 33, 34)
|
|
|
|
def test_onelinefunc(self):
|
|
# Test inspect.getsource with a regular one-line function.
|
|
self.assertSourceEqual(mod2.onelinefunc, 37, 37)
|
|
|
|
def test_manyargs(self):
|
|
# Test inspect.getsource with a regular function where
|
|
# the arguments are on two lines and _not_ indented and
|
|
# the body on the second line with the last arguments.
|
|
self.assertSourceEqual(mod2.manyargs, 40, 41)
|
|
|
|
def test_twolinefunc(self):
|
|
# Test inspect.getsource with a regular function where
|
|
# the body is on two lines, following the argument list and
|
|
# continued on the next line by a \\.
|
|
self.assertSourceEqual(mod2.twolinefunc, 44, 45)
|
|
|
|
def test_lambda_in_list(self):
|
|
# Test inspect.getsource with a one-line lambda function
|
|
# defined in a list, indented.
|
|
self.assertSourceEqual(mod2.a[1], 49, 49)
|
|
|
|
def test_anonymous(self):
|
|
# Test inspect.getsource with a lambda function defined
|
|
# as argument to another function.
|
|
self.assertSourceEqual(mod2.anonymous, 55, 55)
|
|
|
|
class TestBuggyCases(GetSourceBase):
|
|
fodderModule = mod2
|
|
|
|
def test_with_comment(self):
|
|
self.assertSourceEqual(mod2.with_comment, 58, 59)
|
|
|
|
def test_multiline_sig(self):
|
|
self.assertSourceEqual(mod2.multiline_sig[0], 63, 64)
|
|
|
|
def test_nested_class(self):
|
|
self.assertSourceEqual(mod2.func69().func71, 71, 72)
|
|
|
|
def test_one_liner_followed_by_non_name(self):
|
|
self.assertSourceEqual(mod2.func77, 77, 77)
|
|
|
|
def test_one_liner_dedent_non_name(self):
|
|
self.assertSourceEqual(mod2.cls82.func83, 83, 83)
|
|
|
|
def test_with_comment_instead_of_docstring(self):
|
|
self.assertSourceEqual(mod2.func88, 88, 90)
|
|
|
|
def test_method_in_dynamic_class(self):
|
|
self.assertSourceEqual(mod2.method_in_dynamic_class, 95, 97)
|
|
|
|
@unittest.skipIf(
|
|
not hasattr(unicodedata, '__file__') or
|
|
unicodedata.__file__[-4:] in (".pyc", ".pyo"),
|
|
"unicodedata is not an external binary module")
|
|
def test_findsource_binary(self):
|
|
self.assertRaises(IOError, inspect.getsource, unicodedata)
|
|
self.assertRaises(IOError, inspect.findsource, unicodedata)
|
|
|
|
def test_findsource_code_in_linecache(self):
|
|
lines = ["x=1"]
|
|
co = compile(lines[0], "_dynamically_created_file", "exec")
|
|
self.assertRaises(IOError, inspect.findsource, co)
|
|
self.assertRaises(IOError, inspect.getsource, co)
|
|
linecache.cache[co.co_filename] = (1, None, lines, co.co_filename)
|
|
self.assertEqual(inspect.findsource(co), (lines,0))
|
|
self.assertEqual(inspect.getsource(co), lines[0])
|
|
|
|
class TestNoEOL(GetSourceBase):
|
|
def __init__(self, *args, **kwargs):
|
|
self.tempdir = TESTFN + '_dir'
|
|
os.mkdir(self.tempdir)
|
|
with open(os.path.join(self.tempdir,
|
|
'inspect_fodder3%spy' % os.extsep), 'w') as f:
|
|
f.write("class X:\n pass # No EOL")
|
|
with DirsOnSysPath(self.tempdir):
|
|
import inspect_fodder3 as mod3
|
|
self.fodderModule = mod3
|
|
GetSourceBase.__init__(self, *args, **kwargs)
|
|
|
|
def tearDown(self):
|
|
shutil.rmtree(self.tempdir)
|
|
|
|
def test_class(self):
|
|
self.assertSourceEqual(self.fodderModule.X, 1, 2)
|
|
|
|
# Helper for testing classify_class_attrs.
|
|
def attrs_wo_objs(cls):
|
|
return [t[:3] for t in inspect.classify_class_attrs(cls)]
|
|
|
|
class TestClassesAndFunctions(unittest.TestCase):
|
|
def test_newstyle_mro(self):
|
|
# 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)
|
|
self.assertEqual(expected, got)
|
|
|
|
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)
|
|
|
|
def assertFullArgSpecEquals(self, routine, args_e, varargs_e=None,
|
|
varkw_e=None, defaults_e=None,
|
|
kwonlyargs_e=[], kwonlydefaults_e=None,
|
|
ann_e={}, formatted=None):
|
|
args, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, ann = \
|
|
inspect.getfullargspec(routine)
|
|
self.assertEqual(args, args_e)
|
|
self.assertEqual(varargs, varargs_e)
|
|
self.assertEqual(varkw, varkw_e)
|
|
self.assertEqual(defaults, defaults_e)
|
|
self.assertEqual(kwonlyargs, kwonlyargs_e)
|
|
self.assertEqual(kwonlydefaults, kwonlydefaults_e)
|
|
self.assertEqual(ann, ann_e)
|
|
if formatted is not None:
|
|
self.assertEqual(inspect.formatargspec(args, varargs, varkw, defaults,
|
|
kwonlyargs, kwonlydefaults, ann),
|
|
formatted)
|
|
|
|
def test_getargspec(self):
|
|
self.assertArgSpecEquals(mod.eggs, ['x', 'y'], formatted='(x, y)')
|
|
|
|
self.assertArgSpecEquals(mod.spam,
|
|
['a', 'b', 'c', 'd', 'e', 'f'],
|
|
'g', 'h', (3, 4, 5),
|
|
'(a, b, c, d=3, e=4, f=5, *g, **h)')
|
|
|
|
self.assertRaises(ValueError, self.assertArgSpecEquals,
|
|
mod2.keyworded, [])
|
|
|
|
self.assertRaises(ValueError, self.assertArgSpecEquals,
|
|
mod2.annotated, [])
|
|
self.assertRaises(ValueError, self.assertArgSpecEquals,
|
|
mod2.keyword_only_arg, [])
|
|
|
|
|
|
def test_getfullargspec(self):
|
|
self.assertFullArgSpecEquals(mod2.keyworded, [], varargs_e='arg1',
|
|
kwonlyargs_e=['arg2'],
|
|
kwonlydefaults_e={'arg2':1},
|
|
formatted='(*arg1, arg2=1)')
|
|
|
|
self.assertFullArgSpecEquals(mod2.annotated, ['arg1'],
|
|
ann_e={'arg1' : list},
|
|
formatted='(arg1: list)')
|
|
self.assertFullArgSpecEquals(mod2.keyword_only_arg, [],
|
|
kwonlyargs_e=['arg'],
|
|
formatted='(*, arg)')
|
|
|
|
|
|
def test_getargspec_method(self):
|
|
class A(object):
|
|
def m(self):
|
|
pass
|
|
self.assertArgSpecEquals(A.m, ['self'])
|
|
|
|
def test_classify_newstyle(self):
|
|
class A(object):
|
|
|
|
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.assertIn(('s', 'static method', A), attrs, 'missing static method')
|
|
self.assertIn(('c', 'class method', A), attrs, 'missing class method')
|
|
self.assertIn(('p', 'property', A), attrs, 'missing property')
|
|
self.assertIn(('m', 'method', A), attrs,
|
|
'missing plain method: %r' % attrs)
|
|
self.assertIn(('m1', 'method', A), attrs, 'missing plain method')
|
|
self.assertIn(('datablob', 'data', A), attrs, 'missing data')
|
|
|
|
class B(A):
|
|
|
|
def m(self): pass
|
|
|
|
attrs = attrs_wo_objs(B)
|
|
self.assertIn(('s', 'static method', A), attrs, 'missing static method')
|
|
self.assertIn(('c', 'class method', A), attrs, 'missing class method')
|
|
self.assertIn(('p', 'property', A), attrs, 'missing property')
|
|
self.assertIn(('m', 'method', B), attrs, 'missing plain method')
|
|
self.assertIn(('m1', 'method', A), attrs, 'missing plain method')
|
|
self.assertIn(('datablob', 'data', A), attrs, 'missing data')
|
|
|
|
|
|
class C(A):
|
|
|
|
def m(self): pass
|
|
def c(self): pass
|
|
|
|
attrs = attrs_wo_objs(C)
|
|
self.assertIn(('s', 'static method', A), attrs, 'missing static method')
|
|
self.assertIn(('c', 'method', C), attrs, 'missing plain method')
|
|
self.assertIn(('p', 'property', A), attrs, 'missing property')
|
|
self.assertIn(('m', 'method', C), attrs, 'missing plain method')
|
|
self.assertIn(('m1', 'method', A), attrs, 'missing plain method')
|
|
self.assertIn(('datablob', 'data', A), attrs, 'missing data')
|
|
|
|
class D(B, C):
|
|
|
|
def m1(self): pass
|
|
|
|
attrs = attrs_wo_objs(D)
|
|
self.assertIn(('s', 'static method', A), attrs, 'missing static method')
|
|
self.assertIn(('c', 'method', C), attrs, 'missing plain method')
|
|
self.assertIn(('p', 'property', A), attrs, 'missing property')
|
|
self.assertIn(('m', 'method', B), attrs, 'missing plain method')
|
|
self.assertIn(('m1', 'method', D), attrs, 'missing plain method')
|
|
self.assertIn(('datablob', 'data', A), attrs, 'missing data')
|
|
|
|
class TestGetcallargsFunctions(unittest.TestCase):
|
|
|
|
def assertEqualCallArgs(self, func, call_params_string, locs=None):
|
|
locs = dict(locs or {}, func=func)
|
|
r1 = eval('func(%s)' % call_params_string, None, locs)
|
|
r2 = eval('inspect.getcallargs(func, %s)' % call_params_string, None,
|
|
locs)
|
|
self.assertEqual(r1, r2)
|
|
|
|
def assertEqualException(self, func, call_param_string, locs=None):
|
|
locs = dict(locs or {}, func=func)
|
|
try:
|
|
eval('func(%s)' % call_param_string, None, locs)
|
|
except Exception as e:
|
|
ex1 = e
|
|
else:
|
|
self.fail('Exception not raised')
|
|
try:
|
|
eval('inspect.getcallargs(func, %s)' % call_param_string, None,
|
|
locs)
|
|
except Exception as e:
|
|
ex2 = e
|
|
else:
|
|
self.fail('Exception not raised')
|
|
self.assertIs(type(ex1), type(ex2))
|
|
self.assertEqual(str(ex1), str(ex2))
|
|
del ex1, ex2
|
|
|
|
def makeCallable(self, signature):
|
|
"""Create a function that returns its locals()"""
|
|
code = "lambda %s: locals()"
|
|
return eval(code % signature)
|
|
|
|
def test_plain(self):
|
|
f = self.makeCallable('a, b=1')
|
|
self.assertEqualCallArgs(f, '2')
|
|
self.assertEqualCallArgs(f, '2, 3')
|
|
self.assertEqualCallArgs(f, 'a=2')
|
|
self.assertEqualCallArgs(f, 'b=3, a=2')
|
|
self.assertEqualCallArgs(f, '2, b=3')
|
|
# expand *iterable / **mapping
|
|
self.assertEqualCallArgs(f, '*(2,)')
|
|
self.assertEqualCallArgs(f, '*[2]')
|
|
self.assertEqualCallArgs(f, '*(2, 3)')
|
|
self.assertEqualCallArgs(f, '*[2, 3]')
|
|
self.assertEqualCallArgs(f, '**{"a":2}')
|
|
self.assertEqualCallArgs(f, 'b=3, **{"a":2}')
|
|
self.assertEqualCallArgs(f, '2, **{"b":3}')
|
|
self.assertEqualCallArgs(f, '**{"b":3, "a":2}')
|
|
# expand UserList / UserDict
|
|
self.assertEqualCallArgs(f, '*collections.UserList([2])')
|
|
self.assertEqualCallArgs(f, '*collections.UserList([2, 3])')
|
|
self.assertEqualCallArgs(f, '**collections.UserDict(a=2)')
|
|
self.assertEqualCallArgs(f, '2, **collections.UserDict(b=3)')
|
|
self.assertEqualCallArgs(f, 'b=2, **collections.UserDict(a=3)')
|
|
|
|
def test_varargs(self):
|
|
f = self.makeCallable('a, b=1, *c')
|
|
self.assertEqualCallArgs(f, '2')
|
|
self.assertEqualCallArgs(f, '2, 3')
|
|
self.assertEqualCallArgs(f, '2, 3, 4')
|
|
self.assertEqualCallArgs(f, '*(2,3,4)')
|
|
self.assertEqualCallArgs(f, '2, *[3,4]')
|
|
self.assertEqualCallArgs(f, '2, 3, *collections.UserList([4])')
|
|
|
|
def test_varkw(self):
|
|
f = self.makeCallable('a, b=1, **c')
|
|
self.assertEqualCallArgs(f, 'a=2')
|
|
self.assertEqualCallArgs(f, '2, b=3, c=4')
|
|
self.assertEqualCallArgs(f, 'b=3, a=2, c=4')
|
|
self.assertEqualCallArgs(f, 'c=4, **{"a":2, "b":3}')
|
|
self.assertEqualCallArgs(f, '2, c=4, **{"b":3}')
|
|
self.assertEqualCallArgs(f, 'b=2, **{"a":3, "c":4}')
|
|
self.assertEqualCallArgs(f, '**collections.UserDict(a=2, b=3, c=4)')
|
|
self.assertEqualCallArgs(f, '2, c=4, **collections.UserDict(b=3)')
|
|
self.assertEqualCallArgs(f, 'b=2, **collections.UserDict(a=3, c=4)')
|
|
|
|
def test_varkw_only(self):
|
|
# issue11256:
|
|
f = self.makeCallable('**c')
|
|
self.assertEqualCallArgs(f, '')
|
|
self.assertEqualCallArgs(f, 'a=1')
|
|
self.assertEqualCallArgs(f, 'a=1, b=2')
|
|
self.assertEqualCallArgs(f, 'c=3, **{"a": 1, "b": 2}')
|
|
self.assertEqualCallArgs(f, '**collections.UserDict(a=1, b=2)')
|
|
self.assertEqualCallArgs(f, 'c=3, **collections.UserDict(a=1, b=2)')
|
|
|
|
def test_keyword_only(self):
|
|
f = self.makeCallable('a=3, *, c, d=2')
|
|
self.assertEqualCallArgs(f, 'c=3')
|
|
self.assertEqualCallArgs(f, 'c=3, a=3')
|
|
self.assertEqualCallArgs(f, 'a=2, c=4')
|
|
self.assertEqualCallArgs(f, '4, c=4')
|
|
self.assertEqualException(f, '')
|
|
self.assertEqualException(f, '3')
|
|
self.assertEqualException(f, 'a=3')
|
|
self.assertEqualException(f, 'd=4')
|
|
|
|
f = self.makeCallable('*, c, d=2')
|
|
self.assertEqualCallArgs(f, 'c=3')
|
|
self.assertEqualCallArgs(f, 'c=3, d=4')
|
|
self.assertEqualCallArgs(f, 'd=4, c=3')
|
|
|
|
def test_multiple_features(self):
|
|
f = self.makeCallable('a, b=2, *f, **g')
|
|
self.assertEqualCallArgs(f, '2, 3, 7')
|
|
self.assertEqualCallArgs(f, '2, 3, x=8')
|
|
self.assertEqualCallArgs(f, '2, 3, x=8, *[(4,[5,6]), 7]')
|
|
self.assertEqualCallArgs(f, '2, x=8, *[3, (4,[5,6]), 7], y=9')
|
|
self.assertEqualCallArgs(f, 'x=8, *[2, 3, (4,[5,6])], y=9')
|
|
self.assertEqualCallArgs(f, 'x=8, *collections.UserList('
|
|
'[2, 3, (4,[5,6])]), **{"y":9, "z":10}')
|
|
self.assertEqualCallArgs(f, '2, x=8, *collections.UserList([3, '
|
|
'(4,[5,6])]), **collections.UserDict('
|
|
'y=9, z=10)')
|
|
|
|
f = self.makeCallable('a, b=2, *f, x, y=99, **g')
|
|
self.assertEqualCallArgs(f, '2, 3, x=8')
|
|
self.assertEqualCallArgs(f, '2, 3, x=8, *[(4,[5,6]), 7]')
|
|
self.assertEqualCallArgs(f, '2, x=8, *[3, (4,[5,6]), 7], y=9, z=10')
|
|
self.assertEqualCallArgs(f, 'x=8, *[2, 3, (4,[5,6])], y=9, z=10')
|
|
self.assertEqualCallArgs(f, 'x=8, *collections.UserList('
|
|
'[2, 3, (4,[5,6])]), q=0, **{"y":9, "z":10}')
|
|
self.assertEqualCallArgs(f, '2, x=8, *collections.UserList([3, '
|
|
'(4,[5,6])]), q=0, **collections.UserDict('
|
|
'y=9, z=10)')
|
|
|
|
def test_errors(self):
|
|
f0 = self.makeCallable('')
|
|
f1 = self.makeCallable('a, b')
|
|
f2 = self.makeCallable('a, b=1')
|
|
# f0 takes no arguments
|
|
self.assertEqualException(f0, '1')
|
|
self.assertEqualException(f0, 'x=1')
|
|
self.assertEqualException(f0, '1,x=1')
|
|
# f1 takes exactly 2 arguments
|
|
self.assertEqualException(f1, '')
|
|
self.assertEqualException(f1, '1')
|
|
self.assertEqualException(f1, 'a=2')
|
|
self.assertEqualException(f1, 'b=3')
|
|
# f2 takes at least 1 argument
|
|
self.assertEqualException(f2, '')
|
|
self.assertEqualException(f2, 'b=3')
|
|
for f in f1, f2:
|
|
# f1/f2 takes exactly/at most 2 arguments
|
|
self.assertEqualException(f, '2, 3, 4')
|
|
self.assertEqualException(f, '1, 2, 3, a=1')
|
|
self.assertEqualException(f, '2, 3, 4, c=5')
|
|
self.assertEqualException(f, '2, 3, 4, a=1, c=5')
|
|
# f got an unexpected keyword argument
|
|
self.assertEqualException(f, 'c=2')
|
|
self.assertEqualException(f, '2, c=3')
|
|
self.assertEqualException(f, '2, 3, c=4')
|
|
self.assertEqualException(f, '2, c=4, b=3')
|
|
self.assertEqualException(f, '**{u"\u03c0\u03b9": 4}')
|
|
# f got multiple values for keyword argument
|
|
self.assertEqualException(f, '1, a=2')
|
|
self.assertEqualException(f, '1, **{"a":2}')
|
|
self.assertEqualException(f, '1, 2, b=3')
|
|
# XXX: Python inconsistency
|
|
# - for functions and bound methods: unexpected keyword 'c'
|
|
# - for unbound methods: multiple values for keyword 'a'
|
|
#self.assertEqualException(f, '1, c=3, a=2')
|
|
# issue11256:
|
|
f3 = self.makeCallable('**c')
|
|
self.assertEqualException(f3, '1, 2')
|
|
self.assertEqualException(f3, '1, 2, a=1, b=2')
|
|
f4 = self.makeCallable('*, a, b=0')
|
|
self.assertEqualException(f3, '1, 2')
|
|
self.assertEqualException(f3, '1, 2, a=1, b=2')
|
|
|
|
class TestGetcallargsMethods(TestGetcallargsFunctions):
|
|
|
|
def setUp(self):
|
|
class Foo(object):
|
|
pass
|
|
self.cls = Foo
|
|
self.inst = Foo()
|
|
|
|
def makeCallable(self, signature):
|
|
assert 'self' not in signature
|
|
mk = super(TestGetcallargsMethods, self).makeCallable
|
|
self.cls.method = mk('self, ' + signature)
|
|
return self.inst.method
|
|
|
|
class TestGetcallargsUnboundMethods(TestGetcallargsMethods):
|
|
|
|
def makeCallable(self, signature):
|
|
super(TestGetcallargsUnboundMethods, self).makeCallable(signature)
|
|
return self.cls.method
|
|
|
|
def assertEqualCallArgs(self, func, call_params_string, locs=None):
|
|
return super(TestGetcallargsUnboundMethods, self).assertEqualCallArgs(
|
|
*self._getAssertEqualParams(func, call_params_string, locs))
|
|
|
|
def assertEqualException(self, func, call_params_string, locs=None):
|
|
return super(TestGetcallargsUnboundMethods, self).assertEqualException(
|
|
*self._getAssertEqualParams(func, call_params_string, locs))
|
|
|
|
def _getAssertEqualParams(self, func, call_params_string, locs=None):
|
|
assert 'inst' not in call_params_string
|
|
locs = dict(locs or {}, inst=self.inst)
|
|
return (func, 'inst,' + call_params_string, locs)
|
|
|
|
|
|
class TestGetattrStatic(unittest.TestCase):
|
|
|
|
def test_basic(self):
|
|
class Thing(object):
|
|
x = object()
|
|
|
|
thing = Thing()
|
|
self.assertEqual(inspect.getattr_static(thing, 'x'), Thing.x)
|
|
self.assertEqual(inspect.getattr_static(thing, 'x', None), Thing.x)
|
|
with self.assertRaises(AttributeError):
|
|
inspect.getattr_static(thing, 'y')
|
|
|
|
self.assertEqual(inspect.getattr_static(thing, 'y', 3), 3)
|
|
|
|
def test_inherited(self):
|
|
class Thing(object):
|
|
x = object()
|
|
class OtherThing(Thing):
|
|
pass
|
|
|
|
something = OtherThing()
|
|
self.assertEqual(inspect.getattr_static(something, 'x'), Thing.x)
|
|
|
|
def test_instance_attr(self):
|
|
class Thing(object):
|
|
x = 2
|
|
def __init__(self, x):
|
|
self.x = x
|
|
thing = Thing(3)
|
|
self.assertEqual(inspect.getattr_static(thing, 'x'), 3)
|
|
del thing.x
|
|
self.assertEqual(inspect.getattr_static(thing, 'x'), 2)
|
|
|
|
def test_property(self):
|
|
class Thing(object):
|
|
@property
|
|
def x(self):
|
|
raise AttributeError("I'm pretending not to exist")
|
|
thing = Thing()
|
|
self.assertEqual(inspect.getattr_static(thing, 'x'), Thing.x)
|
|
|
|
def test_descriptor_raises_AttributeError(self):
|
|
class descriptor(object):
|
|
def __get__(*_):
|
|
raise AttributeError("I'm pretending not to exist")
|
|
desc = descriptor()
|
|
class Thing(object):
|
|
x = desc
|
|
thing = Thing()
|
|
self.assertEqual(inspect.getattr_static(thing, 'x'), desc)
|
|
|
|
def test_classAttribute(self):
|
|
class Thing(object):
|
|
x = object()
|
|
|
|
self.assertEqual(inspect.getattr_static(Thing, 'x'), Thing.x)
|
|
|
|
def test_inherited_classattribute(self):
|
|
class Thing(object):
|
|
x = object()
|
|
class OtherThing(Thing):
|
|
pass
|
|
|
|
self.assertEqual(inspect.getattr_static(OtherThing, 'x'), Thing.x)
|
|
|
|
def test_slots(self):
|
|
class Thing(object):
|
|
y = 'bar'
|
|
__slots__ = ['x']
|
|
def __init__(self):
|
|
self.x = 'foo'
|
|
thing = Thing()
|
|
self.assertEqual(inspect.getattr_static(thing, 'x'), Thing.x)
|
|
self.assertEqual(inspect.getattr_static(thing, 'y'), 'bar')
|
|
|
|
del thing.x
|
|
self.assertEqual(inspect.getattr_static(thing, 'x'), Thing.x)
|
|
|
|
def test_metaclass(self):
|
|
class meta(type):
|
|
attr = 'foo'
|
|
class Thing(object, metaclass=meta):
|
|
pass
|
|
self.assertEqual(inspect.getattr_static(Thing, 'attr'), 'foo')
|
|
|
|
class sub(meta):
|
|
pass
|
|
class OtherThing(object, metaclass=sub):
|
|
x = 3
|
|
self.assertEqual(inspect.getattr_static(OtherThing, 'attr'), 'foo')
|
|
|
|
class OtherOtherThing(OtherThing):
|
|
pass
|
|
# this test is odd, but it was added as it exposed a bug
|
|
self.assertEqual(inspect.getattr_static(OtherOtherThing, 'x'), 3)
|
|
|
|
def test_no_dict_no_slots(self):
|
|
self.assertEqual(inspect.getattr_static(1, 'foo', None), None)
|
|
self.assertNotEqual(inspect.getattr_static('foo', 'lower'), None)
|
|
|
|
def test_no_dict_no_slots_instance_member(self):
|
|
# returns descriptor
|
|
with open(__file__) as handle:
|
|
self.assertEqual(inspect.getattr_static(handle, 'name'), type(handle).name)
|
|
|
|
def test_inherited_slots(self):
|
|
# returns descriptor
|
|
class Thing(object):
|
|
__slots__ = ['x']
|
|
def __init__(self):
|
|
self.x = 'foo'
|
|
|
|
class OtherThing(Thing):
|
|
pass
|
|
# it would be nice if this worked...
|
|
# we get the descriptor instead of the instance attribute
|
|
self.assertEqual(inspect.getattr_static(OtherThing(), 'x'), Thing.x)
|
|
|
|
def test_descriptor(self):
|
|
class descriptor(object):
|
|
def __get__(self, instance, owner):
|
|
return 3
|
|
class Foo(object):
|
|
d = descriptor()
|
|
|
|
foo = Foo()
|
|
|
|
# for a non data descriptor we return the instance attribute
|
|
foo.__dict__['d'] = 1
|
|
self.assertEqual(inspect.getattr_static(foo, 'd'), 1)
|
|
|
|
# if the descriptor is a data-desciptor we should return the
|
|
# descriptor
|
|
descriptor.__set__ = lambda s, i, v: None
|
|
self.assertEqual(inspect.getattr_static(foo, 'd'), Foo.__dict__['d'])
|
|
|
|
|
|
def test_metaclass_with_descriptor(self):
|
|
class descriptor(object):
|
|
def __get__(self, instance, owner):
|
|
return 3
|
|
class meta(type):
|
|
d = descriptor()
|
|
class Thing(object, metaclass=meta):
|
|
pass
|
|
self.assertEqual(inspect.getattr_static(Thing, 'd'), meta.__dict__['d'])
|
|
|
|
|
|
def test_class_as_property(self):
|
|
class Base(object):
|
|
foo = 3
|
|
|
|
class Something(Base):
|
|
executed = False
|
|
@property
|
|
def __class__(self):
|
|
self.executed = True
|
|
return object
|
|
|
|
instance = Something()
|
|
self.assertEqual(inspect.getattr_static(instance, 'foo'), 3)
|
|
self.assertFalse(instance.executed)
|
|
self.assertEqual(inspect.getattr_static(Something, 'foo'), 3)
|
|
|
|
def test_mro_as_property(self):
|
|
class Meta(type):
|
|
@property
|
|
def __mro__(self):
|
|
return (object,)
|
|
|
|
class Base(object):
|
|
foo = 3
|
|
|
|
class Something(Base, metaclass=Meta):
|
|
pass
|
|
|
|
self.assertEqual(inspect.getattr_static(Something(), 'foo'), 3)
|
|
self.assertEqual(inspect.getattr_static(Something, 'foo'), 3)
|
|
|
|
def test_dict_as_property(self):
|
|
test = self
|
|
test.called = False
|
|
|
|
class Foo(dict):
|
|
a = 3
|
|
@property
|
|
def __dict__(self):
|
|
test.called = True
|
|
return {}
|
|
|
|
foo = Foo()
|
|
foo.a = 4
|
|
self.assertEqual(inspect.getattr_static(foo, 'a'), 3)
|
|
self.assertFalse(test.called)
|
|
|
|
def test_custom_object_dict(self):
|
|
test = self
|
|
test.called = False
|
|
|
|
class Custom(dict):
|
|
def get(self, key, default=None):
|
|
test.called = True
|
|
super().get(key, default)
|
|
|
|
class Foo(object):
|
|
a = 3
|
|
foo = Foo()
|
|
foo.__dict__ = Custom()
|
|
self.assertEqual(inspect.getattr_static(foo, 'a'), 3)
|
|
self.assertFalse(test.called)
|
|
|
|
def test_metaclass_dict_as_property(self):
|
|
class Meta(type):
|
|
@property
|
|
def __dict__(self):
|
|
self.executed = True
|
|
|
|
class Thing(metaclass=Meta):
|
|
executed = False
|
|
|
|
def __init__(self):
|
|
self.spam = 42
|
|
|
|
instance = Thing()
|
|
self.assertEqual(inspect.getattr_static(instance, "spam"), 42)
|
|
self.assertFalse(Thing.executed)
|
|
|
|
class TestGetGeneratorState(unittest.TestCase):
|
|
|
|
def setUp(self):
|
|
def number_generator():
|
|
for number in range(5):
|
|
yield number
|
|
self.generator = number_generator()
|
|
|
|
def _generatorstate(self):
|
|
return inspect.getgeneratorstate(self.generator)
|
|
|
|
def test_created(self):
|
|
self.assertEqual(self._generatorstate(), inspect.GEN_CREATED)
|
|
|
|
def test_suspended(self):
|
|
next(self.generator)
|
|
self.assertEqual(self._generatorstate(), inspect.GEN_SUSPENDED)
|
|
|
|
def test_closed_after_exhaustion(self):
|
|
for i in self.generator:
|
|
pass
|
|
self.assertEqual(self._generatorstate(), inspect.GEN_CLOSED)
|
|
|
|
def test_closed_after_immediate_exception(self):
|
|
with self.assertRaises(RuntimeError):
|
|
self.generator.throw(RuntimeError)
|
|
self.assertEqual(self._generatorstate(), inspect.GEN_CLOSED)
|
|
|
|
def test_running(self):
|
|
# As mentioned on issue #10220, checking for the RUNNING state only
|
|
# makes sense inside the generator itself.
|
|
# The following generator checks for this by using the closure's
|
|
# reference to self and the generator state checking helper method
|
|
def running_check_generator():
|
|
for number in range(5):
|
|
self.assertEqual(self._generatorstate(), inspect.GEN_RUNNING)
|
|
yield number
|
|
self.assertEqual(self._generatorstate(), inspect.GEN_RUNNING)
|
|
self.generator = running_check_generator()
|
|
# Running up to the first yield
|
|
next(self.generator)
|
|
# Running after the first yield
|
|
next(self.generator)
|
|
|
|
def test_easy_debugging(self):
|
|
# repr() and str() of a generator state should contain the state name
|
|
names = 'GEN_CREATED GEN_RUNNING GEN_SUSPENDED GEN_CLOSED'.split()
|
|
for name in names:
|
|
state = getattr(inspect, name)
|
|
self.assertIn(name, repr(state))
|
|
self.assertIn(name, str(state))
|
|
|
|
|
|
def test_main():
|
|
run_unittest(
|
|
TestDecorators, TestRetrievingSourceCode, TestOneliners, TestBuggyCases,
|
|
TestInterpreterStack, TestClassesAndFunctions, TestPredicates,
|
|
TestGetcallargsFunctions, TestGetcallargsMethods,
|
|
TestGetcallargsUnboundMethods, TestGetattrStatic, TestGetGeneratorState,
|
|
TestNoEOL
|
|
)
|
|
|
|
if __name__ == "__main__":
|
|
test_main()
|