← Back to branch summary

~ubuntu-branches/ubuntu/trusty/python3.4/trusty-proposed

« back to all changes in this revision

Viewing changes to Lib/test/test_getargs2.py

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2013-11-25 09:44:27 UTC
  • Revision ID: package-import@ubuntu.com-20131125094427-lzxj8ap5w01lmo7f
Tags: upstream-3.4~b1
Import upstream version 3.4~b1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Lib/test/test_getargs2.py
 
1
import unittest
 
2
from test import support
 
3
from _testcapi import getargs_keywords, getargs_keyword_only
 
4
try:
 
5
    from _testcapi import getargs_L, getargs_K
 
6
except ImportError:
 
7
    getargs_L = None # PY_LONG_LONG not available
 
8
 
 
9
# > How about the following counterproposal. This also changes some of
 
10
# > the other format codes to be a little more regular.
 
11
# >
 
12
# > Code C type Range check
 
13
# >
 
14
# > b unsigned char 0..UCHAR_MAX
 
15
# > h signed short SHRT_MIN..SHRT_MAX
 
16
# > B unsigned char none **
 
17
# > H unsigned short none **
 
18
# > k * unsigned long none
 
19
# > I * unsigned int 0..UINT_MAX
 
20
#
 
21
#
 
22
# > i int INT_MIN..INT_MAX
 
23
# > l long LONG_MIN..LONG_MAX
 
24
#
 
25
# > K * unsigned long long none
 
26
# > L long long LLONG_MIN..LLONG_MAX
 
27
#
 
28
# > Notes:
 
29
# >
 
30
# > * New format codes.
 
31
# >
 
32
# > ** Changed from previous "range-and-a-half" to "none"; the
 
33
# > range-and-a-half checking wasn't particularly useful.
 
34
#
 
35
# Plus a C API or two, e.g. PyInt_AsLongMask() ->
 
36
# unsigned long and PyInt_AsLongLongMask() -> unsigned
 
37
# long long (if that exists).
 
38
 
 
39
LARGE = 0x7FFFFFFF
 
40
VERY_LARGE = 0xFF0000121212121212121242
 
41
 
 
42
from _testcapi import UCHAR_MAX, USHRT_MAX, UINT_MAX, ULONG_MAX, INT_MAX, \
 
43
     INT_MIN, LONG_MIN, LONG_MAX, PY_SSIZE_T_MIN, PY_SSIZE_T_MAX, \
 
44
     SHRT_MIN, SHRT_MAX
 
45
 
 
46
# fake, they are not defined in Python's header files
 
47
LLONG_MAX = 2**63-1
 
48
LLONG_MIN = -2**63
 
49
ULLONG_MAX = 2**64-1
 
50
 
 
51
class Int:
 
52
    def __int__(self):
 
53
        return 99
 
54
 
 
55
class Unsigned_TestCase(unittest.TestCase):
 
56
    def test_b(self):
 
57
        from _testcapi import getargs_b
 
58
        # b returns 'unsigned char', and does range checking (0 ... UCHAR_MAX)
 
59
        self.assertRaises(TypeError, getargs_b, 3.14)
 
60
        self.assertEqual(99, getargs_b(Int()))
 
61
 
 
62
        self.assertRaises(OverflowError, getargs_b, -1)
 
63
        self.assertEqual(0, getargs_b(0))
 
64
        self.assertEqual(UCHAR_MAX, getargs_b(UCHAR_MAX))
 
65
        self.assertRaises(OverflowError, getargs_b, UCHAR_MAX + 1)
 
66
 
 
67
        self.assertEqual(42, getargs_b(42))
 
68
        self.assertRaises(OverflowError, getargs_b, VERY_LARGE)
 
69
 
 
70
    def test_B(self):
 
71
        from _testcapi import getargs_B
 
72
        # B returns 'unsigned char', no range checking
 
73
        self.assertRaises(TypeError, getargs_B, 3.14)
 
74
        self.assertEqual(99, getargs_B(Int()))
 
75
 
 
76
        self.assertEqual(UCHAR_MAX, getargs_B(-1))
 
77
        self.assertEqual(0, getargs_B(0))
 
78
        self.assertEqual(UCHAR_MAX, getargs_B(UCHAR_MAX))
 
79
        self.assertEqual(0, getargs_B(UCHAR_MAX+1))
 
80
 
 
81
        self.assertEqual(42, getargs_B(42))
 
