Lines Matching refs:self
60 def __index__(self):
64 def __index__(self):
68 def __index__(self):
72 def __index__(self):
76 def __index__(self):
81 def __int__(self):
85 def __int__(self):
89 def __int__(self):
93 def __int__(self):
97 def __int__(self):
102 def __float__(self):
109 def __float__(self):
113 def __float__(self):
117 def __float__(self):
121 def __float__(self):
126 def __complex__(self):
133 def __complex__(self):
137 def __complex__(self):
141 def __complex__(self):
145 def __complex__(self):
157 def test_b(self):
160 self.assertRaises(TypeError, getargs_b, 3.14)
161 self.assertEqual(99, getargs_b(Index()))
162 self.assertEqual(0, getargs_b(IndexIntSubclass()))
163 self.assertRaises(TypeError, getargs_b, BadIndex())
164 with self.assertWarns(DeprecationWarning):
165 self.assertEqual(1, getargs_b(BadIndex2()))
166 self.assertEqual(0, getargs_b(BadIndex3()))
167 self.assertRaises(TypeError, getargs_b, Int())
168 self.assertEqual(0, getargs_b(IntSubclass()))
169 self.assertRaises(TypeError, getargs_b, BadInt())
170 self.assertRaises(TypeError, getargs_b, BadInt2())
171 self.assertEqual(0, getargs_b(BadInt3()))
173 self.assertRaises(OverflowError, getargs_b, -1)
174 self.assertEqual(0, getargs_b(0))
175 self.assertEqual(UCHAR_MAX, getargs_b(UCHAR_MAX))
176 self.assertRaises(OverflowError, getargs_b, UCHAR_MAX + 1)
178 self.assertEqual(42, getargs_b(42))
179 self.assertRaises(OverflowError, getargs_b, VERY_LARGE)
181 def test_B(self):
184 self.assertRaises(TypeError, getargs_B, 3.14)
185 self.assertEqual(99, getargs_B(Index()))
186 self.assertEqual(0, getargs_B(IndexIntSubclass()))
187 self.assertRaises(TypeError, getargs_B, BadIndex())
188 with self.assertWarns(DeprecationWarning):
189 self.assertEqual(1, getargs_B(BadIndex2()))
190 self.assertEqual(0, getargs_B(BadIndex3()))
191 self.assertRaises(TypeError, getargs_B, Int())
192 self.assertEqual(0, getargs_B(IntSubclass()))
193 self.assertRaises(TypeError, getargs_B, BadInt())
194 self.assertRaises(TypeError, getargs_B, BadInt2())
195 self.assertEqual(0, getargs_B(BadInt3()))
197 self.assertEqual(UCHAR_MAX, getargs_B(-1))
198 self.assertEqual(0, getargs_B(0))
199 self.assertEqual(UCHAR_MAX, getargs_B(UCHAR_MAX))
200 self.assertEqual(0, getargs_B(UCHAR_MAX+1))
202 self.assertEqual(42, getargs_B(42))
203 self.assertEqual(UCHAR_MAX & VERY_LARGE, getargs_B(VERY_LARGE))
205 def test_H(self):
208 self.assertRaises(TypeError, getargs_H, 3.14)
209 self.assertEqual(99, getargs_H(Index()))
210 self.assertEqual(0, getargs_H(IndexIntSubclass()))
211 self.assertRaises(TypeError, getargs_H, BadIndex())
212 with self.assertWarns(DeprecationWarning):
213 self.assertEqual(1, getargs_H(BadIndex2()))
214 self.assertEqual(0, getargs_H(BadIndex3()))
215 self.assertRaises(TypeError, getargs_H, Int())
216 self.assertEqual(0, getargs_H(IntSubclass()))
217 self.assertRaises(TypeError, getargs_H, BadInt())
218 self.assertRaises(TypeError, getargs_H, BadInt2())
219 self.assertEqual(0, getargs_H(BadInt3()))
221 self.assertEqual(USHRT_MAX, getargs_H(-1))
222 self.assertEqual(0, getargs_H(0))
223 self.assertEqual(USHRT_MAX, getargs_H(USHRT_MAX))
224 self.assertEqual(0, getargs_H(USHRT_MAX+1))
226 self.assertEqual(42, getargs_H(42))
228 self.assertEqual(VERY_LARGE & USHRT_MAX, getargs_H(VERY_LARGE))
230 def test_I(self):
233 self.assertRaises(TypeError, getargs_I, 3.14)
234 self.assertEqual(99, getargs_I(Index()))
235 self.assertEqual(0, getargs_I(IndexIntSubclass()))
236 self.assertRaises(TypeError, getargs_I, BadIndex())
237 with self.assertWarns(DeprecationWarning):
238 self.assertEqual(1, getargs_I(BadIndex2()))
239 self.assertEqual(0, getargs_I(BadIndex3()))
240 self.assertRaises(TypeError, getargs_I, Int())
241 self.assertEqual(0, getargs_I(IntSubclass()))
242 self.assertRaises(TypeError, getargs_I, BadInt())
243 self.assertRaises(TypeError, getargs_I, BadInt2())
244 self.assertEqual(0, getargs_I(BadInt3()))
246 self.assertEqual(UINT_MAX, getargs_I(-1))
247 self.assertEqual(0, getargs_I(0))
248 self.assertEqual(UINT_MAX, getargs_I(UINT_MAX))
249 self.assertEqual(0, getargs_I(UINT_MAX+1))
251 self.assertEqual(42, getargs_I(42))
253 self.assertEqual(VERY_LARGE & UINT_MAX, getargs_I(VERY_LARGE))
255 def test_k(self):
259 self.assertRaises(TypeError, getargs_k, 3.14)
260 self.assertRaises(TypeError, getargs_k, Index())
261 self.assertEqual(0, getargs_k(IndexIntSubclass()))
262 self.assertRaises(TypeError, getargs_k, BadIndex())
263 self.assertRaises(TypeError, getargs_k, BadIndex2())
264 self.assertEqual(0, getargs_k(BadIndex3()))
265 self.assertRaises(TypeError, getargs_k, Int())
266 self.assertEqual(0, getargs_k(IntSubclass()))
267 self.assertRaises(TypeError, getargs_k, BadInt())
268 self.assertRaises(TypeError, getargs_k, BadInt2())
269 self.assertEqual(0, getargs_k(BadInt3()))
271 self.assertEqual(ULONG_MAX, getargs_k(-1))
272 self.assertEqual(0, getargs_k(0))
273 self.assertEqual(ULONG_MAX, getargs_k(ULONG_MAX))
274 self.assertEqual(0, getargs_k(ULONG_MAX+1))
276 self.assertEqual(42, getargs_k(42))
278 self.assertEqual(VERY_LARGE & ULONG_MAX, getargs_k(VERY_LARGE))
281 def test_h(self):
284 self.assertRaises(TypeError, getargs_h, 3.14)
285 self.assertEqual(99, getargs_h(Index()))
286 self.assertEqual(0, getargs_h(IndexIntSubclass()))
287 self.assertRaises(TypeError, getargs_h, BadIndex())
288 with self.assertWarns(DeprecationWarning):
289 self.assertEqual(1, getargs_h(BadIndex2()))
290 self.assertEqual(0, getargs_h(BadIndex3()))
291 self.assertRaises(TypeError, getargs_h, Int())
292 self.assertEqual(0, getargs_h(IntSubclass()))
293 self.assertRaises(TypeError, getargs_h, BadInt())
294 self.assertRaises(TypeError, getargs_h, BadInt2())
295 self.assertEqual(0, getargs_h(BadInt3()))
297 self.assertRaises(OverflowError, getargs_h, SHRT_MIN-1)
298 self.assertEqual(SHRT_MIN, getargs_h(SHRT_MIN))
299 self.assertEqual(SHRT_MAX, getargs_h(SHRT_MAX))
300 self.assertRaises(OverflowError, getargs_h, SHRT_MAX+1)
302 self.assertEqual(42, getargs_h(42))
303 self.assertRaises(OverflowError, getargs_h, VERY_LARGE)
305 def test_i(self):
308 self.assertRaises(TypeError, getargs_i, 3.14)
309 self.assertEqual(99, getargs_i(Index()))
310 self.assertEqual(0, getargs_i(IndexIntSubclass()))
311 self.assertRaises(TypeError, getargs_i, BadIndex())
312 with self.assertWarns(DeprecationWarning):
313 self.assertEqual(1, getargs_i(BadIndex2()))
314 self.assertEqual(0, getargs_i(BadIndex3()))
315 self.assertRaises(TypeError, getargs_i, Int())
316 self.assertEqual(0, getargs_i(IntSubclass()))
317 self.assertRaises(TypeError, getargs_i, BadInt())
318 self.assertRaises(TypeError, getargs_i, BadInt2())
319 self.assertEqual(0, getargs_i(BadInt3()))
321 self.assertRaises(OverflowError, getargs_i, INT_MIN-1)
322 self.assertEqual(INT_MIN, getargs_i(INT_MIN))
323 self.assertEqual(INT_MAX, getargs_i(INT_MAX))
324 self.assertRaises(OverflowError, getargs_i, INT_MAX+1)
326 self.assertEqual(42, getargs_i(42))
327 self.assertRaises(OverflowError, getargs_i, VERY_LARGE)
329 def test_l(self):
332 self.assertRaises(TypeError, getargs_l, 3.14)
333 self.assertEqual(99, getargs_l(Index()))
334 self.assertEqual(0, getargs_l(IndexIntSubclass()))
335 self.assertRaises(TypeError, getargs_l, BadIndex())
336 with self.assertWarns(DeprecationWarning):
337 self.assertEqual(1, getargs_l(BadIndex2()))
338 self.assertEqual(0, getargs_l(BadIndex3()))
339 self.assertRaises(TypeError, getargs_l, Int())
340 self.assertEqual(0, getargs_l(IntSubclass()))
341 self.assertRaises(TypeError, getargs_l, BadInt())
342 self.assertRaises(TypeError, getargs_l, BadInt2())
343 self.assertEqual(0, getargs_l(BadInt3()))
345 self.assertRaises(OverflowError, getargs_l, LONG_MIN-1)
346 self.assertEqual(LONG_MIN, getargs_l(LONG_MIN))
347 self.assertEqual(LONG_MAX, getargs_l(LONG_MAX))
348 self.assertRaises(OverflowError, getargs_l, LONG_MAX+1)
350 self.assertEqual(42, getargs_l(42))
351 self.assertRaises(OverflowError, getargs_l, VERY_LARGE)
353 def test_n(self):
357 self.assertRaises(TypeError, getargs_n, 3.14)
358 self.assertEqual(99, getargs_n(Index()))
359 self.assertEqual(0, getargs_n(IndexIntSubclass()))
360 self.assertRaises(TypeError, getargs_n, BadIndex())
361 with self.assertWarns(DeprecationWarning):
362 self.assertEqual(1, getargs_n(BadIndex2()))
363 self.assertEqual(0, getargs_n(BadIndex3()))
364 self.assertRaises(TypeError, getargs_n, Int())
365 self.assertEqual(0, getargs_n(IntSubclass()))
366 self.assertRaises(TypeError, getargs_n, BadInt())
367 self.assertRaises(TypeError, getargs_n, BadInt2())
368 self.assertEqual(0, getargs_n(BadInt3()))
370 self.assertRaises(OverflowError, getargs_n, PY_SSIZE_T_MIN-1)
371 self.assertEqual(PY_SSIZE_T_MIN, getargs_n(PY_SSIZE_T_MIN))
372 self.assertEqual(PY_SSIZE_T_MAX, getargs_n(PY_SSIZE_T_MAX))
373 self.assertRaises(OverflowError, getargs_n, PY_SSIZE_T_MAX+1)
375 self.assertEqual(42, getargs_n(42))
376 self.assertRaises(OverflowError, getargs_n, VERY_LARGE)
380 def test_L(self):
384 self.assertRaises(TypeError, getargs_L, 3.14)
385 self.assertRaises(TypeError, getargs_L, "Hello")
386 self.assertEqual(99, getargs_L(Index()))
387 self.assertEqual(0, getargs_L(IndexIntSubclass()))
388 self.assertRaises(TypeError, getargs_L, BadIndex())
389 with self.assertWarns(DeprecationWarning):
390 self.assertEqual(1, getargs_L(BadIndex2()))
391 self.assertEqual(0, getargs_L(BadIndex3()))
392 self.assertRaises(TypeError, getargs_L, Int())
393 self.assertEqual(0, getargs_L(IntSubclass()))
394 self.assertRaises(TypeError, getargs_L, BadInt())
395 self.assertRaises(TypeError, getargs_L, BadInt2())
396 self.assertEqual(0, getargs_L(BadInt3()))
398 self.assertRaises(OverflowError, getargs_L, LLONG_MIN-1)
399 self.assertEqual(LLONG_MIN, getargs_L(LLONG_MIN))
400 self.assertEqual(LLONG_MAX, getargs_L(LLONG_MAX))
401 self.assertRaises(OverflowError, getargs_L, LLONG_MAX+1)
403 self.assertEqual(42, getargs_L(42))
404 self.assertRaises(OverflowError, getargs_L, VERY_LARGE)
406 def test_K(self):
409 self.assertRaises(TypeError, getargs_K, 3.14)
410 self.assertRaises(TypeError, getargs_K, Index())
411 self.assertEqual(0, getargs_K(IndexIntSubclass()))
412 self.assertRaises(TypeError, getargs_K, BadIndex())
413 self.assertRaises(TypeError, getargs_K, BadIndex2())
414 self.assertEqual(0, getargs_K(BadIndex3()))
415 self.assertRaises(TypeError, getargs_K, Int())
416 self.assertEqual(0, getargs_K(IntSubclass()))
417 self.assertRaises(TypeError, getargs_K, BadInt())
418 self.assertRaises(TypeError, getargs_K, BadInt2())
419 self.assertEqual(0, getargs_K(BadInt3()))
421 self.assertEqual(ULLONG_MAX, getargs_K(ULLONG_MAX))
422 self.assertEqual(0, getargs_K(0))
423 self.assertEqual(0, getargs_K(ULLONG_MAX+1))
425 self.assertEqual(42, getargs_K(42))
427 self.assertEqual(VERY_LARGE & ULLONG_MAX, getargs_K(VERY_LARGE))
431 def assertEqualWithSign(self, actual, expected):
432 self.assertEqual(actual, expected)
433 self.assertEqual(math.copysign(1, actual), math.copysign(1, expected))
435 def test_f(self):
437 self.assertEqual(getargs_f(4.25), 4.25)
438 self.assertEqual(getargs_f(4), 4.0)
439 self.assertRaises(TypeError, getargs_f, 4.25+0j)
440 self.assertEqual(getargs_f(Float()), 4.25)
441 self.assertEqual(getargs_f(FloatSubclass(7.5)), 7.5)
442 self.assertEqual(getargs_f(FloatSubclass2(7.5)), 7.5)
443 self.assertRaises(TypeError, getargs_f, BadFloat())
444 with self.assertWarns(DeprecationWarning):
445 self.assertEqual(getargs_f(BadFloat2()), 4.25)
446 self.assertEqual(getargs_f(BadFloat3(7.5)), 7.5)
447 self.assertEqual(getargs_f(Index()), 99.0)
448 self.assertRaises(TypeError, getargs_f, Int())
451 self.assertEqual(getargs_f(x), x)
453 self.assertEqual(getargs_f(DBL_MAX), INF)
454 self.assertEqual(getargs_f(-DBL_MAX), -INF)
456 self.assertEqualWithSign(getargs_f(DBL_MIN), 0.0)
457 self.assertEqualWithSign(getargs_f(-DBL_MIN), -0.0)
458 self.assertEqualWithSign(getargs_f(0.0), 0.0)
459 self.assertEqualWithSign(getargs_f(-0.0), -0.0)
461 self.assertNotEqual(r, r)
464 def test_f_rounding(self):
466 self.assertEqual(getargs_f(3.40282356e38), FLT_MAX)
467 self.assertEqual(getargs_f(-3.40282356e38), -FLT_MAX)
469 def test_d(self):
471 self.assertEqual(getargs_d(4.25), 4.25)
472 self.assertEqual(getargs_d(4), 4.0)
473 self.assertRaises(TypeError, getargs_d, 4.25+0j)
474 self.assertEqual(getargs_d(Float()), 4.25)
475 self.assertEqual(getargs_d(FloatSubclass(7.5)), 7.5)
476 self.assertEqual(getargs_d(FloatSubclass2(7.5)), 7.5)
477 self.assertRaises(TypeError, getargs_d, BadFloat())
478 with self.assertWarns(DeprecationWarning):
479 self.assertEqual(getargs_d(BadFloat2()), 4.25)
480 self.assertEqual(getargs_d(BadFloat3(7.5)), 7.5)
481 self.assertEqual(getargs_d(Index()), 99.0)
482 self.assertRaises(TypeError, getargs_d, Int())
485 self.assertEqual(getargs_d(x), x)
486 self.assertRaises(OverflowError, getargs_d, 1<<DBL_MAX_EXP)
487 self.assertRaises(OverflowError, getargs_d, -1<<DBL_MAX_EXP)
488 self.assertEqualWithSign(getargs_d(0.0), 0.0)
489 self.assertEqualWithSign(getargs_d(-0.0), -0.0)
491 self.assertNotEqual(r, r)
493 def test_D(self):
495 self.assertEqual(getargs_D(4.25+0.5j), 4.25+0.5j)
496 self.assertEqual(getargs_D(4.25), 4.25+0j)
497 self.assertEqual(getargs_D(4), 4.0+0j)
498 self.assertEqual(getargs_D(Complex()), 4.25+0.5j)
499 self.assertEqual(getargs_D(ComplexSubclass(7.5+0.25j)), 7.5+0.25j)
500 self.assertEqual(getargs_D(ComplexSubclass2(7.5+0.25j)), 7.5+0.25j)
501 self.assertRaises(TypeError, getargs_D, BadComplex())
502 with self.assertWarns(DeprecationWarning):
503 self.assertEqual(getargs_D(BadComplex2()), 4.25+0.5j)
504 self.assertEqual(getargs_D(BadComplex3(7.5+0.25j)), 7.5+0.25j)
505 self.assertEqual(getargs_D(Index()), 99.0+0j)
506 self.assertRaises(TypeError, getargs_D, Int())
510 self.assertEqual(getargs_D(c), c)
512 self.assertEqual(getargs_D(c), c)
513 self.assertEqualWithSign(getargs_D(complex(0.0, 1.0)).real, 0.0)
514 self.assertEqualWithSign(getargs_D(complex(-0.0, 1.0)).real, -0.0)
515 self.assertEqualWithSign(getargs_D(complex(1.0, 0.0)).imag, 0.0)
516 self.assertEqualWithSign(getargs_D(complex(1.0, -0.0)).imag, -0.0)
521 def __bool__(self):
525 def test_p(self):
527 self.assertEqual(0, getargs_p(False))
528 self.assertEqual(0, getargs_p(None))
529 self.assertEqual(0, getargs_p(0))
530 self.assertEqual(0, getargs_p(0.0))
531 self.assertEqual(0, getargs_p(0j))
532 self.assertEqual(0, getargs_p(''))
533 self.assertEqual(0, getargs_p(()))
534 self.assertEqual(0, getargs_p([]))
535 self.assertEqual(0, getargs_p({}))
537 self.assertEqual(1, getargs_p(True))
538 self.assertEqual(1, getargs_p(1))
539 self.assertEqual(1, getargs_p(1.0))
540 self.assertEqual(1, getargs_p(1j))
541 self.assertEqual(1, getargs_p('x'))
542 self.assertEqual(1, getargs_p((1,)))
543 self.assertEqual(1, getargs_p([1]))
544 self.assertEqual(1, getargs_p({1:2}))
545 self.assertEqual(1, getargs_p(unittest.TestCase))
547 self.assertRaises(NotImplementedError, getargs_p, Paradox())
551 def test_args(self):
555 self.assertEqual(ret, (1, 2))
556 self.assertIs(type(ret), tuple)
559 self.assertEqual(ret, (1, 2, 3))
560 self.assertIs(type(ret), tuple)
563 self.assertEqual(ret, (1, 2))
564 self.assertIs(type(ret), tuple)
567 self.assertEqual(ret, (1, 2))
568 self.assertIs(type(ret), tuple)
571 self.assertIn(ret, ((), None))
572 self.assertIn(type(ret), (tuple, type(None)))
575 self.assertIn(ret, ((), None))
576 self.assertIn(type(ret), (tuple, type(None)))
578 def test_tuple(self):
582 self.assertEqual(ret, (1,2,3))
586 def __len__(self):
588 def __getitem__(self, n):
590 self.assertRaises(TypeError, getargs_tuple, 1, seq())
593 def test_kwargs(self):
597 self.assertEqual(ret, {'a': 1, 'b': 2})
598 self.assertIs(type(ret), dict)
601 self.assertEqual(ret, {'a': 1, 'b': 2, 'c': 3})
602 self.assertIs(type(ret), dict)
605 self.assertEqual(ret, {'a': 1, 'b': 2})
606 self.assertIs(type(ret), dict)
609 self.assertIn(ret, ({}, None))
610 self.assertIn(type(ret), (dict, type(None)))
613 self.assertIn(ret, ({}, None))
614 self.assertIn(type(ret), (dict, type(None)))
616 def test_positional_args(self):
618 self.assertEqual(
623 def test_mixed_args(self):
625 self.assertEqual(
630 def test_keyword_args(self):
632 self.assertEqual(
637 def test_optional_args(self):
639 self.assertEqual(
644 def test_required_args(self):
649 self.assertEqual(
652 self.fail('TypeError should have been raised')
654 def test_too_many_args(self):
658 self.assertEqual(str(err), "function takes at most 5 arguments (6 given)")
660 self.fail('TypeError should have been raised')
662 def test_invalid_keyword(self):
667 self.assertEqual(str(err), "'arg666' is an invalid keyword argument for this function")
669 self.fail('TypeError should have been raised')
671 def test_surrogate_keyword(self):
675 self.assertEqual(str(err), "'\udc80' is an invalid keyword argument for this function")
677 self.fail('TypeError should have been raised')
680 def test_positional_args(self):
682 self.assertEqual(
687 def test_mixed_args(self):
689 self.assertEqual(
694 def test_keyword_args(self):
696 self.assertEqual(
701 def test_optional_args(self):
703 self.assertEqual(
707 self.assertEqual(
712 def test_required_args(self):
713 self.assertEqual(
717 self.assertEqual(
722 with self.assertRaisesRegex(TypeError,
726 with self.assertRaisesRegex(TypeError,
730 def test_too_many_args(self):
731 with self.assertRaisesRegex(TypeError,
735 with self.assertRaisesRegex(TypeError,
739 def test_invalid_keyword(self):
741 with self.assertRaisesRegex(TypeError,
745 def test_surrogate_keyword(self):
746 with self.assertRaisesRegex(TypeError,
750 def test_weird_str_subclass(self):
752 def __eq__(self, other):
754 def __hash__(self):
756 return str.__hash__(self) ^ 3
757 with self.assertRaisesRegex(TypeError,
760 with self.assertRaisesRegex(TypeError,
764 def test_weird_str_subclass2(self):
766 def __eq__(self, other):
768 def __hash__(self):
769 return str.__hash__(self)
770 with self.assertRaisesRegex(TypeError,
773 with self.assertRaisesRegex(TypeError,
781 def test_positional_args(self):
783 self.assertEqual(self.getargs(1, 2, 3), (1, 2, 3))
785 def test_mixed_args(self):
787 self.assertEqual(self.getargs(1, 2, keyword=3), (1, 2, 3))
789 def test_optional_args(self):
791 self.assertEqual(self.getargs(1, 2), (1, 2, -1))
792 self.assertEqual(self.getargs(1, keyword=3), (1, -1, 3))
794 def test_required_args(self):
795 self.assertEqual(self.getargs(1), (1, -1, -1))
797 with self.assertRaisesRegex(TypeError,
799 self.getargs()
801 with self.assertRaisesRegex(TypeError,
803 self.getargs(keyword=3)
805 def test_empty_keyword(self):
806 with self.assertRaisesRegex(TypeError,
808 self.getargs(1, 2, **{'': 666})
812 def test_c(self):
814 self.assertRaises(TypeError, getargs_c, b'abc') # len > 1
815 self.assertEqual(getargs_c(b'a'), 97)
816 self.assertEqual(getargs_c(bytearray(b'a')), 97)
817 self.assertRaises(TypeError, getargs_c, memoryview(b'a'))
818 self.assertRaises(TypeError, getargs_c, 's')
819 self.assertRaises(TypeError, getargs_c, 97)
820 self.assertRaises(TypeError, getargs_c, None)
822 def test_y(self):
824 self.assertRaises(TypeError, getargs_y, 'abc\xe9')
825 self.assertEqual(getargs_y(b'bytes'), b'bytes')
826 self.assertRaises(ValueError, getargs_y, b'nul:\0')
827 self.assertRaises(TypeError, getargs_y, bytearray(b'bytearray'))
828 self.assertRaises(TypeError, getargs_y, memoryview(b'memoryview'))
829 self.assertRaises(TypeError, getargs_y, None)
831 def test_y_star(self):
833 self.assertRaises(TypeError, getargs_y_star, 'abc\xe9')
834 self.assertEqual(getargs_y_star(b'bytes'), b'bytes')
835 self.assertEqual(getargs_y_star(b'nul:\0'), b'nul:\0')
836 self.assertEqual(getargs_y_star(bytearray(b'bytearray')), b'bytearray')
837 self.assertEqual(getargs_y_star(memoryview(b'memoryview')), b'memoryview')
838 self.assertRaises(TypeError, getargs_y_star, None)
840 def test_y_hash(self):
842 self.assertRaises(TypeError, getargs_y_hash, 'abc\xe9')
843 self.assertEqual(getargs_y_hash(b'bytes'), b'bytes')
844 self.assertEqual(getargs_y_hash(b'nul:\0'), b'nul:\0')
845 self.assertRaises(TypeError, getargs_y_hash, bytearray(b'bytearray'))
846 self.assertRaises(TypeError, getargs_y_hash, memoryview(b'memoryview'))
847 self.assertRaises(TypeError, getargs_y_hash, None)
849 def test_w_star(self):
852 self.assertRaises(TypeError, getargs_w_star, 'abc\xe9')
853 self.assertRaises(TypeError, getargs_w_star, b'bytes')
854 self.assertRaises(TypeError, getargs_w_star, b'nul:\0')
855 self.assertRaises(TypeError, getargs_w_star, memoryview(b'bytes'))
857 self.assertEqual(getargs_w_star(buf), b'[ytearra]')
858 self.assertEqual(buf, bytearray(b'[ytearra]'))
860 self.assertEqual(getargs_w_star(memoryview(buf)), b'[emoryvie]')
861 self.assertEqual(buf, bytearray(b'[emoryvie]'))
862 self.assertRaises(TypeError, getargs_w_star, None)
866 def test_C(self):
868 self.assertRaises(TypeError, getargs_C, 'abc') # len > 1
869 self.assertEqual(getargs_C('a'), 97)
870 self.assertEqual(getargs_C('\u20ac'), 0x20ac)
871 self.assertEqual(getargs_C('\U0001f40d'), 0x1f40d)
872 self.assertRaises(TypeError, getargs_C, b'a')
873 self.assertRaises(TypeError, getargs_C, bytearray(b'a'))
874 self.assertRaises(TypeError, getargs_C, memoryview(b'a'))
875 self.assertRaises(TypeError, getargs_C, 97)
876 self.assertRaises(TypeError, getargs_C, None)
878 def test_s(self):
880 self.assertEqual(getargs_s('abc\xe9'), b'abc\xc3\xa9')
881 self.assertRaises(ValueError, getargs_s, 'nul:\0')
882 self.assertRaises(TypeError, getargs_s, b'bytes')
883 self.assertRaises(TypeError, getargs_s, bytearray(b'bytearray'))
884 self.assertRaises(TypeError, getargs_s, memoryview(b'memoryview'))
885 self.assertRaises(TypeError, getargs_s, None)
887 def test_s_star(self):
889 self.assertEqual(getargs_s_star('abc\xe9'), b'abc\xc3\xa9')
890 self.assertEqual(getargs_s_star('nul:\0'), b'nul:\0')
891 self.assertEqual(getargs_s_star(b'bytes'), b'bytes')
892 self.assertEqual(getargs_s_star(bytearray(b'bytearray')), b'bytearray')
893 self.assertEqual(getargs_s_star(memoryview(b'memoryview')), b'memoryview')
894 self.assertRaises(TypeError, getargs_s_star, None)
896 def test_s_hash(self):
898 self.assertEqual(getargs_s_hash('abc\xe9'), b'abc\xc3\xa9')
899 self.assertEqual(getargs_s_hash('nul:\0'), b'nul:\0')
900 self.assertEqual(getargs_s_hash(b'bytes'), b'bytes')
901 self.assertRaises(TypeError, getargs_s_hash, bytearray(b'bytearray'))
902 self.assertRaises(TypeError, getargs_s_hash, memoryview(b'memoryview'))
903 self.assertRaises(TypeError, getargs_s_hash, None)
905 def test_s_hash_int(self):
910 self.assertRaises(SystemError, getargs_s_hash_int, buf, "abc")
911 self.assertRaises(SystemError, getargs_s_hash_int, buf, x=42)
912 self.assertRaises(SystemError, getargs_s_hash_int, buf, x="abc")
913 self.assertRaises(SystemError, getargs_s_hash_int2, buf, ("abc",))
914 self.assertRaises(SystemError, getargs_s_hash_int2, buf, x=42)
915 self.assertRaises(SystemError, getargs_s_hash_int2, buf, x="abc")
922 def test_z(self):
924 self.assertEqual(getargs_z('abc\xe9'), b'abc\xc3\xa9')
925 self.assertRaises(ValueError, getargs_z, 'nul:\0')
926 self.assertRaises(TypeError, getargs_z, b'bytes')
927 self.assertRaises(TypeError, getargs_z, bytearray(b'bytearray'))
928 self.assertRaises(TypeError, getargs_z, memoryview(b'memoryview'))
929 self.assertIsNone(getargs_z(None))
931 def test_z_star(self):
933 self.assertEqual(getargs_z_star('abc\xe9'), b'abc\xc3\xa9')
934 self.assertEqual(getargs_z_star('nul:\0'), b'nul:\0')
935 self.assertEqual(getargs_z_star(b'bytes'), b'bytes')
936 self.assertEqual(getargs_z_star(bytearray(b'bytearray')), b'bytearray')
937 self.assertEqual(getargs_z_star(memoryview(b'memoryview')), b'memoryview')
938 self.assertIsNone(getargs_z_star(None))
940 def test_z_hash(self):
942 self.assertEqual(getargs_z_hash('abc\xe9'), b'abc\xc3\xa9')
943 self.assertEqual(getargs_z_hash('nul:\0'), b'nul:\0')
944 self.assertEqual(getargs_z_hash(b'bytes'), b'bytes')
945 self.assertRaises(TypeError, getargs_z_hash, bytearray(b'bytearray'))
946 self.assertRaises(TypeError, getargs_z_hash, memoryview(b'memoryview'))
947 self.assertIsNone(getargs_z_hash(None))
949 def test_es(self):
951 self.assertEqual(getargs_es('abc\xe9'), b'abc\xc3\xa9')
952 self.assertEqual(getargs_es('abc\xe9', 'latin1'), b'abc\xe9')
953 self.assertRaises(UnicodeEncodeError, getargs_es, 'abc\xe9', 'ascii')
954 self.assertRaises(LookupError, getargs_es, 'abc\xe9', 'spam')
955 self.assertRaises(TypeError, getargs_es, b'bytes', 'latin1')
956 self.assertRaises(TypeError, getargs_es, bytearray(b'bytearray'), 'latin1')
957 self.assertRaises(TypeError, getargs_es, memoryview(b'memoryview'), 'latin1')
958 self.assertRaises(TypeError, getargs_es, None, 'latin1')
959 self.assertRaises(TypeError, getargs_es, 'nul:\0', 'latin1')
961 def test_et(self):
963 self.assertEqual(getargs_et('abc\xe9'), b'abc\xc3\xa9')
964 self.assertEqual(getargs_et('abc\xe9', 'latin1'), b'abc\xe9')
965 self.assertRaises(UnicodeEncodeError, getargs_et, 'abc\xe9', 'ascii')
966 self.assertRaises(LookupError, getargs_et, 'abc\xe9', 'spam')
967 self.assertEqual(getargs_et(b'bytes', 'latin1'), b'bytes')
968 self.assertEqual(getargs_et(bytearray(b'bytearray'), 'latin1'), b'bytearray')
969 self.assertRaises(TypeError, getargs_et, memoryview(b'memoryview'), 'latin1')
970 self.assertRaises(TypeError, getargs_et, None, 'latin1')
971 self.assertRaises(TypeError, getargs_et, 'nul:\0', 'latin1')
972 self.assertRaises(TypeError, getargs_et, b'nul:\0', 'latin1')
973 self.assertRaises(TypeError, getargs_et, bytearray(b'nul:\0'), 'latin1')
975 def test_es_hash(self):
977 self.assertEqual(getargs_es_hash('abc\xe9'), b'abc\xc3\xa9')
978 self.assertEqual(getargs_es_hash('abc\xe9', 'latin1'), b'abc\xe9')
979 self.assertRaises(UnicodeEncodeError, getargs_es_hash, 'abc\xe9', 'ascii')
980 self.assertRaises(LookupError, getargs_es_hash, 'abc\xe9', 'spam')
981 self.assertRaises(TypeError, getargs_es_hash, b'bytes', 'latin1')
982 self.assertRaises(TypeError, getargs_es_hash, bytearray(b'bytearray'), 'latin1')
983 self.assertRaises(TypeError, getargs_es_hash, memoryview(b'memoryview'), 'latin1')
984 self.assertRaises(TypeError, getargs_es_hash, None, 'latin1')
985 self.assertEqual(getargs_es_hash('nul:\0', 'latin1'), b'nul:\0')
988 self.assertEqual(getargs_es_hash('abc\xe9', 'latin1', buf), b'abc\xe9')
989 self.assertEqual(buf, bytearray(b'abc\xe9\x00xxx'))
991 self.assertEqual(getargs_es_hash('abc\xe9', 'latin1', buf), b'abc\xe9')
992 self.assertEqual(buf, bytearray(b'abc\xe9\x00'))
994 self.assertRaises(ValueError, getargs_es_hash, 'abc\xe9', 'latin1', buf)
995 self.assertEqual(buf, bytearray(b'x'*4))
997 self.assertRaises(ValueError, getargs_es_hash, 'abc\xe9', 'latin1', buf)
999 def test_et_hash(self):
1001 self.assertEqual(getargs_et_hash('abc\xe9'), b'abc\xc3\xa9')
1002 self.assertEqual(getargs_et_hash('abc\xe9', 'latin1'), b'abc\xe9')
1003 self.assertRaises(UnicodeEncodeError, getargs_et_hash, 'abc\xe9', 'ascii')
1004 self.assertRaises(LookupError, getargs_et_hash, 'abc\xe9', 'spam')
1005 self.assertEqual(getargs_et_hash(b'bytes', 'latin1'), b'bytes')
1006 self.assertEqual(getargs_et_hash(bytearray(b'bytearray'), 'latin1'), b'bytearray')
1007 self.assertRaises(TypeError, getargs_et_hash, memoryview(b'memoryview'), 'latin1')
1008 self.assertRaises(TypeError, getargs_et_hash, None, 'latin1')
1009 self.assertEqual(getargs_et_hash('nul:\0', 'latin1'), b'nul:\0')
1010 self.assertEqual(getargs_et_hash(b'nul:\0', 'latin1'), b'nul:\0')
1011 self.assertEqual(getargs_et_hash(bytearray(b'nul:\0'), 'latin1'), b'nul:\0')
1014 self.assertEqual(getargs_et_hash('abc\xe9', 'latin1', buf), b'abc\xe9')
1015 self.assertEqual(buf, bytearray(b'abc\xe9\x00xxx'))
1017 self.assertEqual(getargs_et_hash('abc\xe9', 'latin1', buf), b'abc\xe9')
1018 self.assertEqual(buf, bytearray(b'abc\xe9\x00'))
1020 self.assertRaises(ValueError, getargs_et_hash, 'abc\xe9', 'latin1', buf)
1021 self.assertEqual(buf, bytearray(b'x'*4))
1023 self.assertRaises(ValueError, getargs_et_hash, 'abc\xe9', 'latin1', buf)
1026 def test_u(self):
1028 with self.assertWarns(DeprecationWarning):
1029 self.assertEqual(getargs_u('abc\xe9'), 'abc\xe9')
1030 with self.assertWarns(DeprecationWarning):
1031 self.assertRaises(ValueError, getargs_u, 'nul:\0')
1032 with self.assertWarns(DeprecationWarning):
1033 self.assertRaises(TypeError, getargs_u, b'bytes')
1034 with self.assertWarns(DeprecationWarning):
1035 self.assertRaises(TypeError, getargs_u, bytearray(b'bytearray'))
1036 with self.assertWarns(DeprecationWarning):
1037 self.assertRaises(TypeError, getargs_u, memoryview(b'memoryview'))
1038 with self.assertWarns(DeprecationWarning):
1039 self.assertRaises(TypeError, getargs_u, None)
1042 self.assertRaises(DeprecationWarning, getargs_u, 'abc\xe9')
1045 def test_u_hash(self):
1047 with self.assertWarns(DeprecationWarning):
1048 self.assertEqual(getargs_u_hash('abc\xe9'), 'abc\xe9')
1049 with self.assertWarns(DeprecationWarning):
1050 self.assertEqual(getargs_u_hash('nul:\0'), 'nul:\0')
1051 with self.assertWarns(DeprecationWarning):
1052 self.assertRaises(TypeError, getargs_u_hash, b'bytes')
1053 with self.assertWarns(DeprecationWarning):
1054 self.assertRaises(TypeError, getargs_u_hash, bytearray(b'bytearray'))
1055 with self.assertWarns(DeprecationWarning):
1056 self.assertRaises(TypeError, getargs_u_hash, memoryview(b'memoryview'))
1057 with self.assertWarns(DeprecationWarning):
1058 self.assertRaises(TypeError, getargs_u_hash, None)
1061 self.assertRaises(DeprecationWarning, getargs_u_hash, 'abc\xe9')
1064 def test_Z(self):
1066 with self.assertWarns(DeprecationWarning):
1067 self.assertEqual(getargs_Z('abc\xe9'), 'abc\xe9')
1068 with self.assertWarns(DeprecationWarning):
1069 self.assertRaises(ValueError, getargs_Z, 'nul:\0')
1070 with self.assertWarns(DeprecationWarning):
1071 self.assertRaises(TypeError, getargs_Z, b'bytes')
1072 with self.assertWarns(DeprecationWarning):
1073 self.assertRaises(TypeError, getargs_Z, bytearray(b'bytearray'))
1074 with self.assertWarns(DeprecationWarning):
1075 self.assertRaises(TypeError, getargs_Z, memoryview(b'memoryview'))
1076 with self.assertWarns(DeprecationWarning):
1077 self.assertIsNone(getargs_Z(None))
1080 self.assertRaises(DeprecationWarning, getargs_Z, 'abc\xe9')
1083 def test_Z_hash(self):
1085 with self.assertWarns(DeprecationWarning):
1086 self.assertEqual(getargs_Z_hash('abc\xe9'), 'abc\xe9')
1087 with self.assertWarns(DeprecationWarning):
1088 self.assertEqual(getargs_Z_hash('nul:\0'), 'nul:\0')
1089 with self.assertWarns(DeprecationWarning):
1090 self.assertRaises(TypeError, getargs_Z_hash, b'bytes')
1091 with self.assertWarns(DeprecationWarning):
1092 self.assertRaises(TypeError, getargs_Z_hash, bytearray(b'bytearray'))
1093 with self.assertWarns(DeprecationWarning):
1094 self.assertRaises(TypeError, getargs_Z_hash, memoryview(b'memoryview'))
1095 with self.assertWarns(DeprecationWarning):
1096 self.assertIsNone(getargs_Z_hash(None))
1099 self.assertRaises(DeprecationWarning, getargs_Z_hash, 'abc\xe9')
1101 def test_gh_99240_clear_args(self):
1103 self.assertRaises(TypeError, gh_99240_clear_args, 'a', '\0b')
1107 def test_S(self):
1110 self.assertIs(getargs_S(obj), obj)
1111 self.assertRaises(TypeError, getargs_S, bytearray(b'bytearray'))
1112 self.assertRaises(TypeError, getargs_S, 'str')
1113 self.assertRaises(TypeError, getargs_S, None)
1114 self.assertRaises(TypeError, getargs_S, memoryview(obj))
1116 def test_Y(self):
1119 self.assertIs(getargs_Y(obj), obj)
1120 self.assertRaises(TypeError, getargs_Y, b'bytes')
1121 self.assertRaises(TypeError, getargs_Y, 'str')
1122 self.assertRaises(TypeError, getargs_Y, None)
1123 self.assertRaises(TypeError, getargs_Y, memoryview(obj))
1125 def test_U(self):
1128 self.assertIs(getargs_U(obj), obj)
1129 self.assertRaises(TypeError, getargs_U, b'bytes')
1130 self.assertRaises(TypeError, getargs_U, bytearray(b'bytearray'))
1131 self.assertRaises(TypeError, getargs_U, None)
1136 def test(self):
1137 self.assertEqual(_testcapi.argparsing("Hello", "World"), 1)
1144 def test_skipitem(self):
1210 self.assertIs(when_skipped, when_not_skipped, message)
1212 def test_skipitem_with_suffix(self):
1223 with self.subTest(format=f):
1228 with self.assertRaisesRegex(SystemError,
1235 with self.subTest(format=f):
1239 with self.assertRaisesRegex(SystemError,
1246 def test_parse_tuple_and_keywords(self):
1248 self.assertRaises(TypeError, _testcapi.parse_tuple_and_keywords,
1250 self.assertRaises(ValueError, _testcapi.parse_tuple_and_keywords,
1252 self.assertRaises(ValueError, _testcapi.parse_tuple_and_keywords,
1254 self.assertRaises(ValueError, _testcapi.parse_tuple_and_keywords,
1257 def test_bad_use(self):
1260 self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords,
1262 self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords,
1264 self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords,
1266 self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords,
1268 self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords,
1270 self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords,
1272 self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords,
1274 self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords,
1276 self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords,
1278 self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords,
1281 def test_positional_only(self):
1286 with self.assertRaisesRegex(TypeError,
1290 with self.assertRaisesRegex(TypeError,
1294 with self.assertRaisesRegex(TypeError,
1298 with self.assertRaisesRegex(TypeError,
1301 with self.assertRaisesRegex(SystemError, r'Empty parameter name after \$'):
1303 with self.assertRaisesRegex(SystemError, 'Empty keyword'):
1313 def test_u_code(self):
1317 def test_Z_code(self):