1 import unittest 2 import math 3 import string 4 import sys 5 from test import support 6 # Skip this test if the _testcapi module isn't available. 7 _testcapi = support.import_module('_testcapi') 8 from _testcapi import getargs_keywords, getargs_keyword_only 9 10 # > How about the following counterproposal. This also changes some of 11 # > the other format codes to be a little more regular. 12 # > 13 # > Code C type Range check 14 # > 15 # > b unsigned char 0..UCHAR_MAX 16 # > h signed short SHRT_MIN..SHRT_MAX 17 # > B unsigned char none ** 18 # > H unsigned short none ** 19 # > k * unsigned long none 20 # > I * unsigned int 0..UINT_MAX 21 # 22 # 23 # > i int INT_MIN..INT_MAX 24 # > l long LONG_MIN..LONG_MAX 25 # 26 # > K * unsigned long long none 27 # > L long long LLONG_MIN..LLONG_MAX 28 # 29 # > Notes: 30 # > 31 # > * New format codes. 32 # > 33 # > ** Changed from previous "range-and-a-half" to "none"; the 34 # > range-and-a-half checking wasn't particularly useful. 35 # 36 # Plus a C API or two, e.g. PyLong_AsUnsignedLongMask() -> 37 # unsigned long and PyLong_AsUnsignedLongLongMask() -> unsigned 38 # long long (if that exists). 39 40 LARGE = 0x7FFFFFFF 41 VERY_LARGE = 0xFF0000121212121212121242 42 43 from _testcapi import UCHAR_MAX, USHRT_MAX, UINT_MAX, ULONG_MAX, INT_MAX, \ 44 INT_MIN, LONG_MIN, LONG_MAX, PY_SSIZE_T_MIN, PY_SSIZE_T_MAX, \ 45 SHRT_MIN, SHRT_MAX, FLT_MIN, FLT_MAX, DBL_MIN, DBL_MAX 46 47 DBL_MAX_EXP = sys.float_info.max_exp 48 INF = float('inf') 49 NAN = float('nan') 50 51 # fake, they are not defined in Python's header files 52 LLONG_MAX = 2**63-1 53 LLONG_MIN = -2**63 54 ULLONG_MAX = 2**64-1 55 56 class Int: 57 def __int__(self): 58 return 99 59 60 class IntSubclass(int): 61 def __int__(self): 62 return 99 63 64 class BadInt: 65 def __int__(self): 66 return 1.0 67 68 class BadInt2: 69 def __int__(self): 70 return True 71 72 class BadInt3(int): 73 def __int__(self): 74 return True 75 76 77 class Float: 78 def __float__(self): 79 return 4.25 80 81 class FloatSubclass(float): 82 pass 83 84 class FloatSubclass2(float): 85 def __float__(self): 86 return 4.25 87 88 class BadFloat: 89 def __float__(self): 90 return 687 91 92 class BadFloat2: 93 def __float__(self): 94 return FloatSubclass(4.25) 95 96 class BadFloat3(float): 97 def __float__(self): 98 return FloatSubclass(4.25) 99 100 101 class Complex: 102 def __complex__(self): 103 return 4.25+0.5j 104 105 class ComplexSubclass(complex): 106 pass 107 108 class ComplexSubclass2(complex): 109 def __complex__(self): 110 return 4.25+0.5j 111 112 class BadComplex: 113 def __complex__(self): 114 return 1.25 115 116 class BadComplex2: 117 def __complex__(self): 118 return ComplexSubclass(4.25+0.5j) 119 120 class BadComplex3(complex): 121 def __complex__(self): 122 return ComplexSubclass(4.25+0.5j) 123 124 125 class TupleSubclass(tuple): 126 pass 127 128 class DictSubclass(dict): 129 pass 130 131 132 class Unsigned_TestCase(unittest.TestCase): 133 def test_b(self): 134 from _testcapi import getargs_b 135 # b returns 'unsigned char', and does range checking (0 ... UCHAR_MAX) 136 self.assertRaises(TypeError, getargs_b, 3.14) 137 self.assertEqual(99, getargs_b(Int())) 138 self.assertEqual(0, getargs_b(IntSubclass())) 139 self.assertRaises(TypeError, getargs_b, BadInt()) 140 with self.assertWarns(DeprecationWarning): 141 self.assertEqual(1, getargs_b(BadInt2())) 142 self.assertEqual(0, getargs_b(BadInt3())) 143 144 self.assertRaises(OverflowError, getargs_b, -1) 145 self.assertEqual(0, getargs_b(0)) 146 self.assertEqual(UCHAR_MAX, getargs_b(UCHAR_MAX)) 147 self.assertRaises(OverflowError, getargs_b, UCHAR_MAX + 1) 148 149 self.assertEqual(42, getargs_b(42)) 150 self.assertRaises(OverflowError, getargs_b, VERY_LARGE) 151 152 def test_B(self): 153 from _testcapi import getargs_B 154 # B returns 'unsigned char', no range checking 155 self.assertRaises(TypeError, getargs_B, 3.14) 156 self.assertEqual(99, getargs_B(Int())) 157 self.assertEqual(0, getargs_B(IntSubclass())) 158 self.assertRaises(TypeError, getargs_B, BadInt()) 159 with self.assertWarns(DeprecationWarning): 160 self.assertEqual(1, getargs_B(BadInt2())) 161 self.assertEqual(0, getargs_B(BadInt3())) 162 163 self.assertEqual(UCHAR_MAX, getargs_B(-1)) 164 self.assertEqual(0, getargs_B(0)) 165 self.assertEqual(UCHAR_MAX, getargs_B(UCHAR_MAX)) 166 self.assertEqual(0, getargs_B(UCHAR_MAX+1)) 167 168 self.assertEqual(42, getargs_B(42)) 169 self.assertEqual(UCHAR_MAX & VERY_LARGE, getargs_B(VERY_LARGE)) 170 171 def test_H(self): 172 from _testcapi import getargs_H 173 # H returns 'unsigned short', no range checking 174 self.assertRaises(TypeError, getargs_H, 3.14) 175 self.assertEqual(99, getargs_H(Int())) 176 self.assertEqual(0, getargs_H(IntSubclass())) 177 self.assertRaises(TypeError, getargs_H, BadInt()) 178 with self.assertWarns(DeprecationWarning): 179 self.assertEqual(1, getargs_H(BadInt2())) 180 self.assertEqual(0, getargs_H(BadInt3())) 181 182 self.assertEqual(USHRT_MAX, getargs_H(-1)) 183 self.assertEqual(0, getargs_H(0)) 184 self.assertEqual(USHRT_MAX, getargs_H(USHRT_MAX)) 185 self.assertEqual(0, getargs_H(USHRT_MAX+1)) 186 187 self.assertEqual(42, getargs_H(42)) 188 189 self.assertEqual(VERY_LARGE & USHRT_MAX, getargs_H(VERY_LARGE)) 190 191 def test_I(self): 192 from _testcapi import getargs_I 193 # I returns 'unsigned int', no range checking 194 self.assertRaises(TypeError, getargs_I, 3.14) 195 self.assertEqual(99, getargs_I(Int())) 196 self.assertEqual(0, getargs_I(IntSubclass())) 197 self.assertRaises(TypeError, getargs_I, BadInt()) 198 with self.assertWarns(DeprecationWarning): 199 self.assertEqual(1, getargs_I(BadInt2())) 200 self.assertEqual(0, getargs_I(BadInt3())) 201 202 self.assertEqual(UINT_MAX, getargs_I(-1)) 203 self.assertEqual(0, getargs_I(0)) 204 self.assertEqual(UINT_MAX, getargs_I(UINT_MAX)) 205 self.assertEqual(0, getargs_I(UINT_MAX+1)) 206 207 self.assertEqual(42, getargs_I(42)) 208 209 self.assertEqual(VERY_LARGE & UINT_MAX, getargs_I(VERY_LARGE)) 210 211 def test_k(self): 212 from _testcapi import getargs_k 213 # k returns 'unsigned long', no range checking 214 # it does not accept float, or instances with __int__ 215 self.assertRaises(TypeError, getargs_k, 3.14) 216 self.assertRaises(TypeError, getargs_k, Int()) 217 self.assertEqual(0, getargs_k(IntSubclass())) 218 self.assertRaises(TypeError, getargs_k, BadInt()) 219 self.assertRaises(TypeError, getargs_k, BadInt2()) 220 self.assertEqual(0, getargs_k(BadInt3())) 221 222 self.assertEqual(ULONG_MAX, getargs_k(-1)) 223 self.assertEqual(0, getargs_k(0)) 224 self.assertEqual(ULONG_MAX, getargs_k(ULONG_MAX)) 225 self.assertEqual(0, getargs_k(ULONG_MAX+1)) 226 227 self.assertEqual(42, getargs_k(42)) 228 229 self.assertEqual(VERY_LARGE & ULONG_MAX, getargs_k(VERY_LARGE)) 230 231 class Signed_TestCase(unittest.TestCase): 232 def test_h(self): 233 from _testcapi import getargs_h 234 # h returns 'short', and does range checking (SHRT_MIN ... SHRT_MAX) 235 self.assertRaises(TypeError, getargs_h, 3.14) 236 self.assertEqual(99, getargs_h(Int())) 237 self.assertEqual(0, getargs_h(IntSubclass())) 238 self.assertRaises(TypeError, getargs_h, BadInt()) 239 with self.assertWarns(DeprecationWarning): 240 self.assertEqual(1, getargs_h(BadInt2())) 241 self.assertEqual(0, getargs_h(BadInt3())) 242 243 self.assertRaises(OverflowError, getargs_h, SHRT_MIN-1) 244 self.assertEqual(SHRT_MIN, getargs_h(SHRT_MIN)) 245 self.assertEqual(SHRT_MAX, getargs_h(SHRT_MAX)) 246 self.assertRaises(OverflowError, getargs_h, SHRT_MAX+1) 247 248 self.assertEqual(42, getargs_h(42)) 249 self.assertRaises(OverflowError, getargs_h, VERY_LARGE) 250 251 def test_i(self): 252 from _testcapi import getargs_i 253 # i returns 'int', and does range checking (INT_MIN ... INT_MAX) 254 self.assertRaises(TypeError, getargs_i, 3.14) 255 self.assertEqual(99, getargs_i(Int())) 256 self.assertEqual(0, getargs_i(IntSubclass())) 257 self.assertRaises(TypeError, getargs_i, BadInt()) 258 with self.assertWarns(DeprecationWarning): 259 self.assertEqual(1, getargs_i(BadInt2())) 260 self.assertEqual(0, getargs_i(BadInt3())) 261 262 self.assertRaises(OverflowError, getargs_i, INT_MIN-1) 263 self.assertEqual(INT_MIN, getargs_i(INT_MIN)) 264 self.assertEqual(INT_MAX, getargs_i(INT_MAX)) 265 self.assertRaises(OverflowError, getargs_i, INT_MAX+1) 266 267 self.assertEqual(42, getargs_i(42)) 268 self.assertRaises(OverflowError, getargs_i, VERY_LARGE) 269 270 def test_l(self): 271 from _testcapi import getargs_l 272 # l returns 'long', and does range checking (LONG_MIN ... LONG_MAX) 273 self.assertRaises(TypeError, getargs_l, 3.14) 274 self.assertEqual(99, getargs_l(Int())) 275 self.assertEqual(0, getargs_l(IntSubclass())) 276 self.assertRaises(TypeError, getargs_l, BadInt()) 277 with self.assertWarns(DeprecationWarning): 278 self.assertEqual(1, getargs_l(BadInt2())) 279 self.assertEqual(0, getargs_l(BadInt3())) 280 281 self.assertRaises(OverflowError, getargs_l, LONG_MIN-1) 282 self.assertEqual(LONG_MIN, getargs_l(LONG_MIN)) 283 self.assertEqual(LONG_MAX, getargs_l(LONG_MAX)) 284 self.assertRaises(OverflowError, getargs_l, LONG_MAX+1) 285 286 self.assertEqual(42, getargs_l(42)) 287 self.assertRaises(OverflowError, getargs_l, VERY_LARGE) 288 289 def test_n(self): 290 from _testcapi import getargs_n 291 # n returns 'Py_ssize_t', and does range checking 292 # (PY_SSIZE_T_MIN ... PY_SSIZE_T_MAX) 293 self.assertRaises(TypeError, getargs_n, 3.14) 294 self.assertRaises(TypeError, getargs_n, Int()) 295 self.assertEqual(0, getargs_n(IntSubclass())) 296 self.assertRaises(TypeError, getargs_n, BadInt()) 297 self.assertRaises(TypeError, getargs_n, BadInt2()) 298 self.assertEqual(0, getargs_n(BadInt3())) 299 300 self.assertRaises(OverflowError, getargs_n, PY_SSIZE_T_MIN-1) 301 self.assertEqual(PY_SSIZE_T_MIN, getargs_n(PY_SSIZE_T_MIN)) 302 self.assertEqual(PY_SSIZE_T_MAX, getargs_n(PY_SSIZE_T_MAX)) 303 self.assertRaises(OverflowError, getargs_n, PY_SSIZE_T_MAX+1) 304 305 self.assertEqual(42, getargs_n(42)) 306 self.assertRaises(OverflowError, getargs_n, VERY_LARGE) 307 308 309 class LongLong_TestCase(unittest.TestCase): 310 def test_L(self): 311 from _testcapi import getargs_L 312 # L returns 'long long', and does range checking (LLONG_MIN 313 # ... LLONG_MAX) 314 self.assertRaises(TypeError, getargs_L, 3.14) 315 self.assertRaises(TypeError, getargs_L, "Hello") 316 self.assertEqual(99, getargs_L(Int())) 317 self.assertEqual(0, getargs_L(IntSubclass())) 318 self.assertRaises(TypeError, getargs_L, BadInt()) 319 with self.assertWarns(DeprecationWarning): 320 self.assertEqual(1, getargs_L(BadInt2())) 321 self.assertEqual(0, getargs_L(BadInt3())) 322 323 self.assertRaises(OverflowError, getargs_L, LLONG_MIN-1) 324 self.assertEqual(LLONG_MIN, getargs_L(LLONG_MIN)) 325 self.assertEqual(LLONG_MAX, getargs_L(LLONG_MAX)) 326 self.assertRaises(OverflowError, getargs_L, LLONG_MAX+1) 327 328 self.assertEqual(42, getargs_L(42)) 329 self.assertRaises(OverflowError, getargs_L, VERY_LARGE) 330 331 def test_K(self): 332 from _testcapi import getargs_K 333 # K return 'unsigned long long', no range checking 334 self.assertRaises(TypeError, getargs_K, 3.14) 335 self.assertRaises(TypeError, getargs_K, Int()) 336 self.assertEqual(0, getargs_K(IntSubclass())) 337 self.assertRaises(TypeError, getargs_K, BadInt()) 338 self.assertRaises(TypeError, getargs_K, BadInt2()) 339 self.assertEqual(0, getargs_K(BadInt3())) 340 341 self.assertEqual(ULLONG_MAX, getargs_K(ULLONG_MAX)) 342 self.assertEqual(0, getargs_K(0)) 343 self.assertEqual(0, getargs_K(ULLONG_MAX+1)) 344 345 self.assertEqual(42, getargs_K(42)) 346 347 self.assertEqual(VERY_LARGE & ULLONG_MAX, getargs_K(VERY_LARGE)) 348 349 350 class Float_TestCase(unittest.TestCase): 351 def assertEqualWithSign(self, actual, expected): 352 self.assertEqual(actual, expected) 353 self.assertEqual(math.copysign(1, actual), math.copysign(1, expected)) 354 355 def test_f(self): 356 from _testcapi import getargs_f 357 self.assertEqual(getargs_f(4.25), 4.25) 358 self.assertEqual(getargs_f(4), 4.0) 359 self.assertRaises(TypeError, getargs_f, 4.25+0j) 360 self.assertEqual(getargs_f(Float()), 4.25) 361 self.assertEqual(getargs_f(FloatSubclass(7.5)), 7.5) 362 self.assertEqual(getargs_f(FloatSubclass2(7.5)), 7.5) 363 self.assertRaises(TypeError, getargs_f, BadFloat()) 364 with self.assertWarns(DeprecationWarning): 365 self.assertEqual(getargs_f(BadFloat2()), 4.25) 366 self.assertEqual(getargs_f(BadFloat3(7.5)), 7.5) 367 368 for x in (FLT_MIN, -FLT_MIN, FLT_MAX, -FLT_MAX, INF, -INF): 369 self.assertEqual(getargs_f(x), x) 370 if FLT_MAX < DBL_MAX: 371 self.assertEqual(getargs_f(DBL_MAX), INF) 372 self.assertEqual(getargs_f(-DBL_MAX), -INF) 373 if FLT_MIN > DBL_MIN: 374 self.assertEqualWithSign(getargs_f(DBL_MIN), 0.0) 375 self.assertEqualWithSign(getargs_f(-DBL_MIN), -0.0) 376 self.assertEqualWithSign(getargs_f(0.0), 0.0) 377 self.assertEqualWithSign(getargs_f(-0.0), -0.0) 378 r = getargs_f(NAN) 379 self.assertNotEqual(r, r) 380 381 @support.requires_IEEE_754 382 def test_f_rounding(self): 383 from _testcapi import getargs_f 384 self.assertEqual(getargs_f(3.40282356e38), FLT_MAX) 385 self.assertEqual(getargs_f(-3.40282356e38), -FLT_MAX) 386 387 def test_d(self): 388 from _testcapi import getargs_d 389 self.assertEqual(getargs_d(4.25), 4.25) 390 self.assertEqual(getargs_d(4), 4.0) 391 self.assertRaises(TypeError, getargs_d, 4.25+0j) 392 self.assertEqual(getargs_d(Float()), 4.25) 393 self.assertEqual(getargs_d(FloatSubclass(7.5)), 7.5) 394 self.assertEqual(getargs_d(FloatSubclass2(7.5)), 7.5) 395 self.assertRaises(TypeError, getargs_d, BadFloat()) 396 with self.assertWarns(DeprecationWarning): 397 self.assertEqual(getargs_d(BadFloat2()), 4.25) 398 self.assertEqual(getargs_d(BadFloat3(7.5)), 7.5) 399 400 for x in (DBL_MIN, -DBL_MIN, DBL_MAX, -DBL_MAX, INF, -INF): 401 self.assertEqual(getargs_d(x), x) 402 self.assertRaises(OverflowError, getargs_d, 1<<DBL_MAX_EXP) 403 self.assertRaises(OverflowError, getargs_d, -1<<DBL_MAX_EXP) 404 self.assertEqualWithSign(getargs_d(0.0), 0.0) 405 self.assertEqualWithSign(getargs_d(-0.0), -0.0) 406 r = getargs_d(NAN) 407 self.assertNotEqual(r, r) 408 409 def test_D(self): 410 from _testcapi import getargs_D 411 self.assertEqual(getargs_D(4.25+0.5j), 4.25+0.5j) 412 self.assertEqual(getargs_D(4.25), 4.25+0j) 413 self.assertEqual(getargs_D(4), 4.0+0j) 414 self.assertEqual(getargs_D(Complex()), 4.25+0.5j) 415 self.assertEqual(getargs_D(ComplexSubclass(7.5+0.25j)), 7.5+0.25j) 416 self.assertEqual(getargs_D(ComplexSubclass2(7.5+0.25j)), 7.5+0.25j) 417 self.assertRaises(TypeError, getargs_D, BadComplex()) 418 with self.assertWarns(DeprecationWarning): 419 self.assertEqual(getargs_D(BadComplex2()), 4.25+0.5j) 420 self.assertEqual(getargs_D(BadComplex3(7.5+0.25j)), 7.5+0.25j) 421 422 for x in (DBL_MIN, -DBL_MIN, DBL_MAX, -DBL_MAX, INF, -INF): 423 c = complex(x, 1.0) 424 self.assertEqual(getargs_D(c), c) 425 c = complex(1.0, x) 426 self.assertEqual(getargs_D(c), c) 427 self.assertEqualWithSign(getargs_D(complex(0.0, 1.0)).real, 0.0) 428 self.assertEqualWithSign(getargs_D(complex(-0.0, 1.0)).real, -0.0) 429 self.assertEqualWithSign(getargs_D(complex(1.0, 0.0)).imag, 0.0) 430 self.assertEqualWithSign(getargs_D(complex(1.0, -0.0)).imag, -0.0) 431 432 433 class Paradox: 434 "This statement is false." 435 def __bool__(self): 436 raise NotImplementedError 437 438 class Boolean_TestCase(unittest.TestCase): 439 def test_p(self): 440 from _testcapi import getargs_p 441 self.assertEqual(0, getargs_p(False)) 442 self.assertEqual(0, getargs_p(None)) 443 self.assertEqual(0, getargs_p(0)) 444 self.assertEqual(0, getargs_p(0.0)) 445 self.assertEqual(0, getargs_p(0j)) 446 self.assertEqual(0, getargs_p('')) 447 self.assertEqual(0, getargs_p(())) 448 self.assertEqual(0, getargs_p([])) 449 self.assertEqual(0, getargs_p({})) 450 451 self.assertEqual(1, getargs_p(True)) 452 self.assertEqual(1, getargs_p(1)) 453 self.assertEqual(1, getargs_p(1.0)) 454 self.assertEqual(1, getargs_p(1j)) 455 self.assertEqual(1, getargs_p('x')) 456 self.assertEqual(1, getargs_p((1,))) 457 self.assertEqual(1, getargs_p([1])) 458 self.assertEqual(1, getargs_p({1:2})) 459 self.assertEqual(1, getargs_p(unittest.TestCase)) 460 461 self.assertRaises(NotImplementedError, getargs_p, Paradox()) 462 463 464 class Tuple_TestCase(unittest.TestCase): 465 def test_args(self): 466 from _testcapi import get_args 467 468 ret = get_args(1, 2) 469 self.assertEqual(ret, (1, 2)) 470 self.assertIs(type(ret), tuple) 471 472 ret = get_args(1, *(2, 3)) 473 self.assertEqual(ret, (1, 2, 3)) 474 self.assertIs(type(ret), tuple) 475 476 ret = get_args(*[1, 2]) 477 self.assertEqual(ret, (1, 2)) 478 self.assertIs(type(ret), tuple) 479 480 ret = get_args(*TupleSubclass([1, 2])) 481 self.assertEqual(ret, (1, 2)) 482 self.assertIs(type(ret), tuple) 483 484 ret = get_args() 485 self.assertIn(ret, ((), None)) 486 self.assertIn(type(ret), (tuple, type(None))) 487 488 ret = get_args(*()) 489 self.assertIn(ret, ((), None)) 490 self.assertIn(type(ret), (tuple, type(None))) 491 492 def test_tuple(self): 493 from _testcapi import getargs_tuple 494 495 ret = getargs_tuple(1, (2, 3)) 496 self.assertEqual(ret, (1,2,3)) 497 498 # make sure invalid tuple arguments are handled correctly 499 class seq: 500 def __len__(self): 501 return 2 502 def __getitem__(self, n): 503 raise ValueError 504 self.assertRaises(TypeError, getargs_tuple, 1, seq()) 505 506 class Keywords_TestCase(unittest.TestCase): 507 def test_kwargs(self): 508 from _testcapi import get_kwargs 509 510 ret = get_kwargs(a=1, b=2) 511 self.assertEqual(ret, {'a': 1, 'b': 2}) 512 self.assertIs(type(ret), dict) 513 514 ret = get_kwargs(a=1, **{'b': 2, 'c': 3}) 515 self.assertEqual(ret, {'a': 1, 'b': 2, 'c': 3}) 516 self.assertIs(type(ret), dict) 517 518 ret = get_kwargs(**DictSubclass({'a': 1, 'b': 2})) 519 self.assertEqual(ret, {'a': 1, 'b': 2}) 520 self.assertIs(type(ret), dict) 521 522 ret = get_kwargs() 523 self.assertIn(ret, ({}, None)) 524 self.assertIn(type(ret), (dict, type(None))) 525 526 ret = get_kwargs(**{}) 527 self.assertIn(ret, ({}, None)) 528 self.assertIn(type(ret), (dict, type(None))) 529 530 def test_positional_args(self): 531 # using all positional args 532 self.assertEqual( 533 getargs_keywords((1,2), 3, (4,(5,6)), (7,8,9), 10), 534 (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) 535 ) 536 537 def test_mixed_args(self): 538 # positional and keyword args 539 self.assertEqual( 540 getargs_keywords((1,2), 3, (4,(5,6)), arg4=(7,8,9), arg5=10), 541 (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) 542 ) 543 544 def test_keyword_args(self): 545 # all keywords 546 self.assertEqual( 547 getargs_keywords(arg1=(1,2), arg2=3, arg3=(4,(5,6)), arg4=(7,8,9), arg5=10), 548 (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) 549 ) 550 551 def test_optional_args(self): 552 # missing optional keyword args, skipping tuples 553 self.assertEqual( 554 getargs_keywords(arg1=(1,2), arg2=3, arg5=10), 555 (1, 2, 3, -1, -1, -1, -1, -1, -1, 10) 556 ) 557 558 def test_required_args(self): 559 # required arg missing 560 try: 561 getargs_keywords(arg1=(1,2)) 562 except TypeError as err: 563 self.assertEqual( 564 str(err), "function missing required argument 'arg2' (pos 2)") 565 else: 566 self.fail('TypeError should have been raised') 567 568 def test_too_many_args(self): 569 try: 570 getargs_keywords((1,2),3,(4,(5,6)),(7,8,9),10,111) 571 except TypeError as err: 572 self.assertEqual(str(err), "function takes at most 5 arguments (6 given)") 573 else: 574 self.fail('TypeError should have been raised') 575 576 def test_invalid_keyword(self): 577 # extraneous keyword arg 578 try: 579 getargs_keywords((1,2),3,arg5=10,arg666=666) 580 except TypeError as err: 581 self.assertEqual(str(err), "'arg666' is an invalid keyword argument for this function") 582 else: 583 self.fail('TypeError should have been raised') 584 585 def test_surrogate_keyword(self): 586 try: 587 getargs_keywords((1,2), 3, (4,(5,6)), (7,8,9), **{'\uDC80': 10}) 588 except TypeError as err: 589 self.assertEqual(str(err), "'\udc80' is an invalid keyword argument for this function") 590 else: 591 self.fail('TypeError should have been raised') 592 593 class KeywordOnly_TestCase(unittest.TestCase): 594 def test_positional_args(self): 595 # using all possible positional args 596 self.assertEqual( 597 getargs_keyword_only(1, 2), 598 (1, 2, -1) 599 ) 600 601 def test_mixed_args(self): 602 # positional and keyword args 603 self.assertEqual( 604 getargs_keyword_only(1, 2, keyword_only=3), 605 (1, 2, 3) 606 ) 607 608 def test_keyword_args(self): 609 # all keywords 610 self.assertEqual( 611 getargs_keyword_only(required=1, optional=2, keyword_only=3), 612 (1, 2, 3) 613 ) 614 615 def test_optional_args(self): 616 # missing optional keyword args, skipping tuples 617 self.assertEqual( 618 getargs_keyword_only(required=1, optional=2), 619 (1, 2, -1) 620 ) 621 self.assertEqual( 622 getargs_keyword_only(required=1, keyword_only=3), 623 (1, -1, 3) 624 ) 625 626 def test_required_args(self): 627 self.assertEqual( 628 getargs_keyword_only(1), 629 (1, -1, -1) 630 ) 631 self.assertEqual( 632 getargs_keyword_only(required=1), 633 (1, -1, -1) 634 ) 635 # required arg missing 636 with self.assertRaisesRegex(TypeError, 637 r"function missing required argument 'required' \(pos 1\)"): 638 getargs_keyword_only(optional=2) 639 640 with self.assertRaisesRegex(TypeError, 641 r"function missing required argument 'required' \(pos 1\)"): 642 getargs_keyword_only(keyword_only=3) 643 644 def test_too_many_args(self): 645 with self.assertRaisesRegex(TypeError, 646 r"function takes at most 2 positional arguments \(3 given\)"): 647 getargs_keyword_only(1, 2, 3) 648 649 with self.assertRaisesRegex(TypeError, 650 r"function takes at most 3 arguments \(4 given\)"): 651 getargs_keyword_only(1, 2, 3, keyword_only=5) 652 653 def test_invalid_keyword(self): 654 # extraneous keyword arg 655 with self.assertRaisesRegex(TypeError, 656 "'monster' is an invalid keyword argument for this function"): 657 getargs_keyword_only(1, 2, monster=666) 658 659 def test_surrogate_keyword(self): 660 with self.assertRaisesRegex(TypeError, 661 "'\udc80' is an invalid keyword argument for this function"): 662 getargs_keyword_only(1, 2, **{'\uDC80': 10}) 663 664 665 class PositionalOnlyAndKeywords_TestCase(unittest.TestCase): 666 from _testcapi import getargs_positional_only_and_keywords as getargs 667 668 def test_positional_args(self): 669 # using all possible positional args 670 self.assertEqual(self.getargs(1, 2, 3), (1, 2, 3)) 671 672 def test_mixed_args(self): 673 # positional and keyword args 674 self.assertEqual(self.getargs(1, 2, keyword=3), (1, 2, 3)) 675 676 def test_optional_args(self): 677 # missing optional args 678 self.assertEqual(self.getargs(1, 2), (1, 2, -1)) 679 self.assertEqual(self.getargs(1, keyword=3), (1, -1, 3)) 680 681 def test_required_args(self): 682 self.assertEqual(self.getargs(1), (1, -1, -1)) 683 # required positional arg missing 684 with self.assertRaisesRegex(TypeError, 685 r"function takes at least 1 positional arguments \(0 given\)"): 686 self.getargs() 687 688 with self.assertRaisesRegex(TypeError, 689 r"function takes at least 1 positional arguments \(0 given\)"): 690 self.getargs(keyword=3) 691 692 def test_empty_keyword(self): 693 with self.assertRaisesRegex(TypeError, 694 "'' is an invalid keyword argument for this function"): 695 self.getargs(1, 2, **{'': 666}) 696 697 698 class Bytes_TestCase(unittest.TestCase): 699 def test_c(self): 700 from _testcapi import getargs_c 701 self.assertRaises(TypeError, getargs_c, b'abc') # len > 1 702 self.assertEqual(getargs_c(b'a'), 97) 703 self.assertEqual(getargs_c(bytearray(b'a')), 97) 704 self.assertRaises(TypeError, getargs_c, memoryview(b'a')) 705 self.assertRaises(TypeError, getargs_c, 's') 706 self.assertRaises(TypeError, getargs_c, 97) 707 self.assertRaises(TypeError, getargs_c, None) 708 709 def test_y(self): 710 from _testcapi import getargs_y 711 self.assertRaises(TypeError, getargs_y, 'abc\xe9') 712 self.assertEqual(getargs_y(b'bytes'), b'bytes') 713 self.assertRaises(ValueError, getargs_y, b'nul:\0') 714 self.assertRaises(TypeError, getargs_y, bytearray(b'bytearray')) 715 self.assertRaises(TypeError, getargs_y, memoryview(b'memoryview')) 716 self.assertRaises(TypeError, getargs_y, None) 717 718 def test_y_star(self): 719 from _testcapi import getargs_y_star 720 self.assertRaises(TypeError, getargs_y_star, 'abc\xe9') 721 self.assertEqual(getargs_y_star(b'bytes'), b'bytes') 722 self.assertEqual(getargs_y_star(b'nul:\0'), b'nul:\0') 723 self.assertEqual(getargs_y_star(bytearray(b'bytearray')), b'bytearray') 724 self.assertEqual(getargs_y_star(memoryview(b'memoryview')), b'memoryview') 725 self.assertRaises(TypeError, getargs_y_star, None) 726 727 def test_y_hash(self): 728 from _testcapi import getargs_y_hash 729 self.assertRaises(TypeError, getargs_y_hash, 'abc\xe9') 730 self.assertEqual(getargs_y_hash(b'bytes'), b'bytes') 731 self.assertEqual(getargs_y_hash(b'nul:\0'), b'nul:\0') 732 self.assertRaises(TypeError, getargs_y_hash, bytearray(b'bytearray')) 733 self.assertRaises(TypeError, getargs_y_hash, memoryview(b'memoryview')) 734 self.assertRaises(TypeError, getargs_y_hash, None) 735 736 def test_w_star(self): 737 # getargs_w_star() modifies first and last byte 738 from _testcapi import getargs_w_star 739 self.assertRaises(TypeError, getargs_w_star, 'abc\xe9') 740 self.assertRaises(TypeError, getargs_w_star, b'bytes') 741 self.assertRaises(TypeError, getargs_w_star, b'nul:\0') 742 self.assertRaises(TypeError, getargs_w_star, memoryview(b'bytes')) 743 buf = bytearray(b'bytearray') 744 self.assertEqual(getargs_w_star(buf), b'[ytearra]') 745 self.assertEqual(buf, bytearray(b'[ytearra]')) 746 buf = bytearray(b'memoryview') 747 self.assertEqual(getargs_w_star(memoryview(buf)), b'[emoryvie]') 748 self.assertEqual(buf, bytearray(b'[emoryvie]')) 749 self.assertRaises(TypeError, getargs_w_star, None) 750 751 752 class String_TestCase(unittest.TestCase): 753 def test_C(self): 754 from _testcapi import getargs_C 755 self.assertRaises(TypeError, getargs_C, 'abc') # len > 1 756 self.assertEqual(getargs_C('a'), 97) 757 self.assertEqual(getargs_C('\u20ac'), 0x20ac) 758 self.assertEqual(getargs_C('\U0001f40d'), 0x1f40d) 759 self.assertRaises(TypeError, getargs_C, b'a') 760 self.assertRaises(TypeError, getargs_C, bytearray(b'a')) 761 self.assertRaises(TypeError, getargs_C, memoryview(b'a')) 762 self.assertRaises(TypeError, getargs_C, 97) 763 self.assertRaises(TypeError, getargs_C, None) 764 765 def test_s(self): 766 from _testcapi import getargs_s 767 self.assertEqual(getargs_s('abc\xe9'), b'abc\xc3\xa9') 768 self.assertRaises(ValueError, getargs_s, 'nul:\0') 769 self.assertRaises(TypeError, getargs_s, b'bytes') 770 self.assertRaises(TypeError, getargs_s, bytearray(b'bytearray')) 771 self.assertRaises(TypeError, getargs_s, memoryview(b'memoryview')) 772 self.assertRaises(TypeError, getargs_s, None) 773 774 def test_s_star(self): 775 from _testcapi import getargs_s_star 776 self.assertEqual(getargs_s_star('abc\xe9'), b'abc\xc3\xa9') 777 self.assertEqual(getargs_s_star('nul:\0'), b'nul:\0') 778 self.assertEqual(getargs_s_star(b'bytes'), b'bytes') 779 self.assertEqual(getargs_s_star(bytearray(b'bytearray')), b'bytearray') 780 self.assertEqual(getargs_s_star(memoryview(b'memoryview')), b'memoryview') 781 self.assertRaises(TypeError, getargs_s_star, None) 782 783 def test_s_hash(self): 784 from _testcapi import getargs_s_hash 785 self.assertEqual(getargs_s_hash('abc\xe9'), b'abc\xc3\xa9') 786 self.assertEqual(getargs_s_hash('nul:\0'), b'nul:\0') 787 self.assertEqual(getargs_s_hash(b'bytes'), b'bytes') 788 self.assertRaises(TypeError, getargs_s_hash, bytearray(b'bytearray')) 789 self.assertRaises(TypeError, getargs_s_hash, memoryview(b'memoryview')) 790 self.assertRaises(TypeError, getargs_s_hash, None) 791 792 def test_z(self): 793 from _testcapi import getargs_z 794 self.assertEqual(getargs_z('abc\xe9'), b'abc\xc3\xa9') 795 self.assertRaises(ValueError, getargs_z, 'nul:\0') 796 self.assertRaises(TypeError, getargs_z, b'bytes') 797 self.assertRaises(TypeError, getargs_z, bytearray(b'bytearray')) 798 self.assertRaises(TypeError, getargs_z, memoryview(b'memoryview')) 799 self.assertIsNone(getargs_z(None)) 800 801 def test_z_star(self): 802 from _testcapi import getargs_z_star 803 self.assertEqual(getargs_z_star('abc\xe9'), b'abc\xc3\xa9') 804 self.assertEqual(getargs_z_star('nul:\0'), b'nul:\0') 805 self.assertEqual(getargs_z_star(b'bytes'), b'bytes') 806 self.assertEqual(getargs_z_star(bytearray(b'bytearray')), b'bytearray') 807 self.assertEqual(getargs_z_star(memoryview(b'memoryview')), b'memoryview') 808 self.assertIsNone(getargs_z_star(None)) 809 810 def test_z_hash(self): 811 from _testcapi import getargs_z_hash 812 self.assertEqual(getargs_z_hash('abc\xe9'), b'abc\xc3\xa9') 813 self.assertEqual(getargs_z_hash('nul:\0'), b'nul:\0') 814 self.assertEqual(getargs_z_hash(b'bytes'), b'bytes') 815 self.assertRaises(TypeError, getargs_z_hash, bytearray(b'bytearray')) 816 self.assertRaises(TypeError, getargs_z_hash, memoryview(b'memoryview')) 817 self.assertIsNone(getargs_z_hash(None)) 818 819 def test_es(self): 820 from _testcapi import getargs_es 821 self.assertEqual(getargs_es('abc\xe9'), b'abc\xc3\xa9') 822 self.assertEqual(getargs_es('abc\xe9', 'latin1'), b'abc\xe9') 823 self.assertRaises(UnicodeEncodeError, getargs_es, 'abc\xe9', 'ascii') 824 self.assertRaises(LookupError, getargs_es, 'abc\xe9', 'spam') 825 self.assertRaises(TypeError, getargs_es, b'bytes', 'latin1') 826 self.assertRaises(TypeError, getargs_es, bytearray(b'bytearray'), 'latin1') 827 self.assertRaises(TypeError, getargs_es, memoryview(b'memoryview'), 'latin1') 828 self.assertRaises(TypeError, getargs_es, None, 'latin1') 829 self.assertRaises(TypeError, getargs_es, 'nul:\0', 'latin1') 830 831 def test_et(self): 832 from _testcapi import getargs_et 833 self.assertEqual(getargs_et('abc\xe9'), b'abc\xc3\xa9') 834 self.assertEqual(getargs_et('abc\xe9', 'latin1'), b'abc\xe9') 835 self.assertRaises(UnicodeEncodeError, getargs_et, 'abc\xe9', 'ascii') 836 self.assertRaises(LookupError, getargs_et, 'abc\xe9', 'spam') 837 self.assertEqual(getargs_et(b'bytes', 'latin1'), b'bytes') 838 self.assertEqual(getargs_et(bytearray(b'bytearray'), 'latin1'), b'bytearray') 839 self.assertRaises(TypeError, getargs_et, memoryview(b'memoryview'), 'latin1') 840 self.assertRaises(TypeError, getargs_et, None, 'latin1') 841 self.assertRaises(TypeError, getargs_et, 'nul:\0', 'latin1') 842 self.assertRaises(TypeError, getargs_et, b'nul:\0', 'latin1') 843 self.assertRaises(TypeError, getargs_et, bytearray(b'nul:\0'), 'latin1') 844 845 def test_es_hash(self): 846 from _testcapi import getargs_es_hash 847 self.assertEqual(getargs_es_hash('abc\xe9'), b'abc\xc3\xa9') 848 self.assertEqual(getargs_es_hash('abc\xe9', 'latin1'), b'abc\xe9') 849 self.assertRaises(UnicodeEncodeError, getargs_es_hash, 'abc\xe9', 'ascii') 850 self.assertRaises(LookupError, getargs_es_hash, 'abc\xe9', 'spam') 851 self.assertRaises(TypeError, getargs_es_hash, b'bytes', 'latin1') 852 self.assertRaises(TypeError, getargs_es_hash, bytearray(b'bytearray'), 'latin1') 853 self.assertRaises(TypeError, getargs_es_hash, memoryview(b'memoryview'), 'latin1') 854 self.assertRaises(TypeError, getargs_es_hash, None, 'latin1') 855 self.assertEqual(getargs_es_hash('nul:\0', 'latin1'), b'nul:\0') 856 857 buf = bytearray(b'x'*8) 858 self.assertEqual(getargs_es_hash('abc\xe9', 'latin1', buf), b'abc\xe9') 859 self.assertEqual(buf, bytearray(b'abc\xe9\x00xxx')) 860 buf = bytearray(b'x'*5) 861 self.assertEqual(getargs_es_hash('abc\xe9', 'latin1', buf), b'abc\xe9') 862 self.assertEqual(buf, bytearray(b'abc\xe9\x00')) 863 buf = bytearray(b'x'*4) 864 self.assertRaises(ValueError, getargs_es_hash, 'abc\xe9', 'latin1', buf) 865 self.assertEqual(buf, bytearray(b'x'*4)) 866 buf = bytearray() 867 self.assertRaises(ValueError, getargs_es_hash, 'abc\xe9', 'latin1', buf) 868 869 def test_et_hash(self): 870 from _testcapi import getargs_et_hash 871 self.assertEqual(getargs_et_hash('abc\xe9'), b'abc\xc3\xa9') 872 self.assertEqual(getargs_et_hash('abc\xe9', 'latin1'), b'abc\xe9') 873 self.assertRaises(UnicodeEncodeError, getargs_et_hash, 'abc\xe9', 'ascii') 874 self.assertRaises(LookupError, getargs_et_hash, 'abc\xe9', 'spam') 875 self.assertEqual(getargs_et_hash(b'bytes', 'latin1'), b'bytes') 876 self.assertEqual(getargs_et_hash(bytearray(b'bytearray'), 'latin1'), b'bytearray') 877 self.assertRaises(TypeError, getargs_et_hash, memoryview(b'memoryview'), 'latin1') 878 self.assertRaises(TypeError, getargs_et_hash, None, 'latin1') 879 self.assertEqual(getargs_et_hash('nul:\0', 'latin1'), b'nul:\0') 880 self.assertEqual(getargs_et_hash(b'nul:\0', 'latin1'), b'nul:\0') 881 self.assertEqual(getargs_et_hash(bytearray(b'nul:\0'), 'latin1'), b'nul:\0') 882 883 buf = bytearray(b'x'*8) 884 self.assertEqual(getargs_et_hash('abc\xe9', 'latin1', buf), b'abc\xe9') 885 self.assertEqual(buf, bytearray(b'abc\xe9\x00xxx')) 886 buf = bytearray(b'x'*5) 887 self.assertEqual(getargs_et_hash('abc\xe9', 'latin1', buf), b'abc\xe9') 888 self.assertEqual(buf, bytearray(b'abc\xe9\x00')) 889 buf = bytearray(b'x'*4) 890 self.assertRaises(ValueError, getargs_et_hash, 'abc\xe9', 'latin1', buf) 891 self.assertEqual(buf, bytearray(b'x'*4)) 892 buf = bytearray() 893 self.assertRaises(ValueError, getargs_et_hash, 'abc\xe9', 'latin1', buf) 894 895 def test_u(self): 896 from _testcapi import getargs_u 897 self.assertEqual(getargs_u('abc\xe9'), 'abc\xe9') 898 self.assertRaises(ValueError, getargs_u, 'nul:\0') 899 self.assertRaises(TypeError, getargs_u, b'bytes') 900 self.assertRaises(TypeError, getargs_u, bytearray(b'bytearray')) 901 self.assertRaises(TypeError, getargs_u, memoryview(b'memoryview')) 902 self.assertRaises(TypeError, getargs_u, None) 903 904 def test_u_hash(self): 905 from _testcapi import getargs_u_hash 906 self.assertEqual(getargs_u_hash('abc\xe9'), 'abc\xe9') 907 self.assertEqual(getargs_u_hash('nul:\0'), 'nul:\0') 908 self.assertRaises(TypeError, getargs_u_hash, b'bytes') 909 self.assertRaises(TypeError, getargs_u_hash, bytearray(b'bytearray')) 910 self.assertRaises(TypeError, getargs_u_hash, memoryview(b'memoryview')) 911 self.assertRaises(TypeError, getargs_u_hash, None) 912 913 def test_Z(self): 914 from _testcapi import getargs_Z 915 self.assertEqual(getargs_Z('abc\xe9'), 'abc\xe9') 916 self.assertRaises(ValueError, getargs_Z, 'nul:\0') 917 self.assertRaises(TypeError, getargs_Z, b'bytes') 918 self.assertRaises(TypeError, getargs_Z, bytearray(b'bytearray')) 919 self.assertRaises(TypeError, getargs_Z, memoryview(b'memoryview')) 920 self.assertIsNone(getargs_Z(None)) 921 922 def test_Z_hash(self): 923 from _testcapi import getargs_Z_hash 924 self.assertEqual(getargs_Z_hash('abc\xe9'), 'abc\xe9') 925 self.assertEqual(getargs_Z_hash('nul:\0'), 'nul:\0') 926 self.assertRaises(TypeError, getargs_Z_hash, b'bytes') 927 self.assertRaises(TypeError, getargs_Z_hash, bytearray(b'bytearray')) 928 self.assertRaises(TypeError, getargs_Z_hash, memoryview(b'memoryview')) 929 self.assertIsNone(getargs_Z_hash(None)) 930 931 932 class Object_TestCase(unittest.TestCase): 933 def test_S(self): 934 from _testcapi import getargs_S 935 obj = b'bytes' 936 self.assertIs(getargs_S(obj), obj) 937 self.assertRaises(TypeError, getargs_S, bytearray(b'bytearray')) 938 self.assertRaises(TypeError, getargs_S, 'str') 939 self.assertRaises(TypeError, getargs_S, None) 940 self.assertRaises(TypeError, getargs_S, memoryview(obj)) 941 942 def test_Y(self): 943 from _testcapi import getargs_Y 944 obj = bytearray(b'bytearray') 945 self.assertIs(getargs_Y(obj), obj) 946 self.assertRaises(TypeError, getargs_Y, b'bytes') 947 self.assertRaises(TypeError, getargs_Y, 'str') 948 self.assertRaises(TypeError, getargs_Y, None) 949 self.assertRaises(TypeError, getargs_Y, memoryview(obj)) 950 951 def test_U(self): 952 from _testcapi import getargs_U 953 obj = 'str' 954 self.assertIs(getargs_U(obj), obj) 955 self.assertRaises(TypeError, getargs_U, b'bytes') 956 self.assertRaises(TypeError, getargs_U, bytearray(b'bytearray')) 957 self.assertRaises(TypeError, getargs_U, None) 958 959 960 # Bug #6012 961 class Test6012(unittest.TestCase): 962 def test(self): 963 self.assertEqual(_testcapi.argparsing("Hello", "World"), 1) 964 965 966 class SkipitemTest(unittest.TestCase): 967 968 def test_skipitem(self): 969 """ 970 If this test failed, you probably added a new "format unit" 971 in Python/getargs.c, but neglected to update our poor friend 972 skipitem() in the same file. (If so, shame on you!) 973 974 With a few exceptions**, this function brute-force tests all 975 printable ASCII*** characters (32 to 126 inclusive) as format units, 976 checking to see that PyArg_ParseTupleAndKeywords() return consistent 977 errors both when the unit is attempted to be used and when it is 978 skipped. If the format unit doesn't exist, we'll get one of two 979 specific error messages (one for used, one for skipped); if it does 980 exist we *won't* get that error--we'll get either no error or some 981 other error. If we get the specific "does not exist" error for one 982 test and not for the other, there's a mismatch, and the test fails. 983 984 ** Some format units have special funny semantics and it would 985 be difficult to accommodate them here. Since these are all 986 well-established and properly skipped in skipitem() we can 987 get away with not testing them--this test is really intended 988 to catch *new* format units. 989 990 *** Python C source files must be ASCII. Therefore it's impossible 991 to have non-ASCII format units. 992 993 """ 994 empty_tuple = () 995 tuple_1 = (0,) 996 dict_b = {'b':1} 997 keywords = ["a", "b"] 998 999 for i in range(32, 127): 1000 c = chr(i) 1001 1002 # skip parentheses, the error reporting is inconsistent about them 1003 # skip 'e', it's always a two-character code 1004 # skip '|' and '$', they don't represent arguments anyway 1005 if c in '()e|$': 1006 continue 1007 1008 # test the format unit when not skipped 1009 format = c + "i" 1010 try: 1011 _testcapi.parse_tuple_and_keywords(tuple_1, dict_b, 1012 format, keywords) 1013 when_not_skipped = False 1014 except SystemError as e: 1015 s = "argument 1 (impossible<bad format char>)" 1016 when_not_skipped = (str(e) == s) 1017 except TypeError: 1018 when_not_skipped = False 1019 1020 # test the format unit when skipped 1021 optional_format = "|" + format 1022 try: 1023 _testcapi.parse_tuple_and_keywords(empty_tuple, dict_b, 1024 optional_format, keywords) 1025 when_skipped = False 1026 except SystemError as e: 1027 s = "impossible<bad format char>: '{}'".format(format) 1028 when_skipped = (str(e) == s) 1029 1030 message = ("test_skipitem_parity: " 1031 "detected mismatch between convertsimple and skipitem " 1032 "for format unit '{}' ({}), not skipped {}, skipped {}".format( 1033 c, i, when_skipped, when_not_skipped)) 1034 self.assertIs(when_skipped, when_not_skipped, message) 1035 1036 def test_skipitem_with_suffix(self): 1037 parse = _testcapi.parse_tuple_and_keywords 1038 empty_tuple = () 1039 tuple_1 = (0,) 1040 dict_b = {'b':1} 1041 keywords = ["a", "b"] 1042 1043 supported = ('s#', 's*', 'z#', 'z*', 'u#', 'Z#', 'y#', 'y*', 'w#', 'w*') 1044 for c in string.ascii_letters: 1045 for c2 in '#*': 1046 f = c + c2 1047 with self.subTest(format=f): 1048 optional_format = "|" + f + "i" 1049 if f in supported: 1050 parse(empty_tuple, dict_b, optional_format, keywords) 1051 else: 1052 with self.assertRaisesRegex(SystemError, 1053 'impossible<bad format char>'): 1054 parse(empty_tuple, dict_b, optional_format, keywords) 1055 1056 for c in map(chr, range(32, 128)): 1057 f = 'e' + c 1058 optional_format = "|" + f + "i" 1059 with self.subTest(format=f): 1060 if c in 'st': 1061 parse(empty_tuple, dict_b, optional_format, keywords) 1062 else: 1063 with self.assertRaisesRegex(SystemError, 1064 'impossible<bad format char>'): 1065 parse(empty_tuple, dict_b, optional_format, keywords) 1066 1067 1068 class ParseTupleAndKeywords_Test(unittest.TestCase): 1069 1070 def test_parse_tuple_and_keywords(self): 1071 # Test handling errors in the parse_tuple_and_keywords helper itself 1072 self.assertRaises(TypeError, _testcapi.parse_tuple_and_keywords, 1073 (), {}, 42, []) 1074 self.assertRaises(ValueError, _testcapi.parse_tuple_and_keywords, 1075 (), {}, '', 42) 1076 self.assertRaises(ValueError, _testcapi.parse_tuple_and_keywords, 1077 (), {}, '', [''] * 42) 1078 self.assertRaises(ValueError, _testcapi.parse_tuple_and_keywords, 1079 (), {}, '', [42]) 1080 1081 def test_bad_use(self): 1082 # Test handling invalid format and keywords in 1083 # PyArg_ParseTupleAndKeywords() 1084 self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords, 1085 (1,), {}, '||O', ['a']) 1086 self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords, 1087 (1, 2), {}, '|O|O', ['a', 'b']) 1088 self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords, 1089 (), {'a': 1}, '$$O', ['a']) 1090 self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords, 1091 (), {'a': 1, 'b': 2}, '$O$O', ['a', 'b']) 1092 self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords, 1093 (), {'a': 1}, '$|O', ['a']) 1094 self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords, 1095 (), {'a': 1, 'b': 2}, '$O|O', ['a', 'b']) 1096 self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords, 1097 (1,), {}, '|O', ['a', 'b']) 1098 self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords, 1099 (1,), {}, '|OO', ['a']) 1100 self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords, 1101 (), {}, '|$O', ['']) 1102 self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords, 1103 (), {}, '|OO', ['a', '']) 1104 1105 def test_positional_only(self): 1106 parse = _testcapi.parse_tuple_and_keywords 1107 1108 parse((1, 2, 3), {}, 'OOO', ['', '', 'a']) 1109 parse((1, 2), {'a': 3}, 'OOO', ['', '', 'a']) 1110 with self.assertRaisesRegex(TypeError, 1111 r'function takes at least 2 positional arguments \(1 given\)'): 1112 parse((1,), {'a': 3}, 'OOO', ['', '', 'a']) 1113 parse((1,), {}, 'O|OO', ['', '', 'a']) 1114 with self.assertRaisesRegex(TypeError, 1115 r'function takes at least 1 positional arguments \(0 given\)'): 1116 parse((), {}, 'O|OO', ['', '', 'a']) 1117 parse((1, 2), {'a': 3}, 'OO$O', ['', '', 'a']) 1118 with self.assertRaisesRegex(TypeError, 1119 r'function takes exactly 2 positional arguments \(1 given\)'): 1120 parse((1,), {'a': 3}, 'OO$O', ['', '', 'a']) 1121 parse((1,), {}, 'O|O$O', ['', '', 'a']) 1122 with self.assertRaisesRegex(TypeError, 1123 r'function takes at least 1 positional arguments \(0 given\)'): 1124 parse((), {}, 'O|O$O', ['', '', 'a']) 1125 with self.assertRaisesRegex(SystemError, r'Empty parameter name after \$'): 1126 parse((1,), {}, 'O|$OO', ['', '', 'a']) 1127 with self.assertRaisesRegex(SystemError, 'Empty keyword'): 1128 parse((1,), {}, 'O|OO', ['', 'a', '']) 1129 1130 1131 class Test_testcapi(unittest.TestCase): 1132 locals().update((name, getattr(_testcapi, name)) 1133 for name in dir(_testcapi) 1134 if name.startswith('test_') and name.endswith('_code')) 1135 1136 1137 if __name__ == "__main__": 1138 unittest.main() 1139
