_testcapimodule.c 28.6 KB
Newer Older
1 2 3 4 5 6 7
/*
 * C Extension module to test Python interpreter C APIs.
 *
 * The 'test_*' functions exported by this module are run as part of the
 * standard Python regression test, via Lib/test/test_capi.py.
 */

8 9
#define PY_SSIZE_T_CLEAN

10
#include "Python.h"
11 12
#include <float.h>
#include "structmember.h"
13

14 15 16
#ifdef WITH_THREAD
#include "pythread.h"
#endif /* WITH_THREAD */
17 18
static PyObject *TestError;	/* set to exception object in init */

19 20 21 22 23 24 25 26 27 28
/* Raise TestError with test_name + ": " + msg, and return NULL. */

static PyObject *
raiseTestError(const char* test_name, const char* msg)
{
	char buf[2048];

	if (strlen(test_name) + strlen(msg) > sizeof(buf) - 50)
		PyErr_SetString(TestError, "internal error msg too large");
	else {
29
		PyOS_snprintf(buf, sizeof(buf), "%s: %s", test_name, msg);
30 31 32 33 34
		PyErr_SetString(TestError, buf);
	}
	return NULL;
}

35
/* Test #defines from pyconfig.h (particularly the SIZEOF_* defines).
36 37 38 39 40 41

   The ones derived from autoconf on the UNIX-like OSes can be relied
   upon (in the absence of sloppy cross-compiling), but the Windows
   platforms have these hardcoded.  Better safe than sorry.
*/
static PyObject*
42
sizeof_error(const char* fatname, const char* typname,
43 44 45
        int expected, int got)
{
	char buf[1024];
46
	PyOS_snprintf(buf, sizeof(buf),
47
		"%.200s #define == %d but sizeof(%.200s) == %d",
48
		fatname, expected, typname, got);
49 50 51 52 53
	PyErr_SetString(TestError, buf);
	return (PyObject*)NULL;
}

