Branch data Line data Source code
1 : : /*
2 : : * Tests for Python/getargs.c and Python/modsupport.c;
3 : : * APIs that parse and build arguments.
4 : : */
5 : :
6 : : #define PY_SSIZE_T_CLEAN
7 : :
8 : : #include "parts.h"
9 : :
10 : : static PyObject *
11 : 0 : parse_tuple_and_keywords(PyObject *self, PyObject *args)
12 : : {
13 : : PyObject *sub_args;
14 : : PyObject *sub_kwargs;
15 : : const char *sub_format;
16 : : PyObject *sub_keywords;
17 : :
18 : : double buffers[8][4]; /* double ensures alignment where necessary */
19 : : PyObject *converted[8];
20 : : char *keywords[8 + 1]; /* space for NULL at end */
21 : :
22 : 0 : PyObject *return_value = NULL;
23 : :
24 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "OOsO:parse_tuple_and_keywords",
25 : : &sub_args, &sub_kwargs, &sub_format, &sub_keywords))
26 : : {
27 : 0 : return NULL;
28 : : }
29 : :
30 [ # # # # ]: 0 : if (!(PyList_CheckExact(sub_keywords) ||
31 : 0 : PyTuple_CheckExact(sub_keywords)))
32 : : {
33 : 0 : PyErr_SetString(PyExc_ValueError,
34 : : "parse_tuple_and_keywords: "
35 : : "sub_keywords must be either list or tuple");
36 : 0 : return NULL;
37 : : }
38 : :
39 : 0 : memset(buffers, 0, sizeof(buffers));
40 : 0 : memset(converted, 0, sizeof(converted));
41 : 0 : memset(keywords, 0, sizeof(keywords));
42 : :
43 [ # # ]: 0 : Py_ssize_t size = PySequence_Fast_GET_SIZE(sub_keywords);
44 [ # # ]: 0 : if (size > 8) {
45 : 0 : PyErr_SetString(PyExc_ValueError,
46 : : "parse_tuple_and_keywords: too many keywords in sub_keywords");
47 : 0 : goto exit;
48 : : }
49 : :
50 [ # # ]: 0 : for (Py_ssize_t i = 0; i < size; i++) {
51 [ # # # # : 0 : PyObject *o = PySequence_Fast_GET_ITEM(sub_keywords, i);
# # ]
52 [ # # ]: 0 : if (!PyUnicode_FSConverter(o, (void *)(converted + i))) {
53 : 0 : PyErr_Format(PyExc_ValueError,
54 : : "parse_tuple_and_keywords: "
55 : : "could not convert keywords[%zd] to narrow string", i);
56 : 0 : goto exit;
57 : : }
58 : 0 : keywords[i] = PyBytes_AS_STRING(converted[i]);
59 : : }
60 : :
61 : 0 : int result = PyArg_ParseTupleAndKeywords(sub_args, sub_kwargs,
62 : : sub_format, keywords,
63 : : buffers + 0, buffers + 1, buffers + 2, buffers + 3,
64 : : buffers + 4, buffers + 5, buffers + 6, buffers + 7);
65 : :
66 [ # # ]: 0 : if (result) {
67 : 0 : return_value = Py_NewRef(Py_None);
68 : : }
69 : :
70 : 0 : exit:
71 : 0 : size = sizeof(converted) / sizeof(converted[0]);
72 [ # # ]: 0 : for (Py_ssize_t i = 0; i < size; i++) {
73 : 0 : Py_XDECREF(converted[i]);
74 : : }
75 : 0 : return return_value;
76 : : }
77 : :
78 : : static PyObject *
79 : 0 : get_args(PyObject *self, PyObject *args)
80 : : {
81 [ # # ]: 0 : if (args == NULL) {
82 : 0 : args = Py_None;
83 : : }
84 : 0 : return Py_NewRef(args);
85 : : }
86 : :
87 : : static PyObject *
88 : 0 : get_kwargs(PyObject *self, PyObject *args, PyObject *kwargs)
89 : : {
90 [ # # ]: 0 : if (kwargs == NULL) {
91 : 0 : kwargs = Py_None;
92 : : }
93 : 0 : return Py_NewRef(kwargs);
94 : : }
95 : :
96 : : static PyObject *
97 : 0 : getargs_w_star(PyObject *self, PyObject *args)
98 : : {
99 : : Py_buffer buffer;
100 : :
101 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "w*:getargs_w_star", &buffer)) {
102 : 0 : return NULL;
103 : : }
104 : :
105 [ # # ]: 0 : if (2 <= buffer.len) {
106 : 0 : char *str = buffer.buf;
107 : 0 : str[0] = '[';
108 : 0 : str[buffer.len-1] = ']';
109 : : }
110 : :
111 : 0 : PyObject *result = PyBytes_FromStringAndSize(buffer.buf, buffer.len);
112 : 0 : PyBuffer_Release(&buffer);
113 : 0 : return result;
114 : : }
115 : :
116 : : static PyObject *
117 : 0 : test_empty_argparse(PyObject *self, PyObject *Py_UNUSED(ignored))
118 : : {
119 : : /* Test that formats can begin with '|'. See issue #4720. */
120 : 0 : PyObject *dict = NULL;
121 : : static char *kwlist[] = {NULL};
122 : 0 : PyObject *tuple = PyTuple_New(0);
123 [ # # ]: 0 : if (!tuple) {
124 : 0 : return NULL;
125 : : }
126 : : int result;
127 [ # # ]: 0 : if (!(result = PyArg_ParseTuple(tuple, "|:test_empty_argparse"))) {
128 : 0 : goto done;
129 : : }
130 : 0 : dict = PyDict_New();
131 [ # # ]: 0 : if (!dict) {
132 : 0 : goto done;
133 : : }
134 : 0 : result = PyArg_ParseTupleAndKeywords(tuple, dict, "|:test_empty_argparse",
135 : : kwlist);
136 : 0 : done:
137 : 0 : Py_DECREF(tuple);
138 : 0 : Py_XDECREF(dict);
139 [ # # ]: 0 : if (!result) {
140 : 0 : return NULL;
141 : : }
142 : 0 : Py_RETURN_NONE;
143 : : }
144 : :
145 : : /* Test tuple argument processing */
146 : : static PyObject *
147 : 0 : getargs_tuple(PyObject *self, PyObject *args)
148 : : {
149 : : int a, b, c;
150 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "i(ii)", &a, &b, &c)) {
151 : 0 : return NULL;
152 : : }
153 : 0 : return Py_BuildValue("iii", a, b, c);
154 : : }
155 : :
156 : : /* test PyArg_ParseTupleAndKeywords */
157 : : static PyObject *
158 : 0 : getargs_keywords(PyObject *self, PyObject *args, PyObject *kwargs)
159 : : {
160 : : static char *keywords[] = {"arg1","arg2","arg3","arg4","arg5", NULL};
161 : : static const char fmt[] = "(ii)i|(i(ii))(iii)i";
162 : 0 : int int_args[10] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
163 : :
164 [ # # ]: 0 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, fmt, keywords,
165 : : &int_args[0], &int_args[1], &int_args[2], &int_args[3], &int_args[4],
166 : : &int_args[5], &int_args[6], &int_args[7], &int_args[8], &int_args[9]))
167 : : {
168 : 0 : return NULL;
169 : : }
170 : 0 : return Py_BuildValue("iiiiiiiiii",
171 : : int_args[0], int_args[1], int_args[2], int_args[3], int_args[4],
172 : : int_args[5], int_args[6], int_args[7], int_args[8], int_args[9]);
173 : : }
174 : :
175 : : /* test PyArg_ParseTupleAndKeywords keyword-only arguments */
176 : : static PyObject *
177 : 0 : getargs_keyword_only(PyObject *self, PyObject *args, PyObject *kwargs)
178 : : {
179 : : static char *keywords[] = {"required", "optional", "keyword_only", NULL};
180 : 0 : int required = -1;
181 : 0 : int optional = -1;
182 : 0 : int keyword_only = -1;
183 : :
184 [ # # ]: 0 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i|i$i", keywords,
185 : : &required, &optional, &keyword_only))
186 : : {
187 : 0 : return NULL;
188 : : }
189 : 0 : return Py_BuildValue("iii", required, optional, keyword_only);
190 : : }
191 : :
192 : : /* test PyArg_ParseTupleAndKeywords positional-only arguments */
193 : : static PyObject *
194 : 0 : getargs_positional_only_and_keywords(PyObject *self, PyObject *args,
195 : : PyObject *kwargs)
196 : : {
197 : : static char *keywords[] = {"", "", "keyword", NULL};
198 : 0 : int required = -1;
199 : 0 : int optional = -1;
200 : 0 : int keyword = -1;
201 : :
202 [ # # ]: 0 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i|ii", keywords,
203 : : &required, &optional, &keyword))
204 : : {
205 : 0 : return NULL;
206 : : }
207 : 0 : return Py_BuildValue("iii", required, optional, keyword);
208 : : }
209 : :
210 : : /* Functions to call PyArg_ParseTuple with integer format codes,
211 : : and return the result.
212 : : */
213 : : static PyObject *
214 : 0 : getargs_b(PyObject *self, PyObject *args)
215 : : {
216 : : unsigned char value;
217 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "b", &value)) {
218 : 0 : return NULL;
219 : : }
220 : 0 : return PyLong_FromUnsignedLong((unsigned long)value);
221 : : }
222 : :
223 : : static PyObject *
224 : 0 : getargs_B(PyObject *self, PyObject *args)
225 : : {
226 : : unsigned char value;
227 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "B", &value)) {
228 : 0 : return NULL;
229 : : }
230 : 0 : return PyLong_FromUnsignedLong((unsigned long)value);
231 : : }
232 : :
233 : : static PyObject *
234 : 0 : getargs_h(PyObject *self, PyObject *args)
235 : : {
236 : : short value;
237 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "h", &value)) {
238 : 0 : return NULL;
239 : : }
240 : 0 : return PyLong_FromLong((long)value);
241 : : }
242 : :
243 : : static PyObject *
244 : 0 : getargs_H(PyObject *self, PyObject *args)
245 : : {
246 : : unsigned short value;
247 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "H", &value)) {
248 : 0 : return NULL;
249 : : }
250 : 0 : return PyLong_FromUnsignedLong((unsigned long)value);
251 : : }
252 : :
253 : : static PyObject *
254 : 0 : getargs_I(PyObject *self, PyObject *args)
255 : : {
256 : : unsigned int value;
257 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "I", &value)) {
258 : 0 : return NULL;
259 : : }
260 : 0 : return PyLong_FromUnsignedLong((unsigned long)value);
261 : : }
262 : :
263 : : static PyObject *
264 : 0 : getargs_k(PyObject *self, PyObject *args)
265 : : {
266 : : unsigned long value;
267 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "k", &value)) {
268 : 0 : return NULL;
269 : : }
270 : 0 : return PyLong_FromUnsignedLong(value);
271 : : }
272 : :
273 : : static PyObject *
274 : 0 : getargs_i(PyObject *self, PyObject *args)
275 : : {
276 : : int value;
277 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "i", &value)) {
278 : 0 : return NULL;
279 : : }
280 : 0 : return PyLong_FromLong((long)value);
281 : : }
282 : :
283 : : static PyObject *
284 : 0 : getargs_l(PyObject *self, PyObject *args)
285 : : {
286 : : long value;
287 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "l", &value)) {
288 : 0 : return NULL;
289 : : }
290 : 0 : return PyLong_FromLong(value);
291 : : }
292 : :
293 : : static PyObject *
294 : 0 : getargs_n(PyObject *self, PyObject *args)
295 : : {
296 : : Py_ssize_t value;
297 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "n", &value)) {
298 : 0 : return NULL;
299 : : }
300 : 0 : return PyLong_FromSsize_t(value);
301 : : }
302 : :
303 : : static PyObject *
304 : 0 : getargs_p(PyObject *self, PyObject *args)
305 : : {
306 : : int value;
307 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "p", &value)) {
308 : 0 : return NULL;
309 : : }
310 : 0 : return PyLong_FromLong(value);
311 : : }
312 : :
313 : : static PyObject *
314 : 0 : getargs_L(PyObject *self, PyObject *args)
315 : : {
316 : : long long value;
317 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "L", &value)) {
318 : 0 : return NULL;
319 : : }
320 : 0 : return PyLong_FromLongLong(value);
321 : : }
322 : :
323 : : static PyObject *
324 : 0 : getargs_K(PyObject *self, PyObject *args)
325 : : {
326 : : unsigned long long value;
327 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "K", &value)) {
328 : 0 : return NULL;
329 : : }
330 : 0 : return PyLong_FromUnsignedLongLong(value);
331 : : }
332 : :
333 : : /* This function not only tests the 'k' getargs code, but also the
334 : : PyLong_AsUnsignedLongMask() function. */
335 : : static PyObject *
336 : 0 : test_k_code(PyObject *self, PyObject *Py_UNUSED(ignored))
337 : : {
338 : : PyObject *tuple, *num;
339 : : unsigned long value;
340 : :
341 : 0 : tuple = PyTuple_New(1);
342 [ # # ]: 0 : if (tuple == NULL) {
343 : 0 : return NULL;
344 : : }
345 : :
346 : : /* a number larger than ULONG_MAX even on 64-bit platforms */
347 : 0 : num = PyLong_FromString("FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
348 [ # # ]: 0 : if (num == NULL) {
349 : 0 : return NULL;
350 : : }
351 : :
352 : 0 : value = PyLong_AsUnsignedLongMask(num);
353 [ # # ]: 0 : if (value != ULONG_MAX) {
354 : 0 : PyErr_SetString(PyExc_AssertionError,
355 : : "test_k_code: "
356 : : "PyLong_AsUnsignedLongMask() returned wrong value for long 0xFFF...FFF");
357 : 0 : return NULL;
358 : : }
359 : :
360 : 0 : PyTuple_SET_ITEM(tuple, 0, num);
361 : :
362 : 0 : value = 0;
363 [ # # ]: 0 : if (!PyArg_ParseTuple(tuple, "k:test_k_code", &value)) {
364 : 0 : return NULL;
365 : : }
366 [ # # ]: 0 : if (value != ULONG_MAX) {
367 : 0 : PyErr_SetString(PyExc_AssertionError,
368 : : "test_k_code: k code returned wrong value for long 0xFFF...FFF");
369 : 0 : return NULL;
370 : : }
371 : :
372 : 0 : Py_DECREF(num);
373 : 0 : num = PyLong_FromString("-FFFFFFFF000000000000000042", NULL, 16);
374 [ # # ]: 0 : if (num == NULL) {
375 : 0 : return NULL;
376 : : }
377 : :
378 : 0 : value = PyLong_AsUnsignedLongMask(num);
379 [ # # ]: 0 : if (value != (unsigned long)-0x42) {
380 : 0 : PyErr_SetString(PyExc_AssertionError,
381 : : "test_k_code: "
382 : : "PyLong_AsUnsignedLongMask() returned wrong value for long -0xFFF..000042");
383 : 0 : return NULL;
384 : : }
385 : :
386 : 0 : PyTuple_SET_ITEM(tuple, 0, num);
387 : :
388 : 0 : value = 0;
389 [ # # ]: 0 : if (!PyArg_ParseTuple(tuple, "k:test_k_code", &value)) {
390 : 0 : return NULL;
391 : : }
392 [ # # ]: 0 : if (value != (unsigned long)-0x42) {
393 : 0 : PyErr_SetString(PyExc_AssertionError,
394 : : "test_k_code: k code returned wrong value for long -0xFFF..000042");
395 : 0 : return NULL;
396 : : }
397 : :
398 : 0 : Py_DECREF(tuple);
399 : 0 : Py_RETURN_NONE;
400 : : }
401 : :
402 : : static PyObject *
403 : 0 : getargs_f(PyObject *self, PyObject *args)
404 : : {
405 : : float f;
406 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "f", &f)) {
407 : 0 : return NULL;
408 : : }
409 : 0 : return PyFloat_FromDouble(f);
410 : : }
411 : :
412 : : static PyObject *
413 : 0 : getargs_d(PyObject *self, PyObject *args)
414 : : {
415 : : double d;
416 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "d", &d)) {
417 : 0 : return NULL;
418 : : }
419 : 0 : return PyFloat_FromDouble(d);
420 : : }
421 : :
422 : : static PyObject *
423 : 0 : getargs_D(PyObject *self, PyObject *args)
424 : : {
425 : : Py_complex cval;
426 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "D", &cval)) {
427 : 0 : return NULL;
428 : : }
429 : 0 : return PyComplex_FromCComplex(cval);
430 : : }
431 : :
432 : : static PyObject *
433 : 0 : getargs_S(PyObject *self, PyObject *args)
434 : : {
435 : : PyObject *obj;
436 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "S", &obj)) {
437 : 0 : return NULL;
438 : : }
439 : 0 : return Py_NewRef(obj);
440 : : }
441 : :
442 : : static PyObject *
443 : 0 : getargs_Y(PyObject *self, PyObject *args)
444 : : {
445 : : PyObject *obj;
446 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "Y", &obj)) {
447 : 0 : return NULL;
448 : : }
449 : 0 : return Py_NewRef(obj);
450 : : }
451 : :
452 : : static PyObject *
453 : 0 : getargs_U(PyObject *self, PyObject *args)
454 : : {
455 : : PyObject *obj;
456 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "U", &obj)) {
457 : 0 : return NULL;
458 : : }
459 : 0 : return Py_NewRef(obj);
460 : : }
461 : :
462 : : static PyObject *
463 : 0 : getargs_c(PyObject *self, PyObject *args)
464 : : {
465 : : char c;
466 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "c", &c)) {
467 : 0 : return NULL;
468 : : }
469 : 0 : return PyLong_FromLong((unsigned char)c);
470 : : }
471 : :
472 : : static PyObject *
473 : 0 : getargs_C(PyObject *self, PyObject *args)
474 : : {
475 : : int c;
476 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "C", &c)) {
477 : 0 : return NULL;
478 : : }
479 : 0 : return PyLong_FromLong(c);
480 : : }
481 : :
482 : : static PyObject *
483 : 0 : getargs_s(PyObject *self, PyObject *args)
484 : : {
485 : : char *str;
486 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "s", &str)) {
487 : 0 : return NULL;
488 : : }
489 : 0 : return PyBytes_FromString(str);
490 : : }
491 : :
492 : : static PyObject *
493 : 0 : getargs_s_star(PyObject *self, PyObject *args)
494 : : {
495 : : Py_buffer buffer;
496 : : PyObject *bytes;
497 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "s*", &buffer)) {
498 : 0 : return NULL;
499 : : }
500 : 0 : bytes = PyBytes_FromStringAndSize(buffer.buf, buffer.len);
501 : 0 : PyBuffer_Release(&buffer);
502 : 0 : return bytes;
503 : : }
504 : :
505 : : static PyObject *
506 : 0 : getargs_s_hash(PyObject *self, PyObject *args)
507 : : {
508 : : char *str;
509 : : Py_ssize_t size;
510 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "s#", &str, &size)) {
511 : 0 : return NULL;
512 : : }
513 : 0 : return PyBytes_FromStringAndSize(str, size);
514 : : }
515 : :
516 : : static PyObject *
517 : 0 : getargs_z(PyObject *self, PyObject *args)
518 : : {
519 : : char *str;
520 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "z", &str)) {
521 : 0 : return NULL;
522 : : }
523 [ # # ]: 0 : if (str != NULL) {
524 : 0 : return PyBytes_FromString(str);
525 : : }
526 : 0 : Py_RETURN_NONE;
527 : : }
528 : :
529 : : static PyObject *
530 : 0 : getargs_z_star(PyObject *self, PyObject *args)
531 : : {
532 : : Py_buffer buffer;
533 : : PyObject *bytes;
534 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "z*", &buffer)) {
535 : 0 : return NULL;
536 : : }
537 [ # # ]: 0 : if (buffer.buf != NULL) {
538 : 0 : bytes = PyBytes_FromStringAndSize(buffer.buf, buffer.len);
539 : : }
540 : : else {
541 : 0 : bytes = Py_NewRef(Py_None);
542 : : }
543 : 0 : PyBuffer_Release(&buffer);
544 : 0 : return bytes;
545 : : }
546 : :
547 : : static PyObject *
548 : 0 : getargs_z_hash(PyObject *self, PyObject *args)
549 : : {
550 : : char *str;
551 : : Py_ssize_t size;
552 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "z#", &str, &size)) {
553 : 0 : return NULL;
554 : : }
555 [ # # ]: 0 : if (str != NULL) {
556 : 0 : return PyBytes_FromStringAndSize(str, size);
557 : : }
558 : 0 : Py_RETURN_NONE;
559 : : }
560 : :
561 : : static PyObject *
562 : 0 : getargs_y(PyObject *self, PyObject *args)
563 : : {
564 : : char *str;
565 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "y", &str)) {
566 : 0 : return NULL;
567 : : }
568 : 0 : return PyBytes_FromString(str);
569 : : }
570 : :
571 : : static PyObject *
572 : 0 : getargs_y_star(PyObject *self, PyObject *args)
573 : : {
574 : : Py_buffer buffer;
575 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "y*", &buffer)) {
576 : 0 : return NULL;
577 : : }
578 : 0 : PyObject *bytes = PyBytes_FromStringAndSize(buffer.buf, buffer.len);
579 : 0 : PyBuffer_Release(&buffer);
580 : 0 : return bytes;
581 : : }
582 : :
583 : : static PyObject *
584 : 0 : getargs_y_hash(PyObject *self, PyObject *args)
585 : : {
586 : : char *str;
587 : : Py_ssize_t size;
588 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "y#", &str, &size)) {
589 : 0 : return NULL;
590 : : }
591 : 0 : return PyBytes_FromStringAndSize(str, size);
592 : : }
593 : :
594 : : static PyObject *
595 : 0 : getargs_u(PyObject *self, PyObject *args)
596 : : {
597 : : Py_UNICODE *str;
598 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "u", &str)) {
599 : 0 : return NULL;
600 : : }
601 : 0 : return PyUnicode_FromWideChar(str, -1);
602 : : }
603 : :
604 : : static PyObject *
605 : 0 : getargs_u_hash(PyObject *self, PyObject *args)
606 : : {
607 : : Py_UNICODE *str;
608 : : Py_ssize_t size;
609 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "u#", &str, &size)) {
610 : 0 : return NULL;
611 : : }
612 : 0 : return PyUnicode_FromWideChar(str, size);
613 : : }
614 : :
615 : : static PyObject *
616 : 0 : getargs_Z(PyObject *self, PyObject *args)
617 : : {
618 : : Py_UNICODE *str;
619 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "Z", &str)) {
620 : 0 : return NULL;
621 : : }
622 [ # # ]: 0 : if (str != NULL) {
623 : 0 : return PyUnicode_FromWideChar(str, -1);
624 : : }
625 : 0 : Py_RETURN_NONE;
626 : : }
627 : :
628 : : static PyObject *
629 : 0 : getargs_Z_hash(PyObject *self, PyObject *args)
630 : : {
631 : : Py_UNICODE *str;
632 : : Py_ssize_t size;
633 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "Z#", &str, &size)) {
634 : 0 : return NULL;
635 : : }
636 [ # # ]: 0 : if (str != NULL) {
637 : 0 : return PyUnicode_FromWideChar(str, size);
638 : : }
639 : 0 : Py_RETURN_NONE;
640 : : }
641 : :
642 : : static PyObject *
643 : 0 : getargs_es(PyObject *self, PyObject *args)
644 : : {
645 : : PyObject *arg;
646 : 0 : const char *encoding = NULL;
647 : : char *str;
648 : :
649 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "O|s", &arg, &encoding)) {
650 : 0 : return NULL;
651 : : }
652 [ # # ]: 0 : if (!PyArg_Parse(arg, "es", encoding, &str)) {
653 : 0 : return NULL;
654 : : }
655 : 0 : PyObject *result = PyBytes_FromString(str);
656 : 0 : PyMem_Free(str);
657 : 0 : return result;
658 : : }
659 : :
660 : : static PyObject *
661 : 0 : getargs_et(PyObject *self, PyObject *args)
662 : : {
663 : : PyObject *arg;
664 : 0 : const char *encoding = NULL;
665 : : char *str;
666 : :
667 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "O|s", &arg, &encoding)) {
668 : 0 : return NULL;
669 : : }
670 [ # # ]: 0 : if (!PyArg_Parse(arg, "et", encoding, &str)) {
671 : 0 : return NULL;
672 : : }
673 : 0 : PyObject *result = PyBytes_FromString(str);
674 : 0 : PyMem_Free(str);
675 : 0 : return result;
676 : : }
677 : :
678 : : static PyObject *
679 : 0 : getargs_es_hash(PyObject *self, PyObject *args)
680 : : {
681 : : PyObject *arg;
682 : 0 : const char *encoding = NULL;
683 : 0 : PyByteArrayObject *buffer = NULL;
684 : 0 : char *str = NULL;
685 : : Py_ssize_t size;
686 : :
687 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "O|sY", &arg, &encoding, &buffer)) {
688 : 0 : return NULL;
689 : : }
690 [ # # ]: 0 : if (buffer != NULL) {
691 : 0 : str = PyByteArray_AS_STRING(buffer);
692 : 0 : size = PyByteArray_GET_SIZE(buffer);
693 : : }
694 [ # # ]: 0 : if (!PyArg_Parse(arg, "es#", encoding, &str, &size)) {
695 : 0 : return NULL;
696 : : }
697 : 0 : PyObject *result = PyBytes_FromStringAndSize(str, size);
698 [ # # ]: 0 : if (buffer == NULL) {
699 : 0 : PyMem_Free(str);
700 : : }
701 : 0 : return result;
702 : : }
703 : :
704 : : static PyObject *
705 : 0 : getargs_et_hash(PyObject *self, PyObject *args)
706 : : {
707 : : PyObject *arg;
708 : 0 : const char *encoding = NULL;
709 : 0 : PyByteArrayObject *buffer = NULL;
710 : 0 : char *str = NULL;
711 : : Py_ssize_t size;
712 : :
713 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "O|sY", &arg, &encoding, &buffer)) {
714 : 0 : return NULL;
715 : : }
716 [ # # ]: 0 : if (buffer != NULL) {
717 : 0 : str = PyByteArray_AS_STRING(buffer);
718 : 0 : size = PyByteArray_GET_SIZE(buffer);
719 : : }
720 [ # # ]: 0 : if (!PyArg_Parse(arg, "et#", encoding, &str, &size)) {
721 : 0 : return NULL;
722 : : }
723 : 0 : PyObject *result = PyBytes_FromStringAndSize(str, size);
724 [ # # ]: 0 : if (buffer == NULL) {
725 : 0 : PyMem_Free(str);
726 : : }
727 : 0 : return result;
728 : : }
729 : :
730 : : /* Test the L code for PyArg_ParseTuple. This should deliver a long long
731 : : for both long and int arguments. The test may leak a little memory if
732 : : it fails.
733 : : */
734 : : static PyObject *
735 : 0 : test_L_code(PyObject *self, PyObject *Py_UNUSED(ignored))
736 : : {
737 : : PyObject *tuple, *num;
738 : : long long value;
739 : :
740 : 0 : tuple = PyTuple_New(1);
741 [ # # ]: 0 : if (tuple == NULL) {
742 : 0 : return NULL;
743 : : }
744 : :
745 : 0 : num = PyLong_FromLong(42);
746 [ # # ]: 0 : if (num == NULL) {
747 : 0 : return NULL;
748 : : }
749 : :
750 : 0 : PyTuple_SET_ITEM(tuple, 0, num);
751 : :
752 : 0 : value = -1;
753 [ # # ]: 0 : if (!PyArg_ParseTuple(tuple, "L:test_L_code", &value)) {
754 : 0 : return NULL;
755 : : }
756 [ # # ]: 0 : if (value != 42) {
757 : 0 : PyErr_SetString(PyExc_AssertionError,
758 : : "test_L_code: L code returned wrong value for long 42");
759 : 0 : return NULL;
760 : : }
761 : :
762 : 0 : Py_DECREF(num);
763 : 0 : num = PyLong_FromLong(42);
764 [ # # ]: 0 : if (num == NULL) {
765 : 0 : return NULL;
766 : : }
767 : :
768 : 0 : PyTuple_SET_ITEM(tuple, 0, num);
769 : :
770 : 0 : value = -1;
771 [ # # ]: 0 : if (!PyArg_ParseTuple(tuple, "L:test_L_code", &value)) {
772 : 0 : return NULL;
773 : : }
774 [ # # ]: 0 : if (value != 42) {
775 : 0 : PyErr_SetString(PyExc_AssertionError,
776 : : "test_L_code: L code returned wrong value for int 42");
777 : 0 : return NULL;
778 : : }
779 : :
780 : 0 : Py_DECREF(tuple);
781 : 0 : Py_RETURN_NONE;
782 : : }
783 : :
784 : : /* Test the s and z codes for PyArg_ParseTuple.
785 : : */
786 : : static PyObject *
787 : 0 : test_s_code(PyObject *self, PyObject *Py_UNUSED(ignored))
788 : : {
789 : : /* Unicode strings should be accepted */
790 : 0 : PyObject *tuple = PyTuple_New(1);
791 [ # # ]: 0 : if (tuple == NULL) {
792 : 0 : return NULL;
793 : : }
794 : :
795 : 0 : PyObject *obj = PyUnicode_Decode("t\xeate", strlen("t\xeate"),
796 : : "latin-1", NULL);
797 [ # # ]: 0 : if (obj == NULL) {
798 : 0 : return NULL;
799 : : }
800 : :
801 : 0 : PyTuple_SET_ITEM(tuple, 0, obj);
802 : :
803 : : /* These two blocks used to raise a TypeError:
804 : : * "argument must be string without null bytes, not str"
805 : : */
806 : : char *value;
807 [ # # ]: 0 : if (!PyArg_ParseTuple(tuple, "s:test_s_code1", &value)) {
808 : 0 : return NULL;
809 : : }
810 : :
811 [ # # ]: 0 : if (!PyArg_ParseTuple(tuple, "z:test_s_code2", &value)) {
812 : 0 : return NULL;
813 : : }
814 : :
815 : 0 : Py_DECREF(tuple);
816 : 0 : Py_RETURN_NONE;
817 : : }
818 : :
819 : : #undef PyArg_ParseTupleAndKeywords
820 : : PyAPI_FUNC(int) PyArg_ParseTupleAndKeywords(PyObject *, PyObject *,
821 : : const char *, char **, ...);
822 : :
823 : : static PyObject *
824 : 0 : getargs_s_hash_int(PyObject *self, PyObject *args, PyObject *kwargs)
825 : : {
826 : : static char *keywords[] = {"", "", "x", NULL};
827 : 0 : Py_buffer buf = {NULL};
828 : : const char *s;
829 : : int len;
830 : 0 : int i = 0;
831 [ # # ]: 0 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "w*|s#i", keywords,
832 : : &buf, &s, &len, &i))
833 : : {
834 : 0 : return NULL;
835 : : }
836 : 0 : PyBuffer_Release(&buf);
837 : 0 : Py_RETURN_NONE;
838 : : }
839 : :
840 : : static PyObject *
841 : 0 : getargs_s_hash_int2(PyObject *self, PyObject *args, PyObject *kwargs)
842 : : {
843 : : static char *keywords[] = {"", "", "x", NULL};
844 : 0 : Py_buffer buf = {NULL};
845 : : const char *s;
846 : : int len;
847 : 0 : int i = 0;
848 [ # # ]: 0 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "w*|(s#)i", keywords,
849 : : &buf, &s, &len, &i))
850 : : {
851 : 0 : return NULL;
852 : : }
853 : 0 : PyBuffer_Release(&buf);
854 : 0 : Py_RETURN_NONE;
855 : : }
856 : :
857 : : static PyObject *
858 : 0 : gh_99240_clear_args(PyObject *self, PyObject *args)
859 : : {
860 : 0 : char *a = NULL;
861 : 0 : char *b = NULL;
862 : :
863 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "eses", "idna", &a, "idna", &b)) {
864 [ # # # # ]: 0 : if (a || b) {
865 : 0 : PyErr_Clear();
866 : 0 : PyErr_SetString(PyExc_AssertionError, "Arguments are not cleared.");
867 : : }
868 : 0 : return NULL;
869 : : }
870 : 0 : PyMem_Free(a);
871 : 0 : PyMem_Free(b);
872 : 0 : Py_RETURN_NONE;
873 : : }
874 : :
875 : : static PyMethodDef test_methods[] = {
876 : : {"get_args", get_args, METH_VARARGS},
877 : : {"get_kwargs", _PyCFunction_CAST(get_kwargs), METH_VARARGS|METH_KEYWORDS},
878 : : {"getargs_B", getargs_B, METH_VARARGS},
879 : : {"getargs_C", getargs_C, METH_VARARGS},
880 : : {"getargs_D", getargs_D, METH_VARARGS},
881 : : {"getargs_H", getargs_H, METH_VARARGS},
882 : : {"getargs_I", getargs_I, METH_VARARGS},
883 : : {"getargs_K", getargs_K, METH_VARARGS},
884 : : {"getargs_L", getargs_L, METH_VARARGS},
885 : : {"getargs_S", getargs_S, METH_VARARGS},
886 : : {"getargs_U", getargs_U, METH_VARARGS},
887 : : {"getargs_Y", getargs_Y, METH_VARARGS},
888 : : {"getargs_Z", getargs_Z, METH_VARARGS},
889 : : {"getargs_Z_hash", getargs_Z_hash, METH_VARARGS},
890 : : {"getargs_b", getargs_b, METH_VARARGS},
891 : : {"getargs_c", getargs_c, METH_VARARGS},
892 : : {"getargs_d", getargs_d, METH_VARARGS},
893 : : {"getargs_es", getargs_es, METH_VARARGS},
894 : : {"getargs_es_hash", getargs_es_hash, METH_VARARGS},
895 : : {"getargs_et", getargs_et, METH_VARARGS},
896 : : {"getargs_et_hash", getargs_et_hash, METH_VARARGS},
897 : : {"getargs_f", getargs_f, METH_VARARGS},
898 : : {"getargs_h", getargs_h, METH_VARARGS},
899 : : {"getargs_i", getargs_i, METH_VARARGS},
900 : : {"getargs_k", getargs_k, METH_VARARGS},
901 : : {"getargs_keyword_only", _PyCFunction_CAST(getargs_keyword_only), METH_VARARGS|METH_KEYWORDS},
902 : : {"getargs_keywords", _PyCFunction_CAST(getargs_keywords), METH_VARARGS|METH_KEYWORDS},
903 : : {"getargs_l", getargs_l, METH_VARARGS},
904 : : {"getargs_n", getargs_n, METH_VARARGS},
905 : : {"getargs_p", getargs_p, METH_VARARGS},
906 : : {"getargs_positional_only_and_keywords", _PyCFunction_CAST(getargs_positional_only_and_keywords), METH_VARARGS|METH_KEYWORDS},
907 : : {"getargs_s", getargs_s, METH_VARARGS},
908 : : {"getargs_s_hash", getargs_s_hash, METH_VARARGS},
909 : : {"getargs_s_hash_int", _PyCFunction_CAST(getargs_s_hash_int), METH_VARARGS|METH_KEYWORDS},
910 : : {"getargs_s_hash_int2", _PyCFunction_CAST(getargs_s_hash_int2), METH_VARARGS|METH_KEYWORDS},
911 : : {"getargs_s_star", getargs_s_star, METH_VARARGS},
912 : : {"getargs_tuple", getargs_tuple, METH_VARARGS},
913 : : {"getargs_u", getargs_u, METH_VARARGS},
914 : : {"getargs_u_hash", getargs_u_hash, METH_VARARGS},
915 : : {"getargs_w_star", getargs_w_star, METH_VARARGS},
916 : : {"getargs_y", getargs_y, METH_VARARGS},
917 : : {"getargs_y_hash", getargs_y_hash, METH_VARARGS},
918 : : {"getargs_y_star", getargs_y_star, METH_VARARGS},
919 : : {"getargs_z", getargs_z, METH_VARARGS},
920 : : {"getargs_z_hash", getargs_z_hash, METH_VARARGS},
921 : : {"getargs_z_star", getargs_z_star, METH_VARARGS},
922 : : {"parse_tuple_and_keywords", parse_tuple_and_keywords, METH_VARARGS},
923 : : {"test_L_code", test_L_code, METH_NOARGS},
924 : : {"test_empty_argparse", test_empty_argparse, METH_NOARGS},
925 : : {"test_k_code", test_k_code, METH_NOARGS},
926 : : {"test_s_code", test_s_code, METH_NOARGS},
927 : : {"gh_99240_clear_args", gh_99240_clear_args, METH_VARARGS},
928 : : {NULL},
929 : : };
930 : :
931 : : int
932 : 2 : _PyTestCapi_Init_GetArgs(PyObject *mod)
933 : : {
934 [ - + ]: 2 : if (PyModule_AddFunctions(mod, test_methods) < 0) {
935 : 0 : return -1;
936 : : }
937 : :
938 : 2 : return 0;
939 : : }
|