"""

parameters = ['a', 'bar', 'c', 'delta', 'ephraim', 'magical', 'yoyo', 'z']

for i in range(1, 2**len(parameters)):

p = []

bit = 1

for j in range(len(parameters)):

if i & (bit << j):

p.append(parameters[j])

fn_text = "def foo(*, " + ", ".join(p) + "): pass"

symbols = {}

exec(fn_text, symbols, symbols)

predicates = set([inspect.isbuiltin, inspect.isclass, inspect.iscode,

inspect.isframe, inspect.isfunction, inspect.ismethod,

inspect.ismodule, inspect.istraceback,

inspect.isgenerator, inspect.isgeneratorfunction,

inspect.iscoroutine, inspect.iscoroutinefunction,

inspect.isasyncgen, inspect.isasyncgenfunction,

inspect.ismethodwrapper])

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 or \

predicate == inspect.isasyncgenfunction or \

predicate == inspect.iscoroutinefunction) and \

other == inspect.isfunction:

continue

self.assertFalse(other(obj), 'not %s(%s)' % (other.__name__, exp))

def test__all__(self):

def test_excluding_predicates(self):

global tb

self.istest(inspect.isbuiltin, 'sys.exit')

self.istest(inspect.isbuiltin, '[].append')

self.istest(inspect.iscode, 'mod.spam.__code__')

try:

1/0

except Exception as e:

tb = e.__traceback__

self.istest(inspect.isframe, 'tb.tb_frame')

self.istest(inspect.istraceback, 'tb')

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))

finally:

# Clear traceback and all the frames and local variables hanging to it.

tb = None

self.istest(inspect.isfunction, 'mod.spam')

self.istest(inspect.isfunction, 'mod.StupidGit.abuse')

self.istest(inspect.ismethod, 'git.argue')

self.istest(inspect.ismethod, 'mod.custom_method')

self.istest(inspect.ismodule, 'mod')

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')

self.istest(inspect.isasyncgen,

'async_generator_function_example(1)')

self.istest(inspect.isasyncgenfunction,

'async_generator_function_example')

with warnings.catch_warnings():

warnings.simplefilter("ignore")

self.istest(inspect.iscoroutine, 'coroutine_function_example(1)')

self.istest(inspect.iscoroutinefunction, 'coroutine_function_example')

if hasattr(types, 'MemberDescriptorType'):

self.istest(inspect.ismemberdescriptor, 'datetime.timedelta.days')

else:

self.assertFalse(inspect.ismemberdescriptor(datetime.timedelta.days))

self.istest(inspect.ismethodwrapper, "object().__str__")

self.istest(inspect.ismethodwrapper, "object().__eq__")

self.istest(inspect.ismethodwrapper, "object().__repr__")

self.assertFalse(inspect.ismethodwrapper(type))

self.assertFalse(inspect.ismethodwrapper(int))

self.assertFalse(inspect.ismethodwrapper(type("AnyClass", (), {})))

def test_iscoroutine(self):

async_gen_coro = async_generator_function_example(1)

gen_coro = gen_coroutine_function_example(1)

coro = coroutine_function_example(1)

class PMClass:

async_generator_partialmethod_example = functools.partialmethod(

async_generator_function_example)

coroutine_partialmethod_example = functools.partialmethod(

coroutine_function_example)

gen_coroutine_partialmethod_example = functools.partialmethod(

gen_coroutine_function_example)

# partialmethods on the class, bound to an instance

pm_instance = PMClass()

async_gen_coro_pmi = pm_instance.async_generator_partialmethod_example

gen_coro_pmi = pm_instance.gen_coroutine_partialmethod_example

coro_pmi = pm_instance.coroutine_partialmethod_example

# partialmethods on the class, unbound but accessed via the class

async_gen_coro_pmc = PMClass.async_generator_partialmethod_example

gen_coro_pmc = PMClass.gen_coroutine_partialmethod_example

coro_pmc = PMClass.coroutine_partialmethod_example

self.assertFalse(

inspect.iscoroutinefunction(gen_coroutine_function_example))

self.assertFalse(

inspect.iscoroutinefunction(

functools.partial(functools.partial(

gen_coroutine_function_example))))

self.assertFalse(inspect.iscoroutinefunction(gen_coro_pmi))

self.assertFalse(inspect.iscoroutinefunction(gen_coro_pmc))

self.assertFalse(inspect.iscoroutine(gen_coro))

self.assertTrue(

inspect.isgeneratorfunction(gen_coroutine_function_example))

self.assertTrue(

inspect.isgeneratorfunction(

functools.partial(functools.partial(

gen_coroutine_function_example))))

self.assertTrue(inspect.isgeneratorfunction(gen_coro_pmi))

self.assertTrue(inspect.isgeneratorfunction(gen_coro_pmc))

self.assertTrue(inspect.isgenerator(gen_coro))

async def _fn3():

pass

@inspect.markcoroutinefunction

def fn3():

return _fn3()

self.assertTrue(inspect.iscoroutinefunction(fn3))

self.assertTrue(

inspect.iscoroutinefunction(

inspect.markcoroutinefunction(lambda: _fn3())

)

)

class Cl:

async def __call__(self):

pass

self.assertFalse(inspect.iscoroutinefunction(Cl))

# instances with async def __call__ are NOT recognised.

self.assertFalse(inspect.iscoroutinefunction(Cl()))

# unless explicitly marked.

self.assertTrue(inspect.iscoroutinefunction(

inspect.markcoroutinefunction(Cl())

))

class Cl2:

@inspect.markcoroutinefunction

def __call__(self):

pass

self.assertFalse(inspect.iscoroutinefunction(Cl2))

# instances with marked __call__ are NOT recognised.

self.assertFalse(inspect.iscoroutinefunction(Cl2()))

# unless explicitly marked.

self.assertTrue(inspect.iscoroutinefunction(

inspect.markcoroutinefunction(Cl2())

))

class Cl3:

@inspect.markcoroutinefunction

@classmethod

def do_something_classy(cls):

pass

@inspect.markcoroutinefunction

@staticmethod

def do_something_static():

pass

self.assertTrue(inspect.iscoroutinefunction(Cl3.do_something_classy))

self.assertTrue(inspect.iscoroutinefunction(Cl3.do_something_static))

self.assertFalse(

inspect.iscoroutinefunction(unittest.mock.Mock()))

self.assertTrue(

inspect.iscoroutinefunction(unittest.mock.AsyncMock()))

self.assertTrue(

inspect.iscoroutinefunction(coroutine_function_example))

self.assertTrue(

inspect.iscoroutinefunction(

functools.partial(functools.partial(

coroutine_function_example))))

self.assertTrue(inspect.iscoroutinefunction(coro_pmi))

self.assertTrue(inspect.iscoroutinefunction(coro_pmc))

self.assertTrue(inspect.iscoroutine(coro))

self.assertFalse(

inspect.isgeneratorfunction(unittest.mock.Mock()))

self.assertFalse(

inspect.isgeneratorfunction(unittest.mock.AsyncMock()))

self.assertFalse(

inspect.isgeneratorfunction(coroutine_function_example))

self.assertFalse(

inspect.isgeneratorfunction(

functools.partial(functools.partial(

coroutine_function_example))))

self.assertFalse(inspect.isgeneratorfunction(coro_pmi))

self.assertFalse(inspect.isgeneratorfunction(coro_pmc))

self.assertFalse(inspect.isgenerator(coro))

self.assertFalse(

inspect.isasyncgenfunction(unittest.mock.Mock()))

self.assertFalse(

inspect.isasyncgenfunction(unittest.mock.AsyncMock()))

self.assertFalse(

inspect.isasyncgenfunction(coroutine_function_example))

self.assertTrue(

inspect.isasyncgenfunction(async_generator_function_example))

self.assertTrue(

inspect.isasyncgenfunction(

functools.partial(functools.partial(

async_generator_function_example))))

self.assertTrue(inspect.isasyncgenfunction(async_gen_coro_pmi))

self.assertTrue(inspect.isasyncgenfunction(async_gen_coro_pmc))

self.assertTrue(inspect.isasyncgen(async_gen_coro))

coro.close(); gen_coro.close(); # silence warnings

def test_isawaitable(self):

def gen(): yield

self.assertFalse(inspect.isawaitable(gen()))

coro = coroutine_function_example(1)

gen_coro = gen_coroutine_function_example(1)

self.assertTrue(inspect.isawaitable(coro))

self.assertTrue(inspect.isawaitable(gen_coro))

class Future:

def __await__():

pass

self.assertTrue(inspect.isawaitable(Future()))

self.assertFalse(inspect.isawaitable(Future))

class NotFuture: pass

not_fut = NotFuture()

not_fut.__await__ = lambda: None

self.assertFalse(inspect.isawaitable(not_fut))

coro.close(); gen_coro.close() # silence warnings

def test_isroutine(self):

# method

self.assertTrue(inspect.isroutine(git.argue))

self.assertTrue(inspect.isroutine(mod.custom_method))

self.assertTrue(inspect.isroutine([].count))

# function

self.assertTrue(inspect.isroutine(mod.spam))

self.assertTrue(inspect.isroutine(mod.StupidGit.abuse))

# slot-wrapper

self.assertTrue(inspect.isroutine(object.__init__))

self.assertTrue(inspect.isroutine(object.__str__))

self.assertTrue(inspect.isroutine(object.__lt__))

self.assertTrue(inspect.isroutine(int.__lt__))

# method-wrapper

self.assertTrue(inspect.isroutine(object().__init__))

self.assertTrue(inspect.isroutine(object().__str__))

self.assertTrue(inspect.isroutine(object().__lt__))

self.assertTrue(inspect.isroutine((42).__lt__))

# method-descriptor

self.assertTrue(inspect.isroutine(str.join))

self.assertTrue(inspect.isroutine(list.append))

self.assertTrue(inspect.isroutine(''.join))

self.assertTrue(inspect.isroutine([].append))

# object

self.assertFalse(inspect.isroutine(object))

self.assertFalse(inspect.isroutine(object()))

self.assertFalse(inspect.isroutine(str()))

# module

self.assertFalse(inspect.isroutine(mod))

# type

self.assertFalse(inspect.isroutine(type))

self.assertFalse(inspect.isroutine(int))

self.assertFalse(inspect.isroutine(type('some_class', (), {})))

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))

def test_isabstract_during_init_subclass(self):

from abc import ABCMeta, abstractmethod

isabstract_checks = []

class AbstractChecker(metaclass=ABCMeta):

def __init_subclass__(cls):

isabstract_checks.append(inspect.isabstract(cls))

class AbstractClassExample(AbstractChecker):

@abstractmethod

def foo(self):

pass

class ClassExample(AbstractClassExample):

def foo(self):

pass

self.assertEqual(isabstract_checks, [True, False])

isabstract_checks.clear()

class AbstractChild(AbstractClassExample):

pass

class AbstractGrandchild(AbstractChild):

pass

class ConcreteGrandchild(ClassExample):

pass

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.__traceback__')

self.istest(inspect.isframe, 'mod.fr')

def test_stack(self):

self.assertTrue(len(mod.st) >= 5)

frame1, frame2, frame3, frame4, *_ = mod.st

frameinfo = revise(*frame1[1:])

self.assertEqual(frameinfo,

(modfile, 16, 'eggs', [' st = inspect.stack()\n'], 0))

self.assertEqual(frame1.positions, dis.Positions(16, 16, 9, 24))

frameinfo = revise(*frame2[1:])

self.assertEqual(frameinfo,

(modfile, 9, 'spam', [' eggs(b + d, c + f)\n'], 0))

self.assertEqual(frame2.positions, dis.Positions(9, 9, 4, 22))

frameinfo = revise(*frame3[1:])

self.assertEqual(frameinfo,

(modfile, 43, 'argue', [' spam(a, b, c)\n'], 0))

self.assertEqual(frame3.positions, dis.Positions(43, 43, 12, 25))

frameinfo = revise(*frame4[1:])

self.assertEqual(frameinfo,

(modfile, 39, 'abuse', [' self.argue(a, b, c)\n'], 0))

self.assertEqual(frame4.positions, dis.Positions(39, 39, 8, 27))

# Test named tuple fields

record = mod.st[0]

self.assertIs(record.frame, mod.fr)

self.assertEqual(record.lineno, 16)

self.assertEqual(record.filename, mod.__file__)

self.assertEqual(record.function, 'eggs')

self.assertIn('inspect.stack()', record.code_context[0])

self.assertEqual(record.index, 0)

def test_trace(self):

self.assertEqual(len(git.tr), 3)

frame1, frame2, frame3, = git.tr

self.assertEqual(revise(*frame1[1:]),

(modfile, 43, 'argue', [' spam(a, b, c)\n'], 0))

self.assertEqual(frame1.positions, dis.Positions(43, 43, 12, 25))

self.assertEqual(revise(*frame2[1:]),

(modfile, 9, 'spam', [' eggs(b + d, c + f)\n'], 0))

self.assertEqual(frame2.positions, dis.Positions(9, 9, 4, 22))

self.assertEqual(revise(*frame3[1:]),

(modfile, 18, 'eggs', [' q = y / 0\n'], 0))

self.assertEqual(frame3.positions, dis.Positions(18, 18, 8, 13))

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),

# Subclasses must override.

fodderModule = None

def setUp(self):

with open(inspect.getsourcefile(self.fodderModule), encoding="utf-8") as fp:

self.source = fp.read()

def sourcerange(self, top, bottom):

lines = self.source.split("\n")

return "\n".join(lines[top-1:bottom]) + ("\n" if bottom else "")

def assertSourceEqual(self, obj, top, bottom):

self.assertEqual(inspect.getsource(obj),

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),

('Tit', mod.MalodorousPervert),

('WhichComments', mod.WhichComments),

])

tree = inspect.getclasstree([cls[1] for cls in classes])

self.assertEqual(tree,

[(object, ()),

[(mod.ParrotDroppings, (object,)),

[(mod.FesteringGob, (mod.MalodorousPervert,

mod.ParrotDroppings))

],

(mod.StupidGit, (object,)),

[(mod.MalodorousPervert, (mod.StupidGit,)),

[(mod.FesteringGob, (mod.MalodorousPervert,

mod.ParrotDroppings))

]

],

(mod.WhichComments, (object,),)

]

])

tree = inspect.getclasstree([cls[1] for cls in classes], True)

self.assertEqual(tree,

[(object, ()),

[(mod.ParrotDroppings, (object,)),

(mod.StupidGit, (object,)),

[(mod.MalodorousPervert, (mod.StupidGit,)),

[(mod.FesteringGob, (mod.MalodorousPervert,

mod.ParrotDroppings))

]

],

(mod.WhichComments, (object,),)

]

])

def test_getfunctions(self):

functions = inspect.getmembers(mod, inspect.isfunction)

self.assertEqual(functions, [('after_closing', mod.after_closing),

('eggs', mod.eggs),

('lobbest', mod.lobbest),

('spam', mod.spam)])

@unittest.skipIf(sys.flags.optimize >= 2,

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')

self.assertEqual(inspect.getdoc(SlotUser.power),

'measured in kilowatts')

self.assertEqual(inspect.getdoc(SlotUser.distance),

'measured in kilometers')

@unittest.skipIf(sys.flags.optimize >= 2,

def test_getdoc_inherited(self):

self.assertEqual(inspect.getdoc(mod.FesteringGob),

'A longer,\n\nindented\n\ndocstring.')

self.assertEqual(inspect.getdoc(mod.FesteringGob.abuse),

'Another\n\ndocstring\n\ncontaining\n\ntabs')

self.assertEqual(inspect.getdoc(mod.FesteringGob().abuse),

'Another\n\ndocstring\n\ncontaining\n\ntabs')

self.assertEqual(inspect.getdoc(mod.FesteringGob.contradiction),

'The automatic gainsaying.')

@unittest.skipIf(MISSING_C_DOCSTRINGS, "test requires docstrings")

def test_finddoc(self):

finddoc = inspect._finddoc

self.assertEqual(finddoc(int), int.__doc__)

self.assertEqual(finddoc(int.to_bytes), int.to_bytes.__doc__)

self.assertEqual(finddoc(int().to_bytes), int.to_bytes.__doc__)

self.assertEqual(finddoc(int.from_bytes), int.from_bytes.__doc__)

self.assertEqual(finddoc(int.real), int.real.__doc__)

cleandoc_testdata = [

# first line should have different margin

(' An\n indented\n docstring.', 'An\nindented\n docstring.'),

# trailing whitespace are not removed.

(' An \n \n indented \n docstring. ',

'An \n \nindented \n docstring. '),

# NUL is not termination.

('doc\0string\n\n second\0line\n third\0line\0',

'doc\0string\n\nsecond\0line\nthird\0line\0'),

# first line is lstrip()-ped. other lines are kept when no margin.[w:

(' ', ''),

# compiler.cleandoc() doesn't strip leading/trailing newlines

# to keep maximum backward compatibility.

# inspect.cleandoc() removes them.

('\n\n\n first paragraph\n\n second paragraph\n\n',

'\n\n\nfirst paragraph\n\n second paragraph\n\n'),

(' \n \n \n ', '\n \n \n '),

]

def test_cleandoc(self):

func = inspect.cleandoc

for i, (input, expected) in enumerate(self.cleandoc_testdata):

# only inspect.cleandoc() strip \n

expected = expected.strip('\n')

with self.subTest(i=i):

self.assertEqual(func(input), expected)

@cpython_only

def test_c_cleandoc(self):

try:

import _testinternalcapi

except ImportError:

return unittest.skip("requires _testinternalcapi")

func = _testinternalcapi.compiler_cleandoc

for i, (input, expected) in enumerate(self.cleandoc_testdata):

with self.subTest(i=i):

self.assertEqual(func(input), expected)

def test_getcomments(self):

self.assertEqual(inspect.getcomments(mod), '# line 1\n')

self.assertEqual(inspect.getcomments(mod.StupidGit), '# line 20\n')

self.assertEqual(inspect.getcomments(mod2.cls160), '# line 159\n')

# If the object source file is not available, return None.

co = compile('x=1', '_non_existing_filename.py', 'exec')

self.assertIsNone(inspect.getcomments(co))

# If the object has been defined in C, return None.

self.assertIsNone(inspect.getcomments(list))

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_getmodule_file_not_found(self):

# See bpo-45406

def _getabsfile(obj, _filename):

raise FileNotFoundError('bad file')

with unittest.mock.patch('inspect.getabsfile', _getabsfile):

f = inspect.currentframe()

self.assertIsNone(inspect.getmodule(f))

inspect.getouterframes(f) # smoke test

def test_getframeinfo_get_first_line(self):

frame_info = inspect.getframeinfo(self.fodderModule.fr, 50)

self.assertEqual(frame_info.code_context[0], "# line 1\n")

self.assertEqual(frame_info.code_context[1], "'A module docstring.'\n")

def test_getsource(self):

self.assertSourceEqual(git.abuse, 29, 39)

self.assertSourceEqual(mod.StupidGit, 21, 51)

self.assertSourceEqual(mod.lobbest, 75, 76)

self.assertSourceEqual(mod.after_closing, 120, 120)

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("x=1", fn, "exec")

self.assertEqual(inspect.getsourcefile(co), None)

linecache.cache[co.co_filename] = (1, None, "None", co.co_filename)

try:

self.assertEqual(normcase(inspect.getsourcefile(co)), fn)

finally:

del linecache.cache[co.co_filename]

def test_getsource_empty_file(self):

with temp_cwd() as cwd:

with open('empty_file.py', 'w'):

pass

sys.path.insert(0, cwd)

try:

import empty_file

self.assertEqual(inspect.getsource(empty_file), '\n')

self.assertEqual(inspect.getsourcelines(empty_file), (['\n'], 0))

finally:

sys.path.remove(cwd)

def test_getfile(self):

self.assertEqual(inspect.getfile(mod.StupidGit), mod.__file__)

def test_getfile_builtin_module(self):

with self.assertRaises(TypeError) as e:

inspect.getfile(sys)

self.assertTrue(str(e.exception).startswith('<module'))

def test_getfile_builtin_class(self):

with self.assertRaises(TypeError) as e:

inspect.getfile(int)

self.assertTrue(str(e.exception).startswith('<class'))

def test_getfile_builtin_function_or_method(self):

with self.assertRaises(TypeError) as e_abs:

inspect.getfile(abs)

self.assertIn('expected, got', str(e_abs.exception))

with self.assertRaises(TypeError) as e_append:

inspect.getfile(list.append)

self.assertIn('expected, got', str(e_append.exception))

def test_getfile_class_without_module(self):

class CM(type):

@property

def __module__(cls):

raise AttributeError

class C(metaclass=CM):

pass

with self.assertRaises(TypeError):

inspect.getfile(C)

def test_getfile_broken_repr(self):

class ErrorRepr:

def __repr__(self):

raise Exception('xyz')

er = ErrorRepr()

with self.assertRaises(TypeError):

inspect.getfile(er)

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(keepends=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

def test_getsource_on_code_object(self):

self.assertSourceEqual(mod.eggs.__code__, 12, 18)

def test_getsource_on_generated_class(self):

A = type('A', (), {})

self.assertEqual(inspect.getsourcefile(A), __file__)

self.assertEqual(inspect.getfile(A), __file__)

self.assertIs(inspect.getmodule(A), sys.modules[__name__])

self.assertRaises(OSError, inspect.getsource, A)

self.assertRaises(OSError, inspect.getsourcelines, A)

self.assertIsNone(inspect.getcomments(A))

def test_getsource_on_class_without_firstlineno(self):

__firstlineno__ = 1

class C:

nonlocal __firstlineno__

def test_getclasses_interactive(self):

# bpo-44648: simulate a REPL session;

# there is no `__file__` in the __main__ module

code = "import sys, inspect; \

_, _, stderr = assert_python_failure("-c", code, __isolated=True)

fodderModule = mod

def test_range_toplevel_frame(self):

self.maxDiff = None

self.assertSourceEqual(mod.currentframe, 1, None)

def test_range_traceback_toplevel_frame(self):

fodderModule = mod2

def test_wrapped_decorator(self):

self.assertSourceEqual(mod2.wrapped, 14, 17)

def test_replacing_decorator(self):

self.assertSourceEqual(mod2.gone, 9, 10)

def test_getsource_unwrap(self):

self.assertSourceEqual(mod2.real, 130, 132)

def test_decorator_with_lambda(self):

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_parenthesized_multiline_lambda(self):

# Test inspect.getsource with a parenthesized multi-line lambda

# function.

self.assertSourceEqual(mod2.parenthesized_lambda, 279, 279)

self.assertSourceEqual(mod2.parenthesized_lambda2, 281, 281)

self.assertSourceEqual(mod2.parenthesized_lambda3, 283, 283)

def test_post_line_parenthesized_lambda(self):

# Test inspect.getsource with a parenthesized multi-line lambda

# function.

self.assertSourceEqual(mod2.post_line_parenthesized_lambda1, 286, 287)

def test_nested_lambda(self):

# Test inspect.getsource with a nested lambda function.

self.assertSourceEqual(mod2.nested_lambda, 291, 292)

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.

fodderModule = mod

def test_toplevel_class(self):

self.assertSourceEqual(mod.WhichComments, 96, 114)

def test_class_method(self):

self.assertSourceEqual(mod.WhichComments.f, 99, 104)

def test_class_async_method(self):

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)

# This should not skip for CPython, but might on a repackaged python where

# unicodedata is not an external module, or on pypy.

@unittest.skipIf(not hasattr(unicodedata, '__file__') or

def test_findsource_binary(self):

self.assertRaises(OSError, inspect.getsource, unicodedata)

self.assertRaises(OSError, inspect.findsource, unicodedata)

def test_findsource_code_in_linecache(self):

lines = ["x=1"]

co = compile(lines[0], "_dynamically_created_file", "exec")

self.assertRaises(OSError, inspect.findsource, co)

self.assertRaises(OSError, inspect.getsource, co)

linecache.cache[co.co_filename] = (1, None, lines, co.co_filename)

try:

self.assertEqual(inspect.findsource(co), (lines,0))

self.assertEqual(inspect.getsource(co), lines[0])

finally:

del linecache.cache[co.co_filename]

def test_findsource_without_filename(self):

for fname in ['', '<string>']:

co = compile('x=1', fname, "exec")

self.assertRaises(IOError, inspect.findsource, co)

self.assertRaises(IOError, inspect.getsource, co)

def test_findsource_with_out_of_bounds_lineno(self):

mod_len = len(inspect.getsource(mod))

src = '\n' * 2* mod_len + "def f(): pass"

co = compile(src, mod.__file__, "exec")

g, l = {}, {}

eval(co, g, l)

func = l['f']

self.assertEqual(func.__code__.co_firstlineno, 1+2*mod_len)

with self.assertRaisesRegex(IOError, "lineno is out of bounds"):