static PyObject*
54
test_config(PyObject *self)
55 56 57 58 59
{
#define CHECK_SIZEOF(FATNAME, TYPE) \
	    if (FATNAME != sizeof(TYPE)) \
    	    	return sizeof_error(#FATNAME, #TYPE, FATNAME, sizeof(TYPE))

60
	CHECK_SIZEOF(SIZEOF_SHORT, short);
61 62 63 64 65
	CHECK_SIZEOF(SIZEOF_INT, int);
	CHECK_SIZEOF(SIZEOF_LONG, long);
	CHECK_SIZEOF(SIZEOF_VOID_P, void*);
	CHECK_SIZEOF(SIZEOF_TIME_T, time_t);
#ifdef HAVE_LONG_LONG
66
	CHECK_SIZEOF(SIZEOF_LONG_LONG, PY_LONG_LONG);
67 68 69 70 71 72 73 74
#endif

#undef CHECK_SIZEOF

	Py_INCREF(Py_None);
	return Py_None;
}

75
static PyObject*
76
test_list_api(PyObject *self)
77 78 79 80 81 82 83 84 85 86 87
{
	PyObject* list;
	int i;

	/* SF bug 132008:  PyList_Reverse segfaults */
#define NLIST 30
	list = PyList_New(NLIST);
	if (list == (PyObject*)NULL)
		return (PyObject*)NULL;
	/* list = range(NLIST) */
	for (i = 0; i < NLIST; ++i) {
88
		PyObject* anint = PyLong_FromLong(i);
89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
		if (anint == (PyObject*)NULL) {
			Py_DECREF(list);
			return (PyObject*)NULL;
		}
		PyList_SET_ITEM(list, i, anint);
	}
	/* list.reverse(), via PyList_Reverse() */
	i = PyList_Reverse(list);   /* should not blow up! */
	if (i != 0) {
		Py_DECREF(list);
		return (PyObject*)NULL;
	}
	/* Check that list == range(29, -1, -1) now */
	for (i = 0; i < NLIST; ++i) {
		PyObject* anint = PyList_GET_ITEM(list, i);
104
		if (PyLong_AS_LONG(anint) != NLIST-1-i) {
105 106 107 108 109 110 111 112 113 114 115 116 117
			PyErr_SetString(TestError,
			                "test_list_api: reverse screwed up");
			Py_DECREF(list);
			return (PyObject*)NULL;
		}
	}
	Py_DECREF(list);
#undef NLIST

	Py_INCREF(Py_None);
	return Py_None;
}

118 119 120
static int
test_dict_inner(int count)
{
Martin v. Löwis's avatar
Martin v. Löwis committed
121 122
	Py_ssize_t pos = 0, iterations = 0;
	int i;
123 124 125 126 127 128 129
	PyObject *dict = PyDict_New();
	PyObject *v, *k;

	if (dict == NULL)
		return -1;

	for (i = 0; i < count; i++) {
130
		v = PyLong_FromLong(i);
131 132 133 134 135 136 137 138
		PyDict_SetItem(dict, v, v);
		Py_DECREF(v);
	}

	while (PyDict_Next(dict, &pos, &k, &v)) {
		PyObject *o;
		iterations++;

139 140
		i = PyLong_AS_LONG(v) + 1;
		o = PyLong_FromLong(i);
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162
		if (o == NULL)
			return -1;
		if (PyDict_SetItem(dict, k, o) < 0) {
			Py_DECREF(o);
			return -1;
		}
		Py_DECREF(o);
	}

	Py_DECREF(dict);

	if (iterations != count) {
		PyErr_SetString(
			TestError,
			"test_dict_iteration: dict iteration went wrong ");
		return -1;
	} else {
		return 0;
	}
}

static PyObject*
163
test_dict_iteration(PyObject* self)
164 165 166 167 168 169 170 171 172 173 174 175 176
{
	int i;

	for (i = 0; i < 200; i++) {
		if (test_dict_inner(i) < 0) {
			return NULL;
		}
	}

	Py_INCREF(Py_None);
	return Py_None;
}

177

178
/* Tests of PyLong_{As, From}{Unsigned,}Long(), and (#ifdef HAVE_LONG_LONG)
Tim Peters's avatar
Tim Peters committed
179
   PyLong_{As, From}{Unsigned,}LongLong().
180 181 182

   Note that the meat of the test is contained in testcapi_long.h.
   This is revolting, but delicate code duplication is worse:  "almost
183
   exactly the same" code is needed to test PY_LONG_LONG, but the ubiquitous
184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210
   dependence on type names makes it impossible to use a parameterized
   function.  A giant macro would be even worse than this.  A C++ template
   would be perfect.

   The "report an error" functions are deliberately not part of the #include
   file:  if the test fails, you can set a breakpoint in the appropriate
   error function directly, and crawl back from there in the debugger.
*/

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

static PyObject *
raise_test_long_error(const char* msg)
{
	return raiseTestError("test_long_api", msg);
}

#define TESTNAME	test_long_api_inner
#define TYPENAME	long
#define F_S_TO_PY	PyLong_FromLong
#define F_PY_TO_S	PyLong_AsLong
#define F_U_TO_PY	PyLong_FromUnsignedLong
#define F_PY_TO_U	PyLong_AsUnsignedLong

#include "testcapi_long.h"

static PyObject *
211
test_long_api(PyObject* self)
212
{
213
	return TESTNAME(raise_test_long_error);
214 215 216 217 218 219 220 221 222 223
}

#undef TESTNAME
#undef TYPENAME
#undef F_S_TO_PY
#undef F_PY_TO_S
#undef F_U_TO_PY
#undef F_PY_TO_U

#ifdef HAVE_LONG_LONG
224

Tim Peters's avatar
Tim Peters committed
225 226 227 228 229 230
static PyObject *
raise_test_longlong_error(const char* msg)
{
	return raiseTestError("test_longlong_api", msg);
}

231
#define TESTNAME	test_longlong_api_inner
232
#define TYPENAME	PY_LONG_LONG
233 234 235 236 237 238
#define F_S_TO_PY	PyLong_FromLongLong
#define F_PY_TO_S	PyLong_AsLongLong
#define F_U_TO_PY	PyLong_FromUnsignedLongLong
#define F_PY_TO_U	PyLong_AsUnsignedLongLong

#include "testcapi_long.h"
Tim Peters's avatar
Tim Peters committed
239

240
static PyObject *
241
test_longlong_api(PyObject* self, PyObject *args)
242
{
243
	return TESTNAME(raise_test_longlong_error);
244
}
Tim Peters's avatar
Tim Peters committed
245

246 247 248 249 250 251
#undef TESTNAME
#undef TYPENAME
#undef F_S_TO_PY
#undef F_PY_TO_S
#undef F_U_TO_PY
#undef F_PY_TO_U
252

253
/* Test the L code for PyArg_ParseTuple.  This should deliver a PY_LONG_LONG
254 255 256 257
   for both long and int arguments.  The test may leak a little memory if
   it fails.
*/
static PyObject *
258
test_L_code(PyObject *self)
259 260
{
	PyObject *tuple, *num;
261
	PY_LONG_LONG value;
262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280

        tuple = PyTuple_New(1);
        if (tuple == NULL)
        	return NULL;

        num = PyLong_FromLong(42);
        if (num == NULL)
        	return NULL;

        PyTuple_SET_ITEM(tuple, 0, num);

        value = -1;
        if (PyArg_ParseTuple(tuple, "L:test_L_code", &value) < 0)
        	return NULL;
        if (value != 42)
        	return raiseTestError("test_L_code",
			"L code returned wrong value for long 42");

	Py_DECREF(num);
281
        num = PyLong_FromLong(42);
282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298
        if (num == NULL)
        	return NULL;

        PyTuple_SET_ITEM(tuple, 0, num);

	value = -1;
        if (PyArg_ParseTuple(tuple, "L:test_L_code", &value) < 0)
        	return NULL;
        if (value != 42)
        	return raiseTestError("test_L_code",
			"L code returned wrong value for int 42");

	Py_DECREF(tuple);
	Py_INCREF(Py_None);
	return Py_None;
}

299
#endif	/* ifdef HAVE_LONG_LONG */
300

301 302 303 304 305 306 307 308 309 310
/* Test tuple argument processing */
static PyObject *
getargs_tuple(PyObject *self, PyObject *args)
{
	int a, b, c;
	if (!PyArg_ParseTuple(args, "i(ii)", &a, &b, &c))
		return NULL;
	return Py_BuildValue("iii", a, b, c);
}

311 312 313
/* Functions to call PyArg_ParseTuple with integer format codes,
   and return the result.
*/
314
static PyObject *
315
getargs_b(PyObject *self, PyObject *args)
316
{
317 318 319 320 321
	unsigned char value;
	if (!PyArg_ParseTuple(args, "b", &value))
		return NULL;
	return PyLong_FromUnsignedLong((unsigned long)value);
}
322

323 324 325 326 327
static PyObject *
getargs_B(PyObject *self, PyObject *args)
{
	unsigned char value;
	if (!PyArg_ParseTuple(args, "B", &value))
328
		return NULL;
329
	return PyLong_FromUnsignedLong((unsigned long)value);
330 331 332
}

static PyObject *
333
getargs_H(PyObject *self, PyObject *args)
334
{
335 336 337 338 339
	unsigned short value;
	if (!PyArg_ParseTuple(args, "H", &value))
		return NULL;
	return PyLong_FromUnsignedLong((unsigned long)value);
}
340

341 342 343 344 345
static PyObject *
getargs_I(PyObject *self, PyObject *args)
{
	unsigned int value;
	if (!PyArg_ParseTuple(args, "I", &value))
346
		return NULL;
347 348 349 350 351 352 353 354 355 356
	return PyLong_FromUnsignedLong((unsigned long)value);
}

static PyObject *
getargs_k(PyObject *self, PyObject *args)
{
	unsigned long value;
	if (!PyArg_ParseTuple(args, "k", &value))
		return NULL;
	return PyLong_FromUnsignedLong(value);
357 358 359
}

static PyObject *
360
getargs_i(PyObject *self, PyObject *args)
361
{
362 363 364 365 366
	int value;
	if (!PyArg_ParseTuple(args, "i", &value))
		return NULL;
	return PyLong_FromLong((long)value);
}
367

368 369 370 371 372
static PyObject *
getargs_l(PyObject *self, PyObject *args)
{
	long value;
	if (!PyArg_ParseTuple(args, "l", &value))
373
		return NULL;
374
	return PyLong_FromLong(value);
375 376
}

377 378 379 380 381
static PyObject *
getargs_n(PyObject *self, PyObject *args)
{
	Py_ssize_t value;
	if (!PyArg_ParseTuple(args, "n", &value))
382 383
		return NULL;
	return PyLong_FromSsize_t(value);
384 385
}

386
#ifdef HAVE_LONG_LONG
387
static PyObject *
388
getargs_L(PyObject *self, PyObject *args)
389
{
390 391 392 393 394
	PY_LONG_LONG value;
	if (!PyArg_ParseTuple(args, "L", &value))
		return NULL;
	return PyLong_FromLongLong(value);
}
395

396 397 398 399 400
static PyObject *
getargs_K(PyObject *self, PyObject *args)
{
	unsigned PY_LONG_LONG value;
	if (!PyArg_ParseTuple(args, "K", &value))
401
		return NULL;
402
	return PyLong_FromUnsignedLongLong(value);
403 404 405 406
}
#endif

/* This function not only tests the 'k' getargs code, but also the
407
   PyLong_AsUnsignedLongMask() and PyLong_AsUnsignedLongMask() functions. */
408 409 410 411 412 413 414 415 416 417
static PyObject *
test_k_code(PyObject *self)
{
	PyObject *tuple, *num;
	unsigned long value;

        tuple = PyTuple_New(1);
        if (tuple == NULL)
        	return NULL;

418
	/* a number larger than ULONG_MAX even on 64-bit platforms */
419 420 421 422
        num = PyLong_FromString("FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
        if (num == NULL)
        	return NULL;

423
	value = PyLong_AsUnsignedLongMask(num);
424
	if (value != ULONG_MAX)
425
        	return raiseTestError("test_k_code",
426
	    "PyLong_AsUnsignedLongMask() returned wrong value for long 0xFFF...FFF");
427 428 429

        PyTuple_SET_ITEM(tuple, 0, num);

430
        value = 0;
431 432
        if (PyArg_ParseTuple(tuple, "k:test_k_code", &value) < 0)
        	return NULL;
433
        if (value != ULONG_MAX)
434 435 436 437 438 439 440 441
        	return raiseTestError("test_k_code",
			"k code returned wrong value for long 0xFFF...FFF");

	Py_DECREF(num);
        num = PyLong_FromString("-FFFFFFFF000000000000000042", NULL, 16);
        if (num == NULL)
        	return NULL;

442
	value = PyLong_AsUnsignedLongMask(num);
443 444
	if (value != (unsigned long)-0x42)
        	return raiseTestError("test_k_code",
445
	    "PyLong_AsUnsignedLongMask() returned wrong value for long 0xFFF...FFF");
446 447 448

        PyTuple_SET_ITEM(tuple, 0, num);

449
	value = 0;
450 451 452 453 454 455 456 457 458 459 460
        if (PyArg_ParseTuple(tuple, "k:test_k_code", &value) < 0)
        	return NULL;
        if (value != (unsigned long)-0x42)
        	return raiseTestError("test_k_code",
			"k code returned wrong value for long -0xFFF..000042");

	Py_DECREF(tuple);
	Py_INCREF(Py_None);
	return Py_None;
}

461 462 463 464 465

/* Test the u and u# codes for PyArg_ParseTuple. May leak memory in case
   of an error.
*/
static PyObject *
466
test_u_code(PyObject *self)
467 468 469
{
	PyObject *tuple, *obj;
	Py_UNICODE *value;
470
	Py_ssize_t len;
471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495

        tuple = PyTuple_New(1);
        if (tuple == NULL)
        	return NULL;

        obj = PyUnicode_Decode("test", strlen("test"),
			       "ascii", NULL);
        if (obj == NULL)
        	return NULL;

        PyTuple_SET_ITEM(tuple, 0, obj);

        value = 0;
        if (PyArg_ParseTuple(tuple, "u:test_u_code", &value) < 0)
        	return NULL;
        if (value != PyUnicode_AS_UNICODE(obj))
        	return raiseTestError("test_u_code",
			"u code returned wrong value for u'test'");
        value = 0;
        if (PyArg_ParseTuple(tuple, "u#:test_u_code", &value, &len) < 0)
        	return NULL;
        if (value != PyUnicode_AS_UNICODE(obj) ||
	    len != PyUnicode_GET_SIZE(obj))
        	return raiseTestError("test_u_code",
			"u# code returned wrong values for u'test'");
496

497 498 499 500 501
	Py_DECREF(tuple);
	Py_INCREF(Py_None);
	return Py_None;
}

502 503 504 505 506 507
/* Test Z and Z# codes for PyArg_ParseTuple */
static PyObject *
test_Z_code(PyObject *self)
{
	PyObject *tuple, *obj;
	Py_UNICODE *value1, *value2;
508
	Py_ssize_t len1, len2;
509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554

        tuple = PyTuple_New(2);
        if (tuple == NULL)
        	return NULL;

	obj = PyUnicode_FromString("test");
	PyTuple_SET_ITEM(tuple, 0, obj);
	Py_INCREF(Py_None);
	PyTuple_SET_ITEM(tuple, 1, Py_None);

	/* swap values on purpose */
        value1 = NULL;
	value2 = PyUnicode_AS_UNICODE(obj);

	/* Test Z for both values */
        if (PyArg_ParseTuple(tuple, "ZZ:test_Z_code", &value1, &value2) < 0)
		return NULL;
        if (value1 != PyUnicode_AS_UNICODE(obj))
        	return raiseTestError("test_Z_code",
			"Z code returned wrong value for 'test'");
        if (value2 != NULL)
        	return raiseTestError("test_Z_code",
			"Z code returned wrong value for None");

        value1 = NULL;
	value2 = PyUnicode_AS_UNICODE(obj);
	len1 = -1;
	len2 = -1;

	/* Test Z# for both values */
        if (PyArg_ParseTuple(tuple, "Z#Z#:test_Z_code", &value1, &len1, 
			     &value2, &len2) < 0)
        	return NULL;
        if (value1 != PyUnicode_AS_UNICODE(obj) ||
	    len1 != PyUnicode_GET_SIZE(obj))
        	return raiseTestError("test_Z_code",
			"Z# code returned wrong values for 'test'");
        if (value2 != NULL ||
	    len2 != 0)
        	return raiseTestError("test_Z_code",
			"Z# code returned wrong values for None'");

	Py_DECREF(tuple);
	Py_RETURN_NONE;
}

555 556
static PyObject *
codec_incrementalencoder(PyObject *self, PyObject *args)
557 558 559 560 561 562 563 564
{
	const char *encoding, *errors = NULL;
	if (!PyArg_ParseTuple(args, "s|s:test_incrementalencoder",
			      &encoding, &errors))
		return NULL;
	return PyCodec_IncrementalEncoder(encoding, errors);
}

565 566
static PyObject *
codec_incrementaldecoder(PyObject *self, PyObject *args)
567 568 569 570 571 572 573 574
{
	const char *encoding, *errors = NULL;
	if (!PyArg_ParseTuple(args, "s|s:test_incrementaldecoder",
			      &encoding, &errors))
		return NULL;
	return PyCodec_IncrementalDecoder(encoding, errors);
}

575

576
/* Simple test of _PyLong_NumBits and _PyLong_Sign. */
577 578 579
static PyObject *
test_long_numbits(PyObject *self)
{
580
	struct triple {
581
		long input;
582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598
		size_t nbits;
		int sign;
	} testcases[] = {{0, 0, 0},
			 {1L, 1, 1},
			 {-1L, 1, -1},
			 {2L, 2, 1},
			 {-2L, 2, -1},
			 {3L, 2, 1},
			 {-3L, 2, -1},
			 {4L, 3, 1},
			 {-4L, 3, -1},
			 {0x7fffL, 15, 1},	/* one Python long digit */
			 {-0x7fffL, 15, -1},
			 {0xffffL, 16, 1},
			 {-0xffffL, 16, -1},
			 {0xfffffffL, 28, 1},
			 {-0xfffffffL, 28, -1}};
599 600
	int i;

601 602
	for (i = 0; i < sizeof(testcases) / sizeof(struct triple); ++i) {
		PyObject *plong = PyLong_FromLong(testcases[i].input);
603
		size_t nbits = _PyLong_NumBits(plong);
604
		int sign = _PyLong_Sign(plong);
605 606

		Py_DECREF(plong);
607
		if (nbits != testcases[i].nbits)
608
			return raiseTestError("test_long_numbits",
609 610 611 612
					"wrong result for _PyLong_NumBits");
		if (sign != testcases[i].sign)
			return raiseTestError("test_long_numbits",
					"wrong result for _PyLong_Sign");
613 614 615 616 617
	}
	Py_INCREF(Py_None);
	return Py_None;
}

618
/* Example passing NULLs to PyObject_Str(NULL). */
619 620 621 622

static PyObject *
test_null_strings(PyObject *self)
{
623
	PyObject *o1 = PyObject_Str(NULL), *o2 = PyObject_Str(NULL);
624 625 626 627 628 629
	PyObject *tuple = PyTuple_Pack(2, o1, o2);
	Py_XDECREF(o1);
	Py_XDECREF(o2);
	return tuple;
}

630 631 632 633 634 635 636 637 638 639 640 641 642 643 644
static PyObject *
raise_exception(PyObject *self, PyObject *args)
{
	PyObject *exc;
	PyObject *exc_args, *v;
	int num_args, i;

	if (!PyArg_ParseTuple(args, "Oi:raise_exception",
			      &exc, &num_args))
		return NULL;

	exc_args = PyTuple_New(num_args);
	if (exc_args == NULL)
		return NULL;
	for (i = 0; i < num_args; ++i) {
645
		v = PyLong_FromLong(i);
646 647 648 649 650 651 652
		if (v == NULL) {
			Py_DECREF(exc_args);
			return NULL;
		}
		PyTuple_SET_ITEM(exc_args, i, v);
	}
	PyErr_SetObject(exc, exc_args);
653
	Py_DECREF(exc_args);
654 655
	return NULL;
}
656

657 658
#ifdef WITH_THREAD

659 660 661 662 663 664 665 666 667 668 669
/* test_thread_state spawns a thread of its own, and that thread releases
 * `thread_done` when it's finished.  The driver code has to know when the
 * thread finishes, because the thread uses a PyObject (the callable) that
 * may go away when the driver finishes.  The former lack of this explicit
 * synchronization caused rare segfaults, so rare that they were seen only
 * on a Mac buildbot (although they were possible on any box).
 */
static PyThread_type_lock thread_done = NULL;

static void
_make_call(void *callable)
670 671 672
{
	PyObject *rc;
	PyGILState_STATE s = PyGILState_Ensure();
673
	rc = PyObject_CallFunction((PyObject *)callable, "");
674 675 676 677
	Py_XDECREF(rc);
	PyGILState_Release(s);
}

678 679 680 681 682 683 684 685 686 687
/* Same thing, but releases `thread_done` when it returns.  This variant
 * should be called only from threads spawned by test_thread_state().
 */
static void
_make_call_from_thread(void *callable)
{
	_make_call(callable);
	PyThread_release_lock(thread_done);
}

688 689 690 691
static PyObject *
test_thread_state(PyObject *self, PyObject *args)
{
	PyObject *fn;
692

693 694
	if (!PyArg_ParseTuple(args, "O:test_thread_state", &fn))
		return NULL;
695 696

	/* Ensure Python is set up for threading */
697
	PyEval_InitThreads();
698 699 700 701 702 703 704
	thread_done = PyThread_allocate_lock();
	if (thread_done == NULL)
		return PyErr_NoMemory();
	PyThread_acquire_lock(thread_done, 1);

	/* Start a new thread with our callback. */
	PyThread_start_new_thread(_make_call_from_thread, fn);
705 706 707 708 709
	/* Make the callback with the thread lock held by this thread */
	_make_call(fn);
	/* Do it all again, but this time with the thread-lock released */
	Py_BEGIN_ALLOW_THREADS
	_make_call(fn);
710
	PyThread_acquire_lock(thread_done, 1);  /* wait for thread to finish */
711
	Py_END_ALLOW_THREADS
712

713
	/* And once more with and without a thread
714 715
	   XXX - should use a lock and work out exactly what we are trying
	   to test <wink>
716 717
	*/
	Py_BEGIN_ALLOW_THREADS
718
	PyThread_start_new_thread(_make_call_from_thread, fn);
719
	_make_call(fn);
720
	PyThread_acquire_lock(thread_done, 1);  /* wait for thread to finish */
721
	Py_END_ALLOW_THREADS
722

723 724 725
	/* Release lock we acquired above.  This is required on HP-UX. */
	PyThread_release_lock(thread_done);

726 727
	PyThread_free_lock(thread_done);
	Py_RETURN_NONE;
728 729 730
}
#endif

Neal Norwitz's avatar
Neal Norwitz committed
731
/* Some tests of PyUnicode_FromFormat().  This needs more tests. */
732 733 734 735 736 737 738
static PyObject *
test_string_from_format(PyObject *self, PyObject *args)
{
	PyObject *result;
	char *msg;

#define CHECK_1_FORMAT(FORMAT, TYPE) 			\
Neal Norwitz's avatar
Neal Norwitz committed
739
	result = PyUnicode_FromFormat(FORMAT, (TYPE)1);	\
740 741
	if (result == NULL)				\
		return NULL;				\
Neal Norwitz's avatar
Neal Norwitz committed
742
	if (strcmp(PyUnicode_AsString(result), "1")) {	\
743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766
		msg = FORMAT " failed at 1";		\
		goto Fail;				\
	}						\
	Py_DECREF(result)

	CHECK_1_FORMAT("%d", int);
	CHECK_1_FORMAT("%ld", long);
	/* The z width modifier was added in Python 2.5. */
	CHECK_1_FORMAT("%zd", Py_ssize_t);

	/* The u type code was added in Python 2.5. */
	CHECK_1_FORMAT("%u", unsigned int);
	CHECK_1_FORMAT("%lu", unsigned long);
	CHECK_1_FORMAT("%zu", size_t);

	Py_RETURN_NONE;

 Fail:
 	Py_XDECREF(result);
	return raiseTestError("test_string_from_format", msg);

#undef CHECK_1_FORMAT
}

767 768 769 770 771 772 773
/* This is here to provide a docstring for test_descr. */
static PyObject *
test_with_docstring(PyObject *self)
{
	Py_RETURN_NONE;
}

774 775 776 777 778 779 780 781 782 783
#ifdef HAVE_GETTIMEOFDAY
/* Profiling of integer performance */
void print_delta(int test, struct timeval *s, struct timeval *e)
{
	e->tv_sec -= s->tv_sec;
	e->tv_usec -= s->tv_usec;
	if (e->tv_usec < 0) {
		e->tv_sec -=1;
		e->tv_usec += 1000000;
	}
784
	printf("Test %d: %d.%06ds\n", test, (int)e->tv_sec, (int)e->tv_usec);
785 786 787 788 789 790 791 792 793 794 795 796 797 798
}

static PyObject *
profile_int(PyObject *self, PyObject* args)
{
	int i, k;
	struct timeval start, stop;
	PyObject *single, **multiple, *op1, *result;

	/* Test 1: Allocate and immediately deallocate
	   many small integers */
	gettimeofday(&start, NULL);
	for(k=0; k < 20000; k++)
		for(i=0; i < 1000; i++) {
799
			single = PyLong_FromLong(i);
800 801 802 803 804 805 806 807 808 809
			Py_DECREF(single);
		}
	gettimeofday(&stop, NULL);
	print_delta(1, &start, &stop);

	/* Test 2: Allocate and immediately deallocate
	   many large integers */
	gettimeofday(&start, NULL);
	for(k=0; k < 20000; k++)
		for(i=0; i < 1000; i++) {
810
			single = PyLong_FromLong(i+1000000);
811 812 813 814 815 816 817 818 819 820 821
			Py_DECREF(single);
		}
	gettimeofday(&stop, NULL);
	print_delta(2, &start, &stop);

	/* Test 3: Allocate a few integers, then release
	   them all simultaneously. */
	multiple = malloc(sizeof(PyObject*) * 1000);
	gettimeofday(&start, NULL);
	for(k=0; k < 20000; k++) {
		for(i=0; i < 1000; i++) {
822
			multiple[i] = PyLong_FromLong(i+1000000);
823 824 825 826 827 828 829 830 831 832 833 834 835 836
		}
		for(i=0; i < 1000; i++) {
			Py_DECREF(multiple[i]);
		}
	}
	gettimeofday(&stop, NULL);
	print_delta(3, &start, &stop);

	/* Test 4: Allocate many integers, then release
	   them all simultaneously. */
	multiple = malloc(sizeof(PyObject*) * 1000000);
	gettimeofday(&start, NULL);
	for(k=0; k < 20; k++) {
		for(i=0; i < 1000000; i++) {
837
			multiple[i] = PyLong_FromLong(i+1000000);
838 839 840 841 842 843 844 845 846 847 848 849 850
		}
		for(i=0; i < 1000000; i++) {
			Py_DECREF(multiple[i]);
		}
	}
	gettimeofday(&stop, NULL);
	print_delta(4, &start, &stop);

	/* Test 5: Allocate many integers < 32000 */
	multiple = malloc(sizeof(PyObject*) * 1000000);
	gettimeofday(&start, NULL);
	for(k=0; k < 10; k++) {
		for(i=0; i < 1000000; i++) {
851
			multiple[i] = PyLong_FromLong(i+1000);
852 853 854 855 856 857 858 859 860
		}
		for(i=0; i < 1000000; i++) {
			Py_DECREF(multiple[i]);
		}
	}
	gettimeofday(&stop, NULL);
	print_delta(5, &start, &stop);

	/* Test 6: Perform small int addition */
861
	op1 = PyLong_FromLong(1);
862 863 864 865 866 867 868 869 870 871
	gettimeofday(&start, NULL);
	for(i=0; i < 10000000; i++) {
		result = PyNumber_Add(op1, op1);
		Py_DECREF(result);
	}
	gettimeofday(&stop, NULL);
	Py_DECREF(op1);
	print_delta(6, &start, &stop);

	/* Test 7: Perform medium int addition */
872
	op1 = PyLong_FromLong(1000);
873 874 875 876 877 878 879 880 881 882 883 884 885 886
	gettimeofday(&start, NULL);
	for(i=0; i < 10000000; i++) {
		result = PyNumber_Add(op1, op1);
		Py_DECREF(result);
	}
	gettimeofday(&stop, NULL);
	Py_DECREF(op1);
	print_delta(7, &start, &stop);

	Py_INCREF(Py_None);
	return Py_None;
}
#endif

887
static PyMethodDef TestMethods[] = {
888 889 890 891 892
	{"raise_exception",	raise_exception,		 METH_VARARGS},
	{"test_config",		(PyCFunction)test_config,	 METH_NOARGS},
	{"test_list_api",	(PyCFunction)test_list_api,	 METH_NOARGS},
	{"test_dict_iteration",	(PyCFunction)test_dict_iteration,METH_NOARGS},
	{"test_long_api",	(PyCFunction)test_long_api,	 METH_NOARGS},
893
	{"test_long_numbits",	(PyCFunction)test_long_numbits,	 METH_NOARGS},
894
	{"test_k_code",		(PyCFunction)test_k_code,	 METH_NOARGS},
895
	{"test_null_strings",	(PyCFunction)test_null_strings,	 METH_NOARGS},
896
	{"test_string_from_format", (PyCFunction)test_string_from_format, METH_NOARGS},
897 898
	{"test_with_docstring", (PyCFunction)test_with_docstring, METH_NOARGS,
	 PyDoc_STR("This is a pretty normal docstring.")},
899

900
	{"getargs_tuple",	getargs_tuple,			 METH_VARARGS},
901 902 903 904 905 906 907 908
	{"getargs_b",		getargs_b,			 METH_VARARGS},
	{"getargs_B",		getargs_B,			 METH_VARARGS},
	{"getargs_H",		getargs_H,			 METH_VARARGS},
	{"getargs_I",		getargs_I,			 METH_VARARGS},
	{"getargs_k",		getargs_k,			 METH_VARARGS},
	{"getargs_i",		getargs_i,			 METH_VARARGS},
	{"getargs_l",		getargs_l,			 METH_VARARGS},
	{"getargs_n",		getargs_n, 			 METH_VARARGS},
909
#ifdef HAVE_LONG_LONG
910 911 912
	{"getargs_L",		getargs_L,			 METH_VARARGS},
	{"getargs_K",		getargs_K,			 METH_VARARGS},
	{"test_longlong_api",	test_longlong_api,		 METH_NOARGS},
913
	{"test_L_code",		(PyCFunction)test_L_code,	 METH_NOARGS},
914 915 916 917
	{"codec_incrementalencoder",
	 (PyCFunction)codec_incrementalencoder,	 METH_VARARGS},
	{"codec_incrementaldecoder",
	 (PyCFunction)codec_incrementaldecoder,	 METH_VARARGS},
918
#endif
919
	{"test_u_code",		(PyCFunction)test_u_code,	 METH_NOARGS},
920
	{"test_Z_code",		(PyCFunction)test_Z_code,	 METH_NOARGS},
921
#ifdef WITH_THREAD
922
	{"_test_thread_state",  test_thread_state, 		 METH_VARARGS},
923 924 925
#endif
#ifdef HAVE_GETTIMEOFDAY
	{"profile_int",		profile_int,			METH_NOARGS},
926
#endif
927 928 929
	{NULL, NULL} /* sentinel */
};

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

932 933 934 935 936 937 938 939 940 941 942
typedef struct {
	char byte_member;
	unsigned char ubyte_member;
	short short_member;
	unsigned short ushort_member;
	int int_member;
	unsigned int uint_member;
	long long_member;
	unsigned long ulong_member;
	float float_member;
	double double_member;
943 944 945 946
#ifdef HAVE_LONG_LONG
	PY_LONG_LONG longlong_member;
	unsigned PY_LONG_LONG ulonglong_member;
#endif
947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964
} all_structmembers;

typedef struct {
    PyObject_HEAD
	all_structmembers structmembers;
} test_structmembers;

static struct PyMemberDef test_members[] = {
	{"T_BYTE", T_BYTE, offsetof(test_structmembers, structmembers.byte_member), 0, NULL},
	{"T_UBYTE", T_UBYTE, offsetof(test_structmembers, structmembers.ubyte_member), 0, NULL},
	{"T_SHORT", T_SHORT, offsetof(test_structmembers, structmembers.short_member), 0, NULL},
	{"T_USHORT", T_USHORT, offsetof(test_structmembers, structmembers.ushort_member), 0, NULL},
	{"T_INT", T_INT, offsetof(test_structmembers, structmembers.int_member), 0, NULL},
	{"T_UINT", T_UINT, offsetof(test_structmembers, structmembers.uint_member), 0, NULL},
	{"T_LONG", T_LONG, offsetof(test_structmembers, structmembers.long_member), 0, NULL},
	{"T_ULONG", T_ULONG, offsetof(test_structmembers, structmembers.ulong_member), 0, NULL},
	{"T_FLOAT", T_FLOAT, offsetof(test_structmembers, structmembers.float_member), 0, NULL},
	{"T_DOUBLE", T_DOUBLE, offsetof(test_structmembers, structmembers.double_member), 0, NULL},
965 966 967 968
#ifdef HAVE_LONG_LONG
	{"T_LONGLONG", T_LONGLONG, offsetof(test_structmembers, structmembers.longlong_member), 0, NULL},
	{"T_ULONGLONG", T_ULONGLONG, offsetof(test_structmembers, structmembers.ulonglong_member), 0, NULL},
#endif
969 970 971 972 973 974
	{NULL}
};


static PyObject *test_structmembers_new(PyTypeObject *type, PyObject *args, PyObject *kwargs){
	static char *keywords[]={"T_BYTE", "T_UBYTE", "T_SHORT", "T_USHORT", "T_INT", "T_UINT",
975 976 977 978 979 980 981 982 983 984
		"T_LONG", "T_ULONG", "T_FLOAT", "T_DOUBLE",
		#ifdef HAVE_LONG_LONG	
		"T_LONGLONG", "T_ULONGLONG",
		#endif
		NULL};
	static char *fmt="|bBhHiIlkfd"
		#ifdef HAVE_LONG_LONG
		"LK"
		#endif
		;
985 986 987 988
	test_structmembers *ob=PyObject_New(test_structmembers, type);
	if (ob==NULL)
		return NULL;
	memset(&ob->structmembers, 0, sizeof(all_structmembers));
989
	if (!PyArg_ParseTupleAndKeywords(args, kwargs, fmt, keywords,
990 991 992 993
		&ob->structmembers.byte_member, &ob->structmembers.ubyte_member,
		&ob->structmembers.short_member, &ob->structmembers.ushort_member,
		&ob->structmembers.int_member, &ob->structmembers.uint_member, 
		&ob->structmembers.long_member, &ob->structmembers.ulong_member,
994 995 996 997 998
		&ob->structmembers.float_member, &ob->structmembers.double_member
		#ifdef HAVE_LONG_LONG
		,&ob->structmembers.longlong_member, &ob->structmembers.ulonglong_member
		#endif
		)){
999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
		Py_DECREF(ob);
		return NULL;
		}
	return (PyObject *)ob;
}

static void test_structmembers_free(PyObject *ob){
	PyObject_FREE(ob);
}

static PyTypeObject test_structmembersType = {
1010
    PyVarObject_HEAD_INIT(NULL, 0)
1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050
	"test_structmembersType",
	sizeof(test_structmembers),	/* tp_basicsize */
	0,				/* tp_itemsize */
	test_structmembers_free,	/* destructor tp_dealloc */
	0,				/* tp_print */
	0,				/* tp_getattr */
	0,				/* tp_setattr */
	0,				/* tp_compare */
	0,				/* tp_repr */
	0,				/* tp_as_number */
	0,				/* tp_as_sequence */
	0,				/* tp_as_mapping */
	0,				/* tp_hash */
	0,				/* tp_call */
	0,				/* tp_str */
	PyObject_GenericGetAttr,
	PyObject_GenericSetAttr,
	0,				/* tp_as_buffer */
	0,				/* tp_flags */
	"Type containing all structmember types",
	0,				/* traverseproc tp_traverse */
	0,				/* tp_clear */
	0,				/* tp_richcompare */
	0,				/* tp_weaklistoffset */
	0,				/* tp_iter */
	0,				/* tp_iternext */
	0,				/* tp_methods */
	test_members,	/* tp_members */
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	test_structmembers_new,			/* tp_new */
};


1051
PyMODINIT_FUNC
1052
init_testcapi(void)
1053
{
1054
	PyObject *m;
1055

1056
	m = Py_InitModule("_testcapi", TestMethods);
1057 1058
	if (m == NULL)
		return;
1059

1060
	Py_Type(&test_structmembersType)=&PyType_Type;
1061 1062 1063
	Py_INCREF(&test_structmembersType);
	PyModule_AddObject(m, "test_structmembersType", (PyObject *)&test_structmembersType);

1064 1065 1066 1067 1068 1069
	PyModule_AddObject(m, "CHAR_MAX", PyLong_FromLong(CHAR_MAX));
	PyModule_AddObject(m, "CHAR_MIN", PyLong_FromLong(CHAR_MIN));
	PyModule_AddObject(m, "UCHAR_MAX", PyLong_FromLong(UCHAR_MAX));
	PyModule_AddObject(m, "SHRT_MAX", PyLong_FromLong(SHRT_MAX));
	PyModule_AddObject(m, "SHRT_MIN", PyLong_FromLong(SHRT_MIN));
	PyModule_AddObject(m, "USHRT_MAX", PyLong_FromLong(USHRT_MAX));
1070 1071
	PyModule_AddObject(m, "INT_MAX",  PyLong_FromLong(INT_MAX));
	PyModule_AddObject(m, "INT_MIN",  PyLong_FromLong(INT_MIN));
1072
	PyModule_AddObject(m, "UINT_MAX",  PyLong_FromUnsignedLong(UINT_MAX));
1073 1074
	PyModule_AddObject(m, "LONG_MAX", PyLong_FromLong(LONG_MAX));
	PyModule_AddObject(m, "LONG_MIN", PyLong_FromLong(LONG_MIN));
1075 1076 1077 1078 1079
	PyModule_AddObject(m, "ULONG_MAX", PyLong_FromUnsignedLong(ULONG_MAX));
	PyModule_AddObject(m, "FLT_MAX", PyFloat_FromDouble(FLT_MAX));
	PyModule_AddObject(m, "FLT_MIN", PyFloat_FromDouble(FLT_MIN));
	PyModule_AddObject(m, "DBL_MAX", PyFloat_FromDouble(DBL_MAX));
	PyModule_AddObject(m, "DBL_MIN", PyFloat_FromDouble(DBL_MIN));
1080 1081 1082
	PyModule_AddObject(m, "LLONG_MAX", PyLong_FromLongLong(PY_LLONG_MAX));
	PyModule_AddObject(m, "LLONG_MIN", PyLong_FromLongLong(PY_LLONG_MIN));
	PyModule_AddObject(m, "ULLONG_MAX", PyLong_FromUnsignedLongLong(PY_ULLONG_MAX));
1083 1084
	PyModule_AddObject(m, "PY_SSIZE_T_MAX", PyLong_FromSsize_t(PY_SSIZE_T_MAX));
	PyModule_AddObject(m, "PY_SSIZE_T_MIN", PyLong_FromSsize_t(PY_SSIZE_T_MIN));
1085

1086
	TestError = PyErr_NewException("_testcapi.error", NULL, NULL);
1087 1088
	Py_INCREF(TestError);
	PyModule_AddObject(m, "error", TestError);
1089
}