Victor Stinner | 3b5cf85 | 2017-06-09 16:48:45 +0200 | [diff] [blame] | 1 | import datetime |
Jeremy Hylton | bea3947 | 2001-05-29 16:26:20 +0000 | [diff] [blame] | 2 | import unittest |
Serhiy Storchaka | 5eb788b | 2017-06-06 18:45:22 +0300 | [diff] [blame] | 3 | from test.support import cpython_only |
Victor Stinner | 3b5cf85 | 2017-06-09 16:48:45 +0200 | [diff] [blame] | 4 | try: |
| 5 | import _testcapi |
| 6 | except ImportError: |
| 7 | _testcapi = None |
Sylvain | 96c7c06 | 2017-06-15 17:05:23 +0200 | [diff] [blame] | 8 | import struct |
| 9 | import collections |
Oren Milman | bf9075a | 2017-08-23 21:16:48 +0300 | [diff] [blame] | 10 | import itertools |
Jeremy Hylton | bea3947 | 2001-05-29 16:26:20 +0000 | [diff] [blame] | 11 | |
| 12 | # The test cases here cover several paths through the function calling |
| 13 | # code. They depend on the METH_XXX flag that is used to define a C |
| 14 | # function, which can't be verified from Python. If the METH_XXX decl |
| 15 | # for a C function changes, these tests may not cover the right paths. |
| 16 | |
| 17 | class CFunctionCalls(unittest.TestCase): |
| 18 | |
| 19 | def test_varargs0(self): |
Guido van Rossum | e2b70bc | 2006-08-18 22:13:04 +0000 | [diff] [blame] | 20 | self.assertRaises(TypeError, {}.__contains__) |
Jeremy Hylton | bea3947 | 2001-05-29 16:26:20 +0000 | [diff] [blame] | 21 | |
| 22 | def test_varargs1(self): |
Guido van Rossum | e2b70bc | 2006-08-18 22:13:04 +0000 | [diff] [blame] | 23 | {}.__contains__(0) |
Jeremy Hylton | bea3947 | 2001-05-29 16:26:20 +0000 | [diff] [blame] | 24 | |
| 25 | def test_varargs2(self): |
Guido van Rossum | e2b70bc | 2006-08-18 22:13:04 +0000 | [diff] [blame] | 26 | self.assertRaises(TypeError, {}.__contains__, 0, 1) |
Jeremy Hylton | bea3947 | 2001-05-29 16:26:20 +0000 | [diff] [blame] | 27 | |
| 28 | def test_varargs0_ext(self): |
| 29 | try: |
Guido van Rossum | e2b70bc | 2006-08-18 22:13:04 +0000 | [diff] [blame] | 30 | {}.__contains__(*()) |
Jeremy Hylton | bea3947 | 2001-05-29 16:26:20 +0000 | [diff] [blame] | 31 | except TypeError: |
| 32 | pass |
| 33 | |
| 34 | def test_varargs1_ext(self): |
Guido van Rossum | e2b70bc | 2006-08-18 22:13:04 +0000 | [diff] [blame] | 35 | {}.__contains__(*(0,)) |
Jeremy Hylton | bea3947 | 2001-05-29 16:26:20 +0000 | [diff] [blame] | 36 | |
| 37 | def test_varargs2_ext(self): |
| 38 | try: |
Guido van Rossum | e2b70bc | 2006-08-18 22:13:04 +0000 | [diff] [blame] | 39 | {}.__contains__(*(1, 2)) |
Jeremy Hylton | bea3947 | 2001-05-29 16:26:20 +0000 | [diff] [blame] | 40 | except TypeError: |
| 41 | pass |
| 42 | else: |
| 43 | raise RuntimeError |
| 44 | |
Jeremy Hylton | bea3947 | 2001-05-29 16:26:20 +0000 | [diff] [blame] | 45 | def test_varargs1_kw(self): |
Guido van Rossum | e2b70bc | 2006-08-18 22:13:04 +0000 | [diff] [blame] | 46 | self.assertRaises(TypeError, {}.__contains__, x=2) |
Jeremy Hylton | bea3947 | 2001-05-29 16:26:20 +0000 | [diff] [blame] | 47 | |
| 48 | def test_varargs2_kw(self): |
Guido van Rossum | e2b70bc | 2006-08-18 22:13:04 +0000 | [diff] [blame] | 49 | self.assertRaises(TypeError, {}.__contains__, x=2, y=2) |
Jeremy Hylton | bea3947 | 2001-05-29 16:26:20 +0000 | [diff] [blame] | 50 | |
| 51 | def test_oldargs0_0(self): |
| 52 | {}.keys() |
| 53 | |
| 54 | def test_oldargs0_1(self): |
| 55 | self.assertRaises(TypeError, {}.keys, 0) |
| 56 | |
| 57 | def test_oldargs0_2(self): |
| 58 | self.assertRaises(TypeError, {}.keys, 0, 1) |
| 59 | |
| 60 | def test_oldargs0_0_ext(self): |
| 61 | {}.keys(*()) |
| 62 | |
| 63 | def test_oldargs0_1_ext(self): |
| 64 | try: |
| 65 | {}.keys(*(0,)) |
| 66 | except TypeError: |
| 67 | pass |
| 68 | else: |
| 69 | raise RuntimeError |
| 70 | |
| 71 | def test_oldargs0_2_ext(self): |
| 72 | try: |
| 73 | {}.keys(*(1, 2)) |
| 74 | except TypeError: |
| 75 | pass |
| 76 | else: |
| 77 | raise RuntimeError |
| 78 | |
| 79 | def test_oldargs0_0_kw(self): |
| 80 | try: |
| 81 | {}.keys(x=2) |
| 82 | except TypeError: |
| 83 | pass |
| 84 | else: |
| 85 | raise RuntimeError |
| 86 | |
| 87 | def test_oldargs0_1_kw(self): |
| 88 | self.assertRaises(TypeError, {}.keys, x=2) |
| 89 | |
| 90 | def test_oldargs0_2_kw(self): |
| 91 | self.assertRaises(TypeError, {}.keys, x=2, y=2) |
| 92 | |
| 93 | def test_oldargs1_0(self): |
Raymond Hettinger | 31017ae | 2004-03-04 08:25:44 +0000 | [diff] [blame] | 94 | self.assertRaises(TypeError, [].count) |
Jeremy Hylton | bea3947 | 2001-05-29 16:26:20 +0000 | [diff] [blame] | 95 | |
| 96 | def test_oldargs1_1(self): |
Raymond Hettinger | 31017ae | 2004-03-04 08:25:44 +0000 | [diff] [blame] | 97 | [].count(1) |
Jeremy Hylton | bea3947 | 2001-05-29 16:26:20 +0000 | [diff] [blame] | 98 | |
| 99 | def test_oldargs1_2(self): |
Raymond Hettinger | 31017ae | 2004-03-04 08:25:44 +0000 | [diff] [blame] | 100 | self.assertRaises(TypeError, [].count, 1, 2) |
Jeremy Hylton | bea3947 | 2001-05-29 16:26:20 +0000 | [diff] [blame] | 101 | |
| 102 | def test_oldargs1_0_ext(self): |
| 103 | try: |
Raymond Hettinger | 31017ae | 2004-03-04 08:25:44 +0000 | [diff] [blame] | 104 | [].count(*()) |
Jeremy Hylton | bea3947 | 2001-05-29 16:26:20 +0000 | [diff] [blame] | 105 | except TypeError: |
| 106 | pass |
| 107 | else: |
| 108 | raise RuntimeError |
| 109 | |
| 110 | def test_oldargs1_1_ext(self): |
Raymond Hettinger | 31017ae | 2004-03-04 08:25:44 +0000 | [diff] [blame] | 111 | [].count(*(1,)) |
Jeremy Hylton | bea3947 | 2001-05-29 16:26:20 +0000 | [diff] [blame] | 112 | |
| 113 | def test_oldargs1_2_ext(self): |
| 114 | try: |
Raymond Hettinger | 31017ae | 2004-03-04 08:25:44 +0000 | [diff] [blame] | 115 | [].count(*(1, 2)) |
Jeremy Hylton | bea3947 | 2001-05-29 16:26:20 +0000 | [diff] [blame] | 116 | except TypeError: |
| 117 | pass |
| 118 | else: |
| 119 | raise RuntimeError |
| 120 | |
| 121 | def test_oldargs1_0_kw(self): |
Raymond Hettinger | 31017ae | 2004-03-04 08:25:44 +0000 | [diff] [blame] | 122 | self.assertRaises(TypeError, [].count, x=2) |
Jeremy Hylton | bea3947 | 2001-05-29 16:26:20 +0000 | [diff] [blame] | 123 | |
| 124 | def test_oldargs1_1_kw(self): |
Raymond Hettinger | 31017ae | 2004-03-04 08:25:44 +0000 | [diff] [blame] | 125 | self.assertRaises(TypeError, [].count, {}, x=2) |
Jeremy Hylton | bea3947 | 2001-05-29 16:26:20 +0000 | [diff] [blame] | 126 | |
| 127 | def test_oldargs1_2_kw(self): |
Raymond Hettinger | 31017ae | 2004-03-04 08:25:44 +0000 | [diff] [blame] | 128 | self.assertRaises(TypeError, [].count, x=2, y=2) |
Jeremy Hylton | bea3947 | 2001-05-29 16:26:20 +0000 | [diff] [blame] | 129 | |
Fred Drake | 2e2be37 | 2001-09-20 21:33:42 +0000 | [diff] [blame] | 130 | |
Serhiy Storchaka | 5eb788b | 2017-06-06 18:45:22 +0300 | [diff] [blame] | 131 | @cpython_only |
| 132 | class CFunctionCallsErrorMessages(unittest.TestCase): |
| 133 | |
| 134 | def test_varargs0(self): |
| 135 | msg = r"__contains__\(\) takes exactly one argument \(0 given\)" |
| 136 | self.assertRaisesRegex(TypeError, msg, {}.__contains__) |
| 137 | |
| 138 | def test_varargs2(self): |
| 139 | msg = r"__contains__\(\) takes exactly one argument \(2 given\)" |
| 140 | self.assertRaisesRegex(TypeError, msg, {}.__contains__, 0, 1) |
| 141 | |
Serhiy Storchaka | f9f1cca | 2017-06-09 19:27:06 +0300 | [diff] [blame] | 142 | def test_varargs3(self): |
| 143 | msg = r"^from_bytes\(\) takes at most 2 positional arguments \(3 given\)" |
| 144 | self.assertRaisesRegex(TypeError, msg, int.from_bytes, b'a', 'little', False) |
| 145 | |
Serhiy Storchaka | 5eb788b | 2017-06-06 18:45:22 +0300 | [diff] [blame] | 146 | def test_varargs1_kw(self): |
| 147 | msg = r"__contains__\(\) takes no keyword arguments" |
| 148 | self.assertRaisesRegex(TypeError, msg, {}.__contains__, x=2) |
| 149 | |
| 150 | def test_varargs2_kw(self): |
| 151 | msg = r"__contains__\(\) takes no keyword arguments" |
| 152 | self.assertRaisesRegex(TypeError, msg, {}.__contains__, x=2, y=2) |
| 153 | |
Sylvain | 7445381 | 2017-06-10 06:51:48 +0200 | [diff] [blame] | 154 | def test_varargs3_kw(self): |
| 155 | msg = r"bool\(\) takes no keyword arguments" |
| 156 | self.assertRaisesRegex(TypeError, msg, bool, x=2) |
| 157 | |
| 158 | def test_varargs4_kw(self): |
| 159 | msg = r"^index\(\) takes no keyword arguments$" |
| 160 | self.assertRaisesRegex(TypeError, msg, [].index, x=2) |
| 161 | |
| 162 | def test_varargs5_kw(self): |
| 163 | msg = r"^hasattr\(\) takes no keyword arguments$" |
| 164 | self.assertRaisesRegex(TypeError, msg, hasattr, x=2) |
| 165 | |
Sylvain | 96c7c06 | 2017-06-15 17:05:23 +0200 | [diff] [blame] | 166 | def test_varargs6_kw(self): |
| 167 | msg = r"^getattr\(\) takes no keyword arguments$" |
| 168 | self.assertRaisesRegex(TypeError, msg, getattr, x=2) |
| 169 | |
| 170 | def test_varargs7_kw(self): |
| 171 | msg = r"^next\(\) takes no keyword arguments$" |
| 172 | self.assertRaisesRegex(TypeError, msg, next, x=2) |
| 173 | |
| 174 | def test_varargs8_kw(self): |
| 175 | msg = r"^pack\(\) takes no keyword arguments$" |
| 176 | self.assertRaisesRegex(TypeError, msg, struct.pack, x=2) |
| 177 | |
| 178 | def test_varargs9_kw(self): |
| 179 | msg = r"^pack_into\(\) takes no keyword arguments$" |
| 180 | self.assertRaisesRegex(TypeError, msg, struct.pack_into, x=2) |
| 181 | |
| 182 | def test_varargs10_kw(self): |
| 183 | msg = r"^index\(\) takes no keyword arguments$" |
| 184 | self.assertRaisesRegex(TypeError, msg, collections.deque().index, x=2) |
| 185 | |
| 186 | def test_varargs11_kw(self): |
| 187 | msg = r"^pack\(\) takes no keyword arguments$" |
| 188 | self.assertRaisesRegex(TypeError, msg, struct.Struct.pack, struct.Struct(""), x=2) |
| 189 | |
Sylvain | 9648088 | 2017-07-09 05:45:06 +0200 | [diff] [blame] | 190 | def test_varargs12_kw(self): |
| 191 | msg = r"^staticmethod\(\) takes no keyword arguments$" |
| 192 | self.assertRaisesRegex(TypeError, msg, staticmethod, func=id) |
| 193 | |
| 194 | def test_varargs13_kw(self): |
| 195 | msg = r"^classmethod\(\) takes no keyword arguments$" |
| 196 | self.assertRaisesRegex(TypeError, msg, classmethod, func=id) |
| 197 | |
Oren Milman | bf9075a | 2017-08-23 21:16:48 +0300 | [diff] [blame] | 198 | def test_varargs14_kw(self): |
| 199 | msg = r"^product\(\) takes at most 1 keyword argument \(2 given\)$" |
| 200 | self.assertRaisesRegex(TypeError, msg, |
| 201 | itertools.product, 0, repeat=1, foo=2) |
| 202 | |
| 203 | def test_varargs15_kw(self): |
| 204 | msg = r"^ImportError\(\) takes at most 2 keyword arguments \(3 given\)$" |
| 205 | self.assertRaisesRegex(TypeError, msg, |
| 206 | ImportError, 0, name=1, path=2, foo=3) |
| 207 | |
| 208 | def test_varargs16_kw(self): |
| 209 | msg = r"^min\(\) takes at most 2 keyword arguments \(3 given\)$" |
| 210 | self.assertRaisesRegex(TypeError, msg, |
| 211 | min, 0, default=1, key=2, foo=3) |
| 212 | |
| 213 | def test_varargs17_kw(self): |
| 214 | msg = r"^print\(\) takes at most 4 keyword arguments \(5 given\)$" |
| 215 | self.assertRaisesRegex(TypeError, msg, |
| 216 | print, 0, sep=1, end=2, file=3, flush=4, foo=5) |
| 217 | |
Serhiy Storchaka | 5eb788b | 2017-06-06 18:45:22 +0300 | [diff] [blame] | 218 | def test_oldargs0_1(self): |
| 219 | msg = r"keys\(\) takes no arguments \(1 given\)" |
| 220 | self.assertRaisesRegex(TypeError, msg, {}.keys, 0) |
| 221 | |
| 222 | def test_oldargs0_2(self): |
| 223 | msg = r"keys\(\) takes no arguments \(2 given\)" |
| 224 | self.assertRaisesRegex(TypeError, msg, {}.keys, 0, 1) |
| 225 | |
| 226 | def test_oldargs0_1_kw(self): |
| 227 | msg = r"keys\(\) takes no keyword arguments" |
| 228 | self.assertRaisesRegex(TypeError, msg, {}.keys, x=2) |
| 229 | |
| 230 | def test_oldargs0_2_kw(self): |
| 231 | msg = r"keys\(\) takes no keyword arguments" |
| 232 | self.assertRaisesRegex(TypeError, msg, {}.keys, x=2, y=2) |
| 233 | |
| 234 | def test_oldargs1_0(self): |
| 235 | msg = r"count\(\) takes exactly one argument \(0 given\)" |
| 236 | self.assertRaisesRegex(TypeError, msg, [].count) |
| 237 | |
| 238 | def test_oldargs1_2(self): |
| 239 | msg = r"count\(\) takes exactly one argument \(2 given\)" |
| 240 | self.assertRaisesRegex(TypeError, msg, [].count, 1, 2) |
| 241 | |
| 242 | def test_oldargs1_0_kw(self): |
| 243 | msg = r"count\(\) takes no keyword arguments" |
| 244 | self.assertRaisesRegex(TypeError, msg, [].count, x=2) |
| 245 | |
| 246 | def test_oldargs1_1_kw(self): |
| 247 | msg = r"count\(\) takes no keyword arguments" |
| 248 | self.assertRaisesRegex(TypeError, msg, [].count, {}, x=2) |
| 249 | |
| 250 | def test_oldargs1_2_kw(self): |
| 251 | msg = r"count\(\) takes no keyword arguments" |
| 252 | self.assertRaisesRegex(TypeError, msg, [].count, x=2, y=2) |
| 253 | |
| 254 | |
Victor Stinner | 3b5cf85 | 2017-06-09 16:48:45 +0200 | [diff] [blame] | 255 | def pyfunc(arg1, arg2): |
| 256 | return [arg1, arg2] |
| 257 | |
| 258 | |
| 259 | def pyfunc_noarg(): |
| 260 | return "noarg" |
| 261 | |
| 262 | |
| 263 | class PythonClass: |
| 264 | def method(self, arg1, arg2): |
| 265 | return [arg1, arg2] |
| 266 | |
| 267 | def method_noarg(self): |
| 268 | return "noarg" |
| 269 | |
| 270 | @classmethod |
| 271 | def class_method(cls): |
| 272 | return "classmethod" |
| 273 | |
| 274 | @staticmethod |
| 275 | def static_method(): |
| 276 | return "staticmethod" |
| 277 | |
| 278 | |
| 279 | PYTHON_INSTANCE = PythonClass() |
| 280 | |
| 281 | |
| 282 | IGNORE_RESULT = object() |
| 283 | |
| 284 | |
| 285 | @cpython_only |
| 286 | class FastCallTests(unittest.TestCase): |
| 287 | # Test calls with positional arguments |
| 288 | CALLS_POSARGS = ( |
| 289 | # (func, args: tuple, result) |
| 290 | |
| 291 | # Python function with 2 arguments |
| 292 | (pyfunc, (1, 2), [1, 2]), |
| 293 | |
| 294 | # Python function without argument |
| 295 | (pyfunc_noarg, (), "noarg"), |
| 296 | |
| 297 | # Python class methods |
| 298 | (PythonClass.class_method, (), "classmethod"), |
| 299 | (PythonClass.static_method, (), "staticmethod"), |
| 300 | |
| 301 | # Python instance methods |
| 302 | (PYTHON_INSTANCE.method, (1, 2), [1, 2]), |
| 303 | (PYTHON_INSTANCE.method_noarg, (), "noarg"), |
| 304 | (PYTHON_INSTANCE.class_method, (), "classmethod"), |
| 305 | (PYTHON_INSTANCE.static_method, (), "staticmethod"), |
| 306 | |
| 307 | # C function: METH_NOARGS |
| 308 | (globals, (), IGNORE_RESULT), |
| 309 | |
| 310 | # C function: METH_O |
| 311 | (id, ("hello",), IGNORE_RESULT), |
| 312 | |
| 313 | # C function: METH_VARARGS |
| 314 | (dir, (1,), IGNORE_RESULT), |
| 315 | |
| 316 | # C function: METH_VARARGS | METH_KEYWORDS |
| 317 | (min, (5, 9), 5), |
| 318 | |
| 319 | # C function: METH_FASTCALL |
| 320 | (divmod, (1000, 33), (30, 10)), |
| 321 | |
| 322 | # C type static method: METH_FASTCALL | METH_CLASS |
| 323 | (int.from_bytes, (b'\x01\x00', 'little'), 1), |
| 324 | |
| 325 | # bpo-30524: Test that calling a C type static method with no argument |
| 326 | # doesn't crash (ignore the result): METH_FASTCALL | METH_CLASS |
| 327 | (datetime.datetime.now, (), IGNORE_RESULT), |
| 328 | ) |
| 329 | |
| 330 | # Test calls with positional and keyword arguments |
| 331 | CALLS_KWARGS = ( |
| 332 | # (func, args: tuple, kwargs: dict, result) |
| 333 | |
| 334 | # Python function with 2 arguments |
| 335 | (pyfunc, (1,), {'arg2': 2}, [1, 2]), |
| 336 | (pyfunc, (), {'arg1': 1, 'arg2': 2}, [1, 2]), |
| 337 | |
| 338 | # Python instance methods |
| 339 | (PYTHON_INSTANCE.method, (1,), {'arg2': 2}, [1, 2]), |
| 340 | (PYTHON_INSTANCE.method, (), {'arg1': 1, 'arg2': 2}, [1, 2]), |
| 341 | |
| 342 | # C function: METH_VARARGS | METH_KEYWORDS |
| 343 | (max, ([],), {'default': 9}, 9), |
| 344 | |
| 345 | # C type static method: METH_FASTCALL | METH_CLASS |
| 346 | (int.from_bytes, (b'\x01\x00',), {'byteorder': 'little'}, 1), |
| 347 | (int.from_bytes, (), {'bytes': b'\x01\x00', 'byteorder': 'little'}, 1), |
| 348 | ) |
| 349 | |
| 350 | def check_result(self, result, expected): |
| 351 | if expected is IGNORE_RESULT: |
| 352 | return |
| 353 | self.assertEqual(result, expected) |
| 354 | |
| 355 | def test_fastcall(self): |
| 356 | # Test _PyObject_FastCall() |
| 357 | |
| 358 | for func, args, expected in self.CALLS_POSARGS: |
| 359 | with self.subTest(func=func, args=args): |
| 360 | result = _testcapi.pyobject_fastcall(func, args) |
| 361 | self.check_result(result, expected) |
| 362 | |
| 363 | if not args: |
| 364 | # args=NULL, nargs=0 |
| 365 | result = _testcapi.pyobject_fastcall(func, None) |
| 366 | self.check_result(result, expected) |
| 367 | |
| 368 | def test_fastcall_dict(self): |
| 369 | # Test _PyObject_FastCallDict() |
| 370 | |
| 371 | for func, args, expected in self.CALLS_POSARGS: |
| 372 | with self.subTest(func=func, args=args): |
| 373 | # kwargs=NULL |
| 374 | result = _testcapi.pyobject_fastcalldict(func, args, None) |
| 375 | self.check_result(result, expected) |
| 376 | |
| 377 | # kwargs={} |
| 378 | result = _testcapi.pyobject_fastcalldict(func, args, {}) |
| 379 | self.check_result(result, expected) |
| 380 | |
| 381 | if not args: |
| 382 | # args=NULL, nargs=0, kwargs=NULL |
| 383 | result = _testcapi.pyobject_fastcalldict(func, None, None) |
| 384 | self.check_result(result, expected) |
| 385 | |
| 386 | # args=NULL, nargs=0, kwargs={} |
| 387 | result = _testcapi.pyobject_fastcalldict(func, None, {}) |
| 388 | self.check_result(result, expected) |
| 389 | |
| 390 | for func, args, kwargs, expected in self.CALLS_KWARGS: |
| 391 | with self.subTest(func=func, args=args, kwargs=kwargs): |
| 392 | result = _testcapi.pyobject_fastcalldict(func, args, kwargs) |
| 393 | self.check_result(result, expected) |
| 394 | |
| 395 | def test_fastcall_keywords(self): |
| 396 | # Test _PyObject_FastCallKeywords() |
| 397 | |
| 398 | for func, args, expected in self.CALLS_POSARGS: |
| 399 | with self.subTest(func=func, args=args): |
| 400 | # kwnames=NULL |
| 401 | result = _testcapi.pyobject_fastcallkeywords(func, args, None) |
| 402 | self.check_result(result, expected) |
| 403 | |
| 404 | # kwnames=() |
| 405 | result = _testcapi.pyobject_fastcallkeywords(func, args, ()) |
| 406 | self.check_result(result, expected) |
| 407 | |
| 408 | if not args: |
| 409 | # kwnames=NULL |
| 410 | result = _testcapi.pyobject_fastcallkeywords(func, None, None) |
| 411 | self.check_result(result, expected) |
| 412 | |
| 413 | # kwnames=() |
| 414 | result = _testcapi.pyobject_fastcallkeywords(func, None, ()) |
| 415 | self.check_result(result, expected) |
| 416 | |
| 417 | for func, args, kwargs, expected in self.CALLS_KWARGS: |
| 418 | with self.subTest(func=func, args=args, kwargs=kwargs): |
| 419 | kwnames = tuple(kwargs.keys()) |
| 420 | args = args + tuple(kwargs.values()) |
| 421 | result = _testcapi.pyobject_fastcallkeywords(func, args, kwnames) |
| 422 | self.check_result(result, expected) |
| 423 | |
| 424 | |
Fred Drake | 2e2be37 | 2001-09-20 21:33:42 +0000 | [diff] [blame] | 425 | if __name__ == "__main__": |
Zachary Ware | 38c707e | 2015-04-13 15:00:43 -0500 | [diff] [blame] | 426 | unittest.main() |