1import unittest 2import math 3import sys 4from test import support 5# Skip this test if the _testcapi module isn't available. 6support.import_module('_testcapi') 7from _testcapi import getargs_keywords, getargs_keyword_only 8 9# > How about the following counterproposal. This also changes some of 10# > the other format codes to be a little more regular. 11# > 12# > Code C type Range check 13# > 14# > b unsigned char 0..UCHAR_MAX 15# > h signed short SHRT_MIN..SHRT_MAX 16# > B unsigned char none ** 17# > H unsigned short none ** 18# > k * unsigned long none 19# > I * unsigned int 0..UINT_MAX 20# 21# 22# > i int INT_MIN..INT_MAX 23# > l long LONG_MIN..LONG_MAX 24# 25# > K * unsigned long long none 26# > L long long LLONG_MIN..LLONG_MAX 27# 28# > Notes: 29# > 30# > * New format codes. 31# > 32# > ** Changed from previous "range-and-a-half" to "none"; the 33# > range-and-a-half checking wasn't particularly useful. 34# 35# Plus a C API or two, e.g. PyLong_AsUnsignedLongMask() -> 36# unsigned long and PyLong_AsUnsignedLongLongMask() -> unsigned 37# long long (if that exists). 38 39LARGE = 0x7FFFFFFF 40VERY_LARGE = 0xFF0000121212121212121242 41 42from _testcapi import UCHAR_MAX, USHRT_MAX, UINT_MAX, ULONG_MAX, INT_MAX, \ 43 INT_MIN, LONG_MIN, LONG_MAX, PY_SSIZE_T_MIN, PY_SSIZE_T_MAX, \ 44 SHRT_MIN, SHRT_MAX, FLT_MIN, FLT_MAX, DBL_MIN, DBL_MAX 45 46DBL_MAX_EXP = sys.float_info.max_exp 47INF = float('inf') 48NAN = float('nan') 49 50# fake, they are not defined in Python's header files 51LLONG_MAX = 2**63-1 52LLONG_MIN = -2**63 53ULLONG_MAX = 2**64-1 54 55class Int: 56 def __int__(self): 57 return 99 58 59class IntSubclass(int): 60 def __int__(self): 61 return 99 62 63class BadInt: 64 def __int__(self): 65 return 1.0 66 67class BadInt2: 68 def __int__(self): 69 return True 70 71class BadInt3(int): 72 def __int__(self): 73 return True 74 75 76class Float: 77 def __float__(self): 78 return 4.25 79 80class FloatSubclass(float): 81 pass 82 83class FloatSubclass2(float): 84 def __float__(self): 85 return 4.25 86 87class BadFloat: 88 def __float__(self): 89 return 687 90 91class BadFloat2: 92 def __float__(self): 93 return FloatSubclass(4.25) 94 95class BadFloat3(float): 96 def __float__(self): 97 return FloatSubclass(4.25) 98 99 100class Complex: 101 def __complex__(self): 102 return 4.25+0.5j 103 104class ComplexSubclass(complex): 105 pass 106 107class ComplexSubclass2(complex): 108 def __complex__(self): 109 return 4.25+0.5j 110 111class BadComplex: 112 def __complex__(self): 113 return 1.25 114 115class BadComplex2: 116 def __complex__(self): 117 return ComplexSubclass(4.25+0.5j) 118 119class BadComplex3(complex): 120 def __complex__(self): 121 return ComplexSubclass(4.25+0.5j) 122 123 124class TupleSubclass(tuple): 125 pass 126 127class DictSubclass(dict): 128 pass 129 130 131class Unsigned_TestCase(unittest.TestCase): 132 def test_b(self): 133 from _testcapi import getargs_b 134 # b returns 'unsigned char', and does range checking (0 ... UCHAR_MAX) 135 self.assertRaises(TypeError, getargs_b, 3.14) 136 self.assertEqual(99, getargs_b(Int())) 137 self.assertEqual(0, getargs_b(IntSubclass())) 138 self.assertRaises(TypeError, getargs_b, BadInt()) 139 with self.assertWarns(DeprecationWarning): 140 self.assertEqual(1, getargs_b(BadInt2())) 141 self.assertEqual(0, getargs_b(BadInt3())) 142 143 self.assertRaises(OverflowError, getargs_b, -1) 144 self.assertEqual(0, getargs_b(0)) 145 self.assertEqual(UCHAR_MAX, getargs_b(UCHAR_MAX)) 146 self.assertRaises(OverflowError, getargs_b, UCHAR_MAX + 1) 147 148 self.assertEqual(42, getargs_b(42)) 149 self.assertRaises(OverflowError, getargs_b, VERY_LARGE) 150 151 def test_B(self): 152 from _testcapi import getargs_B 153 # B returns 'unsigned char', no range checking 154 self.assertRaises(TypeError, getargs_B, 3.14) 155 self.assertEqual(99, getargs_B(Int())) 156 self.assertEqual(0, getargs_B(IntSubclass())) 157 self.assertRaises(TypeError, getargs_B, BadInt()) 158 with self.assertWarns(DeprecationWarning): 159 self.assertEqual(1, getargs_B(BadInt2())) 160 self.assertEqual(0, getargs_B(BadInt3())) 161 162 self.assertEqual(UCHAR_MAX, getargs_B(-1)) 163 self.assertEqual(0, getargs_B(0)) 164 self.assertEqual(UCHAR_MAX, getargs_B(UCHAR_MAX)) 165 self.assertEqual(0, getargs_B(UCHAR_MAX+1)) 166 167 self.assertEqual(42, getargs_B(42)) 168 self.assertEqual(UCHAR_MAX & VERY_LARGE, getargs_B(VERY_LARGE)) 169 170 def test_H(self): 171 from _testcapi import getargs_H 172 # H returns 'unsigned short', no range checking 173 self.assertRaises(TypeError, getargs_H, 3.14) 174 self.assertEqual(99, getargs_H(Int())) 175 self.assertEqual(0, getargs_H(IntSubclass())) 176 self.assertRaises(TypeError, getargs_H, BadInt()) 177 with self.assertWarns(DeprecationWarning): 178 self.assertEqual(1, getargs_H(BadInt2())) 179 self.assertEqual(0, getargs_H(BadInt3())) 180 181 self.assertEqual(USHRT_MAX, getargs_H(-1)) 182 self.assertEqual(0, getargs_H(0)) 183 self.assertEqual(USHRT_MAX, getargs_H(USHRT_MAX)) 184 self.assertEqual(0, getargs_H(USHRT_MAX+1)) 185 186 self.assertEqual(42, getargs_H(42)) 187 188 self.assertEqual(VERY_LARGE & USHRT_MAX, getargs_H(VERY_LARGE)) 189 190 def test_I(self): 191 from _testcapi import getargs_I 192 # I returns 'unsigned int', no range checking 193 self.assertRaises(TypeError, getargs_I, 3.14) 194 self.assertEqual(99, getargs_I(Int())) 195 self.assertEqual(0, getargs_I(IntSubclass())) 196 self.assertRaises(TypeError, getargs_I, BadInt()) 197 with self.assertWarns(DeprecationWarning): 198 self.assertEqual(1, getargs_I(BadInt2())) 199 self.assertEqual(0, getargs_I(BadInt3())) 200 201 self.assertEqual(UINT_MAX, getargs_I(-1)) 202 self.assertEqual(0, getargs_I(0)) 203 self.assertEqual(UINT_MAX, getargs_I(UINT_MAX)) 204 self.assertEqual(0, getargs_I(UINT_MAX+1)) 205 206 self.assertEqual(42, getargs_I(42)) 207 208 self.assertEqual(VERY_LARGE & UINT_MAX, getargs_I(VERY_LARGE)) 209 210 def test_k(self): 211 from _testcapi import getargs_k 212 # k returns 'unsigned long', no range checking 213 # it does not accept float, or instances with __int__ 214 self.assertRaises(TypeError, getargs_k, 3.14) 215 self.assertRaises(TypeError, getargs_k, Int()) 216 self.assertEqual(0, getargs_k(IntSubclass())) 217 self.assertRaises(TypeError, getargs_k, BadInt()) 218 self.assertRaises(TypeError, getargs_k, BadInt2()) 219 self.assertEqual(0, getargs_k(BadInt3())) 220 221 self.assertEqual(ULONG_MAX, getargs_k(-1)) 222 self.assertEqual(0, getargs_k(0)) 223 self.assertEqual(ULONG_MAX, getargs_k(ULONG_MAX)) 224 self.assertEqual(0, getargs_k(ULONG_MAX+1)) 225 226 self.assertEqual(42, getargs_k(42)) 227 228 self.assertEqual(VERY_LARGE & ULONG_MAX, getargs_k(VERY_LARGE)) 229 230class Signed_TestCase(unittest.TestCase): 231 def test_h(self): 232 from _testcapi import getargs_h 233 # h returns 'short', and does range checking (SHRT_MIN ... SHRT_MAX) 234 self.assertRaises(TypeError, getargs_h, 3.14) 235 self.assertEqual(99, getargs_h(Int())) 236 self.assertEqual(0, getargs_h(IntSubclass())) 237 self.assertRaises(TypeError, getargs_h, BadInt()) 238 with self.assertWarns(DeprecationWarning): 239 self.assertEqual(1, getargs_h(BadInt2())) 240 self.assertEqual(0, getargs_h(BadInt3())) 241 242 self.assertRaises(OverflowError, getargs_h, SHRT_MIN-1) 243 self.assertEqual(SHRT_MIN, getargs_h(SHRT_MIN)) 244 self.assertEqual(SHRT_MAX, getargs_h(SHRT_MAX)) 245 self.assertRaises(OverflowError, getargs_h, SHRT_MAX+1) 246 247 self.assertEqual(42, getargs_h(42)) 248 self.assertRaises(OverflowError, getargs_h, VERY_LARGE) 249 250 def test_i(self): 251 from _testcapi import getargs_i 252 # i returns 'int', and does range checking (INT_MIN ... INT_MAX) 253 self.assertRaises(TypeError, getargs_i, 3.14) 254 self.assertEqual(99, getargs_i(Int())) 255 self.assertEqual(0, getargs_i(IntSubclass())) 256 self.assertRaises(TypeError, getargs_i, BadInt()) 257 with self.assertWarns(DeprecationWarning): 258 self.assertEqual(1, getargs_i(BadInt2())) 259 self.assertEqual(0, getargs_i(BadInt3())) 260 261 self.assertRaises(OverflowError, getargs_i, INT_MIN-1) 262 self.assertEqual(INT_MIN, getargs_i(INT_MIN)) 263 self.assertEqual(INT_MAX, getargs_i(INT_MAX)) 264 self.assertRaises(OverflowError, getargs_i, INT_MAX+1) 265 266 self.assertEqual(42, getargs_i(42)) 267 self.assertRaises(OverflowError, getargs_i, VERY_LARGE) 268 269 def test_l(self): 270 from _testcapi import getargs_l 271 # l returns 'long', and does range checking (LONG_MIN ... LONG_MAX) 272 self.assertRaises(TypeError, getargs_l, 3.14) 273 self.assertEqual(99, getargs_l(Int())) 274 self.assertEqual(0, getargs_l(IntSubclass())) 275 self.assertRaises(TypeError, getargs_l, BadInt()) 276 with self.assertWarns(DeprecationWarning): 277 self.assertEqual(1, getargs_l(BadInt2())) 278 self.assertEqual(0, getargs_l(BadInt3())) 279 280 self.assertRaises(OverflowError, getargs_l, LONG_MIN-1) 281 self.assertEqual(LONG_MIN, getargs_l(LONG_MIN)) 282 self.assertEqual(LONG_MAX, getargs_l(LONG_MAX)) 283 self.assertRaises(OverflowError, getargs_l, LONG_MAX+1) 284 285 self.assertEqual(42, getargs_l(42)) 286 self.assertRaises(OverflowError, getargs_l, VERY_LARGE) 287 288 def test_n(self): 289 from _testcapi import getargs_n 290 # n returns 'Py_ssize_t', and does range checking 291 # (PY_SSIZE_T_MIN ... PY_SSIZE_T_MAX) 292 self.assertRaises(TypeError, getargs_n, 3.14) 293 self.assertRaises(TypeError, getargs_n, Int()) 294 self.assertEqual(0, getargs_n(IntSubclass())) 295 self.assertRaises(TypeError, getargs_n, BadInt()) 296 self.assertRaises(TypeError, getargs_n, BadInt2()) 297 self.assertEqual(0, getargs_n(BadInt3())) 298 299 self.assertRaises(OverflowError, getargs_n, PY_SSIZE_T_MIN-1) 300 self.assertEqual(PY_SSIZE_T_MIN, getargs_n(PY_SSIZE_T_MIN)) 301 self.assertEqual(PY_SSIZE_T_MAX, getargs_n(PY_SSIZE_T_MAX)) 302 self.assertRaises(OverflowError, getargs_n, PY_SSIZE_T_MAX+1) 303 304 self.assertEqual(42, getargs_n(42)) 305 self.assertRaises(OverflowError, getargs_n, VERY_LARGE) 306 307 308class LongLong_TestCase(unittest.TestCase): 309 def test_L(self): 310 from _testcapi import getargs_L 311 # L returns 'long long', and does range checking (LLONG_MIN 312 # ... LLONG_MAX) 313 self.assertRaises(TypeError, getargs_L, 3.14) 314 self.assertRaises(TypeError, getargs_L, "Hello") 315 self.assertEqual(99, getargs_L(Int())) 316 self.assertEqual(0, getargs_L(IntSubclass())) 317 self.assertRaises(TypeError, getargs_L, BadInt()) 318 with self.assertWarns(DeprecationWarning): 319 self.assertEqual(1, getargs_L(BadInt2())) 320 self.assertEqual(0, getargs_L(BadInt3())) 321 322 self.assertRaises(OverflowError, getargs_L, LLONG_MIN-1) 323 self.assertEqual(LLONG_MIN, getargs_L(LLONG_MIN)) 324 self.assertEqual(LLONG_MAX, getargs_L(LLONG_MAX)) 325 self.assertRaises(OverflowError, getargs_L, LLONG_MAX+1) 326 327 self.assertEqual(42, getargs_L(42)) 328 self.assertRaises(OverflowError, getargs_L, VERY_LARGE) 329 330 def test_K(self): 331 from _testcapi import getargs_K 332 # K return 'unsigned long long', no range checking 333 self.assertRaises(TypeError, getargs_K, 3.14) 334 self.assertRaises(TypeError, getargs_K, Int()) 335 self.assertEqual(0, getargs_K(IntSubclass())) 336 self.assertRaises(TypeError, getargs_K, BadInt()) 337 self.assertRaises(TypeError, getargs_K, BadInt2()) 338 self.assertEqual(0, getargs_K(BadInt3())) 339 340 self.assertEqual(ULLONG_MAX, getargs_K(ULLONG_MAX)) 341 self.assertEqual(0, getargs_K(0)) 342 self.assertEqual(0, getargs_K(ULLONG_MAX+1)) 343 344 self.assertEqual(42, getargs_K(42)) 345 346 self.assertEqual(VERY_LARGE & ULLONG_MAX, getargs_K(VERY_LARGE)) 347 348 349class Float_TestCase(unittest.TestCase): 350 def assertEqualWithSign(self, actual, expected): 351 self.assertEqual(actual, expected) 352 self.assertEqual(math.copysign(1, actual), math.copysign(1, expected)) 353 354 def test_f(self): 355 from _testcapi import getargs_f 356 self.assertEqual(getargs_f(4.25), 4.25) 357 self.assertEqual(getargs_f(4), 4.0) 358 self.assertRaises(TypeError, getargs_f, 4.25+0j) 359 self.assertEqual(getargs_f(Float()), 4.25) 360 self.assertEqual(getargs_f(FloatSubclass(7.5)), 7.5) 361 self.assertEqual(getargs_f(FloatSubclass2(7.5)), 7.5) 362 self.assertRaises(TypeError, getargs_f, BadFloat()) 363 with self.assertWarns(DeprecationWarning): 364 self.assertEqual(getargs_f(BadFloat2()), 4.25) 365 self.assertEqual(getargs_f(BadFloat3(7.5)), 7.5) 366 367 for x in (FLT_MIN, -FLT_MIN, FLT_MAX, -FLT_MAX, INF, -INF): 368 self.assertEqual(getargs_f(x), x) 369 if FLT_MAX < DBL_MAX: 370 self.assertEqual(getargs_f(DBL_MAX), INF) 371 self.assertEqual(getargs_f(-DBL_MAX), -INF) 372 if FLT_MIN > DBL_MIN: 373 self.assertEqualWithSign(getargs_f(DBL_MIN), 0.0) 374 self.assertEqualWithSign(getargs_f(-DBL_MIN), -0.0) 375 self.assertEqualWithSign(getargs_f(0.0), 0.0) 376 self.assertEqualWithSign(getargs_f(-0.0), -0.0) 377 r = getargs_f(NAN) 378 self.assertNotEqual(r, r) 379 380 def test_d(self): 381 from _testcapi import getargs_d 382 self.assertEqual(getargs_d(4.25), 4.25) 383 self.assertEqual(getargs_d(4), 4.0) 384 self.assertRaises(TypeError, getargs_d, 4.25+0j) 385 self.assertEqual(getargs_d(Float()), 4.25) 386 self.assertEqual(getargs_d(FloatSubclass(7.5)), 7.5) 387 self.assertEqual(getargs_d(FloatSubclass2(7.5)), 7.5) 388 self.assertRaises(TypeError, getargs_d, BadFloat()) 389 with self.assertWarns(DeprecationWarning): 390 self.assertEqual(getargs_d(BadFloat2()), 4.25) 391 self.assertEqual(getargs_d(BadFloat3(7.5)), 7.5) 392 393 for x in (DBL_MIN, -DBL_MIN, DBL_MAX, -DBL_MAX, INF, -INF): 394 self.assertEqual(getargs_d(x), x) 395 self.assertRaises(OverflowError, getargs_d, 1<<DBL_MAX_EXP) 396 self.assertRaises(OverflowError, getargs_d, -1<<DBL_MAX_EXP) 397 self.assertEqualWithSign(getargs_d(0.0), 0.0) 398 self.assertEqualWithSign(getargs_d(-0.0), -0.0) 399 r = getargs_d(NAN) 400 self.assertNotEqual(r, r) 401 402 def test_D(self): 403 from _testcapi import getargs_D 404 self.assertEqual(getargs_D(4.25+0.5j), 4.25+0.5j) 405 self.assertEqual(getargs_D(4.25), 4.25+0j) 406 self.assertEqual(getargs_D(4), 4.0+0j) 407 self.assertEqual(getargs_D(Complex()), 4.25+0.5j) 408 self.assertEqual(getargs_D(ComplexSubclass(7.5+0.25j)), 7.5+0.25j) 409 self.assertEqual(getargs_D(ComplexSubclass2(7.5+0.25j)), 7.5+0.25j) 410 self.assertRaises(TypeError, getargs_D, BadComplex()) 411 self.assertEqual(getargs_D(BadComplex2()), 4.25+0.5j) 412 self.assertEqual(getargs_D(BadComplex3(7.5+0.25j)), 7.5+0.25j) 413 414 for x in (DBL_MIN, -DBL_MIN, DBL_MAX, -DBL_MAX, INF, -INF): 415 c = complex(x, 1.0) 416 self.assertEqual(getargs_D(c), c) 417 c = complex(1.0, x) 418 self.assertEqual(getargs_D(c), c) 419 self.assertEqualWithSign(getargs_D(complex(0.0, 1.0)).real, 0.0) 420 self.assertEqualWithSign(getargs_D(complex(-0.0, 1.0)).real, -0.0) 421 self.assertEqualWithSign(getargs_D(complex(1.0, 0.0)).imag, 0.0) 422 self.assertEqualWithSign(getargs_D(complex(1.0, -0.0)).imag, -0.0) 423 424 425class Paradox: 426 "This statement is false." 427 def __bool__(self): 428 raise NotImplementedError 429 430class Boolean_TestCase(unittest.TestCase): 431 def test_p(self): 432 from _testcapi import getargs_p 433 self.assertEqual(0, getargs_p(False)) 434 self.assertEqual(0, getargs_p(None)) 435 self.assertEqual(0, getargs_p(0)) 436 self.assertEqual(0, getargs_p(0.0)) 437 self.assertEqual(0, getargs_p(0j)) 438 self.assertEqual(0, getargs_p('')) 439 self.assertEqual(0, getargs_p(())) 440 self.assertEqual(0, getargs_p([])) 441 self.assertEqual(0, getargs_p({})) 442 443 self.assertEqual(1, getargs_p(True)) 444 self.assertEqual(1, getargs_p(1)) 445 self.assertEqual(1, getargs_p(1.0)) 446 self.assertEqual(1, getargs_p(1j)) 447 self.assertEqual(1, getargs_p('x')) 448 self.assertEqual(1, getargs_p((1,))) 449 self.assertEqual(1, getargs_p([1])) 450 self.assertEqual(1, getargs_p({1:2})) 451 self.assertEqual(1, getargs_p(unittest.TestCase)) 452 453 self.assertRaises(NotImplementedError, getargs_p, Paradox()) 454 455 456class Tuple_TestCase(unittest.TestCase): 457 def test_args(self): 458 from _testcapi import get_args 459 460 ret = get_args(1, 2) 461 self.assertEqual(ret, (1, 2)) 462 self.assertIs(type(ret), tuple) 463 464 ret = get_args(1, *(2, 3)) 465 self.assertEqual(ret, (1, 2, 3)) 466 self.assertIs(type(ret), tuple) 467 468 ret = get_args(*[1, 2]) 469 self.assertEqual(ret, (1, 2)) 470 self.assertIs(type(ret), tuple) 471 472 ret = get_args(*TupleSubclass([1, 2])) 473 self.assertEqual(ret, (1, 2)) 474 self.assertIs(type(ret), tuple) 475 476 ret = get_args() 477 self.assertIn(ret, ((), None)) 478 self.assertIn(type(ret), (tuple, type(None))) 479 480 ret = get_args(*()) 481 self.assertIn(ret, ((), None)) 482 self.assertIn(type(ret), (tuple, type(None))) 483 484 def test_tuple(self): 485 from _testcapi import getargs_tuple 486 487 ret = getargs_tuple(1, (2, 3)) 488 self.assertEqual(ret, (1,2,3)) 489 490 # make sure invalid tuple arguments are handled correctly 491 class seq: 492 def __len__(self): 493 return 2 494 def __getitem__(self, n): 495 raise ValueError 496 self.assertRaises(TypeError, getargs_tuple, 1, seq()) 497 498class Keywords_TestCase(unittest.TestCase): 499 def test_kwargs(self): 500 from _testcapi import get_kwargs 501 502 ret = get_kwargs(a=1, b=2) 503 self.assertEqual(ret, {'a': 1, 'b': 2}) 504 self.assertIs(type(ret), dict) 505 506 ret = get_kwargs(a=1, **{'b': 2, 'c': 3}) 507 self.assertEqual(ret, {'a': 1, 'b': 2, 'c': 3}) 508 self.assertIs(type(ret), dict) 509 510 ret = get_kwargs(**DictSubclass({'a': 1, 'b': 2})) 511 self.assertEqual(ret, {'a': 1, 'b': 2}) 512 self.assertIs(type(ret), dict) 513 514 ret = get_kwargs() 515 self.assertIn(ret, ({}, None)) 516 self.assertIn(type(ret), (dict, type(None))) 517 518 ret = get_kwargs(**{}) 519 self.assertIn(ret, ({}, None)) 520 self.assertIn(type(ret), (dict, type(None))) 521 522 def test_positional_args(self): 523 # using all positional args 524 self.assertEqual( 525 getargs_keywords((1,2), 3, (4,(5,6)), (7,8,9), 10), 526 (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) 527 ) 528 529 def test_mixed_args(self): 530 # positional and keyword args 531 self.assertEqual( 532 getargs_keywords((1,2), 3, (4,(5,6)), arg4=(7,8,9), arg5=10), 533 (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) 534 ) 535 536 def test_keyword_args(self): 537 # all keywords 538 self.assertEqual( 539 getargs_keywords(arg1=(1,2), arg2=3, arg3=(4,(5,6)), arg4=(7,8,9), arg5=10), 540 (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) 541 ) 542 543 def test_optional_args(self): 544 # missing optional keyword args, skipping tuples 545 self.assertEqual( 546 getargs_keywords(arg1=(1,2), arg2=3, arg5=10), 547 (1, 2, 3, -1, -1, -1, -1, -1, -1, 10) 548 ) 549 550 def test_required_args(self): 551 # required arg missing 552 try: 553 getargs_keywords(arg1=(1,2)) 554 except TypeError as err: 555 self.assertEqual(str(err), "Required argument 'arg2' (pos 2) not found") 556 else: 557 self.fail('TypeError should have been raised') 558 559 def test_too_many_args(self): 560 try: 561 getargs_keywords((1,2),3,(4,(5,6)),(7,8,9),10,111) 562 except TypeError as err: 563 self.assertEqual(str(err), "function takes at most 5 arguments (6 given)") 564 else: 565 self.fail('TypeError should have been raised') 566 567 def test_invalid_keyword(self): 568 # extraneous keyword arg 569 try: 570 getargs_keywords((1,2),3,arg5=10,arg666=666) 571 except TypeError as err: 572 self.assertEqual(str(err), "'arg666' is an invalid keyword argument for this function") 573 else: 574 self.fail('TypeError should have been raised') 575 576 def test_surrogate_keyword(self): 577 try: 578 getargs_keywords((1,2), 3, (4,(5,6)), (7,8,9), **{'\uDC80': 10}) 579 except TypeError as err: 580 self.assertEqual(str(err), "'\udc80' is an invalid keyword argument for this function") 581 else: 582 self.fail('TypeError should have been raised') 583 584class KeywordOnly_TestCase(unittest.TestCase): 585 def test_positional_args(self): 586 # using all possible positional args 587 self.assertEqual( 588 getargs_keyword_only(1, 2), 589 (1, 2, -1) 590 ) 591 592 def test_mixed_args(self): 593 # positional and keyword args 594 self.assertEqual( 595 getargs_keyword_only(1, 2, keyword_only=3), 596 (1, 2, 3) 597 ) 598 599 def test_keyword_args(self): 600 # all keywords 601 self.assertEqual( 602 getargs_keyword_only(required=1, optional=2, keyword_only=3), 603 (1, 2, 3) 604 ) 605 606 def test_optional_args(self): 607 # missing optional keyword args, skipping tuples 608 self.assertEqual( 609 getargs_keyword_only(required=1, optional=2), 610 (1, 2, -1) 611 ) 612 self.assertEqual( 613 getargs_keyword_only(required=1, keyword_only=3), 614 (1, -1, 3) 615 ) 616 617 def test_required_args(self): 618 self.assertEqual( 619 getargs_keyword_only(1), 620 (1, -1, -1) 621 ) 622 self.assertEqual( 623 getargs_keyword_only(required=1), 624 (1, -1, -1) 625 ) 626 # required arg missing 627 with self.assertRaisesRegex(TypeError, 628 r"Required argument 'required' \(pos 1\) not found"): 629 getargs_keyword_only(optional=2) 630 631 with self.assertRaisesRegex(TypeError, 632 r"Required argument 'required' \(pos 1\) not found"): 633 getargs_keyword_only(keyword_only=3) 634 635 def test_too_many_args(self): 636 with self.assertRaisesRegex(TypeError, 637 r"Function takes at most 2 positional arguments \(3 given\)"): 638 getargs_keyword_only(1, 2, 3) 639 640 with self.assertRaisesRegex(TypeError, 641 r"function takes at most 3 arguments \(4 given\)"): 642 getargs_keyword_only(1, 2, 3, keyword_only=5) 643 644 def test_invalid_keyword(self): 645 # extraneous keyword arg 646 with self.assertRaisesRegex(TypeError, 647 "'monster' is an invalid keyword argument for this function"): 648 getargs_keyword_only(1, 2, monster=666) 649 650 def test_surrogate_keyword(self): 651 with self.assertRaisesRegex(TypeError, 652 "'\udc80' is an invalid keyword argument for this function"): 653 getargs_keyword_only(1, 2, **{'\uDC80': 10}) 654 655 656class PositionalOnlyAndKeywords_TestCase(unittest.TestCase): 657 from _testcapi import getargs_positional_only_and_keywords as getargs 658 659 def test_positional_args(self): 660 # using all possible positional args 661 self.assertEqual(self.getargs(1, 2, 3), (1, 2, 3)) 662 663 def test_mixed_args(self): 664 # positional and keyword args 665 self.assertEqual(self.getargs(1, 2, keyword=3), (1, 2, 3)) 666 667 def test_optional_args(self): 668 # missing optional args 669 self.assertEqual(self.getargs(1, 2), (1, 2, -1)) 670 self.assertEqual(self.getargs(1, keyword=3), (1, -1, 3)) 671 672 def test_required_args(self): 673 self.assertEqual(self.getargs(1), (1, -1, -1)) 674 # required positional arg missing 675 with self.assertRaisesRegex(TypeError, 676 r"Function takes at least 1 positional arguments \(0 given\)"): 677 self.getargs() 678 679 with self.assertRaisesRegex(TypeError, 680 r"Function takes at least 1 positional arguments \(0 given\)"): 681 self.getargs(keyword=3) 682 683 def test_empty_keyword(self): 684 with self.assertRaisesRegex(TypeError, 685 "'' is an invalid keyword argument for this function"): 686 self.getargs(1, 2, **{'': 666}) 687 688 689class Bytes_TestCase(unittest.TestCase): 690 def test_c(self): 691 from _testcapi import getargs_c 692 self.assertRaises(TypeError, getargs_c, b'abc') # len > 1 693 self.assertEqual(getargs_c(b'a'), 97) 694 self.assertEqual(getargs_c(bytearray(b'a')), 97) 695 self.assertRaises(TypeError, getargs_c, memoryview(b'a')) 696 self.assertRaises(TypeError, getargs_c, 's') 697 self.assertRaises(TypeError, getargs_c, 97) 698 self.assertRaises(TypeError, getargs_c, None) 699 700 def test_y(self): 701 from _testcapi import getargs_y 702 self.assertRaises(TypeError, getargs_y, 'abc\xe9') 703 self.assertEqual(getargs_y(b'bytes'), b'bytes') 704 self.assertRaises(ValueError, getargs_y, b'nul:\0') 705 self.assertRaises(TypeError, getargs_y, bytearray(b'bytearray')) 706 self.assertRaises(TypeError, getargs_y, memoryview(b'memoryview')) 707 self.assertRaises(TypeError, getargs_y, None) 708 709 def test_y_star(self): 710 from _testcapi import getargs_y_star 711 self.assertRaises(TypeError, getargs_y_star, 'abc\xe9') 712 self.assertEqual(getargs_y_star(b'bytes'), b'bytes') 713 self.assertEqual(getargs_y_star(b'nul:\0'), b'nul:\0') 714 self.assertEqual(getargs_y_star(bytearray(b'bytearray')), b'bytearray') 715 self.assertEqual(getargs_y_star(memoryview(b'memoryview')), b'memoryview') 716 self.assertRaises(TypeError, getargs_y_star, None) 717 718 def test_y_hash(self): 719 from _testcapi import getargs_y_hash 720 self.assertRaises(TypeError, getargs_y_hash, 'abc\xe9') 721 self.assertEqual(getargs_y_hash(b'bytes'), b'bytes') 722 self.assertEqual(getargs_y_hash(b'nul:\0'), b'nul:\0') 723 self.assertRaises(TypeError, getargs_y_hash, bytearray(b'bytearray')) 724 self.assertRaises(TypeError, getargs_y_hash, memoryview(b'memoryview')) 725 self.assertRaises(TypeError, getargs_y_hash, None) 726 727 def test_w_star(self): 728 # getargs_w_star() modifies first and last byte 729 from _testcapi import getargs_w_star 730 self.assertRaises(TypeError, getargs_w_star, 'abc\xe9') 731 self.assertRaises(TypeError, getargs_w_star, b'bytes') 732 self.assertRaises(TypeError, getargs_w_star, b'nul:\0') 733 self.assertRaises(TypeError, getargs_w_star, memoryview(b'bytes')) 734 buf = bytearray(b'bytearray') 735 self.assertEqual(getargs_w_star(buf), b'[ytearra]') 736 self.assertEqual(buf, bytearray(b'[ytearra]')) 737 buf = bytearray(b'memoryview') 738 self.assertEqual(getargs_w_star(memoryview(buf)), b'[emoryvie]') 739 self.assertEqual(buf, bytearray(b'[emoryvie]')) 740 self.assertRaises(TypeError, getargs_w_star, None) 741 742 743class String_TestCase(unittest.TestCase): 744 def test_C(self): 745 from _testcapi import getargs_C 746 self.assertRaises(TypeError, getargs_C, 'abc') # len > 1 747 self.assertEqual(getargs_C('a'), 97) 748 self.assertEqual(getargs_C('\u20ac'), 0x20ac) 749 self.assertEqual(getargs_C('\U0001f40d'), 0x1f40d) 750 self.assertRaises(TypeError, getargs_C, b'a') 751 self.assertRaises(TypeError, getargs_C, bytearray(b'a')) 752 self.assertRaises(TypeError, getargs_C, memoryview(b'a')) 753 self.assertRaises(TypeError, getargs_C, 97) 754 self.assertRaises(TypeError, getargs_C, None) 755 756 def test_s(self): 757 from _testcapi import getargs_s 758 self.assertEqual(getargs_s('abc\xe9'), b'abc\xc3\xa9') 759 self.assertRaises(ValueError, getargs_s, 'nul:\0') 760 self.assertRaises(TypeError, getargs_s, b'bytes') 761 self.assertRaises(TypeError, getargs_s, bytearray(b'bytearray')) 762 self.assertRaises(TypeError, getargs_s, memoryview(b'memoryview')) 763 self.assertRaises(TypeError, getargs_s, None) 764 765 def test_s_star(self): 766 from _testcapi import getargs_s_star 767 self.assertEqual(getargs_s_star('abc\xe9'), b'abc\xc3\xa9') 768 self.assertEqual(getargs_s_star('nul:\0'), b'nul:\0') 769 self.assertEqual(getargs_s_star(b'bytes'), b'bytes') 770 self.assertEqual(getargs_s_star(bytearray(b'bytearray')), b'bytearray') 771 self.assertEqual(getargs_s_star(memoryview(b'memoryview')), b'memoryview') 772 self.assertRaises(TypeError, getargs_s_star, None) 773 774 def test_s_hash(self): 775 from _testcapi import getargs_s_hash 776 self.assertEqual(getargs_s_hash('abc\xe9'), b'abc\xc3\xa9') 777 self.assertEqual(getargs_s_hash('nul:\0'), b'nul:\0') 778 self.assertEqual(getargs_s_hash(b'bytes'), b'bytes') 779 self.assertRaises(TypeError, getargs_s_hash, bytearray(b'bytearray')) 780 self.assertRaises(TypeError, getargs_s_hash, memoryview(b'memoryview')) 781 self.assertRaises(TypeError, getargs_s_hash, None) 782 783 def test_z(self): 784 from _testcapi import getargs_z 785 self.assertEqual(getargs_z('abc\xe9'), b'abc\xc3\xa9') 786 self.assertRaises(ValueError, getargs_z, 'nul:\0') 787 self.assertRaises(TypeError, getargs_z, b'bytes') 788 self.assertRaises(TypeError, getargs_z, bytearray(b'bytearray')) 789 self.assertRaises(TypeError, getargs_z, memoryview(b'memoryview')) 790 self.assertIsNone(getargs_z(None)) 791 792 def test_z_star(self): 793 from _testcapi import getargs_z_star 794 self.assertEqual(getargs_z_star('abc\xe9'), b'abc\xc3\xa9') 795 self.assertEqual(getargs_z_star('nul:\0'), b'nul:\0') 796 self.assertEqual(getargs_z_star(b'bytes'), b'bytes') 797 self.assertEqual(getargs_z_star(bytearray(b'bytearray')), b'bytearray') 798 self.assertEqual(getargs_z_star(memoryview(b'memoryview')), b'memoryview') 799 self.assertIsNone(getargs_z_star(None)) 800 801 def test_z_hash(self): 802 from _testcapi import getargs_z_hash 803 self.assertEqual(getargs_z_hash('abc\xe9'), b'abc\xc3\xa9') 804 self.assertEqual(getargs_z_hash('nul:\0'), b'nul:\0') 805 self.assertEqual(getargs_z_hash(b'bytes'), b'bytes') 806 self.assertRaises(TypeError, getargs_z_hash, bytearray(b'bytearray')) 807 self.assertRaises(TypeError, getargs_z_hash, memoryview(b'memoryview')) 808 self.assertIsNone(getargs_z_hash(None)) 809 810 def test_es(self): 811 from _testcapi import getargs_es 812 self.assertEqual(getargs_es('abc\xe9'), b'abc\xc3\xa9') 813 self.assertEqual(getargs_es('abc\xe9', 'latin1'), b'abc\xe9') 814 self.assertRaises(UnicodeEncodeError, getargs_es, 'abc\xe9', 'ascii') 815 self.assertRaises(LookupError, getargs_es, 'abc\xe9', 'spam') 816 self.assertRaises(TypeError, getargs_es, b'bytes', 'latin1') 817 self.assertRaises(TypeError, getargs_es, bytearray(b'bytearray'), 'latin1') 818 self.assertRaises(TypeError, getargs_es, memoryview(b'memoryview'), 'latin1') 819 self.assertRaises(TypeError, getargs_es, None, 'latin1') 820 self.assertRaises(TypeError, getargs_es, 'nul:\0', 'latin1') 821 822 def test_et(self): 823 from _testcapi import getargs_et 824 self.assertEqual(getargs_et('abc\xe9'), b'abc\xc3\xa9') 825 self.assertEqual(getargs_et('abc\xe9', 'latin1'), b'abc\xe9') 826 self.assertRaises(UnicodeEncodeError, getargs_et, 'abc\xe9', 'ascii') 827 self.assertRaises(LookupError, getargs_et, 'abc\xe9', 'spam') 828 self.assertEqual(getargs_et(b'bytes', 'latin1'), b'bytes') 829 self.assertEqual(getargs_et(bytearray(b'bytearray'), 'latin1'), b'bytearray') 830 self.assertRaises(TypeError, getargs_et, memoryview(b'memoryview'), 'latin1') 831 self.assertRaises(TypeError, getargs_et, None, 'latin1') 832 self.assertRaises(TypeError, getargs_et, 'nul:\0', 'latin1') 833 self.assertRaises(TypeError, getargs_et, b'nul:\0', 'latin1') 834 self.assertRaises(TypeError, getargs_et, bytearray(b'nul:\0'), 'latin1') 835 836 def test_es_hash(self): 837 from _testcapi import getargs_es_hash 838 self.assertEqual(getargs_es_hash('abc\xe9'), b'abc\xc3\xa9') 839 self.assertEqual(getargs_es_hash('abc\xe9', 'latin1'), b'abc\xe9') 840 self.assertRaises(UnicodeEncodeError, getargs_es_hash, 'abc\xe9', 'ascii') 841 self.assertRaises(LookupError, getargs_es_hash, 'abc\xe9', 'spam') 842 self.assertRaises(TypeError, getargs_es_hash, b'bytes', 'latin1') 843 self.assertRaises(TypeError, getargs_es_hash, bytearray(b'bytearray'), 'latin1') 844 self.assertRaises(TypeError, getargs_es_hash, memoryview(b'memoryview'), 'latin1') 845 self.assertRaises(TypeError, getargs_es_hash, None, 'latin1') 846 self.assertEqual(getargs_es_hash('nul:\0', 'latin1'), b'nul:\0') 847 848 buf = bytearray(b'x'*8) 849 self.assertEqual(getargs_es_hash('abc\xe9', 'latin1', buf), b'abc\xe9') 850 self.assertEqual(buf, bytearray(b'abc\xe9\x00xxx')) 851 buf = bytearray(b'x'*5) 852 self.assertEqual(getargs_es_hash('abc\xe9', 'latin1', buf), b'abc\xe9') 853 self.assertEqual(buf, bytearray(b'abc\xe9\x00')) 854 buf = bytearray(b'x'*4) 855 self.assertRaises(ValueError, getargs_es_hash, 'abc\xe9', 'latin1', buf) 856 self.assertEqual(buf, bytearray(b'x'*4)) 857 buf = bytearray() 858 self.assertRaises(ValueError, getargs_es_hash, 'abc\xe9', 'latin1', buf) 859 860 def test_et_hash(self): 861 from _testcapi import getargs_et_hash 862 self.assertEqual(getargs_et_hash('abc\xe9'), b'abc\xc3\xa9') 863 self.assertEqual(getargs_et_hash('abc\xe9', 'latin1'), b'abc\xe9') 864 self.assertRaises(UnicodeEncodeError, getargs_et_hash, 'abc\xe9', 'ascii') 865 self.assertRaises(LookupError, getargs_et_hash, 'abc\xe9', 'spam') 866 self.assertEqual(getargs_et_hash(b'bytes', 'latin1'), b'bytes') 867 self.assertEqual(getargs_et_hash(bytearray(b'bytearray'), 'latin1'), b'bytearray') 868 self.assertRaises(TypeError, getargs_et_hash, memoryview(b'memoryview'), 'latin1') 869 self.assertRaises(TypeError, getargs_et_hash, None, 'latin1') 870 self.assertEqual(getargs_et_hash('nul:\0', 'latin1'), b'nul:\0') 871 self.assertEqual(getargs_et_hash(b'nul:\0', 'latin1'), b'nul:\0') 872 self.assertEqual(getargs_et_hash(bytearray(b'nul:\0'), 'latin1'), b'nul:\0') 873 874 buf = bytearray(b'x'*8) 875 self.assertEqual(getargs_et_hash('abc\xe9', 'latin1', buf), b'abc\xe9') 876 self.assertEqual(buf, bytearray(b'abc\xe9\x00xxx')) 877 buf = bytearray(b'x'*5) 878 self.assertEqual(getargs_et_hash('abc\xe9', 'latin1', buf), b'abc\xe9') 879 self.assertEqual(buf, bytearray(b'abc\xe9\x00')) 880 buf = bytearray(b'x'*4) 881 self.assertRaises(ValueError, getargs_et_hash, 'abc\xe9', 'latin1', buf) 882 self.assertEqual(buf, bytearray(b'x'*4)) 883 buf = bytearray() 884 self.assertRaises(ValueError, getargs_et_hash, 'abc\xe9', 'latin1', buf) 885 886 def test_u(self): 887 from _testcapi import getargs_u 888 self.assertEqual(getargs_u('abc\xe9'), 'abc\xe9') 889 self.assertRaises(ValueError, getargs_u, 'nul:\0') 890 self.assertRaises(TypeError, getargs_u, b'bytes') 891 self.assertRaises(TypeError, getargs_u, bytearray(b'bytearray')) 892 self.assertRaises(TypeError, getargs_u, memoryview(b'memoryview')) 893 self.assertRaises(TypeError, getargs_u, None) 894 895 def test_u_hash(self): 896 from _testcapi import getargs_u_hash 897 self.assertEqual(getargs_u_hash('abc\xe9'), 'abc\xe9') 898 self.assertEqual(getargs_u_hash('nul:\0'), 'nul:\0') 899 self.assertRaises(TypeError, getargs_u_hash, b'bytes') 900 self.assertRaises(TypeError, getargs_u_hash, bytearray(b'bytearray')) 901 self.assertRaises(TypeError, getargs_u_hash, memoryview(b'memoryview')) 902 self.assertRaises(TypeError, getargs_u_hash, None) 903 904 def test_Z(self): 905 from _testcapi import getargs_Z 906 self.assertEqual(getargs_Z('abc\xe9'), 'abc\xe9') 907 self.assertRaises(ValueError, getargs_Z, 'nul:\0') 908 self.assertRaises(TypeError, getargs_Z, b'bytes') 909 self.assertRaises(TypeError, getargs_Z, bytearray(b'bytearray')) 910 self.assertRaises(TypeError, getargs_Z, memoryview(b'memoryview')) 911 self.assertIsNone(getargs_Z(None)) 912 913 def test_Z_hash(self): 914 from _testcapi import getargs_Z_hash 915 self.assertEqual(getargs_Z_hash('abc\xe9'), 'abc\xe9') 916 self.assertEqual(getargs_Z_hash('nul:\0'), 'nul:\0') 917 self.assertRaises(TypeError, getargs_Z_hash, b'bytes') 918 self.assertRaises(TypeError, getargs_Z_hash, bytearray(b'bytearray')) 919 self.assertRaises(TypeError, getargs_Z_hash, memoryview(b'memoryview')) 920 self.assertIsNone(getargs_Z_hash(None)) 921 922 923class Object_TestCase(unittest.TestCase): 924 def test_S(self): 925 from _testcapi import getargs_S 926 obj = b'bytes' 927 self.assertIs(getargs_S(obj), obj) 928 self.assertRaises(TypeError, getargs_S, bytearray(b'bytearray')) 929 self.assertRaises(TypeError, getargs_S, 'str') 930 self.assertRaises(TypeError, getargs_S, None) 931 self.assertRaises(TypeError, getargs_S, memoryview(obj)) 932 933 def test_Y(self): 934 from _testcapi import getargs_Y 935 obj = bytearray(b'bytearray') 936 self.assertIs(getargs_Y(obj), obj) 937 self.assertRaises(TypeError, getargs_Y, b'bytes') 938 self.assertRaises(TypeError, getargs_Y, 'str') 939 self.assertRaises(TypeError, getargs_Y, None) 940 self.assertRaises(TypeError, getargs_Y, memoryview(obj)) 941 942 def test_U(self): 943 from _testcapi import getargs_U 944 obj = 'str' 945 self.assertIs(getargs_U(obj), obj) 946 self.assertRaises(TypeError, getargs_U, b'bytes') 947 self.assertRaises(TypeError, getargs_U, bytearray(b'bytearray')) 948 self.assertRaises(TypeError, getargs_U, None) 949 950 951if __name__ == "__main__": 952 unittest.main() 953