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