source: vendor/python/2.5/Modules/_testcapimodule.c

Last change on this file was 3225, checked in by bird, 19 years ago

Python 2.5
File size: 19.6 KB
RevLine 
[3225]1/*
2 * C Extension module to test Python interpreter C APIs.
3 *
4 * The 'test_*' functions exported by this module are run as part of the
5 * standard Python regression test, via Lib/test/test_capi.py.
6 */
7
8#include "Python.h"
9
10#ifdef WITH_THREAD
11#include "pythread.h"
12#endif /* WITH_THREAD */
13static PyObject *TestError; /* set to exception object in init */
14
15/* Raise TestError with test_name + ": " + msg, and return NULL. */
16
17static PyObject *
18raiseTestError(const char* test_name, const char* msg)
19{
20 char buf[2048];
21
22 if (strlen(test_name) + strlen(msg) > sizeof(buf) - 50)
23 PyErr_SetString(TestError, "internal error msg too large");
24 else {
25 PyOS_snprintf(buf, sizeof(buf), "%s: %s", test_name, msg);
26 PyErr_SetString(TestError, buf);
27 }
28 return NULL;
29}
30
31/* Test #defines from pyconfig.h (particularly the SIZEOF_* defines).
32
33 The ones derived from autoconf on the UNIX-like OSes can be relied
34 upon (in the absence of sloppy cross-compiling), but the Windows
35 platforms have these hardcoded. Better safe than sorry.
36*/
37static PyObject*
38sizeof_error(const char* fatname, const char* typename,
39 int expected, int got)
40{
41 char buf[1024];
42 PyOS_snprintf(buf, sizeof(buf),
43 "%.200s #define == %d but sizeof(%.200s) == %d",
44 fatname, expected, typename, got);
45 PyErr_SetString(TestError, buf);
46 return (PyObject*)NULL;
47}
48
49static PyObject*
50test_config(PyObject *self)
51{
52#define CHECK_SIZEOF(FATNAME, TYPE) \
53 if (FATNAME != sizeof(TYPE)) \
54 return sizeof_error(#FATNAME, #TYPE, FATNAME, sizeof(TYPE))
55
56 CHECK_SIZEOF(SIZEOF_SHORT, short);
57 CHECK_SIZEOF(SIZEOF_INT, int);
58 CHECK_SIZEOF(SIZEOF_LONG, long);
59 CHECK_SIZEOF(SIZEOF_VOID_P, void*);
60 CHECK_SIZEOF(SIZEOF_TIME_T, time_t);
61#ifdef HAVE_LONG_LONG
62 CHECK_SIZEOF(SIZEOF_LONG_LONG, PY_LONG_LONG);
63#endif
64
65#undef CHECK_SIZEOF
66
67 Py_INCREF(Py_None);
68 return Py_None;
69}
70
71static PyObject*
72test_list_api(PyObject *self)
73{
74 PyObject* list;
75 int i;
76
77 /* SF bug 132008: PyList_Reverse segfaults */
78#define NLIST 30
79 list = PyList_New(NLIST);
80 if (list == (PyObject*)NULL)
81 return (PyObject*)NULL;
82 /* list = range(NLIST) */
83 for (i = 0; i < NLIST; ++i) {
84 PyObject* anint = PyInt_FromLong(i);
85 if (anint == (PyObject*)NULL) {
86 Py_DECREF(list);
87 return (PyObject*)NULL;
88 }
89 PyList_SET_ITEM(list, i, anint);
90 }
91 /* list.reverse(), via PyList_Reverse() */
92 i = PyList_Reverse(list); /* should not blow up! */
93 if (i != 0) {
94 Py_DECREF(list);
95 return (PyObject*)NULL;
96 }
97 /* Check that list == range(29, -1, -1) now */
98 for (i = 0; i < NLIST; ++i) {
99 PyObject* anint = PyList_GET_ITEM(list, i);
100 if (PyInt_AS_LONG(anint) != NLIST-1-i) {
101 PyErr_SetString(TestError,
102 "test_list_api: reverse screwed up");
103 Py_DECREF(list);
104 return (PyObject*)NULL;
105 }
106 }
107 Py_DECREF(list);
108#undef NLIST
109
110 Py_INCREF(Py_None);
111 return Py_None;
112}
113
114static int
115test_dict_inner(int count)
116{
117 Py_ssize_t pos = 0, iterations = 0;
118 int i;
119 PyObject *dict = PyDict_New();
120 PyObject *v, *k;
121
122 if (dict == NULL)
123 return -1;
124
125 for (i = 0; i < count; i++) {
126 v = PyInt_FromLong(i);
127 PyDict_SetItem(dict, v, v);
128 Py_DECREF(v);
129 }
130
131 while (PyDict_Next(dict, &pos, &k, &v)) {
132 PyObject *o;
133 iterations++;
134
135 i = PyInt_AS_LONG(v) + 1;
136 o = PyInt_FromLong(i);
137 if (o == NULL)
138 return -1;
139 if (PyDict_SetItem(dict, k, o) < 0) {
140 Py_DECREF(o);
141 return -1;
142 }
143 Py_DECREF(o);
144 }
145
146 Py_DECREF(dict);
147
148 if (iterations != count) {
149 PyErr_SetString(
150 TestError,
151 "test_dict_iteration: dict iteration went wrong ");
152 return -1;
153 } else {
154 return 0;
155 }
156}
157
158static PyObject*
159test_dict_iteration(PyObject* self)
160{
161 int i;
162
163 for (i = 0; i < 200; i++) {
164 if (test_dict_inner(i) < 0) {
165 return NULL;
166 }
167 }
168
169 Py_INCREF(Py_None);
170 return Py_None;
171}
172
173
174/* Tests of PyLong_{As, From}{Unsigned,}Long(), and (#ifdef HAVE_LONG_LONG)
175 PyLong_{As, From}{Unsigned,}LongLong().
176
177 Note that the meat of the test is contained in testcapi_long.h.
178 This is revolting, but delicate code duplication is worse: "almost
179 exactly the same" code is needed to test PY_LONG_LONG, but the ubiquitous
180 dependence on type names makes it impossible to use a parameterized
181 function. A giant macro would be even worse than this. A C++ template
182 would be perfect.
183
184 The "report an error" functions are deliberately not part of the #include
185 file: if the test fails, you can set a breakpoint in the appropriate
186 error function directly, and crawl back from there in the debugger.
187*/
188
189#define UNBIND(X) Py_DECREF(X); (X) = NULL
190
191static PyObject *
192raise_test_long_error(const char* msg)
193{
194 return raiseTestError("test_long_api", msg);
195}
196
197#define TESTNAME test_long_api_inner
198#define TYPENAME long
199#define F_S_TO_PY PyLong_FromLong
200#define F_PY_TO_S PyLong_AsLong
201#define F_U_TO_PY PyLong_FromUnsignedLong
202#define F_PY_TO_U PyLong_AsUnsignedLong
203
204#include "testcapi_long.h"
205
206static PyObject *
207test_long_api(PyObject* self)
208{
209 return TESTNAME(raise_test_long_error);
210}
211
212#undef TESTNAME
213#undef TYPENAME
214#undef F_S_TO_PY
215#undef F_PY_TO_S
216#undef F_U_TO_PY
217#undef F_PY_TO_U
218
219#ifdef HAVE_LONG_LONG
220
221static PyObject *
222raise_test_longlong_error(const char* msg)
223{
224 return raiseTestError("test_longlong_api", msg);
225}
226
227#define TESTNAME test_longlong_api_inner
228#define TYPENAME PY_LONG_LONG
229#define F_S_TO_PY PyLong_FromLongLong
230#define F_PY_TO_S PyLong_AsLongLong
231#define F_U_TO_PY PyLong_FromUnsignedLongLong
232#define F_PY_TO_U PyLong_AsUnsignedLongLong
233
234#include "testcapi_long.h"
235
236static PyObject *
237test_longlong_api(PyObject* self, PyObject *args)
238{
239 return TESTNAME(raise_test_longlong_error);
240}
241
242#undef TESTNAME
243#undef TYPENAME
244#undef F_S_TO_PY
245#undef F_PY_TO_S
246#undef F_U_TO_PY
247#undef F_PY_TO_U
248
249/* Test the L code for PyArg_ParseTuple. This should deliver a PY_LONG_LONG
250 for both long and int arguments. The test may leak a little memory if
251 it fails.
252*/
253static PyObject *
254test_L_code(PyObject *self)
255{
256 PyObject *tuple, *num;
257 PY_LONG_LONG value;
258
259 tuple = PyTuple_New(1);
260 if (tuple == NULL)
261 return NULL;
262
263 num = PyLong_FromLong(42);
264 if (num == NULL)
265 return NULL;
266
267 PyTuple_SET_ITEM(tuple, 0, num);
268
269 value = -1;
270 if (PyArg_ParseTuple(tuple, "L:test_L_code", &value) < 0)
271 return NULL;
272 if (value != 42)
273 return raiseTestError("test_L_code",
274 "L code returned wrong value for long 42");
275
276 Py_DECREF(num);
277 num = PyInt_FromLong(42);
278 if (num == NULL)
279 return NULL;
280
281 PyTuple_SET_ITEM(tuple, 0, num);
282
283 value = -1;
284 if (PyArg_ParseTuple(tuple, "L:test_L_code", &value) < 0)
285 return NULL;
286 if (value != 42)
287 return raiseTestError("test_L_code",
288 "L code returned wrong value for int 42");
289
290 Py_DECREF(tuple);
291 Py_INCREF(Py_None);
292 return Py_None;
293}
294
295#endif /* ifdef HAVE_LONG_LONG */
296
297/* Test tuple argument processing */
298static PyObject *
299getargs_tuple(PyObject *self, PyObject *args)
300{
301 int a, b, c;
302 if (!PyArg_ParseTuple(args, "i(ii)", &a, &b, &c))
303 return NULL;
304 return Py_BuildValue("iii", a, b, c);
305}
306
307/* Functions to call PyArg_ParseTuple with integer format codes,
308 and return the result.
309*/
310static PyObject *
311getargs_b(PyObject *self, PyObject *args)
312{
313 unsigned char value;
314 if (!PyArg_ParseTuple(args, "b", &value))
315 return NULL;
316 return PyLong_FromUnsignedLong((unsigned long)value);
317}
318
319static PyObject *
320getargs_B(PyObject *self, PyObject *args)
321{
322 unsigned char value;
323 if (!PyArg_ParseTuple(args, "B", &value))
324 return NULL;
325 return PyLong_FromUnsignedLong((unsigned long)value);
326}
327
328static PyObject *
329getargs_H(PyObject *self, PyObject *args)
330{
331 unsigned short value;
332 if (!PyArg_ParseTuple(args, "H", &value))
333 return NULL;
334 return PyLong_FromUnsignedLong((unsigned long)value);
335}
336
337static PyObject *
338getargs_I(PyObject *self, PyObject *args)
339{
340 unsigned int value;
341 if (!PyArg_ParseTuple(args, "I", &value))
342 return NULL;
343 return PyLong_FromUnsignedLong((unsigned long)value);
344}
345
346static PyObject *
347getargs_k(PyObject *self, PyObject *args)
348{
349 unsigned long value;
350 if (!PyArg_ParseTuple(args, "k", &value))
351 return NULL;
352 return PyLong_FromUnsignedLong(value);
353}
354
355static PyObject *
356getargs_i(PyObject *self, PyObject *args)
357{
358 int value;
359 if (!PyArg_ParseTuple(args, "i", &value))
360 return NULL;
361 return PyLong_FromLong((long)value);
362}
363
364static PyObject *
365getargs_l(PyObject *self, PyObject *args)
366{
367 long value;
368 if (!PyArg_ParseTuple(args, "l", &value))
369 return NULL;
370 return PyLong_FromLong(value);
371}
372
373static PyObject *
374getargs_n(PyObject *self, PyObject *args)
375{
376 Py_ssize_t value;
377 if (!PyArg_ParseTuple(args, "n", &value))
378 return NULL;
379 return PyInt_FromSsize_t(value);
380}
381
382#ifdef HAVE_LONG_LONG
383static PyObject *
384getargs_L(PyObject *self, PyObject *args)
385{
386 PY_LONG_LONG value;
387 if (!PyArg_ParseTuple(args, "L", &value))
388 return NULL;
389 return PyLong_FromLongLong(value);
390}
391
392static PyObject *
393getargs_K(PyObject *self, PyObject *args)
394{
395 unsigned PY_LONG_LONG value;
396 if (!PyArg_ParseTuple(args, "K", &value))
397 return NULL;
398 return PyLong_FromUnsignedLongLong(value);
399}
400#endif
401
402/* This function not only tests the 'k' getargs code, but also the
403 PyInt_AsUnsignedLongMask() and PyInt_AsUnsignedLongMask() functions. */
404static PyObject *
405test_k_code(PyObject *self)
406{
407 PyObject *tuple, *num;
408 unsigned long value;
409
410 tuple = PyTuple_New(1);
411 if (tuple == NULL)
412 return NULL;
413
414 /* a number larger than ULONG_MAX even on 64-bit platforms */
415 num = PyLong_FromString("FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
416 if (num == NULL)
417 return NULL;
418
419 value = PyInt_AsUnsignedLongMask(num);
420 if (value != ULONG_MAX)
421 return raiseTestError("test_k_code",
422 "PyInt_AsUnsignedLongMask() returned wrong value for long 0xFFF...FFF");
423
424 PyTuple_SET_ITEM(tuple, 0, num);
425
426 value = 0;
427 if (PyArg_ParseTuple(tuple, "k:test_k_code", &value) < 0)
428 return NULL;
429 if (value != ULONG_MAX)
430 return raiseTestError("test_k_code",
431 "k code returned wrong value for long 0xFFF...FFF");
432
433 Py_DECREF(num);
434 num = PyLong_FromString("-FFFFFFFF000000000000000042", NULL, 16);
435 if (num == NULL)
436 return NULL;
437
438 value = PyInt_AsUnsignedLongMask(num);
439 if (value != (unsigned long)-0x42)
440 return raiseTestError("test_k_code",
441 "PyInt_AsUnsignedLongMask() returned wrong value for long 0xFFF...FFF");
442
443 PyTuple_SET_ITEM(tuple, 0, num);
444
445 value = 0;
446 if (PyArg_ParseTuple(tuple, "k:test_k_code", &value) < 0)
447 return NULL;
448 if (value != (unsigned long)-0x42)
449 return raiseTestError("test_k_code",
450 "k code returned wrong value for long -0xFFF..000042");
451
452 Py_DECREF(tuple);
453 Py_INCREF(Py_None);
454 return Py_None;
455}
456
457#ifdef Py_USING_UNICODE
458
459/* Test the u and u# codes for PyArg_ParseTuple. May leak memory in case
460 of an error.
461*/
462static PyObject *
463test_u_code(PyObject *self)
464{
465 PyObject *tuple, *obj;
466 Py_UNICODE *value;
467 int len;
468
469 tuple = PyTuple_New(1);
470 if (tuple == NULL)
471 return NULL;
472
473 obj = PyUnicode_Decode("test", strlen("test"),
474 "ascii", NULL);
475 if (obj == NULL)
476 return NULL;
477
478 PyTuple_SET_ITEM(tuple, 0, obj);
479
480 value = 0;
481 if (PyArg_ParseTuple(tuple, "u:test_u_code", &value) < 0)
482 return NULL;
483 if (value != PyUnicode_AS_UNICODE(obj))
484 return raiseTestError("test_u_code",
485 "u code returned wrong value for u'test'");
486 value = 0;
487 if (PyArg_ParseTuple(tuple, "u#:test_u_code", &value, &len) < 0)
488 return NULL;
489 if (value != PyUnicode_AS_UNICODE(obj) ||
490 len != PyUnicode_GET_SIZE(obj))
491 return raiseTestError("test_u_code",
492 "u# code returned wrong values for u'test'");
493
494 Py_DECREF(tuple);
495 Py_INCREF(Py_None);
496 return Py_None;
497}
498
499static PyObject *
500codec_incrementalencoder(PyObject *self, PyObject *args)
501{
502 const char *encoding, *errors = NULL;
503 if (!PyArg_ParseTuple(args, "s|s:test_incrementalencoder",
504 &encoding, &errors))
505 return NULL;
506 return PyCodec_IncrementalEncoder(encoding, errors);
507}
508
509static PyObject *
510codec_incrementaldecoder(PyObject *self, PyObject *args)
511{
512 const char *encoding, *errors = NULL;
513 if (!PyArg_ParseTuple(args, "s|s:test_incrementaldecoder",
514 &encoding, &errors))
515 return NULL;
516 return PyCodec_IncrementalDecoder(encoding, errors);
517}
518
519#endif
520
521/* Simple test of _PyLong_NumBits and _PyLong_Sign. */
522static PyObject *
523test_long_numbits(PyObject *self)
524{
525 struct triple {
526 long input;
527 size_t nbits;
528 int sign;
529 } testcases[] = {{0, 0, 0},
530 {1L, 1, 1},
531 {-1L, 1, -1},
532 {2L, 2, 1},
533 {-2L, 2, -1},
534 {3L, 2, 1},
535 {-3L, 2, -1},
536 {4L, 3, 1},
537 {-4L, 3, -1},
538 {0x7fffL, 15, 1}, /* one Python long digit */
539 {-0x7fffL, 15, -1},
540 {0xffffL, 16, 1},
541 {-0xffffL, 16, -1},
542 {0xfffffffL, 28, 1},
543 {-0xfffffffL, 28, -1}};
544 int i;
545
546 for (i = 0; i < sizeof(testcases) / sizeof(struct triple); ++i) {
547 PyObject *plong = PyLong_FromLong(testcases[i].input);
548 size_t nbits = _PyLong_NumBits(plong);
549 int sign = _PyLong_Sign(plong);
550
551 Py_DECREF(plong);
552 if (nbits != testcases[i].nbits)
553 return raiseTestError("test_long_numbits",
554 "wrong result for _PyLong_NumBits");
555 if (sign != testcases[i].sign)
556 return raiseTestError("test_long_numbits",
557 "wrong result for _PyLong_Sign");
558 }
559 Py_INCREF(Py_None);
560 return Py_None;
561}
562
563/* Example passing NULLs to PyObject_Str(NULL) and PyObject_Unicode(NULL). */
564
565static PyObject *
566test_null_strings(PyObject *self)
567{
568 PyObject *o1 = PyObject_Str(NULL), *o2 = PyObject_Unicode(NULL);
569 PyObject *tuple = PyTuple_Pack(2, o1, o2);
570 Py_XDECREF(o1);
571 Py_XDECREF(o2);
572 return tuple;
573}
574
575static PyObject *
576raise_exception(PyObject *self, PyObject *args)
577{
578 PyObject *exc;
579 PyObject *exc_args, *v;
580 int num_args, i;
581
582 if (!PyArg_ParseTuple(args, "Oi:raise_exception",
583 &exc, &num_args))
584 return NULL;
585
586 exc_args = PyTuple_New(num_args);
587 if (exc_args == NULL)
588 return NULL;
589 for (i = 0; i < num_args; ++i) {
590 v = PyInt_FromLong(i);
591 if (v == NULL) {
592 Py_DECREF(exc_args);
593 return NULL;
594 }
595 PyTuple_SET_ITEM(exc_args, i, v);