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