82
        self.assertEqual(UCHAR_MAX & VERY_LARGE, getargs_B(VERY_LARGE))
 
83
 
 
84
    def test_H(self):
 
85
        from _testcapi import getargs_H
 
86
        # H returns 'unsigned short', no range checking
 
87
        self.assertRaises(TypeError, getargs_H, 3.14)
 
88
        self.assertEqual(99, getargs_H(Int()))
 
89
 
 
90
        self.assertEqual(USHRT_MAX, getargs_H(-1))
 
91
        self.assertEqual(0, getargs_H(0))
 
92
        self.assertEqual(USHRT_MAX, getargs_H(USHRT_MAX))
 
93
        self.assertEqual(0, getargs_H(USHRT_MAX+1))
 
94
 
 
95
        self.assertEqual(42, getargs_H(42))
 
96
 
 
97
        self.assertEqual(VERY_LARGE & USHRT_MAX, getargs_H(VERY_LARGE))
 
98
 
 
99
    def test_I(self):
 
100
        from _testcapi import getargs_I
 
101
        # I returns 'unsigned int', no range checking
 
102
        self.assertRaises(TypeError, getargs_I, 3.14)
 
103
        self.assertEqual(99, getargs_I(Int()))
 
104
 
 
105
        self.assertEqual(UINT_MAX, getargs_I(-1))
 
106
        self.assertEqual(0, getargs_I(0))
 
107
        self.assertEqual(UINT_MAX, getargs_I(UINT_MAX))
 
108
        self.assertEqual(0, getargs_I(UINT_MAX+1))
 
109
 
 
110
        self.assertEqual(42, getargs_I(42))
 
111
 
 
112
        self.assertEqual(VERY_LARGE & UINT_MAX, getargs_I(VERY_LARGE))
 
113
 
 
114
    def test_k(self):
 
115
        from _testcapi import getargs_k
 
116
        # k returns 'unsigned long', no range checking
 
117
        # it does not accept float, or instances with __int__
 
118
        self.assertRaises(TypeError, getargs_k, 3.14)
 
119
        self.assertRaises(TypeError, getargs_k, Int())
 
120
 
 
121
        self.assertEqual(ULONG_MAX, getargs_k(-1))
 
122
        self.assertEqual(0, getargs_k(0))
 
123
        self.assertEqual(ULONG_MAX, getargs_k(ULONG_MAX))
 
124
        self.assertEqual(0, getargs_k(ULONG_MAX+1))
 
125
 
 
126
        self.assertEqual(42, getargs_k(42))
 
127
 
 
128
        self.assertEqual(VERY_LARGE & ULONG_MAX, getargs_k(VERY_LARGE))
 
129
 
 
130
class Signed_TestCase(unittest.TestCase):
 
131
    def test_h(self):
 
132
        from _testcapi import getargs_h
 
133
        # h returns 'short', and does range checking (SHRT_MIN ... SHRT_MAX)
 
134
        self.assertRaises(TypeError, getargs_h, 3.14)
 
135
        self.assertEqual(99, getargs_h(Int()))
 
136
 
 
137
        self.assertRaises(OverflowError, getargs_h, SHRT_MIN-1)
 
138
        self.assertEqual(SHRT_MIN, getargs_h(SHRT_MIN))
 
139
        self.assertEqual(SHRT_MAX, getargs_h(SHRT_MAX))
 
140
        self.assertRaises(OverflowError, getargs_h, SHRT_MAX+1)
 
141
 
 
142
        self.assertEqual(42, getargs_h(42))
 
143
        self.assertRaises(OverflowError, getargs_h, VERY_LARGE)
 
144
 
 
145
    def test_i(self):
 
146
        from _testcapi import getargs_i
 
147
        # i returns 'int', and does range checking (INT_MIN ... INT_MAX)
 
148
        self.assertRaises(TypeError, getargs_i, 3.14)
 
149
        self.assertEqual(99, getargs_i(Int()))
 
150
 
 
151
        self.assertRaises(OverflowError, getargs_i, INT_MIN-1)
 
152
        self.assertEqual(INT_MIN, getargs_i(INT_MIN))
 
153
        self.assertEqual(INT_MAX, getargs_i(INT_MAX))
 
154
        self.assertRaises(OverflowError, getargs_i, INT_MAX+1)
 
155
 
 
156
        self.assertEqual(42, getargs_i(42))
 
