| 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) |
| |
| |
| class _BrokenDataDescriptor(object): |
| """ |
| A broken data descriptor. See bug #1785. |
| """ |
| def __get__(*args): |
| raise AssertionError("should not __get__ data descriptors") |
| |
| def __set__(*args): |
| raise RuntimeError |
| |
| def __getattr__(*args): |
| raise AssertionError("should not __getattr__ data descriptors") |
| |
| |
| class _BrokenMethodDescriptor(object): |
| """ |
| A broken method descriptor. See bug #1785. |
| """ |
| def __get__(*args): |
| raise AssertionError("should not __get__ method descriptors") |
| |
| def __getattr__(*args): |
| raise AssertionError("should not __getattr__ method descriptors") |
| |
| |
| # 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' |
| |
| dd = _BrokenDataDescriptor() |
| md = _BrokenMethodDescriptor() |
| |
| 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') |
| self.assertIn(('md', 'method', A), attrs, 'missing method descriptor') |
| self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor') |
| |
| 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') |
| self.assertIn(('md', 'method', A), attrs, 'missing method descriptor') |
| self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor') |
| |
| |
| 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') |
| self.assertIn(('md', 'method', A), attrs, 'missing method descriptor') |
| self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor') |
| |
| 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') |
| self.assertIn(('md', 'method', A), attrs, 'missing method descriptor') |
| self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor') |
| |
| def test_classify_builtin_types(self): |
| # Simple sanity check that all built-in types can have their |
| # attributes classified. |
| for name in dir(__builtins__): |
| builtin = getattr(__builtins__, name) |
| if isinstance(builtin, type): |
| inspect.classify_class_attrs(builtin) |
| |
| def test_getmembers_descriptors(self): |
| class A(object): |
| dd = _BrokenDataDescriptor() |
| md = _BrokenMethodDescriptor() |
| |
| def pred_wrapper(pred): |
| # A quick'n'dirty way to discard standard attributes of new-style |
| # classes. |
| class Empty(object): |
| pass |
| def wrapped(x): |
| if '__name__' in dir(x) and hasattr(Empty, x.__name__): |
| return False |
| return pred(x) |
| return wrapped |
| |
| ismethoddescriptor = pred_wrapper(inspect.ismethoddescriptor) |
| isdatadescriptor = pred_wrapper(inspect.isdatadescriptor) |
| |
| self.assertEqual(inspect.getmembers(A, ismethoddescriptor), |
| [('md', A.__dict__['md'])]) |
| self.assertEqual(inspect.getmembers(A, isdatadescriptor), |
| [('dd', A.__dict__['dd'])]) |
| |
| class B(A): |
| pass |
| |
| self.assertEqual(inspect.getmembers(B, ismethoddescriptor), |
| [('md', A.__dict__['md'])]) |
| self.assertEqual(inspect.getmembers(B, isdatadescriptor), |
| [('dd', A.__dict__['dd'])]) |
| |
| def test_getmembers_method(self): |
| class B: |
| def f(self): |
| pass |
| |
| self.assertIn(('f', B.f), inspect.getmembers(B)) |
| self.assertNotIn(('f', B.f), inspect.getmembers(B, inspect.ismethod)) |
| b = B() |
| self.assertIn(('f', b.f), inspect.getmembers(b)) |
| self.assertIn(('f', b.f), inspect.getmembers(b, inspect.ismethod)) |
| |
| |
| 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') |
| # XXX: success of this one depends on dict order |
| ## 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) |
| |
| def test_module(self): |
| sentinel = object() |
| self.assertIsNot(inspect.getattr_static(sys, "version", sentinel), |
| sentinel) |
| |
| def test_metaclass_with_metaclass_with_dict_as_property(self): |
| class MetaMeta(type): |
| @property |
| def __dict__(self): |
| self.executed = True |
| return dict(spam=42) |
| |
| class Meta(type, metaclass=MetaMeta): |
| executed = False |
| |
| class Thing(metaclass=Meta): |
| pass |
| |
| with self.assertRaises(AttributeError): |
| inspect.getattr_static(Thing, "spam") |
| 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() |