1 #include <stddef.h> // ptrdiff_t
2
3 #define PY_SSIZE_T_CLEAN
4 #include "parts.h"
5 #include "util.h"
6
7 static struct PyModuleDef *_testcapimodule = NULL; // set at initialization
8
9 static PyObject *
10 codec_incrementalencoder(PyObject *self, PyObject *args)
11 {
12 const char *encoding, *errors = NULL;
13 if (!PyArg_ParseTuple(args, "s|s:test_incrementalencoder",
14 &encoding, &errors))
15 return NULL;
16 return PyCodec_IncrementalEncoder(encoding, errors);
17 }
18
19 static PyObject *
20 codec_incrementaldecoder(PyObject *self, PyObject *args)
21 {
22 const char *encoding, *errors = NULL;
23 if (!PyArg_ParseTuple(args, "s|s:test_incrementaldecoder",
24 &encoding, &errors))
25 return NULL;
26 return PyCodec_IncrementalDecoder(encoding, errors);
27 }
28
29 static PyObject *
30 test_unicode_compare_with_ascii(PyObject *self, PyObject *Py_UNUSED(ignored)) {
31 PyObject *py_s = PyUnicode_FromStringAndSize("str\0", 4);
32 int result;
33 if (py_s == NULL)
34 return NULL;
35 result = PyUnicode_CompareWithASCIIString(py_s, "str");
36 Py_DECREF(py_s);
37 if (!result) {
38 PyErr_SetString(PyExc_AssertionError, "Python string ending in NULL "
39 "should not compare equal to c string.");
40 return NULL;
41 }
42 Py_RETURN_NONE;
43 }
44
45 static PyObject *
46 test_widechar(PyObject *self, PyObject *Py_UNUSED(ignored))
47 {
48 #if defined(SIZEOF_WCHAR_T) && (SIZEOF_WCHAR_T == 4)
49 const wchar_t wtext[2] = {(wchar_t)0x10ABCDu};
50 size_t wtextlen = 1;
51 const wchar_t invalid[1] = {(wchar_t)0x110000u};
52 #else
53 const wchar_t wtext[3] = {(wchar_t)0xDBEAu, (wchar_t)0xDFCDu};
54 size_t wtextlen = 2;
55 #endif
56 PyObject *wide, *utf8;
57
58 wide = PyUnicode_FromWideChar(wtext, wtextlen);
59 if (wide == NULL)
60 return NULL;
61
62 utf8 = PyUnicode_FromString("\xf4\x8a\xaf\x8d");
63 if (utf8 == NULL) {
64 Py_DECREF(wide);
65 return NULL;
66 }
67
68 if (PyUnicode_GET_LENGTH(wide) != PyUnicode_GET_LENGTH(utf8)) {
69 Py_DECREF(wide);
70 Py_DECREF(utf8);
71 PyErr_SetString(PyExc_AssertionError,
72 "test_widechar: "
73 "wide string and utf8 string "
74 "have different length");
75 return NULL;
76 }
77 if (PyUnicode_Compare(wide, utf8)) {
78 Py_DECREF(wide);
79 Py_DECREF(utf8);
80 if (PyErr_Occurred())
81 return NULL;
82 PyErr_SetString(PyExc_AssertionError,
83 "test_widechar: "
84 "wide string and utf8 string "
85 "are different");
86 return NULL;
87 }
88
89 Py_DECREF(wide);
90 Py_DECREF(utf8);
91
92 #if defined(SIZEOF_WCHAR_T) && (SIZEOF_WCHAR_T == 4)
93 wide = PyUnicode_FromWideChar(invalid, 1);
94 if (wide == NULL)
95 PyErr_Clear();
96 else {
97 PyErr_SetString(PyExc_AssertionError,
98 "test_widechar: "
99 "PyUnicode_FromWideChar(L\"\\U00110000\", 1) didn't fail");
100 return NULL;
101 }
102 #endif
103 Py_RETURN_NONE;
104 }
105
106
107 static PyObject *
108 unicode_copy(PyObject *unicode)
109 {
110 PyObject *copy;
111
112 if (!unicode) {
113 return NULL;
114 }
115 if (!PyUnicode_Check(unicode)) {
116 Py_INCREF(unicode);
117 return unicode;
118 }
119
120 copy = PyUnicode_New(PyUnicode_GET_LENGTH(unicode),
121 PyUnicode_MAX_CHAR_VALUE(unicode));
122 if (!copy) {
123 return NULL;
124 }
125 if (PyUnicode_CopyCharacters(copy, 0, unicode,
126 0, PyUnicode_GET_LENGTH(unicode)) < 0)
127 {
128 Py_DECREF(copy);
129 return NULL;
130 }
131 return copy;
132 }
133
134 /* Test PyUnicode_New() */
135 static PyObject *
136 unicode_new(PyObject *self, PyObject *args)
137 {
138 Py_ssize_t size;
139 unsigned int maxchar;
140 PyObject *result;
141
142 if (!PyArg_ParseTuple(args, "nI", &size, &maxchar)) {
143 return NULL;
144 }
145
146 result = PyUnicode_New(size, (Py_UCS4)maxchar);
147 if (!result) {
148 return NULL;
149 }
150 if (size > 0 && maxchar <= 0x10ffff &&
151 PyUnicode_Fill(result, 0, size, (Py_UCS4)maxchar) < 0)
152 {
153 Py_DECREF(result);
154 return NULL;
155 }
156 return result;
157 }
158
159 /* Test PyUnicode_Fill() */
160 static PyObject *
161 unicode_fill(PyObject *self, PyObject *args)
162 {
163 PyObject *to, *to_copy;
164 Py_ssize_t start, length, filled;
165 unsigned int fill_char;
166
167 if (!PyArg_ParseTuple(args, "OnnI", &to, &start, &length, &fill_char)) {
168 return NULL;
169 }
170
171 NULLABLE(to);
172 if (!(to_copy = unicode_copy(to)) && to) {
173 return NULL;
174 }
175
176 filled = PyUnicode_Fill(to_copy, start, length, (Py_UCS4)fill_char);
177 if (filled == -1 && PyErr_Occurred()) {
178 Py_DECREF(to_copy);
179 return NULL;
180 }
181 return Py_BuildValue("(Nn)", to_copy, filled);
182 }
183
184 /* Test PyUnicode_WriteChar() */
185 static PyObject *
186 unicode_writechar(PyObject *self, PyObject *args)
187 {
188 PyObject *to, *to_copy;
189 Py_ssize_t index;
190 unsigned int character;
191 int result;
192
193 if (!PyArg_ParseTuple(args, "OnI", &to, &index, &character)) {
194 return NULL;
195 }
196
197 NULLABLE(to);
198 if (!(to_copy = unicode_copy(to)) && to) {
199 return NULL;
200 }
201
202 result = PyUnicode_WriteChar(to_copy, index, (Py_UCS4)character);
203 if (result == -1 && PyErr_Occurred()) {
204 Py_DECREF(to_copy);
205 return NULL;
206 }
207 return Py_BuildValue("(Ni)", to_copy, result);
208 }
209
210 /* Test PyUnicode_Resize() */
211 static PyObject *
212 unicode_resize(PyObject *self, PyObject *args)
213 {
214 PyObject *obj, *copy;
215 Py_ssize_t length;
216 int result;
217
218 if (!PyArg_ParseTuple(args, "On", &obj, &length)) {
219 return NULL;
220 }
221
222 NULLABLE(obj);
223 if (!(copy = unicode_copy(obj)) && obj) {
224 return NULL;
225 }
226 result = PyUnicode_Resize(©, length);
227 if (result == -1 && PyErr_Occurred()) {
228 Py_XDECREF(copy);
229 return NULL;
230 }
231 if (obj && PyUnicode_Check(obj) && length > PyUnicode_GET_LENGTH(obj)) {
232 if (PyUnicode_Fill(copy, PyUnicode_GET_LENGTH(obj), length, 0U) < 0) {
233 Py_DECREF(copy);
234 return NULL;
235 }
236 }
237 return Py_BuildValue("(Ni)", copy, result);
238 }
239
240 /* Test PyUnicode_Append() */
241 static PyObject *
242 unicode_append(PyObject *self, PyObject *args)
243 {
244 PyObject *left, *right, *left_copy;
245
246 if (!PyArg_ParseTuple(args, "OO", &left, &right))
247 return NULL;
248
249 NULLABLE(left);
250 NULLABLE(right);
251 if (!(left_copy = unicode_copy(left)) && left) {
252 return NULL;
253 }
254 PyUnicode_Append(&left_copy, right);
255 return left_copy;
256 }
257
258 /* Test PyUnicode_AppendAndDel() */
259 static PyObject *
260 unicode_appendanddel(PyObject *self, PyObject *args)
261 {
262 PyObject *left, *right, *left_copy;
263
264 if (!PyArg_ParseTuple(args, "OO", &left, &right))
265 return NULL;
266
267 NULLABLE(left);
268 NULLABLE(right);
269 if (!(left_copy = unicode_copy(left)) && left) {
270 return NULL;
271 }
272 Py_XINCREF(right);
273 PyUnicode_AppendAndDel(&left_copy, right);
274 return left_copy;
275 }
276
277 /* Test PyUnicode_FromStringAndSize() */
278 static PyObject *
279 unicode_fromstringandsize(PyObject *self, PyObject *args)
280 {
281 const char *s;
282 Py_ssize_t bsize;
283 Py_ssize_t size = -100;
284
285 if (!PyArg_ParseTuple(args, "z#|n", &s, &bsize, &size)) {
286 return NULL;
287 }
288
289 if (size == -100) {
290 size = bsize;
291 }
292 return PyUnicode_FromStringAndSize(s, size);
293 }
294
295 /* Test PyUnicode_FromString() */
296 static PyObject *
297 unicode_fromstring(PyObject *self, PyObject *arg)
298 {
299 const char *s;
300 Py_ssize_t size;
301
302 if (!PyArg_Parse(arg, "z#", &s, &size)) {
303 return NULL;
304 }
305 return PyUnicode_FromString(s);
306 }
307
308 /* Test PyUnicode_FromKindAndData() */
309 static PyObject *
310 unicode_fromkindanddata(PyObject *self, PyObject *args)
311 {
312 int kind;
313 void *buffer;
314 Py_ssize_t bsize;
315 Py_ssize_t size = -100;
316
317 if (!PyArg_ParseTuple(args, "iz#|n", &kind, &buffer, &bsize, &size)) {
318 return NULL;
319 }
320
321 if (size == -100) {
322 size = bsize;
323 }
324 if (kind && size % kind) {
325 PyErr_SetString(PyExc_AssertionError,
326 "invalid size in unicode_fromkindanddata()");
327 return NULL;
328 }
329 return PyUnicode_FromKindAndData(kind, buffer, kind ? size / kind : 0);
330 }
331
332 /* Test PyUnicode_Substring() */
333 static PyObject *
334 unicode_substring(PyObject *self, PyObject *args)
335 {
336 PyObject *str;
337 Py_ssize_t start, end;
338
339 if (!PyArg_ParseTuple(args, "Onn", &str, &start, &end)) {
340 return NULL;
341 }
342
343 NULLABLE(str);
344 return PyUnicode_Substring(str, start, end);
345 }
346
347 /* Test PyUnicode_GetLength() */
348 static PyObject *
349 unicode_getlength(PyObject *self, PyObject *arg)
350 {
351 NULLABLE(arg);
352 RETURN_SIZE(PyUnicode_GetLength(arg));
353 }
354
355 /* Test PyUnicode_ReadChar() */
356 static PyObject *
357 unicode_readchar(PyObject *self, PyObject *args)
358 {
359 PyObject *unicode;
360 Py_ssize_t index;
361 Py_UCS4 result;
362
363 if (!PyArg_ParseTuple(args, "On", &unicode, &index)) {
364 return NULL;
365 }
366
367 NULLABLE(unicode);
368 result = PyUnicode_ReadChar(unicode, index);
369 if (result == (Py_UCS4)-1)
370 return NULL;
371 return PyLong_FromUnsignedLong(result);
372 }
373
374 /* Test PyUnicode_FromEncodedObject() */
375 static PyObject *
376 unicode_fromencodedobject(PyObject *self, PyObject *args)
377 {
378 PyObject *obj;
379 const char *encoding;
380 const char *errors = NULL;
381
382 if (!PyArg_ParseTuple(args, "Oz|z", &obj, &encoding, &errors)) {
383 return NULL;
384 }
385
386 NULLABLE(obj);
387 return PyUnicode_FromEncodedObject(obj, encoding, errors);
388 }
389
390 /* Test PyUnicode_FromObject() */
391 static PyObject *
392 unicode_fromobject(PyObject *self, PyObject *arg)
393 {
394 NULLABLE(arg);
395 return PyUnicode_FromObject(arg);
396 }
397
398 /* Test PyUnicode_InternInPlace() */
399 static PyObject *
400 unicode_interninplace(PyObject *self, PyObject *arg)
401 {
402 NULLABLE(arg);
403 Py_XINCREF(arg);
404 PyUnicode_InternInPlace(&arg);
405 return arg;
406 }
407
408 /* Test PyUnicode_InternFromString() */
409 static PyObject *
410 unicode_internfromstring(PyObject *self, PyObject *arg)
411 {
412 const char *s;
413 Py_ssize_t size;
414
415 if (!PyArg_Parse(arg, "z#", &s, &size)) {
416 return NULL;
417 }
418 return PyUnicode_InternFromString(s);
419 }
420
421 /* Test PyUnicode_FromWideChar() */
422 static PyObject *
423 unicode_fromwidechar(PyObject *self, PyObject *args)
424 {
425 const char *s;
426 Py_ssize_t bsize;
427 Py_ssize_t size = -100;
428
429 if (!PyArg_ParseTuple(args, "z#|n", &s, &bsize, &size)) {
430 return NULL;
431 }
432 if (size == -100) {
433 if (bsize % SIZEOF_WCHAR_T) {
434 PyErr_SetString(PyExc_AssertionError,
435 "invalid size in unicode_fromwidechar()");
436 return NULL;
437 }
438 size = bsize / SIZEOF_WCHAR_T;
439 }
440 return PyUnicode_FromWideChar((const wchar_t *)s, size);
441 }
442
443 /* Test PyUnicode_AsWideChar() */
444 static PyObject *
445 unicode_aswidechar(PyObject *self, PyObject *args)
446 {
447 PyObject *unicode, *result;
448 Py_ssize_t buflen, size;
449 wchar_t *buffer;
450
451 if (!PyArg_ParseTuple(args, "On", &unicode, &buflen))
452 return NULL;
453 NULLABLE(unicode);
454 buffer = PyMem_New(wchar_t, buflen);
455 if (buffer == NULL)
456 return PyErr_NoMemory();
457
458 size = PyUnicode_AsWideChar(unicode, buffer, buflen);
459 if (size == -1) {
460 PyMem_Free(buffer);
461 return NULL;
462 }
463
464 if (size < buflen)
465 buflen = size + 1;
466 else
467 buflen = size;
468 result = PyUnicode_FromWideChar(buffer, buflen);
469 PyMem_Free(buffer);
470 if (result == NULL)
471 return NULL;
472
473 return Py_BuildValue("(Nn)", result, size);
474 }
475
476 /* Test PyUnicode_AsWideCharString() with NULL as buffer */
477 static PyObject *
478 unicode_aswidechar_null(PyObject *self, PyObject *args)
479 {
480 PyObject *unicode;
481 Py_ssize_t buflen;
482
483 if (!PyArg_ParseTuple(args, "On", &unicode, &buflen))
484 return NULL;
485 NULLABLE(unicode);
486 RETURN_SIZE(PyUnicode_AsWideChar(unicode, NULL, buflen));
487 }
488
489 /* Test PyUnicode_AsWideCharString() */
490 static PyObject *
491 unicode_aswidecharstring(PyObject *self, PyObject *args)
492 {
493 PyObject *unicode, *result;
494 Py_ssize_t size = UNINITIALIZED_SIZE;
495 wchar_t *buffer;
496
497 if (!PyArg_ParseTuple(args, "O", &unicode))
498 return NULL;
499
500 NULLABLE(unicode);
501 buffer = PyUnicode_AsWideCharString(unicode, &size);
502 if (buffer == NULL) {
503 assert(size == UNINITIALIZED_SIZE);
504 return NULL;
505 }
506
507 result = PyUnicode_FromWideChar(buffer, size + 1);
508 PyMem_Free(buffer);
509 if (result == NULL)
510 return NULL;
511 return Py_BuildValue("(Nn)", result, size);
512 }
513
514 /* Test PyUnicode_AsWideCharString() with NULL as the size address */
515 static PyObject *
516 unicode_aswidecharstring_null(PyObject *self, PyObject *args)
517 {
518 PyObject *unicode, *result;
519 wchar_t *buffer;
520
521 if (!PyArg_ParseTuple(args, "O", &unicode))
522 return NULL;
523
524 NULLABLE(unicode);
525 buffer = PyUnicode_AsWideCharString(unicode, NULL);
526 if (buffer == NULL)
527 return NULL;
528
529 result = PyUnicode_FromWideChar(buffer, -1);
530 PyMem_Free(buffer);
531 if (result == NULL)
532 return NULL;
533 return result;
534 }
535
536 /* Test PyUnicode_AsUCS4() */
537 static PyObject *
538 unicode_asucs4(PyObject *self, PyObject *args)
539 {
540 PyObject *unicode, *result;
541 Py_UCS4 *buffer;
542 int copy_null;
543 Py_ssize_t str_len, buf_len;
544
545 if (!PyArg_ParseTuple(args, "Onp:unicode_asucs4", &unicode, &str_len, ©_null)) {
546 return NULL;
547 }
548
549 NULLABLE(unicode);
550 buf_len = str_len + 1;
551 buffer = PyMem_NEW(Py_UCS4, buf_len);
552 if (buffer == NULL) {
553 return PyErr_NoMemory();
554 }
555 memset(buffer, 0, sizeof(Py_UCS4)*buf_len);
556 buffer[str_len] = 0xffffU;
557
558 if (!PyUnicode_AsUCS4(unicode, buffer, buf_len, copy_null)) {
559 PyMem_Free(buffer);
560 return NULL;
561 }
562
563 result = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, buffer, buf_len);
564 PyMem_Free(buffer);
565 return result;
566 }
567
568 /* Test PyUnicode_AsUCS4Copy() */
569 static PyObject *
570 unicode_asucs4copy(PyObject *self, PyObject *args)
571 {
572 PyObject *unicode;
573 Py_UCS4 *buffer;
574 PyObject *result;
575
576 if (!PyArg_ParseTuple(args, "O", &unicode)) {
577 return NULL;
578 }
579
580 NULLABLE(unicode);
581 buffer = PyUnicode_AsUCS4Copy(unicode);
582 if (buffer == NULL) {
583 return NULL;
584 }
585 result = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND,
586 buffer,
587 PyUnicode_GET_LENGTH(unicode) + 1);
588 PyMem_FREE(buffer);
589 return result;
590 }
591
592 /* Test PyUnicode_FromOrdinal() */
593 static PyObject *
594 unicode_fromordinal(PyObject *self, PyObject *args)
595 {
596 int ordinal;
597
598 if (!PyArg_ParseTuple(args, "i", &ordinal))
599 return NULL;
600
601 return PyUnicode_FromOrdinal(ordinal);
602 }
603
604 /* Test PyUnicode_AsUTF8() */
605 static PyObject *
606 unicode_asutf8(PyObject *self, PyObject *args)
607 {
608 PyObject *unicode;
609 Py_ssize_t buflen;
610 const char *s;
611
612 if (!PyArg_ParseTuple(args, "On", &unicode, &buflen))
613 return NULL;
614
615 NULLABLE(unicode);
616 s = PyUnicode_AsUTF8(unicode);
617 if (s == NULL)
618 return NULL;
619
620 return PyBytes_FromStringAndSize(s, buflen);
621 }
622
623 /* Test PyUnicode_AsUTF8AndSize() */
624 static PyObject *
625 unicode_asutf8andsize(PyObject *self, PyObject *args)
626 {
627 PyObject *unicode;
628 Py_ssize_t buflen;
629 const char *s;
630 Py_ssize_t size = UNINITIALIZED_SIZE;
631
632 if (!PyArg_ParseTuple(args, "On", &unicode, &buflen))
633 return NULL;
634
635 NULLABLE(unicode);
636 s = PyUnicode_AsUTF8AndSize(unicode, &size);
637 if (s == NULL) {
638 assert(size == UNINITIALIZED_SIZE);
639 return NULL;
640 }
641
642 return Py_BuildValue("(y#n)", s, buflen, size);
643 }
644
645 /* Test PyUnicode_AsUTF8AndSize() with NULL as the size address */
646 static PyObject *
647 unicode_asutf8andsize_null(PyObject *self, PyObject *args)
648 {
649 PyObject *unicode;
650 Py_ssize_t buflen;
651 const char *s;
652
653 if (!PyArg_ParseTuple(args, "On", &unicode, &buflen))
654 return NULL;
655
656 NULLABLE(unicode);
657 s = PyUnicode_AsUTF8AndSize(unicode, NULL);
658 if (s == NULL)
659 return NULL;
660
661 return PyBytes_FromStringAndSize(s, buflen);
662 }
663
664 /* Test PyUnicode_GetDefaultEncoding() */
665 static PyObject *
666 unicode_getdefaultencoding(PyObject *self, PyObject *Py_UNUSED(ignored))
667 {
668 const char *s = PyUnicode_GetDefaultEncoding();
669 if (s == NULL)
670 return NULL;
671
672 return PyBytes_FromString(s);
673 }
674
675 /* Test _PyUnicode_TransformDecimalAndSpaceToASCII() */
676 static PyObject *
677 unicode_transformdecimalandspacetoascii(PyObject *self, PyObject *arg)
678 {
679 NULLABLE(arg);
680 return _PyUnicode_TransformDecimalAndSpaceToASCII(arg);
681 }
682
683 /* Test PyUnicode_Decode() */
684 static PyObject *
685 unicode_decode(PyObject *self, PyObject *args)
686 {
687 const char *s;
688 Py_ssize_t size;
689 const char *encoding;
690 const char *errors = NULL;
691
692 if (!PyArg_ParseTuple(args, "y#z|z", &s, &size, &encoding, &errors))
693 return NULL;
694
695 return PyUnicode_Decode(s, size, encoding, errors);
696 }
697
698 /* Test PyUnicode_AsEncodedString() */
699 static PyObject *
700 unicode_asencodedstring(PyObject *self, PyObject *args)
701 {
702 PyObject *unicode;
703 const char *encoding;
704 const char *errors = NULL;
705
706 if (!PyArg_ParseTuple(args, "Oz|z", &unicode, &encoding, &errors))
707 return NULL;
708
709 NULLABLE(unicode);
710 return PyUnicode_AsEncodedString(unicode, encoding, errors);
711 }
712
713 /* Test PyUnicode_BuildEncodingMap() */
714 static PyObject *
715 unicode_buildencodingmap(PyObject *self, PyObject *arg)
716 {
717 NULLABLE(arg);
718 return PyUnicode_BuildEncodingMap(arg);
719 }
720
721 /* Test PyUnicode_DecodeUTF7() */
722 static PyObject *
723 unicode_decodeutf7(PyObject *self, PyObject *args)
724 {
725 const char *data;
726 Py_ssize_t size;
727 const char *errors = NULL;
728
729 if (!PyArg_ParseTuple(args, "y#|z", &data, &size, &errors))
730 return NULL;
731
732 return PyUnicode_DecodeUTF7(data, size, errors);
733 }
734
735 /* Test PyUnicode_DecodeUTF7Stateful() */
736 static PyObject *
737 unicode_decodeutf7stateful(PyObject *self, PyObject *args)
738 {
739 const char *data;
740 Py_ssize_t size;
741 const char *errors = NULL;
742 Py_ssize_t consumed = UNINITIALIZED_SIZE;
743 PyObject *result;
744
745 if (!PyArg_ParseTuple(args, "y#|z", &data, &size, &errors))
746 return NULL;
747
748 result = PyUnicode_DecodeUTF7Stateful(data, size, errors, &consumed);
749 if (!result) {
750 assert(consumed == UNINITIALIZED_SIZE);
751 return NULL;
752 }
753 return Py_BuildValue("(Nn)", result, consumed);
754 }
755
756 /* Test PyUnicode_DecodeUTF8() */
757 static PyObject *
758 unicode_decodeutf8(PyObject *self, PyObject *args)
759 {
760 const char *data;
761 Py_ssize_t size;
762 const char *errors = NULL;
763
764 if (!PyArg_ParseTuple(args, "y#|z", &data, &size, &errors))
765 return NULL;
766
767 return PyUnicode_DecodeUTF8(data, size, errors);
768 }
769
770 /* Test PyUnicode_DecodeUTF8Stateful() */
771 static PyObject *
772 unicode_decodeutf8stateful(PyObject *self, PyObject *args)
773 {
774 const char *data;
775 Py_ssize_t size;
776 const char *errors = NULL;
777 Py_ssize_t consumed = UNINITIALIZED_SIZE;
778 PyObject *result;
779
780 if (!PyArg_ParseTuple(args, "y#|z", &data, &size, &errors))
781 return NULL;
782
783 result = PyUnicode_DecodeUTF8Stateful(data, size, errors, &consumed);
784 if (!result) {
785 assert(consumed == UNINITIALIZED_SIZE);
786 return NULL;
787 }
788 return Py_BuildValue("(Nn)", result, consumed);
789 }
790
791 /* Test PyUnicode_AsUTF8String() */
792 static PyObject *
793 unicode_asutf8string(PyObject *self, PyObject *arg)
794 {
795 NULLABLE(arg);
796 return PyUnicode_AsUTF8String(arg);
797 }
798
799 /* Test PyUnicode_DecodeUTF32() */
800 static PyObject *
801 unicode_decodeutf32(PyObject *self, PyObject *args)
802 {
803 const char *data;
804 Py_ssize_t size;
805 const char *errors = NULL;
806 int byteorder = UNINITIALIZED_INT;
807 PyObject *result;
808
809 if (!PyArg_ParseTuple(args, "iy#|z", &byteorder, &data, &size, &errors))
810 return NULL;
811
812 result = PyUnicode_DecodeUTF32(data, size, errors, &byteorder);
813 if (!result) {
814 return NULL;
815 }
816 return Py_BuildValue("(iN)", byteorder, result);
817 }
818
819 /* Test PyUnicode_DecodeUTF32Stateful() */
820 static PyObject *
821 unicode_decodeutf32stateful(PyObject *self, PyObject *args)
822 {
823 const char *data;
824 Py_ssize_t size;
825 const char *errors = NULL;
826 int byteorder = UNINITIALIZED_INT;
827 Py_ssize_t consumed = UNINITIALIZED_SIZE;
828 PyObject *result;
829
830 if (!PyArg_ParseTuple(args, "iy#|z", &byteorder, &data, &size, &errors))
831 return NULL;
832
833 result = PyUnicode_DecodeUTF32Stateful(data, size, errors, &byteorder, &consumed);
834 if (!result) {
835 assert(consumed == UNINITIALIZED_SIZE);
836 return NULL;
837 }
838 return Py_BuildValue("(iNn)", byteorder, result, consumed);
839 }
840
841 /* Test PyUnicode_AsUTF32String() */
842 static PyObject *
843 unicode_asutf32string(PyObject *self, PyObject *arg)
844 {
845 NULLABLE(arg);
846 return PyUnicode_AsUTF32String(arg);
847 }
848
849 /* Test PyUnicode_DecodeUTF16() */
850 static PyObject *
851 unicode_decodeutf16(PyObject *self, PyObject *args)
852 {
853 const char *data;
854 Py_ssize_t size;
855 const char *errors = NULL;
856 int byteorder = UNINITIALIZED_INT;
857 PyObject *result;
858
859 if (!PyArg_ParseTuple(args, "iy#|z", &byteorder, &data, &size, &errors))
860 return NULL;
861
862 result = PyUnicode_DecodeUTF16(data, size, errors, &byteorder);
863 if (!result) {
864 return NULL;
865 }
866 return Py_BuildValue("(iN)", byteorder, result);
867 }
868
869 /* Test PyUnicode_DecodeUTF16Stateful() */
870 static PyObject *
871 unicode_decodeutf16stateful(PyObject *self, PyObject *args)
872 {
873 const char *data;
874 Py_ssize_t size;
875 const char *errors = NULL;
876 int byteorder = UNINITIALIZED_INT;
877 Py_ssize_t consumed = UNINITIALIZED_SIZE;
878 PyObject *result;
879
880 if (!PyArg_ParseTuple(args, "iy#|z", &byteorder, &data, &size, &errors))
881 return NULL;
882
883 result = PyUnicode_DecodeUTF16Stateful(data, size, errors, &byteorder, &consumed);
884 if (!result) {
885 assert(consumed == UNINITIALIZED_SIZE);
886 return NULL;
887 }
888 return Py_BuildValue("(iNn)", byteorder, result, consumed);
889 }
890
891 /* Test PyUnicode_AsUTF16String() */
892 static PyObject *
893 unicode_asutf16string(PyObject *self, PyObject *arg)
894 {
895 NULLABLE(arg);
896 return PyUnicode_AsUTF16String(arg);
897 }
898
899 /* Test PyUnicode_DecodeUnicodeEscape() */
900 static PyObject *
901 unicode_decodeunicodeescape(PyObject *self, PyObject *args)
902 {
903 const char *data;
904 Py_ssize_t size;
905 const char *errors = NULL;
906
907 if (!PyArg_ParseTuple(args, "y#|z", &data, &size, &errors))
908 return NULL;
909
910 return PyUnicode_DecodeUnicodeEscape(data, size, errors);
911 }
912
913 /* Test PyUnicode_AsUnicodeEscapeString() */
914 static PyObject *
915 unicode_asunicodeescapestring(PyObject *self, PyObject *arg)
916 {
917 NULLABLE(arg);
918 return PyUnicode_AsUnicodeEscapeString(arg);
919 }
920
921 static PyObject *
922 unicode_decoderawunicodeescape(PyObject *self, PyObject *args)
923 {
924 const char *data;
925 Py_ssize_t size;
926 const char *errors = NULL;
927
928 if (!PyArg_ParseTuple(args, "y#|z", &data, &size, &errors))
929 return NULL;
930
931 return PyUnicode_DecodeRawUnicodeEscape(data, size, errors);
932 }
933
934 /* Test PyUnicode_AsRawUnicodeEscapeString() */
935 static PyObject *
936 unicode_asrawunicodeescapestring(PyObject *self, PyObject *arg)
937 {
938 NULLABLE(arg);
939 return PyUnicode_AsRawUnicodeEscapeString(arg);
940 }
941
942 static PyObject *
943 unicode_decodelatin1(PyObject *self, PyObject *args)
944 {
945 const char *data;
946 Py_ssize_t size;
947 const char *errors = NULL;
948
949 if (!PyArg_ParseTuple(args, "y#|z", &data, &size, &errors))
950 return NULL;
951
952 return PyUnicode_DecodeLatin1(data, size, errors);
953 }
954
955 /* Test PyUnicode_AsLatin1String() */
956 static PyObject *
957 unicode_aslatin1string(PyObject *self, PyObject *arg)
958 {
959 NULLABLE(arg);
960 return PyUnicode_AsLatin1String(arg);
961 }
962
963 /* Test PyUnicode_DecodeASCII() */
964 static PyObject *
965 unicode_decodeascii(PyObject *self, PyObject *args)
966 {
967 const char *data;
968 Py_ssize_t size;
969 const char *errors = NULL;
970
971 if (!PyArg_ParseTuple(args, "y#|z", &data, &size, &errors))
972 return NULL;
973
974 return PyUnicode_DecodeASCII(data, size, errors);
975 }
976
977 /* Test PyUnicode_AsASCIIString() */
978 static PyObject *
979 unicode_asasciistring(PyObject *self, PyObject *arg)
980 {
981 NULLABLE(arg);
982 return PyUnicode_AsASCIIString(arg);
983 }
984
985 /* Test PyUnicode_DecodeCharmap() */
986 static PyObject *
987 unicode_decodecharmap(PyObject *self, PyObject *args)
988 {
989 const char *data;
990 Py_ssize_t size;
991 PyObject *mapping;
992 const char *errors = NULL;
993
994 if (!PyArg_ParseTuple(args, "y#O|z", &data, &size, &mapping, &errors))
995 return NULL;
996
997 NULLABLE(mapping);
998 return PyUnicode_DecodeCharmap(data, size, mapping, errors);
999 }
1000
1001 /* Test PyUnicode_AsCharmapString() */
1002 static PyObject *
1003 unicode_ascharmapstring(PyObject *self, PyObject *args)
1004 {
1005 PyObject *unicode;
1006 PyObject *mapping;
1007
1008 if (!PyArg_ParseTuple(args, "OO", &unicode, &mapping))
1009 return NULL;
1010
1011 NULLABLE(unicode);
1012 NULLABLE(mapping);
1013 return PyUnicode_AsCharmapString(unicode, mapping);
1014 }
1015
1016 #ifdef MS_WINDOWS
1017
1018 /* Test PyUnicode_DecodeMBCS() */
1019 static PyObject *
1020 unicode_decodembcs(PyObject *self, PyObject *args)
1021 {
1022 const char *data;
1023 Py_ssize_t size;
1024 const char *errors = NULL;
1025
1026 if (!PyArg_ParseTuple(args, "y#|z", &data, &size, &errors))
1027 return NULL;
1028
1029 return PyUnicode_DecodeMBCS(data, size, errors);
1030 }
1031
1032 /* Test PyUnicode_DecodeMBCSStateful() */
1033 static PyObject *
1034 unicode_decodembcsstateful(PyObject *self, PyObject *args)
1035 {
1036 const char *data;
1037 Py_ssize_t size;
1038 const char *errors = NULL;
1039 Py_ssize_t consumed = UNINITIALIZED_SIZE;
1040 PyObject *result;
1041
1042 if (!PyArg_ParseTuple(args, "y#|z", &data, &size, &errors))
1043 return NULL;
1044
1045 result = PyUnicode_DecodeMBCSStateful(data, size, errors, &consumed);
1046 if (!result) {
1047 assert(consumed == UNINITIALIZED_SIZE);
1048 return NULL;
1049 }
1050 return Py_BuildValue("(Nn)", result, consumed);
1051 }
1052
1053 /* Test PyUnicode_DecodeCodePageStateful() */
1054 static PyObject *
1055 unicode_decodecodepagestateful(PyObject *self, PyObject *args)
1056 {
1057 int code_page;
1058 const char *data;
1059 Py_ssize_t size;
1060 const char *errors = NULL;
1061 Py_ssize_t consumed = UNINITIALIZED_SIZE;
1062 PyObject *result;
1063
1064 if (!PyArg_ParseTuple(args, "iy#|z", &code_page, &data, &size, &errors))
1065 return NULL;
1066
1067 result = PyUnicode_DecodeCodePageStateful(code_page, data, size, errors, &consumed);
1068 if (!result) {
1069 assert(consumed == UNINITIALIZED_SIZE);
1070 return NULL;
1071 }
1072 return Py_BuildValue("(Nn)", result, consumed);
1073 }
1074
1075 /* Test PyUnicode_AsMBCSString() */
1076 static PyObject *
1077 unicode_asmbcsstring(PyObject *self, PyObject *arg)
1078 {
1079 NULLABLE(arg);
1080 return PyUnicode_AsMBCSString(arg);
1081 }
1082
1083 /* Test PyUnicode_EncodeCodePage() */
1084 static PyObject *
1085 unicode_encodecodepage(PyObject *self, PyObject *args)
1086 {
1087 int code_page;
1088 PyObject *unicode;
1089 const char *errors;
1090
1091 if (!PyArg_ParseTuple(args, "iO|z", &code_page, &unicode, &errors))
1092 return NULL;
1093
1094 NULLABLE(unicode);
1095 return PyUnicode_EncodeCodePage(code_page, unicode, errors);
1096 }
1097
1098 #endif /* MS_WINDOWS */
1099
1100 /* Test PyUnicode_DecodeLocaleAndSize() */
1101 static PyObject *
1102 unicode_decodelocaleandsize(PyObject *self, PyObject *args)
1103 {
1104 const char *data;
1105 Py_ssize_t size;
1106 const char *errors;
1107
1108 if (!PyArg_ParseTuple(args, "y#|z", &data, &size, &errors))
1109 return NULL;
1110
1111 return PyUnicode_DecodeLocaleAndSize(data, size, errors);
1112 }
1113
1114 /* Test PyUnicode_DecodeLocale() */
1115 static PyObject *
1116 unicode_decodelocale(PyObject *self, PyObject *args)
1117 {
1118 const char *data;
1119 Py_ssize_t size;
1120 const char *errors;
1121
1122 if (!PyArg_ParseTuple(args, "y#|z", &data, &size, &errors))
1123 return NULL;
1124
1125 return PyUnicode_DecodeLocale(data, errors);
1126 }
1127
1128 /* Test PyUnicode_EncodeLocale() */
1129 static PyObject *
1130 unicode_encodelocale(PyObject *self, PyObject *args)
1131 {
1132 PyObject *unicode;
1133 const char *errors;
1134
1135 if (!PyArg_ParseTuple(args, "O|z", &unicode, &errors))
1136 return NULL;
1137
1138 NULLABLE(unicode);
1139 return PyUnicode_EncodeLocale(unicode, errors);
1140 }
1141
1142 /* Test PyUnicode_DecodeFSDefault() */
1143 static PyObject *
1144 unicode_decodefsdefault(PyObject *self, PyObject *args)
1145 {
1146 const char *data;
1147 Py_ssize_t size;
1148
1149 if (!PyArg_ParseTuple(args, "y#", &data, &size))
1150 return NULL;
1151
1152 return PyUnicode_DecodeFSDefault(data);
1153 }
1154
1155 /* Test PyUnicode_DecodeFSDefaultAndSize() */
1156 static PyObject *
1157 unicode_decodefsdefaultandsize(PyObject *self, PyObject *args)
1158 {
1159 const char *data;
1160 Py_ssize_t size;
1161
1162 if (!PyArg_ParseTuple(args, "y#|n", &data, &size, &size))
1163 return NULL;
1164
1165 return PyUnicode_DecodeFSDefaultAndSize(data, size);
1166 }
1167
1168 /* Test PyUnicode_EncodeFSDefault() */
1169 static PyObject *
1170 unicode_encodefsdefault(PyObject *self, PyObject *arg)
1171 {
1172 NULLABLE(arg);
1173 return PyUnicode_EncodeFSDefault(arg);
1174 }
1175
1176 /* Test PyUnicode_Concat() */
1177 static PyObject *
1178 unicode_concat(PyObject *self, PyObject *args)
1179 {
1180 PyObject *left;
1181 PyObject *right;
1182
1183 if (!PyArg_ParseTuple(args, "OO", &left, &right))
1184 return NULL;
1185
1186 NULLABLE(left);
1187 NULLABLE(right);
1188 return PyUnicode_Concat(left, right);
1189 }
1190
1191 /* Test PyUnicode_Split() */
1192 static PyObject *
1193 unicode_split(PyObject *self, PyObject *args)
1194 {
1195 PyObject *s;
1196 PyObject *sep;
1197 Py_ssize_t maxsplit = -1;
1198
1199 if (!PyArg_ParseTuple(args, "OO|n", &s, &sep, &maxsplit))
1200 return NULL;
1201
1202 NULLABLE(s);
1203 NULLABLE(sep);
1204 return PyUnicode_Split(s, sep, maxsplit);
1205 }
1206
1207 /* Test PyUnicode_RSplit() */
1208 static PyObject *
1209 unicode_rsplit(PyObject *self, PyObject *args)
1210 {
1211 PyObject *s;
1212 PyObject *sep;
1213 Py_ssize_t maxsplit = -1;
1214
1215 if (!PyArg_ParseTuple(args, "OO|n", &s, &sep, &maxsplit))
1216 return NULL;
1217
1218 NULLABLE(s);
1219 NULLABLE(sep);
1220 return PyUnicode_RSplit(s, sep, maxsplit);
1221 }
1222
1223 /* Test PyUnicode_Splitlines() */
1224 static PyObject *
1225 unicode_splitlines(PyObject *self, PyObject *args)
1226 {
1227 PyObject *s;
1228 int keepends = 0;
1229
1230 if (!PyArg_ParseTuple(args, "O|i", &s, &keepends))
1231 return NULL;
1232
1233 NULLABLE(s);
1234 return PyUnicode_Splitlines(s, keepends);
1235 }
1236
1237 /* Test PyUnicode_Partition() */
1238 static PyObject *
1239 unicode_partition(PyObject *self, PyObject *args)
1240 {
1241 PyObject *s;
1242 PyObject *sep;
1243
1244 if (!PyArg_ParseTuple(args, "OO", &s, &sep))
1245 return NULL;
1246
1247 NULLABLE(s);
1248 NULLABLE(sep);
1249 return PyUnicode_Partition(s, sep);
1250 }
1251
1252 /* Test PyUnicode_RPartition() */
1253 static PyObject *
1254 unicode_rpartition(PyObject *self, PyObject *args)
1255 {
1256 PyObject *s;
1257 PyObject *sep;
1258
1259 if (!PyArg_ParseTuple(args, "OO", &s, &sep))
1260 return NULL;
1261
1262 NULLABLE(s);
1263 NULLABLE(sep);
1264 return PyUnicode_RPartition(s, sep);
1265 }
1266
1267 /* Test PyUnicode_Translate() */
1268 static PyObject *
1269 unicode_translate(PyObject *self, PyObject *args)
1270 {
1271 PyObject *obj;
1272 PyObject *table;
1273 const char *errors = NULL;
1274
1275 if (!PyArg_ParseTuple(args, "OO|z", &obj, &table, &errors))
1276 return NULL;
1277
1278 NULLABLE(obj);
1279 NULLABLE(table);
1280 return PyUnicode_Translate(obj, table, errors);
1281 }
1282
1283 /* Test PyUnicode_Join() */
1284 static PyObject *
1285 unicode_join(PyObject *self, PyObject *args)
1286 {
1287 PyObject *sep;
1288 PyObject *seq;
1289
1290 if (!PyArg_ParseTuple(args, "OO", &sep, &seq))
1291 return NULL;
1292
1293 NULLABLE(sep);
1294 NULLABLE(seq);
1295 return PyUnicode_Join(sep, seq);
1296 }
1297
1298 /* Test PyUnicode_Count() */
1299 static PyObject *
1300 unicode_count(PyObject *self, PyObject *args)
1301 {
1302 PyObject *str;
1303 PyObject *substr;
1304 Py_ssize_t start;
1305 Py_ssize_t end;
1306
1307 if (!PyArg_ParseTuple(args, "OOnn", &str, &substr, &start, &end))
1308 return NULL;
1309
1310 NULLABLE(str);
1311 NULLABLE(substr);
1312 RETURN_SIZE(PyUnicode_Count(str, substr, start, end));
1313 }
1314
1315 /* Test PyUnicode_Find() */
1316 static PyObject *
1317 unicode_find(PyObject *self, PyObject *args)
1318 {
1319 PyObject *str;
1320 PyObject *substr;
1321 Py_ssize_t start;
1322 Py_ssize_t end;
1323 int direction;
1324 Py_ssize_t result;
1325
1326 if (!PyArg_ParseTuple(args, "OOnni", &str, &substr, &start, &end, &direction))
1327 return NULL;
1328
1329 NULLABLE(str);
1330 NULLABLE(substr);
1331 result = PyUnicode_Find(str, substr, start, end, direction);
1332 if (result == -2) {
1333 assert(PyErr_Occurred());
1334 return NULL;
1335 }
1336 assert(!PyErr_Occurred());
1337 return PyLong_FromSsize_t(result);
1338 }
1339
1340 /* Test PyUnicode_Tailmatch() */
1341 static PyObject *
1342 unicode_tailmatch(PyObject *self, PyObject *args)
1343 {
1344 PyObject *str;
1345 PyObject *substr;
1346 Py_ssize_t start;
1347 Py_ssize_t end;
1348 int direction;
1349
1350 if (!PyArg_ParseTuple(args, "OOnni", &str, &substr, &start, &end, &direction))
1351 return NULL;
1352
1353 NULLABLE(str);
1354 NULLABLE(substr);
1355 RETURN_SIZE(PyUnicode_Tailmatch(str, substr, start, end, direction));
1356 }
1357
1358 /* Test PyUnicode_FindChar() */
1359 static PyObject *
1360 unicode_findchar(PyObject *self, PyObject *args)
1361 {
1362 PyObject *str;
1363 int direction;
1364 unsigned int ch;
1365 Py_ssize_t result;
1366 Py_ssize_t start, end;
1367
1368 if (!PyArg_ParseTuple(args, "OInni:unicode_findchar", &str, &ch,
1369 &start, &end, &direction)) {
1370 return NULL;
1371 }
1372 NULLABLE(str);
1373 result = PyUnicode_FindChar(str, (Py_UCS4)ch, start, end, direction);
1374 if (result == -2) {
1375 assert(PyErr_Occurred());
1376 return NULL;
1377 }
1378 assert(!PyErr_Occurred());
1379 return PyLong_FromSsize_t(result);
1380 }
1381
1382 /* Test PyUnicode_Replace() */
1383 static PyObject *
1384 unicode_replace(PyObject *self, PyObject *args)
1385 {
1386 PyObject *str;
1387 PyObject *substr;
1388 PyObject *replstr;
1389 Py_ssize_t maxcount = -1;
1390
1391 if (!PyArg_ParseTuple(args, "OOO|n", &str, &substr, &replstr, &maxcount))
1392 return NULL;
1393
1394 NULLABLE(str);
1395 NULLABLE(substr);
1396 NULLABLE(replstr);
1397 return PyUnicode_Replace(str, substr, replstr, maxcount);
1398 }
1399
1400 /* Test PyUnicode_Compare() */
1401 static PyObject *
1402 unicode_compare(PyObject *self, PyObject *args)
1403 {
1404 PyObject *left;
1405 PyObject *right;
1406 int result;
1407
1408 if (!PyArg_ParseTuple(args, "OO", &left, &right))
1409 return NULL;
1410
1411 NULLABLE(left);
1412 NULLABLE(right);
1413 result = PyUnicode_Compare(left, right);
1414 if (result == -1 && PyErr_Occurred()) {
1415 return NULL;
1416 }
1417 assert(!PyErr_Occurred());
1418 return PyLong_FromLong(result);
1419 }
1420
1421 /* Test PyUnicode_CompareWithASCIIString() */
1422 static PyObject *
1423 unicode_comparewithasciistring(PyObject *self, PyObject *args)
1424 {
1425 PyObject *left;
1426 const char *right = NULL;
1427 Py_ssize_t right_len;
1428 int result;
1429
1430 if (!PyArg_ParseTuple(args, "O|y#", &left, &right, &right_len))
1431 return NULL;
1432
1433 NULLABLE(left);
1434 result = PyUnicode_CompareWithASCIIString(left, right);
1435 if (result == -1 && PyErr_Occurred()) {
1436 return NULL;
1437 }
1438 return PyLong_FromLong(result);
1439 }
1440
1441 /* Test PyUnicode_RichCompare() */
1442 static PyObject *
1443 unicode_richcompare(PyObject *self, PyObject *args)
1444 {
1445 PyObject *left;
1446 PyObject *right;
1447 int op;
1448
1449 if (!PyArg_ParseTuple(args, "OOi", &left, &right, &op))
1450 return NULL;
1451
1452 NULLABLE(left);
1453 NULLABLE(right);
1454 return PyUnicode_RichCompare(left, right, op);
1455 }
1456
1457 /* Test PyUnicode_Format() */
1458 static PyObject *
1459 unicode_format(PyObject *self, PyObject *args)
1460 {
1461 PyObject *format;
1462 PyObject *fargs;
1463
1464 if (!PyArg_ParseTuple(args, "OO", &format, &fargs))
1465 return NULL;
1466
1467 NULLABLE(format);
1468 NULLABLE(fargs);
1469 return PyUnicode_Format(format, fargs);
1470 }
1471
1472 /* Test PyUnicode_Contains() */
1473 static PyObject *
1474 unicode_contains(PyObject *self, PyObject *args)
1475 {
1476 PyObject *container;
1477 PyObject *element;
1478
1479 if (!PyArg_ParseTuple(args, "OO", &container, &element))
1480 return NULL;
1481
1482 NULLABLE(container);
1483 NULLABLE(element);
1484 RETURN_INT(PyUnicode_Contains(container, element));
1485 }
1486
1487 /* Test PyUnicode_IsIdentifier() */
1488 static PyObject *
1489 unicode_isidentifier(PyObject *self, PyObject *arg)
1490 {
1491 NULLABLE(arg);
1492 RETURN_INT(PyUnicode_IsIdentifier(arg));
1493 }
1494
1495 /* Test PyUnicode_CopyCharacters() */
1496 static PyObject *
1497 unicode_copycharacters(PyObject *self, PyObject *args)
1498 {
1499 PyObject *from, *to, *to_copy;
1500 Py_ssize_t from_start, to_start, how_many, copied;
1501
1502 if (!PyArg_ParseTuple(args, "UnOnn", &to, &to_start,
1503 &from, &from_start, &how_many)) {
1504 return NULL;
1505 }
1506
1507 NULLABLE(from);
1508 if (!(to_copy = PyUnicode_New(PyUnicode_GET_LENGTH(to),
1509 PyUnicode_MAX_CHAR_VALUE(to)))) {
1510 return NULL;
1511 }
1512 if (PyUnicode_Fill(to_copy, 0, PyUnicode_GET_LENGTH(to_copy), 0U) < 0) {
1513 Py_DECREF(to_copy);
1514 return NULL;
1515 }
1516
1517 copied = PyUnicode_CopyCharacters(to_copy, to_start, from,
1518 from_start, how_many);
1519 if (copied == -1 && PyErr_Occurred()) {
1520 Py_DECREF(to_copy);
1521 return NULL;
1522 }
1523
1524 return Py_BuildValue("(Nn)", to_copy, copied);
1525 }
1526
1527 static int
1528 check_raised_systemerror(PyObject *result, char* msg)
1529 {
1530 if (result) {
1531 // no exception
1532 PyErr_Format(PyExc_AssertionError,
1533 "SystemError not raised: %s",
1534 msg);
1535 return 0;
1536 }
1537 if (PyErr_ExceptionMatches(PyExc_SystemError)) {
1538 // expected exception
1539 PyErr_Clear();
1540 return 1;
1541 }
1542 // unexpected exception
1543 return 0;
1544 }
1545
1546 static PyObject *
1547 test_string_from_format(PyObject *self, PyObject *Py_UNUSED(ignored))
1548 {
1549 PyObject *result;
1550 PyObject *unicode = PyUnicode_FromString("None");
1551
1552 #define CHECK_FORMAT_2(FORMAT, EXPECTED, ARG1, ARG2) \
1553 result = PyUnicode_FromFormat(FORMAT, ARG1, ARG2); \
1554 if (EXPECTED == NULL) { \
1555 if (!check_raised_systemerror(result, FORMAT)) { \
1556 goto Fail; \
1557 } \
1558 } \
1559 else if (result == NULL) \
1560 return NULL; \
1561 else if (!_PyUnicode_EqualToASCIIString(result, EXPECTED)) { \
1562 PyErr_Format(PyExc_AssertionError, \
1563 "test_string_from_format: failed at \"%s\" " \
1564 "expected \"%s\" got \"%s\"", \
1565 FORMAT, EXPECTED, PyUnicode_AsUTF8(result)); \
1566 goto Fail; \
1567 } \
1568 Py_XDECREF(result)
1569
1570 #define CHECK_FORMAT_1(FORMAT, EXPECTED, ARG) \
1571 CHECK_FORMAT_2(FORMAT, EXPECTED, ARG, 0)
1572
1573 #define CHECK_FORMAT_0(FORMAT, EXPECTED) \
1574 CHECK_FORMAT_2(FORMAT, EXPECTED, 0, 0)
1575
1576 // Unrecognized
1577 CHECK_FORMAT_2("%u %? %u", NULL, 1, 2);
1578
1579 // "%%" (options are rejected)
1580 CHECK_FORMAT_0( "%%", "%");
1581 CHECK_FORMAT_0( "%0%", NULL);
1582 CHECK_FORMAT_0("%00%", NULL);
1583 CHECK_FORMAT_0( "%2%", NULL);
1584 CHECK_FORMAT_0("%02%", NULL);
1585 CHECK_FORMAT_0("%.0%", NULL);
1586 CHECK_FORMAT_0("%.2%", NULL);
1587
1588 // "%c"
1589 CHECK_FORMAT_1( "%c", "c", 'c');
1590 CHECK_FORMAT_1( "%0c", "c", 'c');
1591 CHECK_FORMAT_1("%00c", "c", 'c');
1592 CHECK_FORMAT_1( "%2c", NULL, 'c');
1593 CHECK_FORMAT_1("%02c", NULL, 'c');
1594 CHECK_FORMAT_1("%.0c", NULL, 'c');
1595 CHECK_FORMAT_1("%.2c", NULL, 'c');
1596
1597 // Integers
1598 CHECK_FORMAT_1("%d", "123", (int)123);
1599 CHECK_FORMAT_1("%i", "123", (int)123);
1600 CHECK_FORMAT_1("%u", "123", (unsigned int)123);
1601 CHECK_FORMAT_1("%x", "7b", (unsigned int)123);
1602 CHECK_FORMAT_1("%X", "7B", (unsigned int)123);
1603 CHECK_FORMAT_1("%o", "173", (unsigned int)123);
1604 CHECK_FORMAT_1("%ld", "123", (long)123);
1605 CHECK_FORMAT_1("%li", "123", (long)123);
1606 CHECK_FORMAT_1("%lu", "123", (unsigned long)123);
1607 CHECK_FORMAT_1("%lx", "7b", (unsigned long)123);
1608 CHECK_FORMAT_1("%lX", "7B", (unsigned long)123);
1609 CHECK_FORMAT_1("%lo", "173", (unsigned long)123);
1610 CHECK_FORMAT_1("%lld", "123", (long long)123);
1611 CHECK_FORMAT_1("%lli", "123", (long long)123);
1612 CHECK_FORMAT_1("%llu", "123", (unsigned long long)123);
1613 CHECK_FORMAT_1("%llx", "7b", (unsigned long long)123);
1614 CHECK_FORMAT_1("%llX", "7B", (unsigned long long)123);
1615 CHECK_FORMAT_1("%llo", "173", (unsigned long long)123);
1616 CHECK_FORMAT_1("%zd", "123", (Py_ssize_t)123);
1617 CHECK_FORMAT_1("%zi", "123", (Py_ssize_t)123);
1618 CHECK_FORMAT_1("%zu", "123", (size_t)123);
1619 CHECK_FORMAT_1("%zx", "7b", (size_t)123);
1620 CHECK_FORMAT_1("%zX", "7B", (size_t)123);
1621 CHECK_FORMAT_1("%zo", "173", (size_t)123);
1622 CHECK_FORMAT_1("%td", "123", (ptrdiff_t)123);
1623 CHECK_FORMAT_1("%ti", "123", (ptrdiff_t)123);
1624 CHECK_FORMAT_1("%tu", "123", (ptrdiff_t)123);
1625 CHECK_FORMAT_1("%tx", "7b", (ptrdiff_t)123);
1626 CHECK_FORMAT_1("%tX", "7B", (ptrdiff_t)123);
1627 CHECK_FORMAT_1("%to", "173", (ptrdiff_t)123);
1628 CHECK_FORMAT_1("%jd", "123", (intmax_t)123);
1629 CHECK_FORMAT_1("%ji", "123", (intmax_t)123);
1630 CHECK_FORMAT_1("%ju", "123", (uintmax_t)123);
1631 CHECK_FORMAT_1("%jx", "7b", (uintmax_t)123);
1632 CHECK_FORMAT_1("%jX", "7B", (uintmax_t)123);
1633 CHECK_FORMAT_1("%jo", "173", (uintmax_t)123);
1634
1635 CHECK_FORMAT_1("%d", "-123", (int)-123);
1636 CHECK_FORMAT_1("%i", "-123", (int)-123);
1637 CHECK_FORMAT_1("%ld", "-123", (long)-123);
1638 CHECK_FORMAT_1("%li", "-123", (long)-123);
1639 CHECK_FORMAT_1("%lld", "-123", (long long)-123);
1640 CHECK_FORMAT_1("%lli", "-123", (long long)-123);
1641 CHECK_FORMAT_1("%zd", "-123", (Py_ssize_t)-123);
1642 CHECK_FORMAT_1("%zi", "-123", (Py_ssize_t)-123);
1643 CHECK_FORMAT_1("%td", "-123", (ptrdiff_t)-123);
1644 CHECK_FORMAT_1("%ti", "-123", (ptrdiff_t)-123);
1645 CHECK_FORMAT_1("%jd", "-123", (intmax_t)-123);
1646 CHECK_FORMAT_1("%ji", "-123", (intmax_t)-123);
1647
1648 // Integers: width < length
1649 CHECK_FORMAT_1("%1d", "123", (int)123);
1650 CHECK_FORMAT_1("%1i", "123", (int)123);
1651 CHECK_FORMAT_1("%1u", "123", (unsigned int)123);
1652 CHECK_FORMAT_1("%1ld", "123", (long)123);
1653 CHECK_FORMAT_1("%1li", "123", (long)123);
1654 CHECK_FORMAT_1("%1lu", "123", (unsigned long)123);
1655 CHECK_FORMAT_1("%1lld", "123", (long long)123);
1656 CHECK_FORMAT_1("%1lli", "123", (long long)123);
1657 CHECK_FORMAT_1("%1llu", "123", (unsigned long long)123);
1658 CHECK_FORMAT_1("%1zd", "123", (Py_ssize_t)123);
1659 CHECK_FORMAT_1("%1zi", "123", (Py_ssize_t)123);
1660 CHECK_FORMAT_1("%1zu", "123", (size_t)123);
1661 CHECK_FORMAT_1("%1x", "7b", (int)123);
1662
1663 CHECK_FORMAT_1("%1d", "-123", (int)-123);
1664 CHECK_FORMAT_1("%1i", "-123", (int)-123);
1665 CHECK_FORMAT_1("%1ld", "-123", (long)-123);
1666 CHECK_FORMAT_1("%1li", "-123", (long)-123);
1667 CHECK_FORMAT_1("%1lld", "-123", (long long)-123);
1668 CHECK_FORMAT_1("%1lli", "-123", (long long)-123);
1669 CHECK_FORMAT_1("%1zd", "-123", (Py_ssize_t)-123);
1670 CHECK_FORMAT_1("%1zi", "-123", (Py_ssize_t)-123);
1671
1672 // Integers: width > length
1673 CHECK_FORMAT_1("%5d", " 123", (int)123);
1674 CHECK_FORMAT_1("%5i", " 123", (int)123);
1675 CHECK_FORMAT_1("%5u", " 123", (unsigned int)123);
1676 CHECK_FORMAT_1("%5ld", " 123", (long)123);
1677 CHECK_FORMAT_1("%5li", " 123", (long)123);
1678 CHECK_FORMAT_1("%5lu", " 123", (unsigned long)123);
1679 CHECK_FORMAT_1("%5lld", " 123", (long long)123);
1680 CHECK_FORMAT_1("%5lli", " 123", (long long)123);
1681 CHECK_FORMAT_1("%5llu", " 123", (unsigned long long)123);
1682 CHECK_FORMAT_1("%5zd", " 123", (Py_ssize_t)123);
1683 CHECK_FORMAT_1("%5zi", " 123", (Py_ssize_t)123);
1684 CHECK_FORMAT_1("%5zu", " 123", (size_t)123);
1685 CHECK_FORMAT_1("%5x", " 7b", (int)123);
1686
1687 CHECK_FORMAT_1("%5d", " -123", (int)-123);
1688 CHECK_FORMAT_1("%5i", " -123", (int)-123);
1689 CHECK_FORMAT_1("%5ld", " -123", (long)-123);
1690 CHECK_FORMAT_1("%5li", " -123", (long)-123);
1691 CHECK_FORMAT_1("%5lld", " -123", (long long)-123);
1692 CHECK_FORMAT_1("%5lli", " -123", (long long)-123);
1693 CHECK_FORMAT_1("%5zd", " -123", (Py_ssize_t)-123);
1694 CHECK_FORMAT_1("%5zi", " -123", (Py_ssize_t)-123);
1695
1696 // Integers: width > length, 0-flag
1697 CHECK_FORMAT_1("%05d", "00123", (int)123);
1698 CHECK_FORMAT_1("%05i", "00123", (int)123);
1699 CHECK_FORMAT_1("%05u", "00123", (unsigned int)123);
1700 CHECK_FORMAT_1("%05ld", "00123", (long)123);
1701 CHECK_FORMAT_1("%05li", "00123", (long)123);
1702 CHECK_FORMAT_1("%05lu", "00123", (unsigned long)123);
1703 CHECK_FORMAT_1("%05lld", "00123", (long long)123);
1704 CHECK_FORMAT_1("%05lli", "00123", (long long)123);
1705 CHECK_FORMAT_1("%05llu", "00123", (unsigned long long)123);
1706 CHECK_FORMAT_1("%05zd", "00123", (Py_ssize_t)123);
1707 CHECK_FORMAT_1("%05zi", "00123", (Py_ssize_t)123);
1708 CHECK_FORMAT_1("%05zu", "00123", (size_t)123);
1709 CHECK_FORMAT_1("%05x", "0007b", (int)123);
1710
1711 CHECK_FORMAT_1("%05d", "-0123", (int)-123);
1712 CHECK_FORMAT_1("%05i", "-0123", (int)-123);
1713 CHECK_FORMAT_1("%05ld", "-0123", (long)-123);
1714 CHECK_FORMAT_1("%05li", "-0123", (long)-123);
1715 CHECK_FORMAT_1("%05lld", "-0123", (long long)-123);
1716 CHECK_FORMAT_1("%05lli", "-0123", (long long)-123);
1717 CHECK_FORMAT_1("%05zd", "-0123", (Py_ssize_t)-123);
1718 CHECK_FORMAT_1("%05zi", "-0123", (Py_ssize_t)-123);
1719
1720 // Integers: precision < length
1721 CHECK_FORMAT_1("%.1d", "123", (int)123);
1722 CHECK_FORMAT_1("%.1i", "123", (int)123);
1723 CHECK_FORMAT_1("%.1u", "123", (unsigned int)123);
1724 CHECK_FORMAT_1("%.1ld", "123", (long)123);
1725 CHECK_FORMAT_1("%.1li", "123", (long)123);
1726 CHECK_FORMAT_1("%.1lu", "123", (unsigned long)123);
1727 CHECK_FORMAT_1("%.1lld", "123", (long long)123);
1728 CHECK_FORMAT_1("%.1lli", "123", (long long)123);
1729 CHECK_FORMAT_1("%.1llu", "123", (unsigned long long)123);
1730 CHECK_FORMAT_1("%.1zd", "123", (Py_ssize_t)123);
1731 CHECK_FORMAT_1("%.1zi", "123", (Py_ssize_t)123);
1732 CHECK_FORMAT_1("%.1zu", "123", (size_t)123);
1733 CHECK_FORMAT_1("%.1x", "7b", (int)123);
1734
1735 CHECK_FORMAT_1("%.1d", "-123", (int)-123);
1736 CHECK_FORMAT_1("%.1i", "-123", (int)-123);
1737 CHECK_FORMAT_1("%.1ld", "-123", (long)-123);
1738 CHECK_FORMAT_1("%.1li", "-123", (long)-123);
1739 CHECK_FORMAT_1("%.1lld", "-123", (long long)-123);
1740 CHECK_FORMAT_1("%.1lli", "-123", (long long)-123);
1741 CHECK_FORMAT_1("%.1zd", "-123", (Py_ssize_t)-123);
1742 CHECK_FORMAT_1("%.1zi", "-123", (Py_ssize_t)-123);
1743
1744 // Integers: precision > length
1745 CHECK_FORMAT_1("%.5d", "00123", (int)123);
1746 CHECK_FORMAT_1("%.5i", "00123", (int)123);
1747 CHECK_FORMAT_1("%.5u", "00123", (unsigned int)123);
1748 CHECK_FORMAT_1("%.5ld", "00123", (long)123);
1749 CHECK_FORMAT_1("%.5li", "00123", (long)123);
1750 CHECK_FORMAT_1("%.5lu", "00123", (unsigned long)123);
1751 CHECK_FORMAT_1("%.5lld", "00123", (long long)123);
1752 CHECK_FORMAT_1("%.5lli", "00123", (long long)123);
1753 CHECK_FORMAT_1("%.5llu", "00123", (unsigned long long)123);
1754 CHECK_FORMAT_1("%.5zd", "00123", (Py_ssize_t)123);
1755 CHECK_FORMAT_1("%.5zi", "00123", (Py_ssize_t)123);
1756 CHECK_FORMAT_1("%.5zu", "00123", (size_t)123);
1757 CHECK_FORMAT_1("%.5x", "0007b", (int)123);
1758
1759 CHECK_FORMAT_1("%.5d", "-00123", (int)-123);
1760 CHECK_FORMAT_1("%.5i", "-00123", (int)-123);
1761 CHECK_FORMAT_1("%.5ld", "-00123", (long)-123);
1762 CHECK_FORMAT_1("%.5li", "-00123", (long)-123);
1763 CHECK_FORMAT_1("%.5lld", "-00123", (long long)-123);
1764 CHECK_FORMAT_1("%.5lli", "-00123", (long long)-123);
1765 CHECK_FORMAT_1("%.5zd", "-00123", (Py_ssize_t)-123);
1766 CHECK_FORMAT_1("%.5zi", "-00123", (Py_ssize_t)-123);
1767
1768 // Integers: width > precision > length
1769 CHECK_FORMAT_1("%7.5d", " 00123", (int)123);
1770 CHECK_FORMAT_1("%7.5i", " 00123", (int)123);
1771 CHECK_FORMAT_1("%7.5u", " 00123", (unsigned int)123);
1772 CHECK_FORMAT_1("%7.5ld", " 00123", (long)123);
1773 CHECK_FORMAT_1("%7.5li", " 00123", (long)123);
1774 CHECK_FORMAT_1("%7.5lu", " 00123", (unsigned long)123);
1775 CHECK_FORMAT_1("%7.5lld", " 00123", (long long)123);
1776 CHECK_FORMAT_1("%7.5lli", " 00123", (long long)123);
1777 CHECK_FORMAT_1("%7.5llu", " 00123", (unsigned long long)123);
1778 CHECK_FORMAT_1("%7.5zd", " 00123", (Py_ssize_t)123);
1779 CHECK_FORMAT_1("%7.5zi", " 00123", (Py_ssize_t)123);
1780 CHECK_FORMAT_1("%7.5zu", " 00123", (size_t)123);
1781 CHECK_FORMAT_1("%7.5x", " 0007b", (int)123);
1782
1783 CHECK_FORMAT_1("%7.5d", " -00123", (int)-123);
1784 CHECK_FORMAT_1("%7.5i", " -00123", (int)-123);
1785 CHECK_FORMAT_1("%7.5ld", " -00123", (long)-123);
1786 CHECK_FORMAT_1("%7.5li", " -00123", (long)-123);
1787 CHECK_FORMAT_1("%7.5lld", " -00123", (long long)-123);
1788 CHECK_FORMAT_1("%7.5lli", " -00123", (long long)-123);
1789 CHECK_FORMAT_1("%7.5zd", " -00123", (Py_ssize_t)-123);
1790 CHECK_FORMAT_1("%7.5zi", " -00123", (Py_ssize_t)-123);
1791
1792 // Integers: width > precision > length, 0-flag
1793 CHECK_FORMAT_1("%07.5d", "0000123", (int)123);
1794 CHECK_FORMAT_1("%07.5i", "0000123", (int)123);
1795 CHECK_FORMAT_1("%07.5u", "0000123", (unsigned int)123);
1796 CHECK_FORMAT_1("%07.5ld", "0000123", (long)123);
1797 CHECK_FORMAT_1("%07.5li", "0000123", (long)123);
1798 CHECK_FORMAT_1("%07.5lu", "0000123", (unsigned long)123);
1799 CHECK_FORMAT_1("%07.5lld", "0000123", (long long)123);
1800 CHECK_FORMAT_1("%07.5lli", "0000123", (long long)123);
1801 CHECK_FORMAT_1("%07.5llu", "0000123", (unsigned long long)123);
1802 CHECK_FORMAT_1("%07.5zd", "0000123", (Py_ssize_t)123);
1803 CHECK_FORMAT_1("%07.5zi", "0000123", (Py_ssize_t)123);
1804 CHECK_FORMAT_1("%07.5zu", "0000123", (size_t)123);
1805 CHECK_FORMAT_1("%07.5x", "000007b", (int)123);
1806
1807 CHECK_FORMAT_1("%07.5d", "-000123", (int)-123);
1808 CHECK_FORMAT_1("%07.5i", "-000123", (int)-123);
1809 CHECK_FORMAT_1("%07.5ld", "-000123", (long)-123);
1810 CHECK_FORMAT_1("%07.5li", "-000123", (long)-123);
1811 CHECK_FORMAT_1("%07.5lld", "-000123", (long long)-123);
1812 CHECK_FORMAT_1("%07.5lli", "-000123", (long long)-123);
1813 CHECK_FORMAT_1("%07.5zd", "-000123", (Py_ssize_t)-123);
1814 CHECK_FORMAT_1("%07.5zi", "-000123", (Py_ssize_t)-123);
1815
1816 // Integers: precision > width > length
1817 CHECK_FORMAT_1("%5.7d", "0000123", (int)123);
1818 CHECK_FORMAT_1("%5.7i", "0000123", (int)123);
1819 CHECK_FORMAT_1("%5.7u", "0000123", (unsigned int)123);
1820 CHECK_FORMAT_1("%5.7ld", "0000123", (long)123);
1821 CHECK_FORMAT_1("%5.7li", "0000123", (long)123);
1822 CHECK_FORMAT_1("%5.7lu", "0000123", (unsigned long)123);
1823 CHECK_FORMAT_1("%5.7lld", "0000123", (long long)123);
1824 CHECK_FORMAT_1("%5.7lli", "0000123", (long long)123);
1825 CHECK_FORMAT_1("%5.7llu", "0000123", (unsigned long long)123);
1826 CHECK_FORMAT_1("%5.7zd", "0000123", (Py_ssize_t)123);
1827 CHECK_FORMAT_1("%5.7zi", "0000123", (Py_ssize_t)123);
1828 CHECK_FORMAT_1("%5.7zu", "0000123", (size_t)123);
1829 CHECK_FORMAT_1("%5.7x", "000007b", (int)123);
1830
1831 CHECK_FORMAT_1("%5.7d", "-0000123", (int)-123);
1832 CHECK_FORMAT_1("%5.7i", "-0000123", (int)-123);
1833 CHECK_FORMAT_1("%5.7ld", "-0000123", (long)-123);
1834 CHECK_FORMAT_1("%5.7li", "-0000123", (long)-123);
1835 CHECK_FORMAT_1("%5.7lld", "-0000123", (long long)-123);
1836 CHECK_FORMAT_1("%5.7lli", "-0000123", (long long)-123);
1837 CHECK_FORMAT_1("%5.7zd", "-0000123", (Py_ssize_t)-123);
1838 CHECK_FORMAT_1("%5.7zi", "-0000123", (Py_ssize_t)-123);
1839
1840 // Integers: precision > width > length, 0-flag
1841 CHECK_FORMAT_1("%05.7d", "0000123", (int)123);
1842 CHECK_FORMAT_1("%05.7i", "0000123", (int)123);
1843 CHECK_FORMAT_1("%05.7u", "0000123", (unsigned int)123);
1844 CHECK_FORMAT_1("%05.7ld", "0000123", (long)123);
1845 CHECK_FORMAT_1("%05.7li", "0000123", (long)123);
1846 CHECK_FORMAT_1("%05.7lu", "0000123", (unsigned long)123);
1847 CHECK_FORMAT_1("%05.7lld", "0000123", (long long)123);
1848 CHECK_FORMAT_1("%05.7lli", "0000123", (long long)123);
1849 CHECK_FORMAT_1("%05.7llu", "0000123", (unsigned long long)123);
1850 CHECK_FORMAT_1("%05.7zd", "0000123", (Py_ssize_t)123);
1851 CHECK_FORMAT_1("%05.7zi", "0000123", (Py_ssize_t)123);
1852 CHECK_FORMAT_1("%05.7zu", "0000123", (size_t)123);
1853 CHECK_FORMAT_1("%05.7x", "000007b", (int)123);
1854
1855 CHECK_FORMAT_1("%05.7d", "-0000123", (int)-123);
1856 CHECK_FORMAT_1("%05.7i", "-0000123", (int)-123);
1857 CHECK_FORMAT_1("%05.7ld", "-0000123", (long)-123);
1858 CHECK_FORMAT_1("%05.7li", "-0000123", (long)-123);
1859 CHECK_FORMAT_1("%05.7lld", "-0000123", (long long)-123);
1860 CHECK_FORMAT_1("%05.7lli", "-0000123", (long long)-123);
1861 CHECK_FORMAT_1("%05.7zd", "-0000123", (Py_ssize_t)-123);
1862 CHECK_FORMAT_1("%05.7zi", "-0000123", (Py_ssize_t)-123);
1863
1864 // Integers: precision = 0, arg = 0 (empty string in C)
1865 CHECK_FORMAT_1("%.0d", "0", (int)0);
1866 CHECK_FORMAT_1("%.0i", "0", (int)0);
1867 CHECK_FORMAT_1("%.0u", "0", (unsigned int)0);
1868 CHECK_FORMAT_1("%.0ld", "0", (long)0);
1869 CHECK_FORMAT_1("%.0li", "0", (long)0);
1870 CHECK_FORMAT_1("%.0lu", "0", (unsigned long)0);
1871 CHECK_FORMAT_1("%.0lld", "0", (long long)0);
1872 CHECK_FORMAT_1("%.0lli", "0", (long long)0);
1873 CHECK_FORMAT_1("%.0llu", "0", (unsigned long long)0);
1874 CHECK_FORMAT_1("%.0zd", "0", (Py_ssize_t)0);
1875 CHECK_FORMAT_1("%.0zi", "0", (Py_ssize_t)0);
1876 CHECK_FORMAT_1("%.0zu", "0", (size_t)0);
1877 CHECK_FORMAT_1("%.0x", "0", (int)0);
1878
1879 // Strings
1880 CHECK_FORMAT_1("%s", "None", "None");
1881 CHECK_FORMAT_1("%ls", "None", L"None");
1882 CHECK_FORMAT_1("%U", "None", unicode);
1883 CHECK_FORMAT_1("%A", "None", Py_None);
1884 CHECK_FORMAT_1("%S", "None", Py_None);
1885 CHECK_FORMAT_1("%R", "None", Py_None);
1886 CHECK_FORMAT_2("%V", "None", unicode, "ignored");
1887 CHECK_FORMAT_2("%V", "None", NULL, "None");
1888 CHECK_FORMAT_2("%lV", "None", NULL, L"None");
1889
1890 // Strings: width < length
1891 CHECK_FORMAT_1("%1s", "None", "None");
1892 CHECK_FORMAT_1("%1ls", "None", L"None");
1893 CHECK_FORMAT_1("%1U", "None", unicode);
1894 CHECK_FORMAT_1("%1A", "None", Py_None);
1895 CHECK_FORMAT_1("%1S", "None", Py_None);
1896 CHECK_FORMAT_1("%1R", "None", Py_None);
1897 CHECK_FORMAT_2("%1V", "None", unicode, "ignored");
1898 CHECK_FORMAT_2("%1V", "None", NULL, "None");
1899 CHECK_FORMAT_2("%1lV", "None", NULL, L"None");
1900
1901 // Strings: width > length
1902 CHECK_FORMAT_1("%5s", " None", "None");
1903 CHECK_FORMAT_1("%5ls", " None", L"None");
1904 CHECK_FORMAT_1("%5U", " None", unicode);
1905 CHECK_FORMAT_1("%5A", " None", Py_None);
1906 CHECK_FORMAT_1("%5S", " None", Py_None);
1907 CHECK_FORMAT_1("%5R", " None", Py_None);
1908 CHECK_FORMAT_2("%5V", " None", unicode, "ignored");
1909 CHECK_FORMAT_2("%5V", " None", NULL, "None");
1910 CHECK_FORMAT_2("%5lV", " None", NULL, L"None");
1911
1912 // Strings: precision < length
1913 CHECK_FORMAT_1("%.1s", "N", "None");
1914 CHECK_FORMAT_1("%.1ls", "N", L"None");
1915 CHECK_FORMAT_1("%.1U", "N", unicode);
1916 CHECK_FORMAT_1("%.1A", "N", Py_None);
1917 CHECK_FORMAT_1("%.1S", "N", Py_None);
1918 CHECK_FORMAT_1("%.1R", "N", Py_None);
1919 CHECK_FORMAT_2("%.1V", "N", unicode, "ignored");
1920 CHECK_FORMAT_2("%.1V", "N", NULL, "None");
1921 CHECK_FORMAT_2("%.1lV", "N", NULL, L"None");
1922
1923 // Strings: precision > length
1924 CHECK_FORMAT_1("%.5s", "None", "None");
1925 CHECK_FORMAT_1("%.5ls", "None", L"None");
1926 CHECK_FORMAT_1("%.5U", "None", unicode);
1927 CHECK_FORMAT_1("%.5A", "None", Py_None);
1928 CHECK_FORMAT_1("%.5S", "None", Py_None);
1929 CHECK_FORMAT_1("%.5R", "None", Py_None);
1930 CHECK_FORMAT_2("%.5V", "None", unicode, "ignored");
1931 CHECK_FORMAT_2("%.5V", "None", NULL, "None");
1932 CHECK_FORMAT_2("%.5lV", "None", NULL, L"None");
1933
1934 // Strings: precision < length, width > length
1935 CHECK_FORMAT_1("%5.1s", " N", "None");
1936 CHECK_FORMAT_1("%5.1ls"," N", L"None");
1937 CHECK_FORMAT_1("%5.1U", " N", unicode);
1938 CHECK_FORMAT_1("%5.1A", " N", Py_None);
1939 CHECK_FORMAT_1("%5.1S", " N", Py_None);
1940 CHECK_FORMAT_1("%5.1R", " N", Py_None);
1941 CHECK_FORMAT_2("%5.1V", " N", unicode, "ignored");
1942 CHECK_FORMAT_2("%5.1V", " N", NULL, "None");
1943 CHECK_FORMAT_2("%5.1lV"," N", NULL, L"None");
1944
1945 // Strings: width < length, precision > length
1946 CHECK_FORMAT_1("%1.5s", "None", "None");
1947 CHECK_FORMAT_1("%1.5ls", "None", L"None");
1948 CHECK_FORMAT_1("%1.5U", "None", unicode);
1949 CHECK_FORMAT_1("%1.5A", "None", Py_None);
1950 CHECK_FORMAT_1("%1.5S", "None", Py_None);
1951 CHECK_FORMAT_1("%1.5R", "None", Py_None);
1952 CHECK_FORMAT_2("%1.5V", "None", unicode, "ignored");
1953 CHECK_FORMAT_2("%1.5V", "None", NULL, "None");
1954 CHECK_FORMAT_2("%1.5lV", "None", NULL, L"None");
1955
1956 Py_XDECREF(unicode);
1957 Py_RETURN_NONE;
1958
1959 Fail:
1960 Py_XDECREF(result);
1961 Py_XDECREF(unicode);
1962 return NULL;
1963
1964 #undef CHECK_FORMAT_2
1965 #undef CHECK_FORMAT_1
1966 #undef CHECK_FORMAT_0
1967 }
1968
1969 static PyMethodDef TestMethods[] = {
1970 {"codec_incrementalencoder", codec_incrementalencoder, METH_VARARGS},
1971 {"codec_incrementaldecoder", codec_incrementaldecoder, METH_VARARGS},
1972 {"test_unicode_compare_with_ascii",
1973 test_unicode_compare_with_ascii, METH_NOARGS},
1974 {"test_string_from_format", test_string_from_format, METH_NOARGS},
1975 {"test_widechar", test_widechar, METH_NOARGS},
1976 {"unicode_new", unicode_new, METH_VARARGS},
1977 {"unicode_fill", unicode_fill, METH_VARARGS},
1978 {"unicode_writechar", unicode_writechar, METH_VARARGS},
1979 {"unicode_resize", unicode_resize, METH_VARARGS},
1980 {"unicode_append", unicode_append, METH_VARARGS},
1981 {"unicode_appendanddel", unicode_appendanddel, METH_VARARGS},
1982 {"unicode_fromstringandsize",unicode_fromstringandsize, METH_VARARGS},
1983 {"unicode_fromstring", unicode_fromstring, METH_O},
1984 {"unicode_fromkindanddata", unicode_fromkindanddata, METH_VARARGS},
1985 {"unicode_substring", unicode_substring, METH_VARARGS},
1986 {"unicode_getlength", unicode_getlength, METH_O},
1987 {"unicode_readchar", unicode_readchar, METH_VARARGS},
1988 {"unicode_fromencodedobject",unicode_fromencodedobject, METH_VARARGS},
1989 {"unicode_fromobject", unicode_fromobject, METH_O},
1990 {"unicode_interninplace", unicode_interninplace, METH_O},
1991 {"unicode_internfromstring", unicode_internfromstring, METH_O},
1992 {"unicode_fromwidechar", unicode_fromwidechar, METH_VARARGS},
1993 {"unicode_aswidechar", unicode_aswidechar, METH_VARARGS},
1994 {"unicode_aswidechar_null", unicode_aswidechar_null, METH_VARARGS},
1995 {"unicode_aswidecharstring", unicode_aswidecharstring, METH_VARARGS},
1996 {"unicode_aswidecharstring_null",unicode_aswidecharstring_null,METH_VARARGS},
1997 {"unicode_asucs4", unicode_asucs4, METH_VARARGS},
1998 {"unicode_asucs4copy", unicode_asucs4copy, METH_VARARGS},
1999 {"unicode_fromordinal", unicode_fromordinal, METH_VARARGS},
2000 {"unicode_asutf8", unicode_asutf8, METH_VARARGS},
2001 {"unicode_asutf8andsize", unicode_asutf8andsize, METH_VARARGS},
2002 {"unicode_asutf8andsize_null",unicode_asutf8andsize_null, METH_VARARGS},
2003 {"unicode_getdefaultencoding",unicode_getdefaultencoding, METH_NOARGS},
2004 {"unicode_decode", unicode_decode, METH_VARARGS},
2005 {"unicode_asencodedstring", unicode_asencodedstring, METH_VARARGS},
2006 {"unicode_buildencodingmap", unicode_buildencodingmap, METH_O},
2007 {"unicode_decodeutf7", unicode_decodeutf7, METH_VARARGS},
2008 {"unicode_decodeutf7stateful",unicode_decodeutf7stateful, METH_VARARGS},
2009 {"unicode_decodeutf8", unicode_decodeutf8, METH_VARARGS},
2010 {"unicode_decodeutf8stateful",unicode_decodeutf8stateful, METH_VARARGS},
2011 {"unicode_asutf8string", unicode_asutf8string, METH_O},
2012 {"unicode_decodeutf16", unicode_decodeutf16, METH_VARARGS},
2013 {"unicode_decodeutf16stateful",unicode_decodeutf16stateful, METH_VARARGS},
2014 {"unicode_asutf16string", unicode_asutf16string, METH_O},
2015 {"unicode_decodeutf32", unicode_decodeutf32, METH_VARARGS},
2016 {"unicode_decodeutf32stateful",unicode_decodeutf32stateful, METH_VARARGS},
2017 {"unicode_asutf32string", unicode_asutf32string, METH_O},
2018 {"unicode_decodeunicodeescape",unicode_decodeunicodeescape, METH_VARARGS},
2019 {"unicode_asunicodeescapestring",unicode_asunicodeescapestring,METH_O},
2020 {"unicode_decoderawunicodeescape",unicode_decoderawunicodeescape,METH_VARARGS},
2021 {"unicode_asrawunicodeescapestring",unicode_asrawunicodeescapestring,METH_O},
2022 {"unicode_decodelatin1", unicode_decodelatin1, METH_VARARGS},
2023 {"unicode_aslatin1string", unicode_aslatin1string, METH_O},
2024 {"unicode_decodeascii", unicode_decodeascii, METH_VARARGS},
2025 {"unicode_asasciistring", unicode_asasciistring, METH_O},
2026 {"unicode_decodecharmap", unicode_decodecharmap, METH_VARARGS},
2027 {"unicode_ascharmapstring", unicode_ascharmapstring, METH_VARARGS},
2028 #ifdef MS_WINDOWS
2029 {"unicode_decodembcs", unicode_decodembcs, METH_VARARGS},
2030 {"unicode_decodembcsstateful",unicode_decodembcsstateful, METH_VARARGS},
2031 {"unicode_decodecodepagestateful",unicode_decodecodepagestateful,METH_VARARGS},
2032 {"unicode_asmbcsstring", unicode_asmbcsstring, METH_O},
2033 {"unicode_encodecodepage", unicode_encodecodepage, METH_VARARGS},
2034 #endif /* MS_WINDOWS */
2035 {"unicode_decodelocaleandsize",unicode_decodelocaleandsize, METH_VARARGS},
2036 {"unicode_decodelocale", unicode_decodelocale, METH_VARARGS},
2037 {"unicode_encodelocale", unicode_encodelocale, METH_VARARGS},
2038 {"unicode_decodefsdefault", unicode_decodefsdefault, METH_VARARGS},
2039 {"unicode_decodefsdefaultandsize",unicode_decodefsdefaultandsize,METH_VARARGS},
2040 {"unicode_encodefsdefault", unicode_encodefsdefault, METH_O},
2041 {"unicode_transformdecimalandspacetoascii", unicode_transformdecimalandspacetoascii, METH_O},
2042 {"unicode_concat", unicode_concat, METH_VARARGS},
2043 {"unicode_splitlines", unicode_splitlines, METH_VARARGS},
2044 {"unicode_split", unicode_split, METH_VARARGS},
2045 {"unicode_rsplit", unicode_rsplit, METH_VARARGS},
2046 {"unicode_partition", unicode_partition, METH_VARARGS},
2047 {"unicode_rpartition", unicode_rpartition, METH_VARARGS},
2048 {"unicode_translate", unicode_translate, METH_VARARGS},
2049 {"unicode_join", unicode_join, METH_VARARGS},
2050 {"unicode_count", unicode_count, METH_VARARGS},
2051 {"unicode_tailmatch", unicode_tailmatch, METH_VARARGS},
2052 {"unicode_find", unicode_find, METH_VARARGS},
2053 {"unicode_findchar", unicode_findchar, METH_VARARGS},
2054 {"unicode_replace", unicode_replace, METH_VARARGS},
2055 {"unicode_compare", unicode_compare, METH_VARARGS},
2056 {"unicode_comparewithasciistring",unicode_comparewithasciistring,METH_VARARGS},
2057 {"unicode_richcompare", unicode_richcompare, METH_VARARGS},
2058 {"unicode_format", unicode_format, METH_VARARGS},
2059 {"unicode_contains", unicode_contains, METH_VARARGS},
2060 {"unicode_isidentifier", unicode_isidentifier, METH_O},
2061 {"unicode_copycharacters", unicode_copycharacters, METH_VARARGS},
2062 {NULL},
2063 };
2064
2065 int
2066 _PyTestCapi_Init_Unicode(PyObject *m) {
2067 _testcapimodule = PyModule_GetDef(m);
2068
2069 if (PyModule_AddFunctions(m, TestMethods) < 0) {
2070 return -1;
2071 }
2072
2073 return 0;
2074 }