157
        self.assertRaises(OverflowError, getargs_i, VERY_LARGE)
 
158
 
 
159
    def test_l(self):
 
160
        from _testcapi import getargs_l
 
161
        # l returns 'long', and does range checking (LONG_MIN ... LONG_MAX)
 
162
        self.assertRaises(TypeError, getargs_l, 3.14)
 
163
        self.assertEqual(99, getargs_l(Int()))
 
164
 
 
165
        self.assertRaises(OverflowError, getargs_l, LONG_MIN-1)
 
166
        self.assertEqual(LONG_MIN, getargs_l(LONG_MIN))
 
167
        self.assertEqual(LONG_MAX, getargs_l(LONG_MAX))
 
168
        self.assertRaises(OverflowError, getargs_l, LONG_MAX+1)
 
169
 
 
170
        self.assertEqual(42, getargs_l(42))
 
171
        self.assertRaises(OverflowError, getargs_l, VERY_LARGE)
 
172
 
 
173
    def test_n(self):
 
174
        from _testcapi import getargs_n
 
175
        # n returns 'Py_ssize_t', and does range checking
 
176
        # (PY_SSIZE_T_MIN ... PY_SSIZE_T_MAX)
 
177
        self.assertRaises(TypeError, getargs_n, 3.14)
 
178
        self.assertRaises(TypeError, getargs_n, Int())
 
179
 
 
180
        self.assertRaises(OverflowError, getargs_n, PY_SSIZE_T_MIN-1)
 
181
        self.assertEqual(PY_SSIZE_T_MIN, getargs_n(PY_SSIZE_T_MIN))
 
182
        self.assertEqual(PY_SSIZE_T_MAX, getargs_n(PY_SSIZE_T_MAX))
 
183
        self.assertRaises(OverflowError, getargs_n, PY_SSIZE_T_MAX+1)
 
184
 
 
185
        self.assertEqual(42, getargs_n(42))
 
186
        self.assertRaises(OverflowError, getargs_n, VERY_LARGE)
 
187
 
 
188
 
 
189
@unittest.skipIf(getargs_L is None, 'PY_LONG_LONG is not available')
 
190
class LongLong_TestCase(unittest.TestCase):
 
191
    def test_L(self):
 
192
        from _testcapi import getargs_L
 
193
        # L returns 'long long', and does range checking (LLONG_MIN
 
194
        # ... LLONG_MAX)
 
195
        self.assertRaises(TypeError, getargs_L, 3.14)
 
196
        self.assertRaises(TypeError, getargs_L, "Hello")
 
197
        self.assertEqual(99, getargs_L(Int()))
 
198
 
 
199
        self.assertRaises(OverflowError, getargs_L, LLONG_MIN-1)
 
200
        self.assertEqual(LLONG_MIN, getargs_L(LLONG_MIN))
 
201
        self.assertEqual(LLONG_MAX, getargs_L(LLONG_MAX))
 
202
        self.assertRaises(OverflowError, getargs_L, LLONG_MAX+1)
 
203
 
 
204
        self.assertEqual(42, getargs_L(42))
 
205
        self.assertRaises(OverflowError, getargs_L, VERY_LARGE)
 
206
 
 
207
    def test_K(self):
 
208
        from _testcapi import getargs_K
 
209
        # K return 'unsigned long long', no range checking
 
210
        self.assertRaises(TypeError, getargs_K, 3.14)
 
211
        self.assertRaises(TypeError, getargs_K, Int())
 
212
        self.assertEqual(ULLONG_MAX, getargs_K(ULLONG_MAX))
 
213
        self.assertEqual(0, getargs_K(0))
 
214
        self.assertEqual(0, getargs_K(ULLONG_MAX+1))
 
215
 
 
216
        self.assertEqual(42, getargs_K(42))
 
217
 
 
218
        self.assertEqual(VERY_LARGE & ULLONG_MAX, getargs_K(VERY_LARGE))
 
219
 
 
220
class Paradox:
 
221
    "This statement is false."
 
222
    def __bool__(self):
 
223
        raise NotImplementedError
 
224
 
 
225
class Boolean_TestCase(unittest.TestCase):
 
226
    def test_p(self):
 
227
        from _testcapi import getargs_p
 
228
        self.assertEqual(0, getargs_p(False))
 
229
        self.assertEqual(0, getargs_p(None))
 
230
        self.assertEqual(0, getargs_p(0))
 
231
        self.assertEqual(0, getargs_p(0.0))
 
