+++ /dev/null
-import re\r
-import sys\r
-import types\r
-import unittest\r
-import inspect\r
-import linecache\r
-import datetime\r
-from UserList import UserList\r
-from UserDict import UserDict\r
-\r
-from test.test_support import run_unittest, check_py3k_warnings\r
-\r
-with check_py3k_warnings(\r
- ("tuple parameter unpacking has been removed", SyntaxWarning),\r
- quiet=True):\r
- from test import inspect_fodder as mod\r
- from test import inspect_fodder2 as mod2\r
-\r
-# C module for test_findsource_binary\r
-import unicodedata\r
-\r
-# Functions tested in this suite:\r
-# ismodule, isclass, ismethod, isfunction, istraceback, isframe, iscode,\r
-# isbuiltin, isroutine, isgenerator, isgeneratorfunction, getmembers,\r
-# getdoc, getfile, getmodule, getsourcefile, getcomments, getsource,\r
-# getclasstree, getargspec, getargvalues, formatargspec, formatargvalues,\r
-# currentframe, stack, trace, isdatadescriptor\r
-\r
-# NOTE: There are some additional tests relating to interaction with\r
-# zipimport in the test_zipimport_support test module.\r
-\r
-modfile = mod.__file__\r
-if modfile.endswith(('c', 'o')):\r
- modfile = modfile[:-1]\r
-\r
-import __builtin__\r
-\r
-try:\r
- 1 // 0\r
-except:\r
- tb = sys.exc_traceback\r
-\r
-git = mod.StupidGit()\r
-\r
-class IsTestBase(unittest.TestCase):\r
- predicates = set([inspect.isbuiltin, inspect.isclass, inspect.iscode,\r
- inspect.isframe, inspect.isfunction, inspect.ismethod,\r
- inspect.ismodule, inspect.istraceback,\r
- inspect.isgenerator, inspect.isgeneratorfunction])\r
-\r
- def istest(self, predicate, exp):\r
- obj = eval(exp)\r
- self.assertTrue(predicate(obj), '%s(%s)' % (predicate.__name__, exp))\r
-\r
- for other in self.predicates - set([predicate]):\r
- if predicate == inspect.isgeneratorfunction and\\r
- other == inspect.isfunction:\r
- continue\r
- self.assertFalse(other(obj), 'not %s(%s)' % (other.__name__, exp))\r
-\r
-def generator_function_example(self):\r
- for i in xrange(2):\r
- yield i\r
-\r
-class TestPredicates(IsTestBase):\r
- def test_sixteen(self):\r
- count = len(filter(lambda x:x.startswith('is'), dir(inspect)))\r
- # This test is here for remember you to update Doc/library/inspect.rst\r
- # which claims there are 16 such functions\r
- expected = 16\r
- err_msg = "There are %d (not %d) is* functions" % (count, expected)\r
- self.assertEqual(count, expected, err_msg)\r
-\r
-\r
- def test_excluding_predicates(self):\r
- self.istest(inspect.isbuiltin, 'sys.exit')\r
- self.istest(inspect.isbuiltin, '[].append')\r
- self.istest(inspect.iscode, 'mod.spam.func_code')\r
- self.istest(inspect.isframe, 'tb.tb_frame')\r
- self.istest(inspect.isfunction, 'mod.spam')\r
- self.istest(inspect.ismethod, 'mod.StupidGit.abuse')\r
- self.istest(inspect.ismethod, 'git.argue')\r
- self.istest(inspect.ismodule, 'mod')\r
- self.istest(inspect.istraceback, 'tb')\r
- self.istest(inspect.isdatadescriptor, '__builtin__.file.closed')\r
- self.istest(inspect.isdatadescriptor, '__builtin__.file.softspace')\r
- self.istest(inspect.isgenerator, '(x for x in xrange(2))')\r
- self.istest(inspect.isgeneratorfunction, 'generator_function_example')\r
- if hasattr(types, 'GetSetDescriptorType'):\r
- self.istest(inspect.isgetsetdescriptor,\r
- 'type(tb.tb_frame).f_locals')\r
- else:\r
- self.assertFalse(inspect.isgetsetdescriptor(type(tb.tb_frame).f_locals))\r
- if hasattr(types, 'MemberDescriptorType'):\r
- self.istest(inspect.ismemberdescriptor, 'datetime.timedelta.days')\r
- else:\r
- self.assertFalse(inspect.ismemberdescriptor(datetime.timedelta.days))\r
-\r
- def test_isroutine(self):\r
- self.assertTrue(inspect.isroutine(mod.spam))\r
- self.assertTrue(inspect.isroutine([].count))\r
-\r
- def test_isclass(self):\r
- self.istest(inspect.isclass, 'mod.StupidGit')\r
- self.assertTrue(inspect.isclass(list))\r
-\r
- class newstyle(object): pass\r
- self.assertTrue(inspect.isclass(newstyle))\r
-\r
- class CustomGetattr(object):\r
- def __getattr__(self, attr):\r
- return None\r
- self.assertFalse(inspect.isclass(CustomGetattr()))\r
-\r
- def test_get_slot_members(self):\r
- class C(object):\r
- __slots__ = ("a", "b")\r
-\r
- x = C()\r
- x.a = 42\r
- members = dict(inspect.getmembers(x))\r
- self.assertIn('a', members)\r
- self.assertNotIn('b', members)\r
-\r
- def test_isabstract(self):\r
- from abc import ABCMeta, abstractmethod\r
-\r
- class AbstractClassExample(object):\r
- __metaclass__ = ABCMeta\r
-\r
- @abstractmethod\r
- def foo(self):\r
- pass\r
-\r
- class ClassExample(AbstractClassExample):\r
- def foo(self):\r
- pass\r
-\r
- a = ClassExample()\r
-\r
- # Test general behaviour.\r
- self.assertTrue(inspect.isabstract(AbstractClassExample))\r
- self.assertFalse(inspect.isabstract(ClassExample))\r
- self.assertFalse(inspect.isabstract(a))\r
- self.assertFalse(inspect.isabstract(int))\r
- self.assertFalse(inspect.isabstract(5))\r
-\r
-\r
-class TestInterpreterStack(IsTestBase):\r
- def __init__(self, *args, **kwargs):\r
- unittest.TestCase.__init__(self, *args, **kwargs)\r
-\r
- git.abuse(7, 8, 9)\r
-\r
- def test_abuse_done(self):\r
- self.istest(inspect.istraceback, 'git.ex[2]')\r
- self.istest(inspect.isframe, 'mod.fr')\r
-\r
- def test_stack(self):\r
- self.assertTrue(len(mod.st) >= 5)\r
- self.assertEqual(mod.st[0][1:],\r
- (modfile, 16, 'eggs', [' st = inspect.stack()\n'], 0))\r
- self.assertEqual(mod.st[1][1:],\r
- (modfile, 9, 'spam', [' eggs(b + d, c + f)\n'], 0))\r
- self.assertEqual(mod.st[2][1:],\r
- (modfile, 43, 'argue', [' spam(a, b, c)\n'], 0))\r
- self.assertEqual(mod.st[3][1:],\r
- (modfile, 39, 'abuse', [' self.argue(a, b, c)\n'], 0))\r
-\r
- def test_trace(self):\r
- self.assertEqual(len(git.tr), 3)\r
- self.assertEqual(git.tr[0][1:], (modfile, 43, 'argue',\r
- [' spam(a, b, c)\n'], 0))\r
- self.assertEqual(git.tr[1][1:], (modfile, 9, 'spam',\r
- [' eggs(b + d, c + f)\n'], 0))\r
- self.assertEqual(git.tr[2][1:], (modfile, 18, 'eggs',\r
- [' q = y // 0\n'], 0))\r
-\r
- def test_frame(self):\r
- args, varargs, varkw, locals = inspect.getargvalues(mod.fr)\r
- self.assertEqual(args, ['x', 'y'])\r
- self.assertEqual(varargs, None)\r
- self.assertEqual(varkw, None)\r
- self.assertEqual(locals, {'x': 11, 'p': 11, 'y': 14})\r
- self.assertEqual(inspect.formatargvalues(args, varargs, varkw, locals),\r
- '(x=11, y=14)')\r
-\r
- def test_previous_frame(self):\r
- args, varargs, varkw, locals = inspect.getargvalues(mod.fr.f_back)\r
- self.assertEqual(args, ['a', 'b', 'c', 'd', ['e', ['f']]])\r
- self.assertEqual(varargs, 'g')\r
- self.assertEqual(varkw, 'h')\r
- self.assertEqual(inspect.formatargvalues(args, varargs, varkw, locals),\r
- '(a=7, b=8, c=9, d=3, (e=4, (f=5,)), *g=(), **h={})')\r
-\r
-class GetSourceBase(unittest.TestCase):\r
- # Subclasses must override.\r
- fodderFile = None\r
-\r
- def __init__(self, *args, **kwargs):\r
- unittest.TestCase.__init__(self, *args, **kwargs)\r
-\r
- with open(inspect.getsourcefile(self.fodderFile)) as fp:\r
- self.source = fp.read()\r
-\r
- def sourcerange(self, top, bottom):\r
- lines = self.source.split("\n")\r
- return "\n".join(lines[top-1:bottom]) + "\n"\r
-\r
- def assertSourceEqual(self, obj, top, bottom):\r
- self.assertEqual(inspect.getsource(obj),\r
- self.sourcerange(top, bottom))\r
-\r
-class TestRetrievingSourceCode(GetSourceBase):\r
- fodderFile = mod\r
-\r
- def test_getclasses(self):\r
- classes = inspect.getmembers(mod, inspect.isclass)\r
- self.assertEqual(classes,\r
- [('FesteringGob', mod.FesteringGob),\r
- ('MalodorousPervert', mod.MalodorousPervert),\r
- ('ParrotDroppings', mod.ParrotDroppings),\r
- ('StupidGit', mod.StupidGit)])\r
- tree = inspect.getclasstree([cls[1] for cls in classes], 1)\r
- self.assertEqual(tree,\r
- [(mod.ParrotDroppings, ()),\r
- (mod.StupidGit, ()),\r
- [(mod.MalodorousPervert, (mod.StupidGit,)),\r
- [(mod.FesteringGob, (mod.MalodorousPervert,\r
- mod.ParrotDroppings))\r
- ]\r
- ]\r
- ])\r
-\r
- def test_getfunctions(self):\r
- functions = inspect.getmembers(mod, inspect.isfunction)\r
- self.assertEqual(functions, [('eggs', mod.eggs),\r
- ('spam', mod.spam)])\r
-\r
- @unittest.skipIf(sys.flags.optimize >= 2,\r
- "Docstrings are omitted with -O2 and above")\r
- def test_getdoc(self):\r
- self.assertEqual(inspect.getdoc(mod), 'A module docstring.')\r
- self.assertEqual(inspect.getdoc(mod.StupidGit),\r
- 'A longer,\n\nindented\n\ndocstring.')\r
- self.assertEqual(inspect.getdoc(git.abuse),\r
- 'Another\n\ndocstring\n\ncontaining\n\ntabs')\r
-\r
- def test_cleandoc(self):\r
- self.assertEqual(inspect.cleandoc('An\n indented\n docstring.'),\r
- 'An\nindented\ndocstring.')\r
-\r
- def test_getcomments(self):\r
- self.assertEqual(inspect.getcomments(mod), '# line 1\n')\r
- self.assertEqual(inspect.getcomments(mod.StupidGit), '# line 20\n')\r
-\r
- def test_getmodule(self):\r
- # Check actual module\r
- self.assertEqual(inspect.getmodule(mod), mod)\r
- # Check class (uses __module__ attribute)\r
- self.assertEqual(inspect.getmodule(mod.StupidGit), mod)\r
- # Check a method (no __module__ attribute, falls back to filename)\r
- self.assertEqual(inspect.getmodule(mod.StupidGit.abuse), mod)\r
- # Do it again (check the caching isn't broken)\r
- self.assertEqual(inspect.getmodule(mod.StupidGit.abuse), mod)\r
- # Check a builtin\r
- self.assertEqual(inspect.getmodule(str), sys.modules["__builtin__"])\r
- # Check filename override\r
- self.assertEqual(inspect.getmodule(None, modfile), mod)\r
-\r
- def test_getsource(self):\r
- self.assertSourceEqual(git.abuse, 29, 39)\r
- self.assertSourceEqual(mod.StupidGit, 21, 46)\r
-\r
- def test_getsourcefile(self):\r
- self.assertEqual(inspect.getsourcefile(mod.spam), modfile)\r
- self.assertEqual(inspect.getsourcefile(git.abuse), modfile)\r
- fn = "_non_existing_filename_used_for_sourcefile_test.py"\r
- co = compile("None", fn, "exec")\r
- self.assertEqual(inspect.getsourcefile(co), None)\r
- linecache.cache[co.co_filename] = (1, None, "None", co.co_filename)\r
- self.assertEqual(inspect.getsourcefile(co), fn)\r
-\r
- def test_getfile(self):\r
- self.assertEqual(inspect.getfile(mod.StupidGit), mod.__file__)\r
-\r
- def test_getmodule_recursion(self):\r
- from types import ModuleType\r
- name = '__inspect_dummy'\r
- m = sys.modules[name] = ModuleType(name)\r
- m.__file__ = "<string>" # hopefully not a real filename...\r
- m.__loader__ = "dummy" # pretend the filename is understood by a loader\r
- exec "def x(): pass" in m.__dict__\r
- self.assertEqual(inspect.getsourcefile(m.x.func_code), '<string>')\r
- del sys.modules[name]\r
- inspect.getmodule(compile('a=10','','single'))\r
-\r
-class TestDecorators(GetSourceBase):\r
- fodderFile = mod2\r
-\r
- def test_wrapped_decorator(self):\r
- self.assertSourceEqual(mod2.wrapped, 14, 17)\r
-\r
- def test_replacing_decorator(self):\r
- self.assertSourceEqual(mod2.gone, 9, 10)\r
-\r
-class TestOneliners(GetSourceBase):\r
- fodderFile = mod2\r
- def test_oneline_lambda(self):\r
- # Test inspect.getsource with a one-line lambda function.\r
- self.assertSourceEqual(mod2.oll, 25, 25)\r
-\r
- def test_threeline_lambda(self):\r
- # Test inspect.getsource with a three-line lambda function,\r
- # where the second and third lines are _not_ indented.\r
- self.assertSourceEqual(mod2.tll, 28, 30)\r
-\r
- def test_twoline_indented_lambda(self):\r
- # Test inspect.getsource with a two-line lambda function,\r
- # where the second line _is_ indented.\r
- self.assertSourceEqual(mod2.tlli, 33, 34)\r
-\r
- def test_onelinefunc(self):\r
- # Test inspect.getsource with a regular one-line function.\r
- self.assertSourceEqual(mod2.onelinefunc, 37, 37)\r
-\r
- def test_manyargs(self):\r
- # Test inspect.getsource with a regular function where\r
- # the arguments are on two lines and _not_ indented and\r
- # the body on the second line with the last arguments.\r
- self.assertSourceEqual(mod2.manyargs, 40, 41)\r
-\r
- def test_twolinefunc(self):\r
- # Test inspect.getsource with a regular function where\r
- # the body is on two lines, following the argument list and\r
- # continued on the next line by a \\.\r
- self.assertSourceEqual(mod2.twolinefunc, 44, 45)\r
-\r
- def test_lambda_in_list(self):\r
- # Test inspect.getsource with a one-line lambda function\r
- # defined in a list, indented.\r
- self.assertSourceEqual(mod2.a[1], 49, 49)\r
-\r
- def test_anonymous(self):\r
- # Test inspect.getsource with a lambda function defined\r
- # as argument to another function.\r
- self.assertSourceEqual(mod2.anonymous, 55, 55)\r
-\r
-class TestBuggyCases(GetSourceBase):\r
- fodderFile = mod2\r
-\r
- def test_with_comment(self):\r
- self.assertSourceEqual(mod2.with_comment, 58, 59)\r
-\r
- def test_multiline_sig(self):\r
- self.assertSourceEqual(mod2.multiline_sig[0], 63, 64)\r
-\r
- def test_nested_class(self):\r
- self.assertSourceEqual(mod2.func69().func71, 71, 72)\r
-\r
- def test_one_liner_followed_by_non_name(self):\r
- self.assertSourceEqual(mod2.func77, 77, 77)\r
-\r
- def test_one_liner_dedent_non_name(self):\r
- self.assertSourceEqual(mod2.cls82.func83, 83, 83)\r
-\r
- def test_with_comment_instead_of_docstring(self):\r
- self.assertSourceEqual(mod2.func88, 88, 90)\r
-\r
- def test_method_in_dynamic_class(self):\r
- self.assertSourceEqual(mod2.method_in_dynamic_class, 95, 97)\r
-\r
- @unittest.skipIf(\r
- not hasattr(unicodedata, '__file__') or\r
- unicodedata.__file__[-4:] in (".pyc", ".pyo"),\r
- "unicodedata is not an external binary module")\r
- def test_findsource_binary(self):\r
- self.assertRaises(IOError, inspect.getsource, unicodedata)\r
- self.assertRaises(IOError, inspect.findsource, unicodedata)\r
-\r
- def test_findsource_code_in_linecache(self):\r
- lines = ["x=1"]\r
- co = compile(lines[0], "_dynamically_created_file", "exec")\r
- self.assertRaises(IOError, inspect.findsource, co)\r
- self.assertRaises(IOError, inspect.getsource, co)\r
- linecache.cache[co.co_filename] = (1, None, lines, co.co_filename)\r
- self.assertEqual(inspect.findsource(co), (lines,0))\r
- self.assertEqual(inspect.getsource(co), lines[0])\r
-\r
-# Helper for testing classify_class_attrs.\r
-def attrs_wo_objs(cls):\r
- return [t[:3] for t in inspect.classify_class_attrs(cls)]\r
-\r
-class TestClassesAndFunctions(unittest.TestCase):\r
- def test_classic_mro(self):\r
- # Test classic-class method resolution order.\r
- class A: pass\r
- class B(A): pass\r
- class C(A): pass\r
- class D(B, C): pass\r
-\r
- expected = (D, B, A, C)\r
- got = inspect.getmro(D)\r
- self.assertEqual(expected, got)\r
-\r
- def test_newstyle_mro(self):\r
- # The same w/ new-class MRO.\r
- class A(object): pass\r
- class B(A): pass\r
- class C(A): pass\r
- class D(B, C): pass\r
-\r
- expected = (D, B, C, A, object)\r
- got = inspect.getmro(D)\r
- self.assertEqual(expected, got)\r
-\r
- def assertArgSpecEquals(self, routine, args_e, varargs_e = None,\r
- varkw_e = None, defaults_e = None,\r
- formatted = None):\r
- args, varargs, varkw, defaults = inspect.getargspec(routine)\r
- self.assertEqual(args, args_e)\r
- self.assertEqual(varargs, varargs_e)\r
- self.assertEqual(varkw, varkw_e)\r
- self.assertEqual(defaults, defaults_e)\r
- if formatted is not None:\r
- self.assertEqual(inspect.formatargspec(args, varargs, varkw, defaults),\r
- formatted)\r
-\r
- def test_getargspec(self):\r
- self.assertArgSpecEquals(mod.eggs, ['x', 'y'], formatted = '(x, y)')\r
-\r
- self.assertArgSpecEquals(mod.spam,\r
- ['a', 'b', 'c', 'd', ['e', ['f']]],\r
- 'g', 'h', (3, (4, (5,))),\r
- '(a, b, c, d=3, (e, (f,))=(4, (5,)), *g, **h)')\r
-\r
- def test_getargspec_method(self):\r
- class A(object):\r
- def m(self):\r
- pass\r
- self.assertArgSpecEquals(A.m, ['self'])\r
-\r
- def test_getargspec_sublistofone(self):\r
- with check_py3k_warnings(\r
- ("tuple parameter unpacking has been removed", SyntaxWarning),\r
- ("parenthesized argument names are invalid", SyntaxWarning)):\r
- exec 'def sublistOfOne((foo,)): return 1'\r
- self.assertArgSpecEquals(sublistOfOne, [['foo']])\r
-\r
- exec 'def fakeSublistOfOne((foo)): return 1'\r
- self.assertArgSpecEquals(fakeSublistOfOne, ['foo'])\r
-\r
-\r
- def _classify_test(self, newstyle):\r
- """Helper for testing that classify_class_attrs finds a bunch of\r
- different kinds of attributes on a given class.\r
- """\r
- if newstyle:\r
- base = object\r
- else:\r
- class base:\r
- pass\r
-\r
- class A(base):\r
- def s(): pass\r
- s = staticmethod(s)\r
-\r
- def c(cls): pass\r
- c = classmethod(c)\r
-\r
- def getp(self): pass\r
- p = property(getp)\r
-\r
- def m(self): pass\r
-\r
- def m1(self): pass\r
-\r
- datablob = '1'\r
-\r
- attrs = attrs_wo_objs(A)\r
- self.assertIn(('s', 'static method', A), attrs, 'missing static method')\r
- self.assertIn(('c', 'class method', A), attrs, 'missing class method')\r
- self.assertIn(('p', 'property', A), attrs, 'missing property')\r
- self.assertIn(('m', 'method', A), attrs, 'missing plain method')\r
- self.assertIn(('m1', 'method', A), attrs, 'missing plain method')\r
- self.assertIn(('datablob', 'data', A), attrs, 'missing data')\r
-\r
- class B(A):\r
- def m(self): pass\r
-\r
- attrs = attrs_wo_objs(B)\r
- self.assertIn(('s', 'static method', A), attrs, 'missing static method')\r
- self.assertIn(('c', 'class method', A), attrs, 'missing class method')\r
- self.assertIn(('p', 'property', A), attrs, 'missing property')\r
- self.assertIn(('m', 'method', B), attrs, 'missing plain method')\r
- self.assertIn(('m1', 'method', A), attrs, 'missing plain method')\r
- self.assertIn(('datablob', 'data', A), attrs, 'missing data')\r
-\r
-\r
- class C(A):\r
- def m(self): pass\r
- def c(self): pass\r
-\r
- attrs = attrs_wo_objs(C)\r
- self.assertIn(('s', 'static method', A), attrs, 'missing static method')\r
- self.assertIn(('c', 'method', C), attrs, 'missing plain method')\r
- self.assertIn(('p', 'property', A), attrs, 'missing property')\r
- self.assertIn(('m', 'method', C), attrs, 'missing plain method')\r
- self.assertIn(('m1', 'method', A), attrs, 'missing plain method')\r
- self.assertIn(('datablob', 'data', A), attrs, 'missing data')\r
-\r
- class D(B, C):\r
- def m1(self): pass\r
-\r
- attrs = attrs_wo_objs(D)\r
- self.assertIn(('s', 'static method', A), attrs, 'missing static method')\r
- if newstyle:\r
- self.assertIn(('c', 'method', C), attrs, 'missing plain method')\r
- else:\r
- self.assertIn(('c', 'class method', A), attrs, 'missing class method')\r
- self.assertIn(('p', 'property', A), attrs, 'missing property')\r
- self.assertIn(('m', 'method', B), attrs, 'missing plain method')\r
- self.assertIn(('m1', 'method', D), attrs, 'missing plain method')\r
- self.assertIn(('datablob', 'data', A), attrs, 'missing data')\r
-\r
-\r
- def test_classify_oldstyle(self):\r
- """classify_class_attrs finds static methods, class methods,\r
- properties, normal methods, and data attributes on an old-style\r
- class.\r
- """\r
- self._classify_test(False)\r
-\r
-\r
- def test_classify_newstyle(self):\r
- """Just like test_classify_oldstyle, but for a new-style class.\r
- """\r
- self._classify_test(True)\r
-\r
-\r
-\r
-class TestGetcallargsFunctions(unittest.TestCase):\r
-\r
- # tuple parameters are named '.1', '.2', etc.\r
- is_tuplename = re.compile(r'^\.\d+$').match\r
-\r
- def assertEqualCallArgs(self, func, call_params_string, locs=None):\r
- locs = dict(locs or {}, func=func)\r
- r1 = eval('func(%s)' % call_params_string, None, locs)\r
- r2 = eval('inspect.getcallargs(func, %s)' % call_params_string, None,\r
- locs)\r
- self.assertEqual(r1, r2)\r
-\r
- def assertEqualException(self, func, call_param_string, locs=None):\r
- locs = dict(locs or {}, func=func)\r
- try:\r
- eval('func(%s)' % call_param_string, None, locs)\r
- except Exception, ex1:\r
- pass\r
- else:\r
- self.fail('Exception not raised')\r
- try:\r
- eval('inspect.getcallargs(func, %s)' % call_param_string, None,\r
- locs)\r
- except Exception, ex2:\r
- pass\r
- else:\r
- self.fail('Exception not raised')\r
- self.assertIs(type(ex1), type(ex2))\r
- self.assertEqual(str(ex1), str(ex2))\r
-\r
- def makeCallable(self, signature):\r
- """Create a function that returns its locals(), excluding the\r
- autogenerated '.1', '.2', etc. tuple param names (if any)."""\r
- with check_py3k_warnings(\r
- ("tuple parameter unpacking has been removed", SyntaxWarning),\r
- quiet=True):\r
- code = ("lambda %s: dict(i for i in locals().items() "\r
- "if not is_tuplename(i[0]))")\r
- return eval(code % signature, {'is_tuplename' : self.is_tuplename})\r
-\r
- def test_plain(self):\r
- f = self.makeCallable('a, b=1')\r
- self.assertEqualCallArgs(f, '2')\r
- self.assertEqualCallArgs(f, '2, 3')\r
- self.assertEqualCallArgs(f, 'a=2')\r
- self.assertEqualCallArgs(f, 'b=3, a=2')\r
- self.assertEqualCallArgs(f, '2, b=3')\r
- # expand *iterable / **mapping\r
- self.assertEqualCallArgs(f, '*(2,)')\r
- self.assertEqualCallArgs(f, '*[2]')\r
- self.assertEqualCallArgs(f, '*(2, 3)')\r
- self.assertEqualCallArgs(f, '*[2, 3]')\r
- self.assertEqualCallArgs(f, '**{"a":2}')\r
- self.assertEqualCallArgs(f, 'b=3, **{"a":2}')\r
- self.assertEqualCallArgs(f, '2, **{"b":3}')\r
- self.assertEqualCallArgs(f, '**{"b":3, "a":2}')\r
- # expand UserList / UserDict\r
- self.assertEqualCallArgs(f, '*UserList([2])')\r
- self.assertEqualCallArgs(f, '*UserList([2, 3])')\r
- self.assertEqualCallArgs(f, '**UserDict(a=2)')\r
- self.assertEqualCallArgs(f, '2, **UserDict(b=3)')\r
- self.assertEqualCallArgs(f, 'b=2, **UserDict(a=3)')\r
- # unicode keyword args\r
- self.assertEqualCallArgs(f, '**{u"a":2}')\r
- self.assertEqualCallArgs(f, 'b=3, **{u"a":2}')\r
- self.assertEqualCallArgs(f, '2, **{u"b":3}')\r
- self.assertEqualCallArgs(f, '**{u"b":3, u"a":2}')\r
-\r
- def test_varargs(self):\r
- f = self.makeCallable('a, b=1, *c')\r
- self.assertEqualCallArgs(f, '2')\r
- self.assertEqualCallArgs(f, '2, 3')\r
- self.assertEqualCallArgs(f, '2, 3, 4')\r
- self.assertEqualCallArgs(f, '*(2,3,4)')\r
- self.assertEqualCallArgs(f, '2, *[3,4]')\r
- self.assertEqualCallArgs(f, '2, 3, *UserList([4])')\r
-\r
- def test_varkw(self):\r
- f = self.makeCallable('a, b=1, **c')\r
- self.assertEqualCallArgs(f, 'a=2')\r
- self.assertEqualCallArgs(f, '2, b=3, c=4')\r
- self.assertEqualCallArgs(f, 'b=3, a=2, c=4')\r
- self.assertEqualCallArgs(f, 'c=4, **{"a":2, "b":3}')\r
- self.assertEqualCallArgs(f, '2, c=4, **{"b":3}')\r
- self.assertEqualCallArgs(f, 'b=2, **{"a":3, "c":4}')\r
- self.assertEqualCallArgs(f, '**UserDict(a=2, b=3, c=4)')\r
- self.assertEqualCallArgs(f, '2, c=4, **UserDict(b=3)')\r
- self.assertEqualCallArgs(f, 'b=2, **UserDict(a=3, c=4)')\r
- # unicode keyword args\r
- self.assertEqualCallArgs(f, 'c=4, **{u"a":2, u"b":3}')\r
- self.assertEqualCallArgs(f, '2, c=4, **{u"b":3}')\r
- self.assertEqualCallArgs(f, 'b=2, **{u"a":3, u"c":4}')\r
-\r
- def test_varkw_only(self):\r
- # issue11256:\r
- f = self.makeCallable('**c')\r
- self.assertEqualCallArgs(f, '')\r
- self.assertEqualCallArgs(f, 'a=1')\r
- self.assertEqualCallArgs(f, 'a=1, b=2')\r
- self.assertEqualCallArgs(f, 'c=3, **{"a": 1, "b": 2}')\r
- self.assertEqualCallArgs(f, '**UserDict(a=1, b=2)')\r
- self.assertEqualCallArgs(f, 'c=3, **UserDict(a=1, b=2)')\r
-\r
- def test_tupleargs(self):\r
- f = self.makeCallable('(b,c), (d,(e,f))=(0,[1,2])')\r
- self.assertEqualCallArgs(f, '(2,3)')\r
- self.assertEqualCallArgs(f, '[2,3]')\r
- self.assertEqualCallArgs(f, 'UserList([2,3])')\r
- self.assertEqualCallArgs(f, '(2,3), (4,(5,6))')\r
- self.assertEqualCallArgs(f, '(2,3), (4,[5,6])')\r
- self.assertEqualCallArgs(f, '(2,3), [4,UserList([5,6])]')\r
-\r
- def test_multiple_features(self):\r
- f = self.makeCallable('a, b=2, (c,(d,e))=(3,[4,5]), *f, **g')\r
- self.assertEqualCallArgs(f, '2, 3, (4,[5,6]), 7')\r
- self.assertEqualCallArgs(f, '2, 3, *[(4,[5,6]), 7], x=8')\r
- self.assertEqualCallArgs(f, '2, 3, x=8, *[(4,[5,6]), 7]')\r
- self.assertEqualCallArgs(f, '2, x=8, *[3, (4,[5,6]), 7], y=9')\r
- self.assertEqualCallArgs(f, 'x=8, *[2, 3, (4,[5,6])], y=9')\r
- self.assertEqualCallArgs(f, 'x=8, *UserList([2, 3, (4,[5,6])]), '\r
- '**{"y":9, "z":10}')\r
- self.assertEqualCallArgs(f, '2, x=8, *UserList([3, (4,[5,6])]), '\r
- '**UserDict(y=9, z=10)')\r
-\r
- def test_errors(self):\r
- f0 = self.makeCallable('')\r
- f1 = self.makeCallable('a, b')\r
- f2 = self.makeCallable('a, b=1')\r
- # f0 takes no arguments\r
- self.assertEqualException(f0, '1')\r
- self.assertEqualException(f0, 'x=1')\r
- self.assertEqualException(f0, '1,x=1')\r
- # f1 takes exactly 2 arguments\r
- self.assertEqualException(f1, '')\r
- self.assertEqualException(f1, '1')\r
- self.assertEqualException(f1, 'a=2')\r
- self.assertEqualException(f1, 'b=3')\r
- # f2 takes at least 1 argument\r
- self.assertEqualException(f2, '')\r
- self.assertEqualException(f2, 'b=3')\r
- for f in f1, f2:\r
- # f1/f2 takes exactly/at most 2 arguments\r
- self.assertEqualException(f, '2, 3, 4')\r
- self.assertEqualException(f, '1, 2, 3, a=1')\r
- self.assertEqualException(f, '2, 3, 4, c=5')\r
- self.assertEqualException(f, '2, 3, 4, a=1, c=5')\r
- # f got an unexpected keyword argument\r
- self.assertEqualException(f, 'c=2')\r
- self.assertEqualException(f, '2, c=3')\r
- self.assertEqualException(f, '2, 3, c=4')\r
- self.assertEqualException(f, '2, c=4, b=3')\r
- self.assertEqualException(f, '**{u"\u03c0\u03b9": 4}')\r
- # f got multiple values for keyword argument\r
- self.assertEqualException(f, '1, a=2')\r
- self.assertEqualException(f, '1, **{"a":2}')\r
- self.assertEqualException(f, '1, 2, b=3')\r
- # XXX: Python inconsistency\r
- # - for functions and bound methods: unexpected keyword 'c'\r
- # - for unbound methods: multiple values for keyword 'a'\r
- #self.assertEqualException(f, '1, c=3, a=2')\r
- f = self.makeCallable('(a,b)=(0,1)')\r
- self.assertEqualException(f, '1')\r
- self.assertEqualException(f, '[1]')\r
- self.assertEqualException(f, '(1,2,3)')\r
- # issue11256:\r
- f3 = self.makeCallable('**c')\r
- self.assertEqualException(f3, '1, 2')\r
- self.assertEqualException(f3, '1, 2, a=1, b=2')\r
-\r
-class TestGetcallargsMethods(TestGetcallargsFunctions):\r
-\r
- def setUp(self):\r
- class Foo(object):\r
- pass\r
- self.cls = Foo\r
- self.inst = Foo()\r
-\r
- def makeCallable(self, signature):\r
- assert 'self' not in signature\r
- mk = super(TestGetcallargsMethods, self).makeCallable\r
- self.cls.method = mk('self, ' + signature)\r
- return self.inst.method\r
-\r
-class TestGetcallargsUnboundMethods(TestGetcallargsMethods):\r
-\r
- def makeCallable(self, signature):\r
- super(TestGetcallargsUnboundMethods, self).makeCallable(signature)\r
- return self.cls.method\r
-\r
- def assertEqualCallArgs(self, func, call_params_string, locs=None):\r
- return super(TestGetcallargsUnboundMethods, self).assertEqualCallArgs(\r
- *self._getAssertEqualParams(func, call_params_string, locs))\r
-\r
- def assertEqualException(self, func, call_params_string, locs=None):\r
- return super(TestGetcallargsUnboundMethods, self).assertEqualException(\r
- *self._getAssertEqualParams(func, call_params_string, locs))\r
-\r
- def _getAssertEqualParams(self, func, call_params_string, locs=None):\r
- assert 'inst' not in call_params_string\r
- locs = dict(locs or {}, inst=self.inst)\r
- return (func, 'inst,' + call_params_string, locs)\r
-\r
-def test_main():\r
- run_unittest(\r
- TestDecorators, TestRetrievingSourceCode, TestOneliners, TestBuggyCases,\r
- TestInterpreterStack, TestClassesAndFunctions, TestPredicates,\r
- TestGetcallargsFunctions, TestGetcallargsMethods,\r
- TestGetcallargsUnboundMethods)\r
-\r
-if __name__ == "__main__":\r
- test_main()\r
projects / mirror_edk2.git / blobdiff