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