232
        self.assertEqual(0, getargs_p(0j))
 
233
        self.assertEqual(0, getargs_p(''))
 
234
        self.assertEqual(0, getargs_p(()))
 
235
        self.assertEqual(0, getargs_p([]))
 
236
        self.assertEqual(0, getargs_p({}))
 
237
 
 
238
        self.assertEqual(1, getargs_p(True))
 
239
        self.assertEqual(1, getargs_p(1))
 
240
        self.assertEqual(1, getargs_p(1.0))
 
241
        self.assertEqual(1, getargs_p(1j))
 
242
        self.assertEqual(1, getargs_p('x'))
 
243
        self.assertEqual(1, getargs_p((1,)))
 
244
        self.assertEqual(1, getargs_p([1]))
 
245
        self.assertEqual(1, getargs_p({1:2}))
 
246
        self.assertEqual(1, getargs_p(unittest.TestCase))
 
247
 
 
248
        self.assertRaises(NotImplementedError, getargs_p, Paradox())
 
249
 
 
250
 
 
251
class Tuple_TestCase(unittest.TestCase):
 
252
    def test_tuple(self):
 
253
        from _testcapi import getargs_tuple
 
254
 
 
255
        ret = getargs_tuple(1, (2, 3))
 
256
        self.assertEqual(ret, (1,2,3))
 
257
 
 
258
        # make sure invalid tuple arguments are handled correctly
 
259
        class seq:
 
260
            def __len__(self):
 
261
                return 2
 
262
            def __getitem__(self, n):
 
263
                raise ValueError
 
264
        self.assertRaises(TypeError, getargs_tuple, 1, seq())
 
265
 
 
266
class Keywords_TestCase(unittest.TestCase):
 
267
    def test_positional_args(self):
 
268
        # using all positional args
 
