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