1import unittest
2import math
3import string
4import sys
5import warnings
6from test import support
7from test.support import import_helper
8from test.support import warnings_helper
9# Skip this test if the _testcapi module isn't available.
10_testcapi = import_helper.import_module('_testcapi')
11from _testcapi import getargs_keywords, getargs_keyword_only
12
13# > How about the following counterproposal. This also changes some of
14# > the other format codes to be a little more regular.
15# >
16# > Code C type Range check
17# >
18# > b unsigned char 0..UCHAR_MAX
19# > h signed short SHRT_MIN..SHRT_MAX
20# > B unsigned char none **
21# > H unsigned short none **
22# > k * unsigned long none
23# > I * unsigned int 0..UINT_MAX
24#
25#
26# > i int INT_MIN..INT_MAX
27# > l long LONG_MIN..LONG_MAX
28#
29# > K * unsigned long long none
30# > L long long LLONG_MIN..LLONG_MAX
31#
32# > Notes:
33# >
34# > * New format codes.
35# >
36# > ** Changed from previous "range-and-a-half" to "none"; the
37# > range-and-a-half checking wasn't particularly useful.
38#
39# Plus a C API or two, e.g. PyLong_AsUnsignedLongMask() ->
40# unsigned long and PyLong_AsUnsignedLongLongMask() -> unsigned
41# long long (if that exists).
42
43LARGE = 0x7FFFFFFF
44VERY_LARGE = 0xFF0000121212121212121242
45
46from _testcapi import UCHAR_MAX, USHRT_MAX, UINT_MAX, ULONG_MAX, INT_MAX, \
47     INT_MIN, LONG_MIN, LONG_MAX, PY_SSIZE_T_MIN, PY_SSIZE_T_MAX, \
48     SHRT_MIN, SHRT_MAX, FLT_MIN, FLT_MAX, DBL_MIN, DBL_MAX
49
50DBL_MAX_EXP = sys.float_info.max_exp
51INF = float('inf')
52NAN = float('nan')
53
54# fake, they are not defined in Python's header files
55LLONG_MAX = 2**63-1
56LLONG_MIN = -2**63
57ULLONG_MAX = 2**64-1
58
59class Index:
60    def __index__(self):
61        return 99
62
63class IndexIntSubclass(int):
64    def __index__(self):
65        return 99
66
67class BadIndex:
68    def __index__(self):
69        return 1.0
70
71class BadIndex2:
72    def __index__(self):
73        return True
74
75class BadIndex3(int):
76    def __index__(self):
77        return True
78
79
80class Int:
81    def __int__(self):
82        return 99
83
84class IntSubclass(int):
85    def __int__(self):
86        return 99
87
88class BadInt:
89    def __int__(self):
90        return 1.0
91
92class BadInt2:
93    def __int__(self):
94        return True
95
96class BadInt3(int):
97    def __int__(self):
98        return True
99
100
101class Float:
102    def __float__(self):
103        return 4.25
104
105class FloatSubclass(float):
106    pass
107
108class FloatSubclass2(float):
109    def __float__(self):
110        return 4.25
111
112class BadFloat:
113    def __float__(self):
114        return 687
115
116class BadFloat2:
117    def __float__(self):
118        return FloatSubclass(4.25)
119
120class BadFloat3(float):
121    def __float__(self):
122        return FloatSubclass(4.25)
123
124
125class Complex:
126    def __complex__(self):
127        return 4.25+0.5j
128
129class ComplexSubclass(complex):
130    pass
131
132class ComplexSubclass2(complex):
133    def __complex__(self):
134        return 4.25+0.5j
135
136class BadComplex:
137    def __complex__(self):
138        return 1.25
139
140class BadComplex2:
141    def __complex__(self):
142        return ComplexSubclass(4.25+0.5j)
143
144class BadComplex3(complex):
145    def __complex__(self):
146        return ComplexSubclass(4.25+0.5j)
147
148
149class TupleSubclass(tuple):
150    pass
151
152class DictSubclass(dict):
153    pass
154
155
156class Unsigned_TestCase(unittest.TestCase):
157    def test_b(self):
158        from _testcapi import getargs_b
159        # b returns 'unsigned char', and does range checking (0 ... UCHAR_MAX)
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()))
172
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)
177
178        self.assertEqual(42, getargs_b(42))
179        self.assertRaises(OverflowError, getargs_b, VERY_LARGE)
180
181    def test_B(self):
182        from _testcapi import getargs_B
183        # B returns 'unsigned char', no range checking
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()))
196
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))
201
202        self.assertEqual(42, getargs_B(42))
203        self.assertEqual(UCHAR_MAX & VERY_LARGE, getargs_B(VERY_LARGE))
204
205    def test_H(self):
206        from _testcapi import getargs_H
207        # H returns 'unsigned short', no range checking
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()))
220
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))
225
226        self.assertEqual(42, getargs_H(42))
227
228        self.assertEqual(VERY_LARGE & USHRT_MAX, getargs_H(VERY_LARGE))
229
230    def test_I(self):
231        from _testcapi import getargs_I
232        # I returns 'unsigned int', no range checking
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()))
245
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))
250
251        self.assertEqual(42, getargs_I(42))
252
253        self.assertEqual(VERY_LARGE & UINT_MAX, getargs_I(VERY_LARGE))
254
255    def test_k(self):
256        from _testcapi import getargs_k
257        # k returns 'unsigned long', no range checking
258        # it does not accept float, or instances with __int__
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()))
270
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))
275
276        self.assertEqual(42, getargs_k(42))
277
278        self.assertEqual(VERY_LARGE & ULONG_MAX, getargs_k(VERY_LARGE))
279
280class Signed_TestCase(unittest.TestCase):
281    def test_h(self):
282        from _testcapi import getargs_h
283        # h returns 'short', and does range checking (SHRT_MIN ... SHRT_MAX)
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()))
296
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)
301
302        self.assertEqual(42, getargs_h(42))
303        self.assertRaises(OverflowError, getargs_h, VERY_LARGE)
304
305    def test_i(self):
306        from _testcapi import getargs_i
307        # i returns 'int', and does range checking (INT_MIN ... INT_MAX)
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()))
320
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)
325
326        self.assertEqual(42, getargs_i(42))
327        self.assertRaises(OverflowError, getargs_i, VERY_LARGE)
328
329    def test_l(self):
330        from _testcapi import getargs_l
331        # l returns 'long', and does range checking (LONG_MIN ... LONG_MAX)
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()))
344
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)
349
350        self.assertEqual(42, getargs_l(42))
351        self.assertRaises(OverflowError, getargs_l, VERY_LARGE)
352
353    def test_n(self):
354        from _testcapi import getargs_n
355        # n returns 'Py_ssize_t', and does range checking
356        # (PY_SSIZE_T_MIN ... PY_SSIZE_T_MAX)
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()))
369
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)
374
375        self.assertEqual(42, getargs_n(42))
376        self.assertRaises(OverflowError, getargs_n, VERY_LARGE)
377
378
379class LongLong_TestCase(unittest.TestCase):
380    def test_L(self):
381        from _testcapi import getargs_L
382        # L returns 'long long', and does range checking (LLONG_MIN
383        # ... LLONG_MAX)
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()))
397
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)
402
403        self.assertEqual(42, getargs_L(42))
404        self.assertRaises(OverflowError, getargs_L, VERY_LARGE)
405
406    def test_K(self):
407        from _testcapi import getargs_K
408        # K return 'unsigned long long', no range checking
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()))
420
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))
424
425        self.assertEqual(42, getargs_K(42))
426
427        self.assertEqual(VERY_LARGE & ULLONG_MAX, getargs_K(VERY_LARGE))
428
429
430class Float_TestCase(unittest.TestCase):
431    def assertEqualWithSign(self, actual, expected):
432        self.assertEqual(actual, expected)
433        self.assertEqual(math.copysign(1, actual), math.copysign(1, expected))
434
435    def test_f(self):
436        from _testcapi import getargs_f
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())
449
450        for x in (FLT_MIN, -FLT_MIN, FLT_MAX, -FLT_MAX, INF, -INF):
451            self.assertEqual(getargs_f(x), x)
452        if FLT_MAX < DBL_MAX:
453            self.assertEqual(getargs_f(DBL_MAX), INF)
454            self.assertEqual(getargs_f(-DBL_MAX), -INF)
455        if FLT_MIN > DBL_MIN:
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)
460        r = getargs_f(NAN)
461        self.assertNotEqual(r, r)
462
463    @support.requires_IEEE_754
464    def test_f_rounding(self):
465        from _testcapi import getargs_f
466        self.assertEqual(getargs_f(3.40282356e38), FLT_MAX)
467        self.assertEqual(getargs_f(-3.40282356e38), -FLT_MAX)
468
469    def test_d(self):
470        from _testcapi import getargs_d
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())
483
484        for x in (DBL_MIN, -DBL_MIN, DBL_MAX, -DBL_MAX, INF, -INF):
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)
490        r = getargs_d(NAN)
491        self.assertNotEqual(r, r)
492
493    def test_D(self):
494        from _testcapi import getargs_D
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())
507
508        for x in (DBL_MIN, -DBL_MIN, DBL_MAX, -DBL_MAX, INF, -INF):
509            c = complex(x, 1.0)
510            self.assertEqual(getargs_D(c), c)
511            c = complex(1.0, x)
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)
517
518
519class Paradox:
520    "This statement is false."
521    def __bool__(self):
522        raise NotImplementedError
523
524class Boolean_TestCase(unittest.TestCase):
525    def test_p(self):
526        from _testcapi import getargs_p
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({}))
536
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))
546
547        self.assertRaises(NotImplementedError, getargs_p, Paradox())
548
549
550class Tuple_TestCase(unittest.TestCase):
551    def test_args(self):
552        from _testcapi import get_args
553
554        ret = get_args(1, 2)
555        self.assertEqual(ret, (1, 2))
556        self.assertIs(type(ret), tuple)
557
558        ret = get_args(1, *(2, 3))
559        self.assertEqual(ret, (1, 2, 3))
560        self.assertIs(type(ret), tuple)
561
562        ret = get_args(*[1, 2])
563        self.assertEqual(ret, (1, 2))
564        self.assertIs(type(ret), tuple)
565
566        ret = get_args(*TupleSubclass([1, 2]))
567        self.assertEqual(ret, (1, 2))
568        self.assertIs(type(ret), tuple)
569
570        ret = get_args()
571        self.assertIn(ret, ((), None))
572        self.assertIn(type(ret), (tuple, type(None)))
573
574        ret = get_args(*())
575        self.assertIn(ret, ((), None))
576        self.assertIn(type(ret), (tuple, type(None)))
577
578    def test_tuple(self):
579        from _testcapi import getargs_tuple
580
581        ret = getargs_tuple(1, (2, 3))
582        self.assertEqual(ret, (1,2,3))
583
584        # make sure invalid tuple arguments are handled correctly
585        class seq:
586            def __len__(self):
587                return 2
588            def __getitem__(self, n):
589                raise ValueError
590        self.assertRaises(TypeError, getargs_tuple, 1, seq())
591
592class Keywords_TestCase(unittest.TestCase):
593    def test_kwargs(self):
594        from _testcapi import get_kwargs
595
596        ret = get_kwargs(a=1, b=2)
597        self.assertEqual(ret, {'a': 1, 'b': 2})
598        self.assertIs(type(ret), dict)
599
600        ret = get_kwargs(a=1, **{'b': 2, 'c': 3})
601        self.assertEqual(ret, {'a': 1, 'b': 2, 'c': 3})
602        self.assertIs(type(ret), dict)
603
604        ret = get_kwargs(**DictSubclass({'a': 1, 'b': 2}))
605        self.assertEqual(ret, {'a': 1, 'b': 2})
606        self.assertIs(type(ret), dict)
607
608        ret = get_kwargs()
609        self.assertIn(ret, ({}, None))
610        self.assertIn(type(ret), (dict, type(None)))
611
612        ret = get_kwargs(**{})
613        self.assertIn(ret, ({}, None))
614        self.assertIn(type(ret), (dict, type(None)))
615
616    def test_positional_args(self):
617        # using all positional args
618        self.assertEqual(
619            getargs_keywords((1,2), 3, (4,(5,6)), (7,8,9), 10),
620            (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
621            )
622
623    def test_mixed_args(self):
624        # positional and keyword args
625        self.assertEqual(
626            getargs_keywords((1,2), 3, (4,(5,6)), arg4=(7,8,9), arg5=10),
627            (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
628            )
629
630    def test_keyword_args(self):
631        # all keywords
632        self.assertEqual(
633            getargs_keywords(arg1=(1,2), arg2=3, arg3=(4,(5,6)), arg4=(7,8,9), arg5=10),
634            (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
635            )
636
637    def test_optional_args(self):
638        # missing optional keyword args, skipping tuples
639        self.assertEqual(
640            getargs_keywords(arg1=(1,2), arg2=3, arg5=10),
641            (1, 2, 3, -1, -1, -1, -1, -1, -1, 10)
642            )
643
644    def test_required_args(self):
645        # required arg missing
646        try:
647            getargs_keywords(arg1=(1,2))
648        except TypeError as err:
649            self.assertEqual(
650                str(err), "function missing required argument 'arg2' (pos 2)")
651        else:
652            self.fail('TypeError should have been raised')
653
654    def test_too_many_args(self):
655        try:
656            getargs_keywords((1,2),3,(4,(5,6)),(7,8,9),10,111)
657        except TypeError as err:
658            self.assertEqual(str(err), "function takes at most 5 arguments (6 given)")
659        else:
660            self.fail('TypeError should have been raised')
661
662    def test_invalid_keyword(self):
663        # extraneous keyword arg
664        try:
665            getargs_keywords((1,2),3,arg5=10,arg666=666)
666        except TypeError as err:
667            self.assertEqual(str(err), "'arg666' is an invalid keyword argument for this function")
668        else:
669            self.fail('TypeError should have been raised')
670
671    def test_surrogate_keyword(self):
672        try:
673            getargs_keywords((1,2), 3, (4,(5,6)), (7,8,9), **{'\uDC80': 10})
674        except TypeError as err:
675            self.assertEqual(str(err), "'\udc80' is an invalid keyword argument for this function")
676        else:
677            self.fail('TypeError should have been raised')
678
679class KeywordOnly_TestCase(unittest.TestCase):
680    def test_positional_args(self):
681        # using all possible positional args
682        self.assertEqual(
683            getargs_keyword_only(1, 2),
684            (1, 2, -1)
685            )
686
687    def test_mixed_args(self):
688        # positional and keyword args
689        self.assertEqual(
690            getargs_keyword_only(1, 2, keyword_only=3),
691            (1, 2, 3)
692            )
693
694    def test_keyword_args(self):
695        # all keywords
696        self.assertEqual(
697            getargs_keyword_only(required=1, optional=2, keyword_only=3),
698            (1, 2, 3)
699            )
700
701    def test_optional_args(self):
702        # missing optional keyword args, skipping tuples
703        self.assertEqual(
704            getargs_keyword_only(required=1, optional=2),
705            (1, 2, -1)
706            )
707        self.assertEqual(
708            getargs_keyword_only(required=1, keyword_only=3),
709            (1, -1, 3)
710            )
711
712    def test_required_args(self):
713        self.assertEqual(
714            getargs_keyword_only(1),
715            (1, -1, -1)
716            )
717        self.assertEqual(
718            getargs_keyword_only(required=1),
719            (1, -1, -1)
720            )
721        # required arg missing
722        with self.assertRaisesRegex(TypeError,
723            r"function missing required argument 'required' \(pos 1\)"):
724            getargs_keyword_only(optional=2)
725
726        with self.assertRaisesRegex(TypeError,
727            r"function missing required argument 'required' \(pos 1\)"):
728            getargs_keyword_only(keyword_only=3)
729
730    def test_too_many_args(self):
731        with self.assertRaisesRegex(TypeError,
732            r"function takes at most 2 positional arguments \(3 given\)"):
733            getargs_keyword_only(1, 2, 3)
734
735        with self.assertRaisesRegex(TypeError,
736            r"function takes at most 3 arguments \(4 given\)"):
737            getargs_keyword_only(1, 2, 3, keyword_only=5)
738
739    def test_invalid_keyword(self):
740        # extraneous keyword arg
741        with self.assertRaisesRegex(TypeError,
742            "'monster' is an invalid keyword argument for this function"):
743            getargs_keyword_only(1, 2, monster=666)
744
745    def test_surrogate_keyword(self):
746        with self.assertRaisesRegex(TypeError,
747            "'\udc80' is an invalid keyword argument for this function"):
748            getargs_keyword_only(1, 2, **{'\uDC80': 10})
749
750    def test_weird_str_subclass(self):
751        class BadStr(str):
752            def __eq__(self, other):
753                return True
754            def __hash__(self):
755                # Guaranteed different hash
756                return str.__hash__(self) ^ 3
757        with self.assertRaisesRegex(TypeError,
758            "invalid keyword argument for this function"):
759            getargs_keyword_only(1, 2, **{BadStr("keyword_only"): 3})
760        with self.assertRaisesRegex(TypeError,
761            "invalid keyword argument for this function"):
762            getargs_keyword_only(1, 2, **{BadStr("monster"): 666})
763
764    def test_weird_str_subclass2(self):
765        class BadStr(str):
766            def __eq__(self, other):
767                return False
768            def __hash__(self):
769                return str.__hash__(self)
770        with self.assertRaisesRegex(TypeError,
771            "invalid keyword argument for this function"):
772            getargs_keyword_only(1, 2, **{BadStr("keyword_only"): 3})
773        with self.assertRaisesRegex(TypeError,
774            "invalid keyword argument for this function"):
775            getargs_keyword_only(1, 2, **{BadStr("monster"): 666})
776
777
778class PositionalOnlyAndKeywords_TestCase(unittest.TestCase):
779    from _testcapi import getargs_positional_only_and_keywords as getargs
780
781    def test_positional_args(self):
782        # using all possible positional args
783        self.assertEqual(self.getargs(1, 2, 3), (1, 2, 3))
784
785    def test_mixed_args(self):
786        # positional and keyword args
787        self.assertEqual(self.getargs(1, 2, keyword=3), (1, 2, 3))
788
789    def test_optional_args(self):
790        # missing optional args
791        self.assertEqual(self.getargs(1, 2), (1, 2, -1))
792        self.assertEqual(self.getargs(1, keyword=3), (1, -1, 3))
793
794    def test_required_args(self):
795        self.assertEqual(self.getargs(1), (1, -1, -1))
796        # required positional arg missing
797        with self.assertRaisesRegex(TypeError,
798            r"function takes at least 1 positional argument \(0 given\)"):
799            self.getargs()
800
801        with self.assertRaisesRegex(TypeError,
802            r"function takes at least 1 positional argument \(0 given\)"):
803            self.getargs(keyword=3)
804
805    def test_empty_keyword(self):
806        with self.assertRaisesRegex(TypeError,
807            "'' is an invalid keyword argument for this function"):
808            self.getargs(1, 2, **{'': 666})
809
810
811class Bytes_TestCase(unittest.TestCase):
812    def test_c(self):
813        from _testcapi import getargs_c
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)
821
822    def test_y(self):
823        from _testcapi import getargs_y
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)
830
831    def test_y_star(self):
832        from _testcapi import getargs_y_star
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)
839
840    def test_y_hash(self):
841        from _testcapi import getargs_y_hash
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)
848
849    def test_w_star(self):
850        # getargs_w_star() modifies first and last byte
851        from _testcapi import getargs_w_star
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'))
856        buf = bytearray(b'bytearray')
857        self.assertEqual(getargs_w_star(buf), b'[ytearra]')
858        self.assertEqual(buf, bytearray(b'[ytearra]'))
859        buf = bytearray(b'memoryview')
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)
863
864
865class String_TestCase(unittest.TestCase):
866    def test_C(self):
867        from _testcapi import getargs_C
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)
877
878    def test_s(self):
879        from _testcapi import getargs_s
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)
886
887    def test_s_star(self):
888        from _testcapi import getargs_s_star
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)
895
896    def test_s_hash(self):
897        from _testcapi import getargs_s_hash
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)
904
905    def test_s_hash_int(self):
906        # "s#" without PY_SSIZE_T_CLEAN defined.
907        from _testcapi import getargs_s_hash_int
908        from _testcapi import getargs_s_hash_int2
909        buf = bytearray([1, 2])
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")
916        buf.append(3)  # still mutable -- not locked by a buffer export
917        # getargs_s_hash_int(buf) may not raise SystemError because skipitem()
918        # is not called. But it is an implementation detail.
919        # getargs_s_hash_int(buf)
920        # getargs_s_hash_int2(buf)
921
922    def test_z(self):
923        from _testcapi import getargs_z
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))
930
931    def test_z_star(self):
932        from _testcapi import getargs_z_star
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))
939
940    def test_z_hash(self):
941        from _testcapi import getargs_z_hash
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))
948
949    def test_es(self):
950        from _testcapi import getargs_es
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')
960
961    def test_et(self):
962        from _testcapi import getargs_et
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')
974
975    def test_es_hash(self):
976        from _testcapi import getargs_es_hash
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')
986
987        buf = bytearray(b'x'*8)
988        self.assertEqual(getargs_es_hash('abc\xe9', 'latin1', buf), b'abc\xe9')
989        self.assertEqual(buf, bytearray(b'abc\xe9\x00xxx'))
990        buf = bytearray(b'x'*5)
991        self.assertEqual(getargs_es_hash('abc\xe9', 'latin1', buf), b'abc\xe9')
992        self.assertEqual(buf, bytearray(b'abc\xe9\x00'))
993        buf = bytearray(b'x'*4)
994        self.assertRaises(ValueError, getargs_es_hash, 'abc\xe9', 'latin1', buf)
995        self.assertEqual(buf, bytearray(b'x'*4))
996        buf = bytearray()
997        self.assertRaises(ValueError, getargs_es_hash, 'abc\xe9', 'latin1', buf)
998
999    def test_et_hash(self):
1000        from _testcapi import getargs_et_hash
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')
1012
1013        buf = bytearray(b'x'*8)
1014        self.assertEqual(getargs_et_hash('abc\xe9', 'latin1', buf), b'abc\xe9')
1015        self.assertEqual(buf, bytearray(b'abc\xe9\x00xxx'))
1016        buf = bytearray(b'x'*5)
1017        self.assertEqual(getargs_et_hash('abc\xe9', 'latin1', buf), b'abc\xe9')
1018        self.assertEqual(buf, bytearray(b'abc\xe9\x00'))
1019        buf = bytearray(b'x'*4)
1020        self.assertRaises(ValueError, getargs_et_hash, 'abc\xe9', 'latin1', buf)
1021        self.assertEqual(buf, bytearray(b'x'*4))
1022        buf = bytearray()
1023        self.assertRaises(ValueError, getargs_et_hash, 'abc\xe9', 'latin1', buf)
1024
1025    @support.requires_legacy_unicode_capi
1026    def test_u(self):
1027        from _testcapi import getargs_u
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)
1040        with warnings.catch_warnings():
1041            warnings.simplefilter('error', DeprecationWarning)
1042            self.assertRaises(DeprecationWarning, getargs_u, 'abc\xe9')
1043
1044    @support.requires_legacy_unicode_capi
1045    def test_u_hash(self):
1046        from _testcapi import getargs_u_hash
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)
1059        with warnings.catch_warnings():
1060            warnings.simplefilter('error', DeprecationWarning)
1061            self.assertRaises(DeprecationWarning, getargs_u_hash, 'abc\xe9')
1062
1063    @support.requires_legacy_unicode_capi
1064    def test_Z(self):
1065        from _testcapi import getargs_Z
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))
1078        with warnings.catch_warnings():
1079            warnings.simplefilter('error', DeprecationWarning)
1080            self.assertRaises(DeprecationWarning, getargs_Z, 'abc\xe9')
1081
1082    @support.requires_legacy_unicode_capi
1083    def test_Z_hash(self):
1084        from _testcapi import getargs_Z_hash
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))
1097        with warnings.catch_warnings():
1098            warnings.simplefilter('error', DeprecationWarning)
1099            self.assertRaises(DeprecationWarning, getargs_Z_hash, 'abc\xe9')
1100
1101    def test_gh_99240_clear_args(self):
1102        from _testcapi import gh_99240_clear_args
1103        self.assertRaises(TypeError, gh_99240_clear_args, 'a', '\0b')
1104
1105
1106class Object_TestCase(unittest.TestCase):
1107    def test_S(self):
1108        from _testcapi import getargs_S
1109        obj = b'bytes'
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))
1115
1116    def test_Y(self):
1117        from _testcapi import getargs_Y
1118        obj = bytearray(b'bytearray')
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))
1124
1125    def test_U(self):
1126        from _testcapi import getargs_U
1127        obj = 'str'
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)
1132
1133
1134# Bug #6012
1135class Test6012(unittest.TestCase):
1136    def test(self):
1137        self.assertEqual(_testcapi.argparsing("Hello", "World"), 1)
1138
1139
1140class SkipitemTest(unittest.TestCase):
1141
1142    # u, and Z raises DeprecationWarning
1143    @warnings_helper.ignore_warnings(category=DeprecationWarning)
1144    def test_skipitem(self):
1145        """
1146        If this test failed, you probably added a new "format unit"
1147        in Python/getargs.c, but neglected to update our poor friend
1148        skipitem() in the same file.  (If so, shame on you!)
1149
1150        With a few exceptions**, this function brute-force tests all
1151        printable ASCII*** characters (32 to 126 inclusive) as format units,
1152        checking to see that PyArg_ParseTupleAndKeywords() return consistent
1153        errors both when the unit is attempted to be used and when it is
1154        skipped.  If the format unit doesn't exist, we'll get one of two
1155        specific error messages (one for used, one for skipped); if it does
1156        exist we *won't* get that error--we'll get either no error or some
1157        other error.  If we get the specific "does not exist" error for one
1158        test and not for the other, there's a mismatch, and the test fails.
1159
1160           ** Some format units have special funny semantics and it would
1161              be difficult to accommodate them here.  Since these are all
1162              well-established and properly skipped in skipitem() we can
1163              get away with not testing them--this test is really intended
1164              to catch *new* format units.
1165
1166          *** Python C source files must be ASCII.  Therefore it's impossible
1167              to have non-ASCII format units.
1168
1169        """
1170        empty_tuple = ()
1171        tuple_1 = (0,)
1172        dict_b = {'b':1}
1173        keywords = ["a", "b"]
1174
1175        for i in range(32, 127):
1176            c = chr(i)
1177
1178            # skip parentheses, the error reporting is inconsistent about them
1179            # skip 'e', it's always a two-character code
1180            # skip '|' and '$', they don't represent arguments anyway
1181            if c in '()e|$':
1182                continue
1183
1184            # test the format unit when not skipped
1185            format = c + "i"
1186            try:
1187                _testcapi.parse_tuple_and_keywords(tuple_1, dict_b,
1188                    format, keywords)
1189                when_not_skipped = False
1190            except SystemError as e:
1191                s = "argument 1 (impossible<bad format char>)"
1192                when_not_skipped = (str(e) == s)
1193            except TypeError:
1194                when_not_skipped = False
1195
1196            # test the format unit when skipped
1197            optional_format = "|" + format
1198            try:
1199                _testcapi.parse_tuple_and_keywords(empty_tuple, dict_b,
1200                    optional_format, keywords)
1201                when_skipped = False
1202            except SystemError as e:
1203                s = "impossible<bad format char>: '{}'".format(format)
1204                when_skipped = (str(e) == s)
1205
1206            message = ("test_skipitem_parity: "
1207                "detected mismatch between convertsimple and skipitem "
1208                "for format unit '{}' ({}), not skipped {}, skipped {}".format(
1209                    c, i, when_skipped, when_not_skipped))
1210            self.assertIs(when_skipped, when_not_skipped, message)
1211
1212    def test_skipitem_with_suffix(self):
1213        parse = _testcapi.parse_tuple_and_keywords
1214        empty_tuple = ()
1215        tuple_1 = (0,)
1216        dict_b = {'b':1}
1217        keywords = ["a", "b"]
1218
1219        supported = ('s#', 's*', 'z#', 'z*', 'u#', 'Z#', 'y#', 'y*', 'w#', 'w*')
1220        for c in string.ascii_letters:
1221            for c2 in '#*':
1222                f = c + c2
1223                with self.subTest(format=f):
1224                    optional_format = "|" + f + "i"
1225                    if f in supported:
1226                        parse(empty_tuple, dict_b, optional_format, keywords)
1227                    else:
1228                        with self.assertRaisesRegex(SystemError,
1229                                    'impossible<bad format char>'):
1230                            parse(empty_tuple, dict_b, optional_format, keywords)
1231
1232        for c in map(chr, range(32, 128)):
1233            f = 'e' + c
1234            optional_format = "|" + f + "i"
1235            with self.subTest(format=f):
1236                if c in 'st':
1237                    parse(empty_tuple, dict_b, optional_format, keywords)
1238                else:
1239                    with self.assertRaisesRegex(SystemError,
1240                                'impossible<bad format char>'):
1241                        parse(empty_tuple, dict_b, optional_format, keywords)
1242
1243
1244class ParseTupleAndKeywords_Test(unittest.TestCase):
1245
1246    def test_parse_tuple_and_keywords(self):
1247        # Test handling errors in the parse_tuple_and_keywords helper itself
1248        self.assertRaises(TypeError, _testcapi.parse_tuple_and_keywords,
1249                          (), {}, 42, [])
1250        self.assertRaises(ValueError, _testcapi.parse_tuple_and_keywords,
1251                          (), {}, '', 42)
1252        self.assertRaises(ValueError, _testcapi.parse_tuple_and_keywords,
1253                          (), {}, '', [''] * 42)
1254        self.assertRaises(ValueError, _testcapi.parse_tuple_and_keywords,
1255                          (), {}, '', [42])
1256
1257    def test_bad_use(self):
1258        # Test handling invalid format and keywords in
1259        # PyArg_ParseTupleAndKeywords()
1260        self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords,
1261                          (1,), {}, '||O', ['a'])
1262        self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords,
1263                          (1, 2), {}, '|O|O', ['a', 'b'])
1264        self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords,
1265                          (), {'a': 1}, '$$O', ['a'])
1266        self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords,
1267                          (), {'a': 1, 'b': 2}, '$O$O', ['a', 'b'])
1268        self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords,
1269                          (), {'a': 1}, '$|O', ['a'])
1270        self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords,
1271                          (), {'a': 1, 'b': 2}, '$O|O', ['a', 'b'])
1272        self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords,
1273                          (1,), {}, '|O', ['a', 'b'])
1274        self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords,
1275                          (1,), {}, '|OO', ['a'])
1276        self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords,
1277                          (), {}, '|$O', [''])
1278        self.assertRaises(SystemError, _testcapi.parse_tuple_and_keywords,
1279                          (), {}, '|OO', ['a', ''])
1280
1281    def test_positional_only(self):
1282        parse = _testcapi.parse_tuple_and_keywords
1283
1284        parse((1, 2, 3), {}, 'OOO', ['', '', 'a'])
1285        parse((1, 2), {'a': 3}, 'OOO', ['', '', 'a'])
1286        with self.assertRaisesRegex(TypeError,
1287               r'function takes at least 2 positional arguments \(1 given\)'):
1288            parse((1,), {'a': 3}, 'OOO', ['', '', 'a'])
1289        parse((1,), {}, 'O|OO', ['', '', 'a'])
1290        with self.assertRaisesRegex(TypeError,
1291               r'function takes at least 1 positional argument \(0 given\)'):
1292            parse((), {}, 'O|OO', ['', '', 'a'])
1293        parse((1, 2), {'a': 3}, 'OO$O', ['', '', 'a'])
1294        with self.assertRaisesRegex(TypeError,
1295               r'function takes exactly 2 positional arguments \(1 given\)'):
1296            parse((1,), {'a': 3}, 'OO$O', ['', '', 'a'])
1297        parse((1,), {}, 'O|O$O', ['', '', 'a'])
1298        with self.assertRaisesRegex(TypeError,
1299               r'function takes at least 1 positional argument \(0 given\)'):
1300            parse((), {}, 'O|O$O', ['', '', 'a'])
1301        with self.assertRaisesRegex(SystemError, r'Empty parameter name after \$'):
1302            parse((1,), {}, 'O|$OO', ['', '', 'a'])
1303        with self.assertRaisesRegex(SystemError, 'Empty keyword'):
1304            parse((1,), {}, 'O|OO', ['', 'a', ''])
1305
1306
1307class Test_testcapi(unittest.TestCase):
1308    locals().update((name, getattr(_testcapi, name))
1309                    for name in dir(_testcapi)
1310                    if name.startswith('test_') and name.endswith('_code'))
1311
1312    @warnings_helper.ignore_warnings(category=DeprecationWarning)
1313    def test_u_code(self):
1314        _testcapi.test_u_code()
1315
1316    @warnings_helper.ignore_warnings(category=DeprecationWarning)
1317    def test_Z_code(self):
1318        _testcapi.test_Z_code()
1319
1320
1321if __name__ == "__main__":
1322    unittest.main()
1323