269
        self.assertEqual(
 
270
            getargs_keywords((1,2), 3, (4,(5,6)), (7,8,9), 10),
 
271
            (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
 
272
            )
 
273
 
 
274
    def test_mixed_args(self):
 
275
        # positional and keyword args
 
276
        self.assertEqual(
 
277
            getargs_keywords((1,2), 3, (4,(5,6)), arg4=(7,8,9), arg5=10),
 
278
            (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
 
279
            )
 
280
 
 
281
    def test_keyword_args(self):
 
282
        # all keywords
 
283
        self.assertEqual(
 
284
            getargs_keywords(arg1=(1,2), arg2=3, arg3=(4,(5,6)), arg4=(7,8,9), arg5=10),
 
285
            (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
 
286
            )
 
287
 
 
288
    def test_optional_args(self):
 
289
        # missing optional keyword args, skipping tuples
 
290
        self.assertEqual(
 
291
            getargs_keywords(arg1=(1,2), arg2=3, arg5=10),
 
292
            (1, 2, 3, -1, -1, -1, -1, -1, -1, 10)
 
293
            )
 
294
 
 
295
    def test_required_args(self):
 
296
        # required arg missing
 
297
        try:
 
298
            getargs_keywords(arg1=(1,2))
 
299
        except TypeError as err:
 
300
            self.assertEqual(str(err), "Required argument 'arg2' (pos 2) not found")
 
301
        else:
 
302
            self.fail('TypeError should have been raised')
 
303
 
 
304
    def test_too_many_args(self):
 
305
        try:
 
306
            getargs_keywords((1,2),3,(4,(5,6)),(7,8,9),10,111)
 
307
        except TypeError as err:
 
308
            self.assertEqual(str(err), "function takes at most 5 arguments (6 given)")
 
309
        else:
 
310
            self.fail('TypeError should have been raised')
 
311
 
 
312
    def test_invalid_keyword(self):
 
313
        # extraneous keyword arg
 
314
        try:
 
315
            getargs_keywords((1,2),3,arg5=10,arg666=666)
 
316
        except TypeError as err:
 
317
            self.assertEqual(str(err), "'arg666' is an invalid keyword argument for this function")
 
318
        else:
 
319
            self.fail('TypeError should have been raised')
 
320
 
 
321
    def test_surrogate_keyword(self):
 
322
        try:
 
323
            getargs_keywords((1,2), 3, (4,(5,6)), (7,8,9), **{'\uDC80': 10})
 
324
        except TypeError as err:
 
325
            self.assertEqual(str(err), "'\udc80' is an invalid keyword argument for this function")
 
326
        else:
 
327
            self.fail('TypeError should have been raised')
 
328
 
 
329
class KeywordOnly_TestCase(unittest.TestCase):
 
330
    def test_positional_args(self):
 
331
        # using all possible positional args
 
332
        self.assertEqual(
 
333
            getargs_keyword_only(1, 2),
 
334
            (1, 2, -1)
 
335
            )
 
336
 
 
337
    def test_mixed_args(self):
 
338
        # positional and keyword args
 
339
        self.assertEqual(
 
340
            getargs_keyword_only(1, 2, keyword_only=3),
 
341
            (1, 2, 3)
 
342
            )
 
343
 
 
344
    def test_keyword_args(self):
 
345
        # all keywords
 
346
        self.assertEqual(
 
347
            getargs_keyword_only(required=1, optional=2, keyword_only=3),
 
348
            (1, 2, 3)
 
349
            )
 
350
 
 
351
    def test_optional_args(self):
 
352
        # missing optional keyword args, skipping tuples
 
353
        self.assertEqual(
 
354
            getargs_keyword_only(required=1, optional=2),
 
355
            (1, 2, -1)
 
356
            )
 
357
        self.assertEqual(
 
358
            getargs_keyword_only(required=1, keyword_only=3),
 
359
            (1, -1, 3)
 
360
            )
 
361
 
 
362
    def test_required_args(self):
 
363
        self.assertEqual(
 
364
            getargs_keyword_only(1),
 
365
            (1, -1, -1)
 
366
            )
 
367
        self.assertEqual(
 
368
            getargs_keyword_only(required=1),
 
369
            (1, -1, -1)
 
370
            )
 
371
        # required arg missing
 
372
        with self.assertRaisesRegex(TypeError,
 
373
            "Required argument 'required' \(pos 1\) not found"):
 
374
            getargs_keyword_only(optional=2)
 
375
 
 
376
        with self.assertRaisesRegex(TypeError,
 
377
            "Required argument 'required' \(pos 1\) not found"):
 
378
            getargs_keyword_only(keyword_only=3)
 
379
 
 
380
    def test_too_many_args(self):
 
381
        with self.assertRaisesRegex(TypeError,
 
382
            "Function takes at most 2 positional arguments \(3 given\)"):
 
383
            getargs_keyword_only(1, 2, 3)
 
384
 
 
385
        with self.assertRaisesRegex(TypeError,
 
386
            "function takes at most 3 arguments \(4 given\)"):
 
387
            getargs_keyword_only(1, 2, 3, keyword_only=5)
 
388
 
 
389
    def test_invalid_keyword(self):
 
390
        # extraneous keyword arg
 
391
        with self.assertRaisesRegex(TypeError,
 
392
            "'monster' is an invalid keyword argument for this function"):
 
393
            getargs_keyword_only(1, 2, monster=666)
 
394
 
 
395
    def test_surrogate_keyword(self):
 
396
        with self.assertRaisesRegex(TypeError,
 
397
            "'\udc80' is an invalid keyword argument for this function"):
 
398
            getargs_keyword_only(1, 2, **{'\uDC80': 10})
 
399
 
 
400
class Bytes_TestCase(unittest.TestCase):
 
401
    def test_c(self):
 
402
        from _testcapi import getargs_c
 
403
        self.assertRaises(TypeError, getargs_c, b'abc')  # len > 1
 
404
        self.assertEqual(getargs_c(b'a'), b'a')
 
405
        self.assertEqual(getargs_c(bytearray(b'a')), b'a')
 
406
        self.assertRaises(TypeError, getargs_c, memoryview(b'a'))
 
407
        self.assertRaises(TypeError, getargs_c, 's')
 
408
        self.assertRaises(TypeError, getargs_c, None)
 
409
 
 
410
    def test_s(self):
 
411
        from _testcapi import getargs_s
 
412
        self.assertEqual(getargs_s('abc\xe9'), b'abc\xc3\xa9')
 
413
        self.assertRaises(TypeError, getargs_s, 'nul:\0')
 
414
        self.assertRaises(TypeError, getargs_s, b'bytes')
 
415
        self.assertRaises(TypeError, getargs_s, bytearray(b'bytearray'))
 
416
        self.assertRaises(TypeError, getargs_s, memoryview(b'memoryview'))
 
417
        self.assertRaises(TypeError, getargs_s, None)
 
418
 
 
419
    def test_s_star(self):
 
420
        from _testcapi import getargs_s_star
 
421
        self.assertEqual(getargs_s_star('abc\xe9'), b'abc\xc3\xa9')
 
422
        self.assertEqual(getargs_s_star('nul:\0'), b'nul:\0')
 
423
        self.assertEqual(getargs_s_star(b'bytes'), b'bytes')
 
424
        self.assertEqual(getargs_s_star(bytearray(b'bytearray')), b'bytearray')
 
425
        self.assertEqual(getargs_s_star(memoryview(b'memoryview')), b'memoryview')
 
426
        self.assertRaises(TypeError, getargs_s_star, None)
 
427
 
 
428
    def test_s_hash(self):
 
429
        from _testcapi import getargs_s_hash
 
430
        self.assertEqual(getargs_s_hash('abc\xe9'), b'abc\xc3\xa9')
 
431
        self.assertEqual(getargs_s_hash('nul:\0'), b'nul:\0')
 
432
        self.assertEqual(getargs_s_hash(b'bytes'), b'bytes')
 
433
        self.assertRaises(TypeError, getargs_s_hash, bytearray(b'bytearray'))
 
434
        self.assertRaises(TypeError, getargs_s_hash, memoryview(b'memoryview'))
 
435
        self.assertRaises(TypeError, getargs_s_hash, None)
 
436
 
 
437
    def test_z(self):
 
438
        from _testcapi import getargs_z
 
439
        self.assertEqual(getargs_z('abc\xe9'), b'abc\xc3\xa9')
 
440
        self.assertRaises(TypeError, getargs_z, 'nul:\0')
 
441
        self.assertRaises(TypeError, getargs_z, b'bytes')
 
442
        self.assertRaises(TypeError, getargs_z, bytearray(b'bytearray'))
 
443
        self.assertRaises(TypeError, getargs_z, memoryview(b'memoryview'))
 
444
        self.assertIsNone(getargs_z(None))
 
445
 
 
446
    def test_z_star(self):
 
447
        from _testcapi import getargs_z_star
 
448
        self.assertEqual(getargs_z_star('abc\xe9'), b'abc\xc3\xa9')
 
449
        self.assertEqual(getargs_z_star('nul:\0'), b'nul:\0')
 
450
        self.assertEqual(getargs_z_star(b'bytes'), b'bytes')
 
451
        self.assertEqual(getargs_z_star(bytearray(b'bytearray')), b'bytearray')
 
452
        self.assertEqual(getargs_z_star(memoryview(b'memoryview')), b'memoryview')
 
453
        self.assertIsNone(getargs_z_star(None))
 
454
 
 
455
    def test_z_hash(self):
 
456
        from _testcapi import getargs_z_hash
 
457
        self.assertEqual(getargs_z_hash('abc\xe9'), b'abc\xc3\xa9')
 
458
        self.assertEqual(getargs_z_hash('nul:\0'), b'nul:\0')
 
459
        self.assertEqual(getargs_z_hash(b'bytes'), b'bytes')
 
460
        self.assertRaises(TypeError, getargs_z_hash, bytearray(b'bytearray'))
 
461
        self.assertRaises(TypeError, getargs_z_hash, memoryview(b'memoryview'))
 
462
        self.assertIsNone(getargs_z_hash(None))
 
463
 
 
464
    def test_y(self):
 
465
        from _testcapi import getargs_y
 
466
        self.assertRaises(TypeError, getargs_y, 'abc\xe9')
 
467
        self.assertEqual(getargs_y(b'bytes'), b'bytes')
 
468
        self.assertRaises(TypeError, getargs_y, b'nul:\0')
 
469
        self.assertRaises(TypeError, getargs_y, bytearray(b'bytearray'))
 
470
        self.assertRaises(TypeError, getargs_y, memoryview(b'memoryview'))
 
471
        self.assertRaises(TypeError, getargs_y, None)
 
472
 
 
473
    def test_y_star(self):
 
474
        from _testcapi import getargs_y_star
 
475
        self.assertRaises(TypeError, getargs_y_star, 'abc\xe9')
 
476
        self.assertEqual(getargs_y_star(b'bytes'), b'bytes')
 
477
        self.assertEqual(getargs_y_star(b'nul:\0'), b'nul:\0')
 
478
        self.assertEqual(getargs_y_star(bytearray(b'bytearray')), b'bytearray')
 
479
        self.assertEqual(getargs_y_star(memoryview(b'memoryview')), b'memoryview')
 
480
        self.assertRaises(TypeError, getargs_y_star, None)
 
481
 
 
482
    def test_y_hash(self):
 
483
        from _testcapi import getargs_y_hash
 
484
        self.assertRaises(TypeError, getargs_y_hash, 'abc\xe9')
 
485
        self.assertEqual(getargs_y_hash(b'bytes'), b'bytes')
 
486
        self.assertEqual(getargs_y_hash(b'nul:\0'), b'nul:\0')
 
487
        self.assertRaises(TypeError, getargs_y_hash, bytearray(b'bytearray'))
 
488
        self.assertRaises(TypeError, getargs_y_hash, memoryview(b'memoryview'))
 
489
        self.assertRaises(TypeError, getargs_y_hash, None)
 
490
 
 
491
    def test_w_star(self):
 
492
        # getargs_w_star() modifies first and last byte
 
493
        from _testcapi import getargs_w_star
 
494
        self.assertRaises(TypeError, getargs_w_star, 'abc\xe9')
 
495
        self.assertRaises(TypeError, getargs_w_star, b'bytes')
 
496
        self.assertRaises(TypeError, getargs_w_star, b'nul:\0')
 
497
        self.assertRaises(TypeError, getargs_w_star, memoryview(b'bytes'))
 
498
        self.assertEqual(getargs_w_star(bytearray(b'bytearray')), b'[ytearra]')
 
499
        self.assertEqual(getargs_w_star(memoryview(bytearray(b'memoryview'))),
 
500
                         b'[emoryvie]')
 
501
        self.assertRaises(TypeError, getargs_w_star, None)
 
502
 
 
503
 
 
504
class Unicode_TestCase(unittest.TestCase):
 
505
    def test_u(self):
 
506
        from _testcapi import getargs_u
 
507
        self.assertEqual(getargs_u('abc\xe9'), 'abc\xe9')
 
508
        self.assertRaises(TypeError, getargs_u, 'nul:\0')
 
509
        self.assertRaises(TypeError, getargs_u, b'bytes')
 
510
        self.assertRaises(TypeError, getargs_u, bytearray(b'bytearray'))
 
511
        self.assertRaises(TypeError, getargs_u, memoryview(b'memoryview'))
 
512
        self.assertRaises(TypeError, getargs_u, None)
 
513
 
 
514
    def test_u_hash(self):
 
515
        from _testcapi import getargs_u_hash
 
516
        self.assertEqual(getargs_u_hash('abc\xe9'), 'abc\xe9')
 
517
        self.assertEqual(getargs_u_hash('nul:\0'), 'nul:\0')
 
518
        self.assertRaises(TypeError, getargs_u_hash, b'bytes')
 
519
        self.assertRaises(TypeError, getargs_u_hash, bytearray(b'bytearray'))
 
520
        self.assertRaises(TypeError, getargs_u_hash, memoryview(b'memoryview'))
 
521
        self.assertRaises(TypeError, getargs_u_hash, None)
 
522
 
 
523
    def test_Z(self):
 
524
        from _testcapi import getargs_Z
 
525
        self.assertEqual(getargs_Z('abc\xe9'), 'abc\xe9')
 
526
        self.assertRaises(TypeError, getargs_Z, 'nul:\0')
 
527
        self.assertRaises(TypeError, getargs_Z, b'bytes')
 
528
        self.assertRaises(TypeError, getargs_Z, bytearray(b'bytearray'))
 
529
        self.assertRaises(TypeError, getargs_Z, memoryview(b'memoryview'))
 
530
        self.assertIsNone(getargs_Z(None))
 
531
 
 
532
    def test_Z_hash(self):
 
533
        from _testcapi import getargs_Z_hash
 
534
        self.assertEqual(getargs_Z_hash('abc\xe9'), 'abc\xe9')
 
535
        self.assertEqual(getargs_Z_hash('nul:\0'), 'nul:\0')
 
536
        self.assertRaises(TypeError, getargs_Z_hash, b'bytes')
 
537
        self.assertRaises(TypeError, getargs_Z_hash, bytearray(b'bytearray'))
 
538
        self.assertRaises(TypeError, getargs_Z_hash, memoryview(b'memoryview'))
 
539
        self.assertIsNone(getargs_Z_hash(None))
 
540
 
 
541
 
 
542
if __name__ == "__main__":
 
543
    unittest.main()