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 #include <float.h>

    10 #include "structmember.h"

    11 

    12 #ifdef WITH_THREAD

    13 #include "pythread.h"

    14 #endif /* WITH_THREAD */

    15 static PyObject *TestError;	/* set to exception object in init */

    16 

    17 /* Raise TestError with test_name + ": " + msg, and return NULL. */

    18 

    19 static PyObject *

    20 raiseTestError(const char* test_name, const char* msg)

    21 {

    22 	char buf[2048];

    23 

    24 	if (strlen(test_name) + strlen(msg) > sizeof(buf) - 50)

    25 		PyErr_SetString(TestError, "internal error msg too large");

    26 	else {

    27 		PyOS_snprintf(buf, sizeof(buf), "%s: %s", test_name, msg);

    28 		PyErr_SetString(TestError, buf);

    29 	}

    30 	return NULL;

    31 }

    32 

    33 /* Test #defines from pyconfig.h (particularly the SIZEOF_* defines).

    34 

    35    The ones derived from autoconf on the UNIX-like OSes can be relied

    36    upon (in the absence of sloppy cross-compiling), but the Windows

    37    platforms have these hardcoded.  Better safe than sorry.

    38 */

    39 static PyObject*

    40 sizeof_error(const char* fatname, const char* typname,

    41         int expected, int got)

    42 {

    43 	char buf[1024];

    44 	PyOS_snprintf(buf, sizeof(buf),

    45 		"%.200s #define == %d but sizeof(%.200s) == %d",

    46 		fatname, expected, typname, got);

    47 	PyErr_SetString(TestError, buf);

    48 	return (PyObject*)NULL;

    49 }

    50 

    51 static PyObject*

    52 test_config(PyObject *self)

    53 {

    54 #define CHECK_SIZEOF(FATNAME, TYPE) \

    55 	    if (FATNAME != sizeof(TYPE)) \

    56     	    	return sizeof_error(#FATNAME, #TYPE, FATNAME, sizeof(TYPE))

    57 

    58 	CHECK_SIZEOF(SIZEOF_SHORT, short);

    59 	CHECK_SIZEOF(SIZEOF_INT, int);

    60 	CHECK_SIZEOF(SIZEOF_LONG, long);

    61 	CHECK_SIZEOF(SIZEOF_VOID_P, void*);

    62 	CHECK_SIZEOF(SIZEOF_TIME_T, time_t);

    63 #ifdef HAVE_LONG_LONG

    64 	CHECK_SIZEOF(SIZEOF_LONG_LONG, PY_LONG_LONG);

    65 #endif

    66 

    67 #undef CHECK_SIZEOF

    68 

    69 	Py_INCREF(Py_None);

    70 	return Py_None;

    71 }

    72 

    73 static PyObject*

    74 test_list_api(PyObject *self)

    75 {

    76 	PyObject* list;

    77 	int i;

    78 

    79 	/* SF bug 132008:  PyList_Reverse segfaults */

    80 #define NLIST 30

    81 	list = PyList_New(NLIST);

    82 	if (list == (PyObject*)NULL)

    83 		return (PyObject*)NULL;

    84 	/* list = range(NLIST) */

    85 	for (i = 0; i < NLIST; ++i) {

    86 		PyObject* anint = PyInt_FromLong(i);

    87 		if (anint == (PyObject*)NULL) {

    88 			Py_DECREF(list);

    89 			return (PyObject*)NULL;

    90 		}

    91 		PyList_SET_ITEM(list, i, anint);

    92 	}

    93 	/* list.reverse(), via PyList_Reverse() */

    94 	i = PyList_Reverse(list);   /* should not blow up! */

    95 	if (i != 0) {

    96 		Py_DECREF(list);

    97 		return (PyObject*)NULL;

    98 	}

    99 	/* Check that list == range(29, -1, -1) now */

   100 	for (i = 0; i < NLIST; ++i) {

   101 		PyObject* anint = PyList_GET_ITEM(list, i);

   102 		if (PyInt_AS_LONG(anint) != NLIST-1-i) {

   103 			PyErr_SetString(TestError,

   104 			                "test_list_api: reverse screwed up");

   105 			Py_DECREF(list);

   106 			return (PyObject*)NULL;

   107 		}

   108 	}

   109 	Py_DECREF(list);

   110 #undef NLIST

   111 

   112 	Py_INCREF(Py_None);

   113 	return Py_None;

   114 }

   115 

   116 static int

   117 test_dict_inner(int count)

   118 {

   119 	Py_ssize_t pos = 0, iterations = 0;

   120 	int i;

   121 	PyObject *dict = PyDict_New();

   122 	PyObject *v, *k;

   123 

   124 	if (dict == NULL)

   125 		return -1;

   126 

   127 	for (i = 0; i < count; i++) {

   128 		v = PyInt_FromLong(i);

   129 		PyDict_SetItem(dict, v, v);

   130 		Py_DECREF(v);

   131 	}

   132 

   133 	while (PyDict_Next(dict, &pos, &k, &v)) {

   134 		PyObject *o;

   135 		iterations++;

   136 

   137 		i = PyInt_AS_LONG(v) + 1;

   138 		o = PyInt_FromLong(i);

   139 		if (o == NULL)

   140 			return -1;

   141 		if (PyDict_SetItem(dict, k, o) < 0) {

   142 			Py_DECREF(o);

   143 			return -1;

   144 		}

   145 		Py_DECREF(o);

   146 	}

   147 

   148 	Py_DECREF(dict);

   149 

   150 	if (iterations != count) {

   151 		PyErr_SetString(

   152 			TestError,

   153 			"test_dict_iteration: dict iteration went wrong ");

   154 		return -1;

   155 	} else {

   156 		return 0;

   157 	}

   158 }

   159 

   160 static PyObject*

   161 test_dict_iteration(PyObject* self)

   162 {

   163 	int i;

   164 

   165 	for (i = 0; i < 200; i++) {

   166 		if (test_dict_inner(i) < 0) {

   167 			return NULL;

   168 		}

   169 	}

   170 

   171 	Py_INCREF(Py_None);

   172 	return Py_None;

   173 }

   174 

   175 

   176 /* Tests of PyLong_{As, From}{Unsigned,}Long(), and (#ifdef HAVE_LONG_LONG)

   177    PyLong_{As, From}{Unsigned,}LongLong().

   178 

   179    Note that the meat of the test is contained in testcapi_long.h.

   180    This is revolting, but delicate code duplication is worse:  "almost

   181    exactly the same" code is needed to test PY_LONG_LONG, but the ubiquitous

   182    dependence on type names makes it impossible to use a parameterized

   183    function.  A giant macro would be even worse than this.  A C++ template

   184    would be perfect.

   185 

   186    The "report an error" functions are deliberately not part of the #include

   187    file:  if the test fails, you can set a breakpoint in the appropriate

   188    error function directly, and crawl back from there in the debugger.

   189 */

   190 

   191 #define UNBIND(X)  Py_DECREF(X); (X) = NULL

   192 

   193 static PyObject *

   194 raise_test_long_error(const char* msg)

   195 {

   196 	return raiseTestError("test_long_api", msg);

   197 }

   198 

   199 #define TESTNAME	test_long_api_inner

   200 #define TYPENAME	long

   201 #define F_S_TO_PY	PyLong_FromLong

   202 #define F_PY_TO_S	PyLong_AsLong

   203 #define F_U_TO_PY	PyLong_FromUnsignedLong

   204 #define F_PY_TO_U	PyLong_AsUnsignedLong

   205 

   206 #include "testcapi_long.h"

   207 

   208 static PyObject *

   209 test_long_api(PyObject* self)

   210 {

   211 	return TESTNAME(raise_test_long_error);

   212 }

   213 

   214 #undef TESTNAME

   215 #undef TYPENAME

   216 #undef F_S_TO_PY

   217 #undef F_PY_TO_S

   218 #undef F_U_TO_PY

   219 #undef F_PY_TO_U

   220 

   221 #ifdef HAVE_LONG_LONG

   222 

   223 static PyObject *

   224 raise_test_longlong_error(const char* msg)

   225 {

   226 	return raiseTestError("test_longlong_api", msg);

   227 }

   228 

   229 #define TESTNAME	test_longlong_api_inner

   230 #define TYPENAME	PY_LONG_LONG

   231 #define F_S_TO_PY	PyLong_FromLongLong

   232 #define F_PY_TO_S	PyLong_AsLongLong

   233 #define F_U_TO_PY	PyLong_FromUnsignedLongLong

   234 #define F_PY_TO_U	PyLong_AsUnsignedLongLong

   235 

   236 #include "testcapi_long.h"

   237 

   238 static PyObject *

   239 test_longlong_api(PyObject* self, PyObject *args)

   240 {

   241 	return TESTNAME(raise_test_longlong_error);

   242 }

   243 

   244 #undef TESTNAME

   245 #undef TYPENAME

   246 #undef F_S_TO_PY

   247 #undef F_PY_TO_S

   248 #undef F_U_TO_PY

   249 #undef F_PY_TO_U

   250 

   251 /* Test the L code for PyArg_ParseTuple.  This should deliver a PY_LONG_LONG

   252    for both long and int arguments.  The test may leak a little memory if

   253    it fails.

   254 */

   255 static PyObject *

   256 test_L_code(PyObject *self)

   257 {

   258 	PyObject *tuple, *num;

   259 	PY_LONG_LONG value;

   260 

   261         tuple = PyTuple_New(1);

   262         if (tuple == NULL)

   263         	return NULL;

   264 

   265         num = PyLong_FromLong(42);

   266         if (num == NULL)

   267         	return NULL;

   268 

   269         PyTuple_SET_ITEM(tuple, 0, num);

   270 

   271         value = -1;

   272         if (PyArg_ParseTuple(tuple, "L:test_L_code", &value) < 0)

   273         	return NULL;

   274         if (value != 42)

   275         	return raiseTestError("test_L_code",

   276 			"L code returned wrong value for long 42");

   277 

   278 	Py_DECREF(num);

   279         num = PyInt_FromLong(42);

   280         if (num == NULL)

   281         	return NULL;

   282 

   283         PyTuple_SET_ITEM(tuple, 0, num);

   284 

   285 	value = -1;

   286         if (PyArg_ParseTuple(tuple, "L:test_L_code", &value) < 0)

   287         	return NULL;

   288         if (value != 42)

   289         	return raiseTestError("test_L_code",

   290 			"L code returned wrong value for int 42");

   291 

   292 	Py_DECREF(tuple);

   293 	Py_INCREF(Py_None);

   294 	return Py_None;

   295 }

   296 

   297 #endif	/* ifdef HAVE_LONG_LONG */

   298 

   299 /* Test tuple argument processing */

   300 static PyObject *

   301 getargs_tuple(PyObject *self, PyObject *args)

   302 {

   303 	int a, b, c;

   304 	if (!PyArg_ParseTuple(args, "i(ii)", &a, &b, &c))

   305 		return NULL;

   306 	return Py_BuildValue("iii", a, b, c);

   307 }

   308 

   309 /* test PyArg_ParseTupleAndKeywords */

   310 static PyObject *getargs_keywords(PyObject *self, PyObject *args, PyObject *kwargs)

   311 {

   312 	static char *keywords[] = {"arg1","arg2","arg3","arg4","arg5", NULL};

   313 	static char *fmt="(ii)i|(i(ii))(iii)i";

   314 	int int_args[10]={-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};

   315 

   316 	if (!PyArg_ParseTupleAndKeywords(args, kwargs, fmt, keywords,

   317 		&int_args[0], &int_args[1], &int_args[2], &int_args[3], &int_args[4],

   318 		&int_args[5], &int_args[6], &int_args[7], &int_args[8], &int_args[9]))

   319 		return NULL;

   320 	return Py_BuildValue("iiiiiiiiii",

   321 		int_args[0], int_args[1], int_args[2], int_args[3], int_args[4],

   322 		int_args[5], int_args[6], int_args[7], int_args[8], int_args[9]);

   323 }

   324 

   325 /* Functions to call PyArg_ParseTuple with integer format codes,

   326    and return the result.

   327 */

   328 static PyObject *

   329 getargs_b(PyObject *self, PyObject *args)

   330 {

   331 	unsigned char value;

   332 	if (!PyArg_ParseTuple(args, "b", &value))

   333 		return NULL;

   334 	return PyLong_FromUnsignedLong((unsigned long)value);

   335 }

   336 

   337 static PyObject *

   338 getargs_B(PyObject *self, PyObject *args)

   339 {

   340 	unsigned char value;

   341 	if (!PyArg_ParseTuple(args, "B", &value))

   342 		return NULL;

   343 	return PyLong_FromUnsignedLong((unsigned long)value);

   344 }

   345 

   346 static PyObject *

   347 getargs_H(PyObject *self, PyObject *args)

   348 {

   349 	unsigned short value;

   350 	if (!PyArg_ParseTuple(args, "H", &value))

   351 		return NULL;

   352 	return PyLong_FromUnsignedLong((unsigned long)value);

   353 }

   354 

   355 static PyObject *

   356 getargs_I(PyObject *self, PyObject *args)

   357 {

   358 	unsigned int value;

   359 	if (!PyArg_ParseTuple(args, "I", &value))

   360 		return NULL;

   361 	return PyLong_FromUnsignedLong((unsigned long)value);

   362 }

   363 

   364 static PyObject *

   365 getargs_k(PyObject *self, PyObject *args)

   366 {

   367 	unsigned long value;

   368 	if (!PyArg_ParseTuple(args, "k", &value))

   369 		return NULL;

   370 	return PyLong_FromUnsignedLong(value);

   371 }

   372 

   373 static PyObject *

   374 getargs_i(PyObject *self, PyObject *args)

   375 {

   376 	int value;

   377 	if (!PyArg_ParseTuple(args, "i", &value))

   378 		return NULL;

   379 	return PyLong_FromLong((long)value);

   380 }

   381 

   382 static PyObject *

   383 getargs_l(PyObject *self, PyObject *args)

   384 {

   385 	long value;

   386 	if (!PyArg_ParseTuple(args, "l", &value))

   387 		return NULL;

   388 	return PyLong_FromLong(value);

   389 }

   390 

   391 static PyObject *

   392 getargs_n(PyObject *self, PyObject *args)

   393 {

   394 	Py_ssize_t value;

   395 	if (!PyArg_ParseTuple(args, "n", &value))

   396 	return NULL;

   397 	return PyInt_FromSsize_t(value);

   398 }

   399 

   400 #ifdef HAVE_LONG_LONG

   401 static PyObject *

   402 getargs_L(PyObject *self, PyObject *args)

   403 {

   404 	PY_LONG_LONG value;

   405 	if (!PyArg_ParseTuple(args, "L", &value))

   406 		return NULL;

   407 	return PyLong_FromLongLong(value);

   408 }

   409 

   410 static PyObject *

   411 getargs_K(PyObject *self, PyObject *args)

   412 {

   413 	unsigned PY_LONG_LONG value;

   414 	if (!PyArg_ParseTuple(args, "K", &value))

   415 		return NULL;

   416 	return PyLong_FromUnsignedLongLong(value);

   417 }

   418 #endif

   419 

   420 /* This function not only tests the 'k' getargs code, but also the

   421    PyInt_AsUnsignedLongMask() and PyInt_AsUnsignedLongMask() functions. */

   422 static PyObject *

   423 test_k_code(PyObject *self)

   424 {

   425 	PyObject *tuple, *num;

   426 	unsigned long value;

   427 

   428         tuple = PyTuple_New(1);

   429         if (tuple == NULL)

   430         	return NULL;

   431 

   432 	/* a number larger than ULONG_MAX even on 64-bit platforms */

   433         num = PyLong_FromString("FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);

   434         if (num == NULL)

   435         	return NULL;

   436 

   437 	value = PyInt_AsUnsignedLongMask(num);

   438 	if (value != ULONG_MAX)

   439         	return raiseTestError("test_k_code",

   440 	    "PyInt_AsUnsignedLongMask() returned wrong value for long 0xFFF...FFF");

   441 

   442         PyTuple_SET_ITEM(tuple, 0, num);

   443 

   444         value = 0;

   445         if (PyArg_ParseTuple(tuple, "k:test_k_code", &value) < 0)

   446         	return NULL;

   447         if (value != ULONG_MAX)

   448         	return raiseTestError("test_k_code",

   449 			"k code returned wrong value for long 0xFFF...FFF");

   450 

   451 	Py_DECREF(num);

   452         num = PyLong_FromString("-FFFFFFFF000000000000000042", NULL, 16);

   453         if (num == NULL)

   454         	return NULL;

   455 

   456 	value = PyInt_AsUnsignedLongMask(num);

   457 	if (value != (unsigned long)-0x42)

   458         	return raiseTestError("test_k_code",

   459 	    "PyInt_AsUnsignedLongMask() returned wrong value for long 0xFFF...FFF");

   460 

   461         PyTuple_SET_ITEM(tuple, 0, num);

   462 

   463 	value = 0;

   464         if (PyArg_ParseTuple(tuple, "k:test_k_code", &value) < 0)

   465         	return NULL;

   466         if (value != (unsigned long)-0x42)

   467         	return raiseTestError("test_k_code",

   468 			"k code returned wrong value for long -0xFFF..000042");

   469 

   470 	Py_DECREF(tuple);

   471 	Py_INCREF(Py_None);

   472 	return Py_None;

   473 }

   474 

   475 #ifdef Py_USING_UNICODE

   476 

   477 /* Test the u and u# codes for PyArg_ParseTuple. May leak memory in case

   478    of an error.

   479 */

   480 static PyObject *

   481 test_u_code(PyObject *self)

   482 {

   483 	PyObject *tuple, *obj;

   484 	Py_UNICODE *value;

   485 	int len;

   486 

   487 	/* issue4122: Undefined reference to _Py_ascii_whitespace on Windows */

   488 	/* Just use the macro and check that it compiles */

   489 	int x = Py_UNICODE_ISSPACE(25);

   490 

   491         tuple = PyTuple_New(1);

   492         if (tuple == NULL)

   493         	return NULL;

   494 

   495         obj = PyUnicode_Decode("test", strlen("test"),

   496 			       "ascii", NULL);

   497         if (obj == NULL)

   498         	return NULL;

   499 

   500         PyTuple_SET_ITEM(tuple, 0, obj);

   501 

   502         value = 0;

   503         if (PyArg_ParseTuple(tuple, "u:test_u_code", &value) < 0)

   504         	return NULL;

   505         if (value != PyUnicode_AS_UNICODE(obj))

   506         	return raiseTestError("test_u_code",

   507 			"u code returned wrong value for u'test'");

   508         value = 0;

   509         if (PyArg_ParseTuple(tuple, "u#:test_u_code", &value, &len) < 0)

   510         	return NULL;

   511         if (value != PyUnicode_AS_UNICODE(obj) ||

   512 	    len != PyUnicode_GET_SIZE(obj))

   513         	return raiseTestError("test_u_code",

   514 			"u# code returned wrong values for u'test'");

   515 

   516 	Py_DECREF(tuple);

   517 	Py_INCREF(Py_None);

   518 	return Py_None;

   519 }

   520 

   521 static PyObject *

   522 codec_incrementalencoder(PyObject *self, PyObject *args)

   523 {

   524 	const char *encoding, *errors = NULL;

   525 	if (!PyArg_ParseTuple(args, "s|s:test_incrementalencoder",

   526 			      &encoding, &errors))

   527 		return NULL;

   528 	return PyCodec_IncrementalEncoder(encoding, errors);

   529 }

   530 

   531 static PyObject *

   532 codec_incrementaldecoder(PyObject *self, PyObject *args)

   533 {

   534 	const char *encoding, *errors = NULL;

   535 	if (!PyArg_ParseTuple(args, "s|s:test_incrementaldecoder",

   536 			      &encoding, &errors))

   537 		return NULL;

   538 	return PyCodec_IncrementalDecoder(encoding, errors);

   539 }

   540 

   541 #endif

   542 

   543 /* Simple test of _PyLong_NumBits and _PyLong_Sign. */

   544 static PyObject *

   545 test_long_numbits(PyObject *self)

   546 {

   547 	struct triple {

   548 		long input;

   549 		size_t nbits;

   550 		int sign;

   551 	} testcases[] = {{0, 0, 0},

   552 			 {1L, 1, 1},

   553 			 {-1L, 1, -1},

   554 			 {2L, 2, 1},

   555 			 {-2L, 2, -1},

   556 			 {3L, 2, 1},

   557 			 {-3L, 2, -1},

   558 			 {4L, 3, 1},

   559 			 {-4L, 3, -1},

   560 			 {0x7fffL, 15, 1},	/* one Python long digit */

   561 			 {-0x7fffL, 15, -1},

   562 			 {0xffffL, 16, 1},

   563 			 {-0xffffL, 16, -1},

   564 			 {0xfffffffL, 28, 1},

   565 			 {-0xfffffffL, 28, -1}};

   566 	int i;

   567 

   568 	for (i = 0; i < sizeof(testcases) / sizeof(struct triple); ++i) {

   569 		PyObject *plong = PyLong_FromLong(testcases[i].input);

   570 		size_t nbits = _PyLong_NumBits(plong);

   571 		int sign = _PyLong_Sign(plong);

   572 

   573 		Py_DECREF(plong);

   574 		if (nbits != testcases[i].nbits)

   575 			return raiseTestError("test_long_numbits",

   576 					"wrong result for _PyLong_NumBits");

   577 		if (sign != testcases[i].sign)

   578 			return raiseTestError("test_long_numbits",

   579 					"wrong result for _PyLong_Sign");

   580 	}

   581 	Py_INCREF(Py_None);

   582 	return Py_None;

   583 }

   584 

   585 /* Example passing NULLs to PyObject_Str(NULL) and PyObject_Unicode(NULL). */

   586 

   587 static PyObject *

   588 test_null_strings(PyObject *self)

   589 {

   590 	PyObject *o1 = PyObject_Str(NULL), *o2 = PyObject_Unicode(NULL);

   591 	PyObject *tuple = PyTuple_Pack(2, o1, o2);

   592 	Py_XDECREF(o1);

   593 	Py_XDECREF(o2);

   594 	return tuple;

   595 }

   596 

   597 static PyObject *

   598 raise_exception(PyObject *self, PyObject *args)

   599 {

   600 	PyObject *exc;

   601 	PyObject *exc_args, *v;

   602 	int num_args, i;

   603 

   604 	if (!PyArg_ParseTuple(args, "Oi:raise_exception",

   605 			      &exc, &num_args))

   606 		return NULL;

   607 	if (!PyExceptionClass_Check(exc)) {

   608 		PyErr_Format(PyExc_TypeError, "an exception class is required");

   609 		return NULL;

   610 	}

   611 

   612 	exc_args = PyTuple_New(num_args);

   613 	if (exc_args == NULL)

   614 		return NULL;

   615 	for (i = 0; i < num_args; ++i) {

   616 		v = PyInt_FromLong(i);

   617 		if (v == NULL) {

   618 			Py_DECREF(exc_args);

   619 			return NULL;

   620 		}

   621 		PyTuple_SET_ITEM(exc_args, i, v);

   622 	}

   623 	PyErr_SetObject(exc, exc_args);

   624 	Py_DECREF(exc_args);

   625 	return NULL;

   626 }

   627 

   628 #ifdef WITH_THREAD

   629 

   630 /* test_thread_state spawns a thread of its own, and that thread releases

   631  * `thread_done` when it's finished.  The driver code has to know when the

   632  * thread finishes, because the thread uses a PyObject (the callable) that

   633  * may go away when the driver finishes.  The former lack of this explicit

   634  * synchronization caused rare segfaults, so rare that they were seen only

   635  * on a Mac buildbot (although they were possible on any box).

   636  */

   637 static PyThread_type_lock thread_done = NULL;

   638 

   639 static int

   640 _make_call(void *callable)

   641 {

   642 	PyObject *rc;

   643 	int success;

   644 	PyGILState_STATE s = PyGILState_Ensure();

   645 	rc = PyObject_CallFunction((PyObject *)callable, "");

   646 	success = (rc != NULL);

   647 	Py_XDECREF(rc);

   648 	PyGILState_Release(s);

   649 	return success;

   650 }

   651 

   652 /* Same thing, but releases `thread_done` when it returns.  This variant

   653  * should be called only from threads spawned by test_thread_state().

   654  */

   655 static void

   656 _make_call_from_thread(void *callable)

   657 {

   658 	_make_call(callable);

   659 	PyThread_release_lock(thread_done);

   660 }

   661 

   662 static PyObject *

   663 test_thread_state(PyObject *self, PyObject *args)

   664 {

   665 	PyObject *fn;

   666 	int success = 1;

   667 

   668 	if (!PyArg_ParseTuple(args, "O:test_thread_state", &fn))

   669 		return NULL;

   670 

   671 	if (!PyCallable_Check(fn)) {

   672 		PyErr_Format(PyExc_TypeError, "'%s' object is not callable",

   673 			fn->ob_type->tp_name);

   674 		return NULL;

   675 	}

   676 

   677 	/* Ensure Python is set up for threading */

   678 	PyEval_InitThreads();

   679 	thread_done = PyThread_allocate_lock();

   680 	if (thread_done == NULL)

   681 		return PyErr_NoMemory();

   682 	PyThread_acquire_lock(thread_done, 1);

   683 

   684 	/* Start a new thread with our callback. */

   685 	PyThread_start_new_thread(_make_call_from_thread, fn);

   686 	/* Make the callback with the thread lock held by this thread */

   687 	success &= _make_call(fn);

   688 	/* Do it all again, but this time with the thread-lock released */

   689 	Py_BEGIN_ALLOW_THREADS

   690 	success &= _make_call(fn);

   691 	PyThread_acquire_lock(thread_done, 1);  /* wait for thread to finish */

   692 	Py_END_ALLOW_THREADS

   693 

   694 	/* And once more with and without a thread

   695 	   XXX - should use a lock and work out exactly what we are trying

   696 	   to test <wink>

   697 	*/

   698 	Py_BEGIN_ALLOW_THREADS

   699 	PyThread_start_new_thread(_make_call_from_thread, fn);

   700 	success &= _make_call(fn);

   701 	PyThread_acquire_lock(thread_done, 1);  /* wait for thread to finish */

   702 	Py_END_ALLOW_THREADS

   703 

   704 	/* Release lock we acquired above.  This is required on HP-UX. */

   705 	PyThread_release_lock(thread_done);

   706 

   707 	PyThread_free_lock(thread_done);

   708 	if (!success)

   709 		return NULL;

   710 	Py_RETURN_NONE;

   711 }

   712 #endif

   713 

   714 /* Some tests of PyString_FromFormat().  This needs more tests. */

   715 static PyObject *

   716 test_string_from_format(PyObject *self, PyObject *args)

   717 {

   718 	PyObject *result;

   719 	char *msg;

   720 

   721 #define CHECK_1_FORMAT(FORMAT, TYPE) 			\

   722 	result = PyString_FromFormat(FORMAT, (TYPE)1);	\

   723 	if (result == NULL)				\

   724 		return NULL;				\

   725 	if (strcmp(PyString_AsString(result), "1")) {	\

   726 		msg = FORMAT " failed at 1";		\

   727 		goto Fail;				\

   728 	}						\

   729 	Py_DECREF(result)

   730 

   731 	CHECK_1_FORMAT("%d", int);

   732 	CHECK_1_FORMAT("%ld", long);

   733 	/* The z width modifier was added in Python 2.5. */

   734 	CHECK_1_FORMAT("%zd", Py_ssize_t);

   735 

   736 	/* The u type code was added in Python 2.5. */

   737 	CHECK_1_FORMAT("%u", unsigned int);

   738 	CHECK_1_FORMAT("%lu", unsigned long);

   739 	CHECK_1_FORMAT("%zu", size_t);

   740 

   741 	Py_RETURN_NONE;

   742 

   743  Fail:

   744  	Py_XDECREF(result);

   745 	return raiseTestError("test_string_from_format", msg);

   746 

   747 #undef CHECK_1_FORMAT

   748 }

   749 

   750 /* This is here to provide a docstring for test_descr. */

   751 static PyObject *

   752 test_with_docstring(PyObject *self)

   753 {

   754 	Py_RETURN_NONE;

   755 }

   756 

   757 /* To test the format of tracebacks as printed out. */

   758 static PyObject *

   759 traceback_print(PyObject *self, PyObject *args)

   760 {

   761 	PyObject *file;

   762 	PyObject *traceback;

   763 	int result;

   764 	

   765 	if (!PyArg_ParseTuple(args, "OO:traceback_print",

   766 				&traceback, &file))

   767 		return NULL;

   768 		

   769 	result = PyTraceBack_Print(traceback, file);

   770 	if (result < 0)

   771 		return NULL;

   772 	Py_RETURN_NONE;

   773 }

   774 

   775 static PyMethodDef TestMethods[] = {

   776 	{"raise_exception",	raise_exception,		 METH_VARARGS},

   777 	{"test_config",		(PyCFunction)test_config,	 METH_NOARGS},

   778 	{"test_list_api",	(PyCFunction)test_list_api,	 METH_NOARGS},

   779 	{"test_dict_iteration",	(PyCFunction)test_dict_iteration,METH_NOARGS},

   780 	{"test_long_api",	(PyCFunction)test_long_api,	 METH_NOARGS},

   781 	{"test_long_numbits",	(PyCFunction)test_long_numbits,	 METH_NOARGS},

   782 	{"test_k_code",		(PyCFunction)test_k_code,	 METH_NOARGS},

   783 	{"test_null_strings",	(PyCFunction)test_null_strings,	 METH_NOARGS},

   784 	{"test_string_from_format", (PyCFunction)test_string_from_format, METH_NOARGS},

   785 	{"test_with_docstring", (PyCFunction)test_with_docstring, METH_NOARGS,

   786 	 PyDoc_STR("This is a pretty normal docstring.")},

   787 

   788 	{"getargs_tuple",	getargs_tuple,			 METH_VARARGS},

   789 	{"getargs_keywords", (PyCFunction)getargs_keywords, 

   790 	  METH_VARARGS|METH_KEYWORDS},

   791 	{"getargs_b",		getargs_b,			 METH_VARARGS},

   792 	{"getargs_B",		getargs_B,			 METH_VARARGS},

   793 	{"getargs_H",		getargs_H,			 METH_VARARGS},

   794 	{"getargs_I",		getargs_I,			 METH_VARARGS},

   795 	{"getargs_k",		getargs_k,			 METH_VARARGS},

   796 	{"getargs_i",		getargs_i,			 METH_VARARGS},

   797 	{"getargs_l",		getargs_l,			 METH_VARARGS},

   798 	{"getargs_n",		getargs_n, 			 METH_VARARGS},

   799 #ifdef HAVE_LONG_LONG

   800 	{"getargs_L",		getargs_L,			 METH_VARARGS},

   801 	{"getargs_K",		getargs_K,			 METH_VARARGS},

   802 	{"test_longlong_api",	test_longlong_api,		 METH_NOARGS},

   803 	{"test_L_code",		(PyCFunction)test_L_code,	 METH_NOARGS},

   804 	{"codec_incrementalencoder",

   805 	 (PyCFunction)codec_incrementalencoder,	 METH_VARARGS},

   806 	{"codec_incrementaldecoder",

   807 	 (PyCFunction)codec_incrementaldecoder,	 METH_VARARGS},

   808 #endif

   809 #ifdef Py_USING_UNICODE

   810 	{"test_u_code",		(PyCFunction)test_u_code,	 METH_NOARGS},

   811 #endif

   812 #ifdef WITH_THREAD

   813 	{"_test_thread_state",  test_thread_state, 		 METH_VARARGS},

   814 #endif

   815 	{"traceback_print", traceback_print, 	         METH_VARARGS},

   816 	{NULL, NULL} /* sentinel */

   817 };

   818 

   819 #define AddSym(d, n, f, v) {PyObject *o = f(v); PyDict_SetItemString(d, n, o); Py_DECREF(o);}

   820 

   821 typedef struct {

   822 	char bool_member;

   823 	char byte_member;

   824 	unsigned char ubyte_member;

   825 	short short_member;

   826 	unsigned short ushort_member;

   827 	int int_member;

   828 	unsigned int uint_member;

   829 	long long_member;

   830 	unsigned long ulong_member;

   831 	float float_member;

   832 	double double_member;

   833 #ifdef HAVE_LONG_LONG

   834 	PY_LONG_LONG longlong_member;

   835 	unsigned PY_LONG_LONG ulonglong_member;

   836 #endif

   837 } all_structmembers;

   838 

   839 typedef struct {

   840     PyObject_HEAD

   841 	all_structmembers structmembers;

   842 } test_structmembers;

   843 

   844 static struct PyMemberDef test_members[] = {

   845 	{"T_BOOL", T_BOOL, offsetof(test_structmembers, structmembers.bool_member), 0, NULL},

   846 	{"T_BYTE", T_BYTE, offsetof(test_structmembers, structmembers.byte_member), 0, NULL},

   847 	{"T_UBYTE", T_UBYTE, offsetof(test_structmembers, structmembers.ubyte_member), 0, NULL},

   848 	{"T_SHORT", T_SHORT, offsetof(test_structmembers, structmembers.short_member), 0, NULL},

   849 	{"T_USHORT", T_USHORT, offsetof(test_structmembers, structmembers.ushort_member), 0, NULL},

   850 	{"T_INT", T_INT, offsetof(test_structmembers, structmembers.int_member), 0, NULL},

   851 	{"T_UINT", T_UINT, offsetof(test_structmembers, structmembers.uint_member), 0, NULL},

   852 	{"T_LONG", T_LONG, offsetof(test_structmembers, structmembers.long_member), 0, NULL},

   853 	{"T_ULONG", T_ULONG, offsetof(test_structmembers, structmembers.ulong_member), 0, NULL},

   854 	{"T_FLOAT", T_FLOAT, offsetof(test_structmembers, structmembers.float_member), 0, NULL},

   855 	{"T_DOUBLE", T_DOUBLE, offsetof(test_structmembers, structmembers.double_member), 0, NULL},

   856 #ifdef HAVE_LONG_LONG

   857 	{"T_LONGLONG", T_LONGLONG, offsetof(test_structmembers, structmembers.longlong_member), 0, NULL},

   858 	{"T_ULONGLONG", T_ULONGLONG, offsetof(test_structmembers, structmembers.ulonglong_member), 0, NULL},

   859 #endif

   860 	{NULL}

   861 };

   862 

   863 

   864 static PyObject *

   865 test_structmembers_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)

   866 {

   867 	static char *keywords[] = {

   868 		"T_BOOL", "T_BYTE", "T_UBYTE", "T_SHORT", "T_USHORT",

   869 		"T_INT", "T_UINT", "T_LONG", "T_ULONG",

   870 		"T_FLOAT", "T_DOUBLE",

   871 #ifdef HAVE_LONG_LONG	

   872 		"T_LONGLONG", "T_ULONGLONG",

   873 #endif

   874 		NULL};

   875 	static char *fmt = "|bbBhHiIlkfd"

   876 #ifdef HAVE_LONG_LONG

   877 		"LK"

   878 #endif

   879 		;

   880 	test_structmembers *ob;

   881 	ob = PyObject_New(test_structmembers, type);

   882 	if (ob == NULL)

   883 		return NULL;

   884 	memset(&ob->structmembers, 0, sizeof(all_structmembers));

   885 	if (!PyArg_ParseTupleAndKeywords(args, kwargs, fmt, keywords,

   886 					 &ob->structmembers.bool_member,

   887 					 &ob->structmembers.byte_member,

   888 					 &ob->structmembers.ubyte_member,

   889 					 &ob->structmembers.short_member,

   890 					 &ob->structmembers.ushort_member,

   891 					 &ob->structmembers.int_member,

   892 					 &ob->structmembers.uint_member, 

   893 					 &ob->structmembers.long_member,

   894 					 &ob->structmembers.ulong_member,

   895 					 &ob->structmembers.float_member,

   896 					 &ob->structmembers.double_member

   897 #ifdef HAVE_LONG_LONG

   898 					 , &ob->structmembers.longlong_member,

   899 					 &ob->structmembers.ulonglong_member

   900 #endif

   901 		)) {

   902 		Py_DECREF(ob);

   903 		return NULL;

   904 	}

   905 	return (PyObject *)ob;

   906 }

   907 

   908 static void

   909 test_structmembers_free(PyObject *ob)

   910 {

   911 	PyObject_FREE(ob);

   912 }

   913 

   914 static PyTypeObject test_structmembersType = {

   915     PyVarObject_HEAD_INIT(NULL, 0)

   916 	"test_structmembersType",

   917 	sizeof(test_structmembers),	/* tp_basicsize */

   918 	0,				/* tp_itemsize */

   919 	test_structmembers_free,	/* destructor tp_dealloc */

   920 	0,				/* tp_print */

   921 	0,				/* tp_getattr */

   922 	0,				/* tp_setattr */

   923 	0,				/* tp_compare */

   924 	0,				/* tp_repr */

   925 	0,				/* tp_as_number */

   926 	0,				/* tp_as_sequence */

   927 	0,				/* tp_as_mapping */

   928 	0,				/* tp_hash */

   929 	0,				/* tp_call */

   930 	0,				/* tp_str */

   931 	PyObject_GenericGetAttr,	/* tp_getattro */

   932 	PyObject_GenericSetAttr,	/* tp_setattro */

   933 	0,				/* tp_as_buffer */

   934 	0,				/* tp_flags */

   935 	"Type containing all structmember types",

   936 	0,				/* traverseproc tp_traverse */

   937 	0,				/* tp_clear */

   938 	0,				/* tp_richcompare */

   939 	0,				/* tp_weaklistoffset */

   940 	0,				/* tp_iter */

   941 	0,				/* tp_iternext */

   942 	0,				/* tp_methods */

   943 	test_members,			/* tp_members */

   944 	0,

   945 	0,

   946 	0,

   947 	0,

   948 	0,

   949 	0,

   950 	0,

   951 	0,

   952 	test_structmembers_new,	       	/* tp_new */

   953 };

   954 

   955 

   956 PyMODINIT_FUNC

   957 init_testcapi(void)

   958 {

   959 	PyObject *m;

   960 

   961 	m = Py_InitModule("_testcapi", TestMethods);

   962 	if (m == NULL)

   963 		return;

   964 

   965 	Py_TYPE(&test_structmembersType)=&PyType_Type;

   966 	Py_INCREF(&test_structmembersType);

   967 	PyModule_AddObject(m, "test_structmembersType", (PyObject *)&test_structmembersType);

   968 

   969 	PyModule_AddObject(m, "CHAR_MAX", PyInt_FromLong(CHAR_MAX));

   970 	PyModule_AddObject(m, "CHAR_MIN", PyInt_FromLong(CHAR_MIN));

   971 	PyModule_AddObject(m, "UCHAR_MAX", PyInt_FromLong(UCHAR_MAX));

   972 	PyModule_AddObject(m, "SHRT_MAX", PyInt_FromLong(SHRT_MAX));

   973 	PyModule_AddObject(m, "SHRT_MIN", PyInt_FromLong(SHRT_MIN));

   974 	PyModule_AddObject(m, "USHRT_MAX", PyInt_FromLong(USHRT_MAX));

   975 	PyModule_AddObject(m, "INT_MAX",  PyLong_FromLong(INT_MAX));

   976 	PyModule_AddObject(m, "INT_MIN",  PyLong_FromLong(INT_MIN));

   977 	PyModule_AddObject(m, "UINT_MAX",  PyLong_FromUnsignedLong(UINT_MAX));

   978 	PyModule_AddObject(m, "LONG_MAX", PyInt_FromLong(LONG_MAX));

   979 	PyModule_AddObject(m, "LONG_MIN", PyInt_FromLong(LONG_MIN));

   980 	PyModule_AddObject(m, "ULONG_MAX", PyLong_FromUnsignedLong(ULONG_MAX));

   981 	PyModule_AddObject(m, "FLT_MAX", PyFloat_FromDouble(FLT_MAX));

   982 	PyModule_AddObject(m, "FLT_MIN", PyFloat_FromDouble(FLT_MIN));

   983 	PyModule_AddObject(m, "DBL_MAX", PyFloat_FromDouble(DBL_MAX));

   984 	PyModule_AddObject(m, "DBL_MIN", PyFloat_FromDouble(DBL_MIN));

   985 	PyModule_AddObject(m, "LLONG_MAX", PyLong_FromLongLong(PY_LLONG_MAX));

   986 	PyModule_AddObject(m, "LLONG_MIN", PyLong_FromLongLong(PY_LLONG_MIN));

   987 	PyModule_AddObject(m, "ULLONG_MAX", PyLong_FromUnsignedLongLong(PY_ULLONG_MAX));

   988 	PyModule_AddObject(m, "PY_SSIZE_T_MAX", PyInt_FromSsize_t(PY_SSIZE_T_MAX));

   989 	PyModule_AddObject(m, "PY_SSIZE_T_MIN", PyInt_FromSsize_t(PY_SSIZE_T_MIN));

   990 	PyModule_AddObject(m, "SIZEOF_PYGC_HEAD", PyInt_FromSsize_t(sizeof(PyGC_Head)));

   991 

   992 	TestError = PyErr_NewException("_testcapi.error", NULL, NULL);

   993 	Py_INCREF(TestError);

   994 	PyModule_AddObject(m, "error", TestError);

   995 }