Modules/_testcapimodule.c

   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 #define PY_SSIZE_T_CLEAN
   9
  10 #include "Python.h"
  11 #include <float.h>
  12 #include "structmember.h"
  13
  14 #ifdef WITH_THREAD
  15 #include "pythread.h"
  16 #endif /* WITH_THREAD */
  17 static PyObject *TestError;     /* set to exception object in init */
  18
  19 /* Raise TestError with test_name + ": " + msg, and return NULL. */
  20
  21 static PyObject *
  22 raiseTestError(const char* test_name, const char* msg)
  23 {
  24         char buf[2048];
  25
  26         if (strlen(test_name) + strlen(msg) > sizeof(buf) - 50)
  27                 PyErr_SetString(TestError, "internal error msg too large");
  28         else {
  29                 PyOS_snprintf(buf, sizeof(buf), "%s: %s", test_name, msg);
  30                 PyErr_SetString(TestError, buf);
  31         }
  32         return NULL;
  33 }
  34
  35 /* Test #defines from pyconfig.h (particularly the SIZEOF_* defines).
  36
  37    The ones derived from autoconf on the UNIX-like OSes can be relied
  38    upon (in the absence of sloppy cross-compiling), but the Windows
  39    platforms have these hardcoded.  Better safe than sorry.
  40 */
  41 static PyObject*
  42 sizeof_error(const char* fatname, const char* typname,
  43         int expected, int got)
  44 {
  45         char buf[1024];
  46         PyOS_snprintf(buf, sizeof(buf),
  47                 "%.200s #define == %d but sizeof(%.200s) == %d",
  48                 fatname, expected, typname, got);
  49         PyErr_SetString(TestError, buf);
  50         return (PyObject*)NULL;
  51 }
  52
  53 static PyObject*
  54 test_config(PyObject *self)
  55 {
  56 #define CHECK_SIZEOF(FATNAME, TYPE) \
  57             if (FATNAME != sizeof(TYPE)) \
  58                 return sizeof_error(#FATNAME, #TYPE, FATNAME, sizeof(TYPE))
  59
  60         CHECK_SIZEOF(SIZEOF_SHORT, short);
  61         CHECK_SIZEOF(SIZEOF_INT, int);
  62         CHECK_SIZEOF(SIZEOF_LONG, long);
  63         CHECK_SIZEOF(SIZEOF_VOID_P, void*);
  64         CHECK_SIZEOF(SIZEOF_TIME_T, time_t);
  65 #ifdef HAVE_LONG_LONG
  66         CHECK_SIZEOF(SIZEOF_LONG_LONG, PY_LONG_LONG);
  67 #endif
  68
  69 #undef CHECK_SIZEOF
  70
  71         Py_INCREF(Py_None);
  72         return Py_None;
  73 }
  74
  75 static PyObject*
  76 test_list_api(PyObject *self)
  77 {
  78         PyObject* list;
  79         int i;
  80
  81         /* SF bug 132008:  PyList_Reverse segfaults */
  82 #define NLIST 30
  83         list = PyList_New(NLIST);
  84         if (list == (PyObject*)NULL)
  85                 return (PyObject*)NULL;
  86         /* list = range(NLIST) */
  87         for (i = 0; i < NLIST; ++i) {
  88                 PyObject* anint = PyLong_FromLong(i);
  89                 if (anint == (PyObject*)NULL) {
  90                         Py_DECREF(list);
  91                         return (PyObject*)NULL;
  92                 }
  93                 PyList_SET_ITEM(list, i, anint);
  94         }
  95         /* list.reverse(), via PyList_Reverse() */
  96         i = PyList_Reverse(list);   /* should not blow up! */
  97         if (i != 0) {
  98                 Py_DECREF(list);
  99                 return (PyObject*)NULL;
 100         }
 101         /* Check that list == range(29, -1, -1) now */
 102         for (i = 0; i < NLIST; ++i) {
 103                 PyObject* anint = PyList_GET_ITEM(list, i);
 104                 if (PyLong_AS_LONG(anint) != NLIST-1-i) {
 105                         PyErr_SetString(TestError,
 106                                         "test_list_api: reverse screwed up");
 107                         Py_DECREF(list);
 108                         return (PyObject*)NULL;
 109                 }
 110         }
 111         Py_DECREF(list);
 112 #undef NLIST
 113
 114         Py_INCREF(Py_None);
 115         return Py_None;
 116 }
 117
 118 static int
 119 test_dict_inner(int count)
 120 {
 121         Py_ssize_t pos = 0, iterations = 0;
 122         int i;
 123         PyObject *dict = PyDict_New();
 124         PyObject *v, *k;
 125
 126         if (dict == NULL)
 127                 return -1;
 128
 129         for (i = 0; i < count; i++) {
 130                 v = PyLong_FromLong(i);
 131                 PyDict_SetItem(dict, v, v);
 132                 Py_DECREF(v);
 133         }
 134
 135         while (PyDict_Next(dict, &pos, &k, &v)) {
 136                 PyObject *o;
 137                 iterations++;
 138
 139                 i = PyLong_AS_LONG(v) + 1;
 140                 o = PyLong_FromLong(i);
 141                 if (o == NULL)
 142                         return -1;
 143                 if (PyDict_SetItem(dict, k, o) < 0) {
 144                         Py_DECREF(o);
 145                         return -1;
 146                 }
 147                 Py_DECREF(o);
 148         }
 149
 150         Py_DECREF(dict);
 151
 152         if (iterations != count) {
 153                 PyErr_SetString(
 154                         TestError,
 155                         "test_dict_iteration: dict iteration went wrong ");
 156                 return -1;
 157         } else {
 158                 return 0;
 159         }
 160 }
 161
 162 static PyObject*
 163 test_dict_iteration(PyObject* self)
 164 {
 165         int i;
 166
 167         for (i = 0; i < 200; i++) {
 168                 if (test_dict_inner(i) < 0) {
 169                         return NULL;
 170                 }
 171         }
 172
 173         Py_INCREF(Py_None);
 174         return Py_None;
 175 }
 176
 177
 178 /* Issue #4701: Check that PyObject_Hash implicitly calls
 179  *   PyType_Ready if it hasn't already been called
 180  */
 181 static PyTypeObject _HashInheritanceTester_Type = {
 182         PyVarObject_HEAD_INIT(NULL, 0)
 183         "hashinheritancetester",        /* Name of this type */
 184         sizeof(PyObject),       /* Basic object size */
 185         0,                      /* Item size for varobject */
 186         (destructor)PyObject_Del, /* tp_dealloc */
 187         0,                      /* tp_print */
 188         0,                      /* tp_getattr */
 189         0,                      /* tp_setattr */
 190         0,                      /* tp_reserved */
 191         0,                      /* tp_repr */
 192         0,                      /* tp_as_number */
 193         0,                      /* tp_as_sequence */
 194         0,                      /* tp_as_mapping */
 195         0,                      /* tp_hash */
 196         0,                      /* tp_call */
 197         0,                      /* tp_str */
 198         PyObject_GenericGetAttr,  /* tp_getattro */
 199         0,                      /* tp_setattro */
 200         0,                      /* tp_as_buffer */
 201         Py_TPFLAGS_DEFAULT,     /* tp_flags */
 202         0,                      /* tp_doc */
 203         0,                      /* tp_traverse */
 204         0,                      /* tp_clear */
 205         0,                      /* tp_richcompare */
 206         0,                      /* tp_weaklistoffset */
 207         0,                      /* tp_iter */
 208         0,                      /* tp_iternext */
 209         0,                      /* tp_methods */
 210         0,                      /* tp_members */
 211         0,                      /* tp_getset */
 212         0,                      /* tp_base */
 213         0,                      /* tp_dict */
 214         0,                      /* tp_descr_get */
 215         0,                      /* tp_descr_set */
 216         0,                      /* tp_dictoffset */
 217         0,                      /* tp_init */
 218         0,                      /* tp_alloc */
 219         PyType_GenericNew,              /* tp_new */
 220 };
 221
 222 static PyObject*
 223 test_lazy_hash_inheritance(PyObject* self)
 224 {
 225         PyTypeObject *type;
 226         PyObject *obj;
 227         long hash;
 228
 229         type = &_HashInheritanceTester_Type;
 230         obj = PyObject_New(PyObject, type);
 231         if (obj == NULL) {
 232                 PyErr_Clear();
 233                 PyErr_SetString(
 234                         TestError,
 235                         "test_lazy_hash_inheritance: failed to create object");
 236                 return NULL;
 237         }
 238
 239         if (type->tp_dict != NULL) {
 240                 PyErr_SetString(
 241                         TestError,
 242                         "test_lazy_hash_inheritance: type initialised too soon");
 243                 Py_DECREF(obj);
 244                 return NULL;
 245         }
 246
 247         hash = PyObject_Hash(obj);
 248         if ((hash == -1) && PyErr_Occurred()) {
 249                 PyErr_Clear();
 250                 PyErr_SetString(
 251                         TestError,
 252                         "test_lazy_hash_inheritance: could not hash object");
 253                 Py_DECREF(obj);
 254                 return NULL;
 255         }
 256
 257         if (type->tp_dict == NULL) {
 258                 PyErr_SetString(
 259                         TestError,
 260                         "test_lazy_hash_inheritance: type not initialised by hash()");
 261                 Py_DECREF(obj);
 262                 return NULL;
 263         }
 264
 265         if (type->tp_hash != PyType_Type.tp_hash) {
 266                 PyErr_SetString(
 267                         TestError,
 268                         "test_lazy_hash_inheritance: unexpected hash function");
 269                 Py_DECREF(obj);
 270                 return NULL;
 271         }
 272
 273         Py_RETURN_NONE;
 274 }
 275
 276
 277 /* Tests of PyLong_{As, From}{Unsigned,}Long(), and (#ifdef HAVE_LONG_LONG)
 278    PyLong_{As, From}{Unsigned,}LongLong().
 279
 280    Note that the meat of the test is contained in testcapi_long.h.
 281    This is revolting, but delicate code duplication is worse:  "almost
 282    exactly the same" code is needed to test PY_LONG_LONG, but the ubiquitous
 283    dependence on type names makes it impossible to use a parameterized
 284    function.  A giant macro would be even worse than this.  A C++ template
 285    would be perfect.
 286
 287    The "report an error" functions are deliberately not part of the #include
 288    file:  if the test fails, you can set a breakpoint in the appropriate
 289    error function directly, and crawl back from there in the debugger.
 290 */
 291
 292 #define UNBIND(X)  Py_DECREF(X); (X) = NULL
 293
 294 static PyObject *
 295 raise_test_long_error(const char* msg)
 296 {
 297         return raiseTestError("test_long_api", msg);
 298 }
 299
 300 #define TESTNAME        test_long_api_inner
 301 #define TYPENAME        long
 302 #define F_S_TO_PY       PyLong_FromLong
 303 #define F_PY_TO_S       PyLong_AsLong
 304 #define F_U_TO_PY       PyLong_FromUnsignedLong
 305 #define F_PY_TO_U       PyLong_AsUnsignedLong
 306
 307 #include "testcapi_long.h"
 308
 309 static PyObject *
 310 test_long_api(PyObject* self)
 311 {
 312         return TESTNAME(raise_test_long_error);
 313 }
 314
 315 #undef TESTNAME
 316 #undef TYPENAME
 317 #undef F_S_TO_PY
 318 #undef F_PY_TO_S
 319 #undef F_U_TO_PY
 320 #undef F_PY_TO_U
 321
 322 #ifdef HAVE_LONG_LONG
 323
 324 static PyObject *
 325 raise_test_longlong_error(const char* msg)
 326 {
 327         return raiseTestError("test_longlong_api", msg);
 328 }
 329
 330 #define TESTNAME        test_longlong_api_inner
 331 #define TYPENAME        PY_LONG_LONG
 332 #define F_S_TO_PY       PyLong_FromLongLong
 333 #define F_PY_TO_S       PyLong_AsLongLong
 334 #define F_U_TO_PY       PyLong_FromUnsignedLongLong
 335 #define F_PY_TO_U       PyLong_AsUnsignedLongLong
 336
 337 #include "testcapi_long.h"
 338
 339 static PyObject *
 340 test_longlong_api(PyObject* self, PyObject *args)
 341 {
 342         return TESTNAME(raise_test_longlong_error);
 343 }
 344
 345 #undef TESTNAME
 346 #undef TYPENAME
 347 #undef F_S_TO_PY
 348 #undef F_PY_TO_S
 349 #undef F_U_TO_PY
 350 #undef F_PY_TO_U
 351
 352 /* Test the L code for PyArg_ParseTuple.  This should deliver a PY_LONG_LONG
 353    for both long and int arguments.  The test may leak a little memory if
 354    it fails.
 355 */
 356 static PyObject *
 357 test_L_code(PyObject *self)
 358 {
 359         PyObject *tuple, *num;
 360         PY_LONG_LONG value;
 361
 362         tuple = PyTuple_New(1);
 363         if (tuple == NULL)
 364                 return NULL;
 365
 366         num = PyLong_FromLong(42);
 367         if (num == NULL)
 368                 return NULL;
 369
 370         PyTuple_SET_ITEM(tuple, 0, num);
 371
 372         value = -1;
 373         if (PyArg_ParseTuple(tuple, "L:test_L_code", &value) < 0)
 374                 return NULL;
 375         if (value != 42)
 376                 return raiseTestError("test_L_code",
 377                         "L code returned wrong value for long 42");
 378
 379         Py_DECREF(num);
 380         num = PyLong_FromLong(42);
 381         if (num == NULL)
 382                 return NULL;
 383
 384         PyTuple_SET_ITEM(tuple, 0, num);
 385
 386         value = -1;
 387         if (PyArg_ParseTuple(tuple, "L:test_L_code", &value) < 0)
 388                 return NULL;
 389         if (value != 42)
 390                 return raiseTestError("test_L_code",
 391                         "L code returned wrong value for int 42");
 392
 393         Py_DECREF(tuple);
 394         Py_INCREF(Py_None);
 395         return Py_None;
 396 }
 397
 398 #endif  /* ifdef HAVE_LONG_LONG */
 399
 400 /* Test tuple argument processing */
 401 static PyObject *
 402 getargs_tuple(PyObject *self, PyObject *args)
 403 {
 404         int a, b, c;
 405         if (!PyArg_ParseTuple(args, "i(ii)", &a, &b, &c))
 406                 return NULL;
 407         return Py_BuildValue("iii", a, b, c);
 408 }
 409
 410 /* test PyArg_ParseTupleAndKeywords */
 411 static PyObject *getargs_keywords(PyObject *self, PyObject *args, PyObject *kwargs)
 412 {
 413         static char *keywords[] = {"arg1","arg2","arg3","arg4","arg5", NULL};
 414         static char *fmt="(ii)i|(i(ii))(iii)i";
 415         int int_args[10]={-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
 416
 417         if (!PyArg_ParseTupleAndKeywords(args, kwargs, fmt, keywords,
 418                 &int_args[0], &int_args[1], &int_args[2], &int_args[3], &int_args[4],
 419                 &int_args[5], &int_args[6], &int_args[7], &int_args[8], &int_args[9]))
 420                 return NULL;
 421         return Py_BuildValue("iiiiiiiiii",
 422                 int_args[0], int_args[1], int_args[2], int_args[3], int_args[4],
 423                 int_args[5], int_args[6], int_args[7], int_args[8], int_args[9]);
 424 }
 425
 426 /* Functions to call PyArg_ParseTuple with integer format codes,
 427    and return the result.
 428 */
 429 static PyObject *
 430 getargs_b(PyObject *self, PyObject *args)
 431 {
 432         unsigned char value;
 433         if (!PyArg_ParseTuple(args, "b", &value))
 434                 return NULL;
 435         return PyLong_FromUnsignedLong((unsigned long)value);
 436 }
 437
 438 static PyObject *
 439 getargs_B(PyObject *self, PyObject *args)
 440 {
 441         unsigned char value;
 442         if (!PyArg_ParseTuple(args, "B", &value))
 443                 return NULL;
 444         return PyLong_FromUnsignedLong((unsigned long)value);
 445 }
 446
 447 static PyObject *
 448 getargs_H(PyObject *self, PyObject *args)
 449 {
 450         unsigned short value;
 451         if (!PyArg_ParseTuple(args, "H", &value))
 452                 return NULL;
 453         return PyLong_FromUnsignedLong((unsigned long)value);
 454 }
 455
 456 static PyObject *
 457 getargs_I(PyObject *self, PyObject *args)
 458 {
 459         unsigned int value;
 460         if (!PyArg_ParseTuple(args, "I", &value))
 461                 return NULL;
 462         return PyLong_FromUnsignedLong((unsigned long)value);
 463 }
 464
 465 static PyObject *
 466 getargs_k(PyObject *self, PyObject *args)
 467 {
 468         unsigned long value;
 469         if (!PyArg_ParseTuple(args, "k", &value))
 470                 return NULL;
 471         return PyLong_FromUnsignedLong(value);
 472 }
 473
 474 static PyObject *
 475 getargs_i(PyObject *self, PyObject *args)
 476 {
 477         int value;
 478         if (!PyArg_ParseTuple(args, "i", &value))
 479                 return NULL;
 480         return PyLong_FromLong((long)value);
 481 }
 482
 483 static PyObject *
 484 getargs_l(PyObject *self, PyObject *args)
 485 {
 486         long value;
 487         if (!PyArg_ParseTuple(args, "l", &value))
 488                 return NULL;
 489         return PyLong_FromLong(value);
 490 }
 491
 492 static PyObject *
 493 getargs_n(PyObject *self, PyObject *args)
 494 {
 495         Py_ssize_t value;
 496         if (!PyArg_ParseTuple(args, "n", &value))
 497                 return NULL;
 498         return PyLong_FromSsize_t(value);
 499 }
 500
 501 #ifdef HAVE_LONG_LONG
 502 static PyObject *
 503 getargs_L(PyObject *self, PyObject *args)
 504 {
 505         PY_LONG_LONG value;
 506         if (!PyArg_ParseTuple(args, "L", &value))
 507                 return NULL;
 508         return PyLong_FromLongLong(value);
 509 }
 510
 511 static PyObject *
 512 getargs_K(PyObject *self, PyObject *args)
 513 {
 514         unsigned PY_LONG_LONG value;
 515         if (!PyArg_ParseTuple(args, "K", &value))
 516                 return NULL;
 517         return PyLong_FromUnsignedLongLong(value);
 518 }
 519 #endif
 520
 521 /* This function not only tests the 'k' getargs code, but also the
 522    PyLong_AsUnsignedLongMask() and PyLong_AsUnsignedLongMask() functions. */
 523 static PyObject *
 524 test_k_code(PyObject *self)
 525 {
 526         PyObject *tuple, *num;
 527         unsigned long value;
 528
 529         tuple = PyTuple_New(1);
 530         if (tuple == NULL)
 531                 return NULL;
 532
 533         /* a number larger than ULONG_MAX even on 64-bit platforms */
 534         num = PyLong_FromString("FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
 535         if (num == NULL)
 536                 return NULL;
 537
 538         value = PyLong_AsUnsignedLongMask(num);
 539         if (value != ULONG_MAX)
 540                 return raiseTestError("test_k_code",
 541             "PyLong_AsUnsignedLongMask() returned wrong value for long 0xFFF...FFF");
 542
 543         PyTuple_SET_ITEM(tuple, 0, num);
 544
 545         value = 0;
 546         if (PyArg_ParseTuple(tuple, "k:test_k_code", &value) < 0)
 547                 return NULL;
 548         if (value != ULONG_MAX)
 549                 return raiseTestError("test_k_code",
 550                         "k code returned wrong value for long 0xFFF...FFF");
 551
 552         Py_DECREF(num);
 553         num = PyLong_FromString("-FFFFFFFF000000000000000042", NULL, 16);
 554         if (num == NULL)
 555                 return NULL;
 556
 557         value = PyLong_AsUnsignedLongMask(num);
 558         if (value != (unsigned long)-0x42)
 559                 return raiseTestError("test_k_code",
 560             "PyLong_AsUnsignedLongMask() returned wrong value for long 0xFFF...FFF");
 561
 562         PyTuple_SET_ITEM(tuple, 0, num);
 563
 564         value = 0;
 565         if (PyArg_ParseTuple(tuple, "k:test_k_code", &value) < 0)
 566                 return NULL;
 567         if (value != (unsigned long)-0x42)
 568                 return raiseTestError("test_k_code",
 569                         "k code returned wrong value for long -0xFFF..000042");
 570
 571         Py_DECREF(tuple);
 572         Py_INCREF(Py_None);
 573         return Py_None;
 574 }
 575
 576
 577 /* Test the s and z codes for PyArg_ParseTuple.
 578 */
 579 static PyObject *
 580 test_s_code(PyObject *self)
 581 {
 582     /* Unicode strings should be accepted */
 583     PyObject *tuple, *obj;
 584     char *value;
 585
 586     tuple = PyTuple_New(1);
 587     if (tuple == NULL)
 588         return NULL;
 589
 590     obj = PyUnicode_Decode("t\xeate", strlen("t\xeate"),
 591                            "latin-1", NULL);
 592     if (obj == NULL)
 593         return NULL;
 594
 595     PyTuple_SET_ITEM(tuple, 0, obj);
 596
 597     /* These two blocks used to raise a TypeError:
 598      * "argument must be string without null bytes, not str"
 599      */
 600     if (PyArg_ParseTuple(tuple, "s:test_s_code1", &value) < 0)
 601         return NULL;
 602
 603     if (PyArg_ParseTuple(tuple, "z:test_s_code2", &value) < 0)
 604         return NULL;
 605
 606     Py_DECREF(tuple);
 607     Py_RETURN_NONE;
 608 }
 609
 610 static volatile int x;
 611
 612 /* Test the u and u# codes for PyArg_ParseTuple. May leak memory in case
 613    of an error.
 614 */
 615 static PyObject *
 616 test_u_code(PyObject *self)
 617 {
 618         PyObject *tuple, *obj;
 619         Py_UNICODE *value;
 620         Py_ssize_t len;
 621         int x;
 622
 623         /* issue4122: Undefined reference to _Py_ascii_whitespace on Windows */
 624         /* Just use the macro and check that it compiles */
 625         x = Py_UNICODE_ISSPACE(25);
 626
 627         tuple = PyTuple_New(1);
 628         if (tuple == NULL)
 629                 return NULL;
 630
 631         obj = PyUnicode_Decode("test", strlen("test"),
 632                                "ascii", NULL);
 633         if (obj == NULL)
 634                 return NULL;
 635
 636         PyTuple_SET_ITEM(tuple, 0, obj);
 637
 638         value = 0;
 639         if (PyArg_ParseTuple(tuple, "u:test_u_code", &value) < 0)
 640                 return NULL;
 641         if (value != PyUnicode_AS_UNICODE(obj))
 642                 return raiseTestError("test_u_code",
 643                         "u code returned wrong value for u'test'");
 644         value = 0;
 645         if (PyArg_ParseTuple(tuple, "u#:test_u_code", &value, &len) < 0)
 646                 return NULL;
 647         if (value != PyUnicode_AS_UNICODE(obj) ||
 648             len != PyUnicode_GET_SIZE(obj))
 649                 return raiseTestError("test_u_code",
 650                         "u# code returned wrong values for u'test'");
 651
 652         Py_DECREF(tuple);
 653         Py_INCREF(Py_None);
 654         return Py_None;
 655 }
 656
 657 /* Test Z and Z# codes for PyArg_ParseTuple */
 658 static PyObject *
 659 test_Z_code(PyObject *self)
 660 {
 661         PyObject *tuple, *obj;
 662         Py_UNICODE *value1, *value2;
 663         Py_ssize_t len1, len2;
 664
 665         tuple = PyTuple_New(2);
 666         if (tuple == NULL)
 667                 return NULL;
 668
 669         obj = PyUnicode_FromString("test");
 670         PyTuple_SET_ITEM(tuple, 0, obj);
 671         Py_INCREF(Py_None);
 672         PyTuple_SET_ITEM(tuple, 1, Py_None);
 673
 674         /* swap values on purpose */
 675         value1 = NULL;
 676         value2 = PyUnicode_AS_UNICODE(obj);
 677
 678         /* Test Z for both values */
 679         if (PyArg_ParseTuple(tuple, "ZZ:test_Z_code", &value1, &value2) < 0)
 680                 return NULL;
 681         if (value1 != PyUnicode_AS_UNICODE(obj))
 682                 return raiseTestError("test_Z_code",
 683                         "Z code returned wrong value for 'test'");
 684         if (value2 != NULL)
 685                 return raiseTestError("test_Z_code",
 686                         "Z code returned wrong value for None");
 687
 688         value1 = NULL;
 689         value2 = PyUnicode_AS_UNICODE(obj);
 690         len1 = -1;
 691         len2 = -1;
 692
 693         /* Test Z# for both values */
 694         if (PyArg_ParseTuple(tuple, "Z#Z#:test_Z_code", &value1, &len1,
 695                              &value2, &len2) < 0)
 696                 return NULL;
 697         if (value1 != PyUnicode_AS_UNICODE(obj) ||
 698             len1 != PyUnicode_GET_SIZE(obj))
 699                 return raiseTestError("test_Z_code",
 700                         "Z# code returned wrong values for 'test'");
 701         if (value2 != NULL ||
 702             len2 != 0)
 703                 return raiseTestError("test_Z_code",
 704                         "Z# code returned wrong values for None'");
 705
 706         Py_DECREF(tuple);
 707         Py_RETURN_NONE;
 708 }
 709
 710 static PyObject *
 711 test_widechar(PyObject *self)
 712 {
 713 #if defined(SIZEOF_WCHAR_T) && (SIZEOF_WCHAR_T == 4)
 714         const wchar_t wtext[2] = {(wchar_t)0x10ABCDu};
 715         size_t wtextlen = 1;
 716 #else
 717         const wchar_t wtext[3] = {(wchar_t)0xDBEAu, (wchar_t)0xDFCDu};
 718         size_t wtextlen = 2;
 719 #endif
 720         PyObject *wide, *utf8;
 721
 722         wide = PyUnicode_FromWideChar(wtext, wtextlen);
 723         if (wide == NULL)
 724                 return NULL;
 725
 726         utf8 = PyUnicode_FromString("\xf4\x8a\xaf\x8d");
 727         if (utf8 == NULL) {
 728                 Py_DECREF(wide);
 729                 return NULL;
 730         }
 731
 732         if (PyUnicode_GET_SIZE(wide) != PyUnicode_GET_SIZE(utf8)) {
 733                 Py_DECREF(wide);
 734                 Py_DECREF(utf8);
 735                 return raiseTestError("test_widechar",
 736                                       "wide string and utf8 string "
 737                                       "have different length");
 738         }
 739         if (PyUnicode_Compare(wide, utf8)) {
 740                 Py_DECREF(wide);
 741                 Py_DECREF(utf8);
 742                 if (PyErr_Occurred())
 743                         return NULL;
 744                 return raiseTestError("test_widechar",
 745                                       "wide string and utf8 string "
 746                                       "are different");
 747         }
 748
 749         Py_DECREF(wide);
 750         Py_DECREF(utf8);
 751         Py_RETURN_NONE;
 752 }
 753
 754 static PyObject *
 755 test_empty_argparse(PyObject *self)
 756 {
 757         /* Test that formats can begin with '|'. See issue #4720. */
 758         PyObject *tuple, *dict = NULL;
 759         static char *kwlist[] = {NULL};
 760         int result;
 761         tuple = PyTuple_New(0);
 762         if (!tuple)
 763                 return NULL;
 764         if ((result = PyArg_ParseTuple(tuple, "|:test_empty_argparse")) < 0)
 765                 goto done;
 766         dict = PyDict_New();
 767         if (!dict)
 768                 goto done;
 769         result = PyArg_ParseTupleAndKeywords(tuple, dict, "|:test_empty_argparse", kwlist);
 770   done:
 771         Py_DECREF(tuple);
 772         Py_XDECREF(dict);
 773         if (result < 0)
 774                 return NULL;
 775         else {
 776                 Py_RETURN_NONE;
 777         }
 778 }
 779
 780 static PyObject *
 781 codec_incrementalencoder(PyObject *self, PyObject *args)
 782 {
 783         const char *encoding, *errors = NULL;
 784         if (!PyArg_ParseTuple(args, "s|s:test_incrementalencoder",
 785                               &encoding, &errors))
 786                 return NULL;
 787         return PyCodec_IncrementalEncoder(encoding, errors);
 788 }
 789
 790 static PyObject *
 791 codec_incrementaldecoder(PyObject *self, PyObject *args)
 792 {
 793         const char *encoding, *errors = NULL;
 794         if (!PyArg_ParseTuple(args, "s|s:test_incrementaldecoder",
 795                               &encoding, &errors))
 796                 return NULL;
 797         return PyCodec_IncrementalDecoder(encoding, errors);
 798 }
 799
 800
 801 /* Simple test of _PyLong_NumBits and _PyLong_Sign. */
 802 static PyObject *
 803 test_long_numbits(PyObject *self)
 804 {
 805         struct triple {
 806                 long input;
 807                 size_t nbits;
 808                 int sign;
 809         } testcases[] = {{0, 0, 0},
 810                          {1L, 1, 1},
 811                          {-1L, 1, -1},
 812                          {2L, 2, 1},
 813                          {-2L, 2, -1},
 814                          {3L, 2, 1},
 815                          {-3L, 2, -1},
 816                          {4L, 3, 1},
 817                          {-4L, 3, -1},
 818                          {0x7fffL, 15, 1},      /* one Python long digit */
 819                          {-0x7fffL, 15, -1},
 820                          {0xffffL, 16, 1},
 821                          {-0xffffL, 16, -1},
 822                          {0xfffffffL, 28, 1},
 823                          {-0xfffffffL, 28, -1}};
 824         int i;
 825
 826         for (i = 0; i < sizeof(testcases) / sizeof(struct triple); ++i) {
 827                 PyObject *plong = PyLong_FromLong(testcases[i].input);
 828                 size_t nbits = _PyLong_NumBits(plong);
 829                 int sign = _PyLong_Sign(plong);
 830
 831                 Py_DECREF(plong);
 832                 if (nbits != testcases[i].nbits)
 833                         return raiseTestError("test_long_numbits",
 834                                         "wrong result for _PyLong_NumBits");
 835                 if (sign != testcases[i].sign)
 836                         return raiseTestError("test_long_numbits",
 837                                         "wrong result for _PyLong_Sign");
 838         }
 839         Py_INCREF(Py_None);
 840         return Py_None;
 841 }
 842
 843 /* Example passing NULLs to PyObject_Str(NULL). */
 844
 845 static PyObject *
 846 test_null_strings(PyObject *self)
 847 {
 848         PyObject *o1 = PyObject_Str(NULL), *o2 = PyObject_Str(NULL);
 849         PyObject *tuple = PyTuple_Pack(2, o1, o2);
 850         Py_XDECREF(o1);
 851         Py_XDECREF(o2);
 852         return tuple;
 853 }
 854
 855 static PyObject *
 856 raise_exception(PyObject *self, PyObject *args)
 857 {
 858         PyObject *exc;
 859         PyObject *exc_args, *v;
 860         int num_args, i;
 861
 862         if (!PyArg_ParseTuple(args, "Oi:raise_exception",
 863                               &exc, &num_args))
 864                 return NULL;
 865
 866         exc_args = PyTuple_New(num_args);
 867         if (exc_args == NULL)
 868                 return NULL;
 869         for (i = 0; i < num_args; ++i) {
 870                 v = PyLong_FromLong(i);
 871                 if (v == NULL) {
 872                         Py_DECREF(exc_args);
 873                         return NULL;
 874                 }
 875                 PyTuple_SET_ITEM(exc_args, i, v);
 876         }
 877         PyErr_SetObject(exc, exc_args);
 878         Py_DECREF(exc_args);
 879         return NULL;
 880 }
 881
 882 #ifdef WITH_THREAD
 883
 884 /* test_thread_state spawns a thread of its own, and that thread releases
 885  * `thread_done` when it's finished.  The driver code has to know when the
 886  * thread finishes, because the thread uses a PyObject (the callable) that
 887  * may go away when the driver finishes.  The former lack of this explicit
 888  * synchronization caused rare segfaults, so rare that they were seen only
 889  * on a Mac buildbot (although they were possible on any box).
 890  */
 891 static PyThread_type_lock thread_done = NULL;
 892
 893 static int
 894 _make_call(void *callable)
 895 {
 896         PyObject *rc;
 897         int success;
 898         PyGILState_STATE s = PyGILState_Ensure();
 899         rc = PyObject_CallFunction((PyObject *)callable, "");
 900         success = (rc != NULL);
 901         Py_XDECREF(rc);
 902         PyGILState_Release(s);
 903         return success;
 904 }
 905
 906 /* Same thing, but releases `thread_done` when it returns.  This variant
 907  * should be called only from threads spawned by test_thread_state().
 908  */
 909 static void
 910 _make_call_from_thread(void *callable)
 911 {
 912         _make_call(callable);
 913         PyThread_release_lock(thread_done);
 914 }
 915
 916 static PyObject *
 917 test_thread_state(PyObject *self, PyObject *args)
 918 {
 919         PyObject *fn;
 920         int success = 1;
 921
 922         if (!PyArg_ParseTuple(args, "O:test_thread_state", &fn))
 923                 return NULL;
 924
 925         if (!PyCallable_Check(fn)) {
 926                 PyErr_Format(PyExc_TypeError, "'%s' object is not callable",
 927                         fn->ob_type->tp_name);
 928                 return NULL;
 929         }
 930
 931         /* Ensure Python is set up for threading */
 932         PyEval_InitThreads();
 933         thread_done = PyThread_allocate_lock();
 934         if (thread_done == NULL)
 935                 return PyErr_NoMemory();
 936         PyThread_acquire_lock(thread_done, 1);
 937
 938         /* Start a new thread with our callback. */
 939         PyThread_start_new_thread(_make_call_from_thread, fn);
 940         /* Make the callback with the thread lock held by this thread */
 941         success &= _make_call(fn);
 942         /* Do it all again, but this time with the thread-lock released */
 943         Py_BEGIN_ALLOW_THREADS
 944         success &= _make_call(fn);
 945         PyThread_acquire_lock(thread_done, 1);  /* wait for thread to finish */
 946         Py_END_ALLOW_THREADS
 947
 948         /* And once more with and without a thread
 949            XXX - should use a lock and work out exactly what we are trying
 950            to test <wink>
 951         */
 952         Py_BEGIN_ALLOW_THREADS
 953         PyThread_start_new_thread(_make_call_from_thread, fn);
 954         success &= _make_call(fn);
 955         PyThread_acquire_lock(thread_done, 1);  /* wait for thread to finish */
 956         Py_END_ALLOW_THREADS
 957
 958         /* Release lock we acquired above.  This is required on HP-UX. */
 959         PyThread_release_lock(thread_done);
 960
 961         PyThread_free_lock(thread_done);
 962         if (!success)
 963                 return NULL;
 964         Py_RETURN_NONE;
 965 }
 966
 967 /* test Py_AddPendingCalls using threads */
 968 static int _pending_callback(void *arg)
 969 {
 970         /* we assume the argument is callable object to which we own a reference */
 971         PyObject *callable = (PyObject *)arg;
 972         PyObject *r = PyObject_CallObject(callable, NULL);
 973         Py_DECREF(callable);
 974         Py_XDECREF(r);
 975         return r != NULL ? 0 : -1;
 976 }
 977
 978 /* The following requests n callbacks to _pending_callback.  It can be
 979  * run from any python thread.
 980  */
 981 PyObject *pending_threadfunc(PyObject *self, PyObject *arg)
 982 {
 983         PyObject *callable;
 984         int r;
 985         if (PyArg_ParseTuple(arg, "O", &callable) == 0)
 986                 return NULL;
 987
 988         /* create the reference for the callbackwhile we hold the lock */
 989         Py_INCREF(callable);
 990
 991         Py_BEGIN_ALLOW_THREADS
 992         r = Py_AddPendingCall(&_pending_callback, callable);
 993         Py_END_ALLOW_THREADS
 994
 995         if (r<0) {
 996                 Py_DECREF(callable); /* unsuccessful add, destroy the extra reference */
 997                 Py_INCREF(Py_False);
 998                 return Py_False;
 999         }
1000         Py_INCREF(Py_True);
1001         return Py_True;
1002 }
1003 #endif
1004
1005 /* Some tests of PyUnicode_FromFormat().  This needs more tests. */
1006 static PyObject *
1007 test_string_from_format(PyObject *self, PyObject *args)
1008 {
1009         PyObject *result;
1010         char *msg;
1011
1012 #define CHECK_1_FORMAT(FORMAT, TYPE)                    \
1013         result = PyUnicode_FromFormat(FORMAT, (TYPE)1); \
1014         if (result == NULL)                             \
1015                 return NULL;                            \
1016         if (strcmp(_PyUnicode_AsString(result), "1")) { \
1017                 msg = FORMAT " failed at 1";            \
1018                 goto Fail;                              \
1019         }                                               \
1020         Py_DECREF(result)
1021
1022         CHECK_1_FORMAT("%d", int);
1023         CHECK_1_FORMAT("%ld", long);
1024         /* The z width modifier was added in Python 2.5. */
1025         CHECK_1_FORMAT("%zd", Py_ssize_t);
1026
1027         /* The u type code was added in Python 2.5. */
1028         CHECK_1_FORMAT("%u", unsigned int);
1029         CHECK_1_FORMAT("%lu", unsigned long);
1030         CHECK_1_FORMAT("%zu", size_t);
1031
1032         Py_RETURN_NONE;
1033
1034  Fail:
1035         Py_XDECREF(result);
1036         return raiseTestError("test_string_from_format", msg);
1037
1038 #undef CHECK_1_FORMAT
1039 }
1040
1041 /* This is here to provide a docstring for test_descr. */
1042 static PyObject *
1043 test_with_docstring(PyObject *self)
1044 {
1045         Py_RETURN_NONE;
1046 }
1047
1048 #ifdef HAVE_GETTIMEOFDAY
1049 /* Profiling of integer performance */
1050 static void print_delta(int test, struct timeval *s, struct timeval *e)
1051 {
1052         e->tv_sec -= s->tv_sec;
1053         e->tv_usec -= s->tv_usec;
1054         if (e->tv_usec < 0) {
1055                 e->tv_sec -=1;
1056                 e->tv_usec += 1000000;
1057         }
1058         printf("Test %d: %d.%06ds\n", test, (int)e->tv_sec, (int)e->tv_usec);
1059 }
1060
1061 static PyObject *
1062 profile_int(PyObject *self, PyObject* args)
1063 {
1064         int i, k;
1065         struct timeval start, stop;
1066         PyObject *single, **multiple, *op1, *result;
1067
1068         /* Test 1: Allocate and immediately deallocate
1069            many small integers */
1070         gettimeofday(&start, NULL);
1071         for(k=0; k < 20000; k++)
1072                 for(i=0; i < 1000; i++) {
1073                         single = PyLong_FromLong(i);
1074                         Py_DECREF(single);
1075                 }
1076         gettimeofday(&stop, NULL);
1077         print_delta(1, &start, &stop);
1078
1079         /* Test 2: Allocate and immediately deallocate
1080            many large integers */
1081         gettimeofday(&start, NULL);
1082         for(k=0; k < 20000; k++)
1083                 for(i=0; i < 1000; i++) {
1084                         single = PyLong_FromLong(i+1000000);
1085                         Py_DECREF(single);
1086                 }
1087         gettimeofday(&stop, NULL);
1088         print_delta(2, &start, &stop);
1089
1090         /* Test 3: Allocate a few integers, then release
1091            them all simultaneously. */
1092         multiple = malloc(sizeof(PyObject*) * 1000);
1093         gettimeofday(&start, NULL);
1094         for(k=0; k < 20000; k++) {
1095                 for(i=0; i < 1000; i++) {
1096                         multiple[i] = PyLong_FromLong(i+1000000);
1097                 }
1098                 for(i=0; i < 1000; i++) {
1099                         Py_DECREF(multiple[i]);
1100                 }
1101         }
1102         gettimeofday(&stop, NULL);
1103         print_delta(3, &start, &stop);
1104
1105         /* Test 4: Allocate many integers, then release
1106            them all simultaneously. */
1107         multiple = malloc(sizeof(PyObject*) * 1000000);
1108         gettimeofday(&start, NULL);
1109         for(k=0; k < 20; k++) {
1110                 for(i=0; i < 1000000; i++) {
1111                         multiple[i] = PyLong_FromLong(i+1000000);
1112                 }
1113                 for(i=0; i < 1000000; i++) {
1114                         Py_DECREF(multiple[i]);
1115                 }
1116         }
1117         gettimeofday(&stop, NULL);
1118         print_delta(4, &start, &stop);
1119
1120         /* Test 5: Allocate many integers < 32000 */
1121         multiple = malloc(sizeof(PyObject*) * 1000000);
1122         gettimeofday(&start, NULL);
1123         for(k=0; k < 10; k++) {
1124                 for(i=0; i < 1000000; i++) {
1125                         multiple[i] = PyLong_FromLong(i+1000);
1126                 }
1127                 for(i=0; i < 1000000; i++) {
1128                         Py_DECREF(multiple[i]);
1129                 }
1130         }
1131         gettimeofday(&stop, NULL);
1132         print_delta(5, &start, &stop);
1133
1134         /* Test 6: Perform small int addition */
1135         op1 = PyLong_FromLong(1);
1136         gettimeofday(&start, NULL);
1137         for(i=0; i < 10000000; i++) {
1138                 result = PyNumber_Add(op1, op1);
1139                 Py_DECREF(result);
1140         }
1141         gettimeofday(&stop, NULL);
1142         Py_DECREF(op1);
1143         print_delta(6, &start, &stop);
1144
1145         /* Test 7: Perform medium int addition */
1146         op1 = PyLong_FromLong(1000);
1147         gettimeofday(&start, NULL);
1148         for(i=0; i < 10000000; i++) {
1149                 result = PyNumber_Add(op1, op1);
1150                 Py_DECREF(result);
1151         }
1152         gettimeofday(&stop, NULL);
1153         Py_DECREF(op1);
1154         print_delta(7, &start, &stop);
1155
1156         Py_INCREF(Py_None);
1157         return Py_None;
1158 }
1159 #endif
1160
1161 /* To test the format of tracebacks as printed out. */
1162 static PyObject *
1163 traceback_print(PyObject *self, PyObject *args)
1164 {
1165         PyObject *file;
1166         PyObject *traceback;
1167         int result;
1168
1169         if (!PyArg_ParseTuple(args, "OO:traceback_print",
1170                                 &traceback, &file))
1171                 return NULL;
1172
1173         result = PyTraceBack_Print(traceback, file);
1174         if (result < 0)
1175                 return NULL;
1176         Py_RETURN_NONE;
1177 }
1178
1179 /* To test the format of exceptions as printed out. */
1180 static PyObject *
1181 exception_print(PyObject *self, PyObject *args)
1182 {
1183         PyObject *value;
1184         PyObject *tb;
1185
1186         if (!PyArg_ParseTuple(args, "O:exception_print",
1187                                 &value))
1188                 return NULL;
1189         if (!PyExceptionInstance_Check(value)) {
1190                 PyErr_Format(PyExc_TypeError, "an exception instance is required");
1191                 return NULL;
1192         }
1193
1194         tb = PyException_GetTraceback(value);
1195         PyErr_Display((PyObject *) Py_TYPE(value), value, tb);
1196         Py_XDECREF(tb);
1197
1198         Py_RETURN_NONE;
1199 }
1200
1201
1202
1203
1204 /* reliably raise a MemoryError */
1205 static PyObject *
1206 raise_memoryerror(PyObject *self)
1207 {
1208         PyErr_NoMemory();
1209         return NULL;
1210 }
1211
1212
1213 static PyMethodDef TestMethods[] = {
1214         {"raise_exception",     raise_exception,                 METH_VARARGS},
1215         {"raise_memoryerror",   (PyCFunction)raise_memoryerror,  METH_NOARGS},
1216         {"test_config",         (PyCFunction)test_config,        METH_NOARGS},
1217         {"test_list_api",       (PyCFunction)test_list_api,      METH_NOARGS},
1218         {"test_dict_iteration", (PyCFunction)test_dict_iteration,METH_NOARGS},
1219         {"test_lazy_hash_inheritance",  (PyCFunction)test_lazy_hash_inheritance,METH_NOARGS},
1220         {"test_long_api",       (PyCFunction)test_long_api,      METH_NOARGS},
1221         {"test_long_numbits",   (PyCFunction)test_long_numbits,  METH_NOARGS},
1222         {"test_k_code",         (PyCFunction)test_k_code,        METH_NOARGS},
1223         {"test_empty_argparse", (PyCFunction)test_empty_argparse,METH_NOARGS},
1224         {"test_null_strings",   (PyCFunction)test_null_strings,  METH_NOARGS},
1225         {"test_string_from_format", (PyCFunction)test_string_from_format, METH_NOARGS},
1226         {"test_with_docstring", (PyCFunction)test_with_docstring, METH_NOARGS,
1227          PyDoc_STR("This is a pretty normal docstring.")},
1228
1229         {"getargs_tuple",       getargs_tuple,                   METH_VARARGS},
1230         {"getargs_keywords", (PyCFunction)getargs_keywords,
1231           METH_VARARGS|METH_KEYWORDS},
1232         {"getargs_b",           getargs_b,                       METH_VARARGS},
1233         {"getargs_B",           getargs_B,                       METH_VARARGS},
1234         {"getargs_H",           getargs_H,                       METH_VARARGS},
1235         {"getargs_I",           getargs_I,                       METH_VARARGS},
1236         {"getargs_k",           getargs_k,                       METH_VARARGS},
1237         {"getargs_i",           getargs_i,                       METH_VARARGS},
1238         {"getargs_l",           getargs_l,                       METH_VARARGS},
1239         {"getargs_n",           getargs_n,                       METH_VARARGS},
1240 #ifdef HAVE_LONG_LONG
1241         {"getargs_L",           getargs_L,                       METH_VARARGS},
1242         {"getargs_K",           getargs_K,                       METH_VARARGS},
1243         {"test_longlong_api",   test_longlong_api,               METH_NOARGS},
1244         {"test_L_code",         (PyCFunction)test_L_code,        METH_NOARGS},
1245         {"codec_incrementalencoder",
1246          (PyCFunction)codec_incrementalencoder,  METH_VARARGS},
1247         {"codec_incrementaldecoder",
1248          (PyCFunction)codec_incrementaldecoder,  METH_VARARGS},
1249 #endif
1250         {"test_s_code",         (PyCFunction)test_s_code,        METH_NOARGS},
1251         {"test_u_code",         (PyCFunction)test_u_code,        METH_NOARGS},
1252         {"test_Z_code",         (PyCFunction)test_Z_code,        METH_NOARGS},
1253         {"test_widechar",       (PyCFunction)test_widechar,      METH_NOARGS},
1254 #ifdef WITH_THREAD
1255         {"_test_thread_state",  test_thread_state,               METH_VARARGS},
1256         {"_pending_threadfunc", pending_threadfunc,              METH_VARARGS},
1257 #endif
1258 #ifdef HAVE_GETTIMEOFDAY
1259         {"profile_int",         profile_int,                    METH_NOARGS},
1260 #endif
1261         {"traceback_print", traceback_print,             METH_VARARGS},
1262         {"exception_print", exception_print,             METH_VARARGS},
1263         {NULL, NULL} /* sentinel */
1264 };
1265
1266 #define AddSym(d, n, f, v) {PyObject *o = f(v); PyDict_SetItemString(d, n, o); Py_DECREF(o);}
1267
1268 typedef struct {
1269         char bool_member;
1270         char byte_member;
1271         unsigned char ubyte_member;
1272         short short_member;
1273         unsigned short ushort_member;
1274         int int_member;
1275         unsigned int uint_member;
1276         long long_member;
1277         unsigned long ulong_member;
1278         float float_member;
1279         double double_member;
1280 #ifdef HAVE_LONG_LONG
1281         PY_LONG_LONG longlong_member;
1282         unsigned PY_LONG_LONG ulonglong_member;
1283 #endif
1284 } all_structmembers;
1285
1286 typedef struct {
1287     PyObject_HEAD
1288         all_structmembers structmembers;
1289 } test_structmembers;
1290
1291 static struct PyMemberDef test_members[] = {
1292         {"T_BOOL", T_BOOL, offsetof(test_structmembers, structmembers.bool_member), 0, NULL},
1293         {"T_BYTE", T_BYTE, offsetof(test_structmembers, structmembers.byte_member), 0, NULL},
1294         {"T_UBYTE", T_UBYTE, offsetof(test_structmembers, structmembers.ubyte_member), 0, NULL},
1295         {"T_SHORT", T_SHORT, offsetof(test_structmembers, structmembers.short_member), 0, NULL},
1296         {"T_USHORT", T_USHORT, offsetof(test_structmembers, structmembers.ushort_member), 0, NULL},
1297         {"T_INT", T_INT, offsetof(test_structmembers, structmembers.int_member), 0, NULL},
1298         {"T_UINT", T_UINT, offsetof(test_structmembers, structmembers.uint_member), 0, NULL},
1299         {"T_LONG", T_LONG, offsetof(test_structmembers, structmembers.long_member), 0, NULL},
1300         {"T_ULONG", T_ULONG, offsetof(test_structmembers, structmembers.ulong_member), 0, NULL},
1301         {"T_FLOAT", T_FLOAT, offsetof(test_structmembers, structmembers.float_member), 0, NULL},
1302         {"T_DOUBLE", T_DOUBLE, offsetof(test_structmembers, structmembers.double_member), 0, NULL},
1303 #ifdef HAVE_LONG_LONG
1304         {"T_LONGLONG", T_LONGLONG, offsetof(test_structmembers, structmembers.longlong_member), 0, NULL},
1305         {"T_ULONGLONG", T_ULONGLONG, offsetof(test_structmembers, structmembers.ulonglong_member), 0, NULL},
1306 #endif
1307         {NULL}
1308 };
1309
1310
1311 static PyObject *
1312 test_structmembers_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1313 {
1314         static char *keywords[] = {
1315                 "T_BOOL", "T_BYTE", "T_UBYTE", "T_SHORT", "T_USHORT",
1316                 "T_INT", "T_UINT", "T_LONG", "T_ULONG",
1317                 "T_FLOAT", "T_DOUBLE",
1318 #ifdef HAVE_LONG_LONG
1319                 "T_LONGLONG", "T_ULONGLONG",
1320 #endif
1321                 NULL};
1322         static char *fmt = "|bbBhHiIlkfd"
1323 #ifdef HAVE_LONG_LONG
1324                 "LK"
1325 #endif
1326                 ;
1327         test_structmembers *ob;
1328         ob = PyObject_New(test_structmembers, type);
1329         if (ob == NULL)
1330                 return NULL;
1331         memset(&ob->structmembers, 0, sizeof(all_structmembers));
1332         if (!PyArg_ParseTupleAndKeywords(args, kwargs, fmt, keywords,
1333                                          &ob->structmembers.bool_member,
1334                                          &ob->structmembers.byte_member,
1335                                          &ob->structmembers.ubyte_member,
1336                                          &ob->structmembers.short_member,
1337                                          &ob->structmembers.ushort_member,
1338                                          &ob->structmembers.int_member,
1339                                          &ob->structmembers.uint_member,
1340                                          &ob->structmembers.long_member,
1341                                          &ob->structmembers.ulong_member,
1342                                          &ob->structmembers.float_member,
1343                                          &ob->structmembers.double_member
1344 #ifdef HAVE_LONG_LONG
1345                                          , &ob->structmembers.longlong_member,
1346                                          &ob->structmembers.ulonglong_member
1347 #endif
1348                 )) {
1349                 Py_DECREF(ob);
1350                 return NULL;
1351         }
1352         return (PyObject *)ob;
1353 }
1354
1355 static void
1356 test_structmembers_free(PyObject *ob)
1357 {
1358         PyObject_FREE(ob);
1359 }
1360
1361 static PyTypeObject test_structmembersType = {
1362     PyVarObject_HEAD_INIT(NULL, 0)
1363         "test_structmembersType",
1364         sizeof(test_structmembers),     /* tp_basicsize */
1365         0,                              /* tp_itemsize */
1366         test_structmembers_free,        /* destructor tp_dealloc */
1367         0,                              /* tp_print */
1368         0,                              /* tp_getattr */
1369         0,                              /* tp_setattr */
1370         0,                              /* tp_reserved */
1371         0,                              /* tp_repr */
1372         0,                              /* tp_as_number */
1373         0,                              /* tp_as_sequence */
1374         0,                              /* tp_as_mapping */
1375         0,                              /* tp_hash */
1376         0,                              /* tp_call */
1377         0,                              /* tp_str */
1378         PyObject_GenericGetAttr,        /* tp_getattro */
1379         PyObject_GenericSetAttr,        /* tp_setattro */
1380         0,                              /* tp_as_buffer */
1381         0,                              /* tp_flags */
1382         "Type containing all structmember types",
1383         0,                              /* traverseproc tp_traverse */
1384         0,                              /* tp_clear */
1385         0,                              /* tp_richcompare */
1386         0,                              /* tp_weaklistoffset */
1387         0,                              /* tp_iter */
1388         0,                              /* tp_iternext */
1389         0,                              /* tp_methods */
1390         test_members,                   /* tp_members */
1391         0,
1392         0,
1393         0,
1394         0,
1395         0,
1396         0,
1397         0,
1398         0,
1399         test_structmembers_new,         /* tp_new */
1400 };
1401
1402
1403
1404 static struct PyModuleDef _testcapimodule = {
1405         PyModuleDef_HEAD_INIT,
1406         "_testcapi",
1407         NULL,
1408         -1,
1409         TestMethods,
1410         NULL,
1411         NULL,
1412         NULL,
1413         NULL
1414 };
1415
1416 PyMODINIT_FUNC
1417 PyInit__testcapi(void)
1418 {
1419         PyObject *m;
1420
1421         m = PyModule_Create(&_testcapimodule);
1422         if (m == NULL)
1423                 return NULL;
1424
1425         Py_TYPE(&_HashInheritanceTester_Type)=&PyType_Type;
1426
1427         Py_TYPE(&test_structmembersType)=&PyType_Type;
1428         Py_INCREF(&test_structmembersType);
1429         PyModule_AddObject(m, "test_structmembersType", (PyObject *)&test_structmembersType);
1430
1431         PyModule_AddObject(m, "CHAR_MAX", PyLong_FromLong(CHAR_MAX));
1432         PyModule_AddObject(m, "CHAR_MIN", PyLong_FromLong(CHAR_MIN));
1433         PyModule_AddObject(m, "UCHAR_MAX", PyLong_FromLong(UCHAR_MAX));
1434         PyModule_AddObject(m, "SHRT_MAX", PyLong_FromLong(SHRT_MAX));
1435         PyModule_AddObject(m, "SHRT_MIN", PyLong_FromLong(SHRT_MIN));
1436         PyModule_AddObject(m, "USHRT_MAX", PyLong_FromLong(USHRT_MAX));
1437         PyModule_AddObject(m, "INT_MAX",  PyLong_FromLong(INT_MAX));
1438         PyModule_AddObject(m, "INT_MIN",  PyLong_FromLong(INT_MIN));
1439         PyModule_AddObject(m, "UINT_MAX",  PyLong_FromUnsignedLong(UINT_MAX));
1440         PyModule_AddObject(m, "LONG_MAX", PyLong_FromLong(LONG_MAX));
1441         PyModule_AddObject(m, "LONG_MIN", PyLong_FromLong(LONG_MIN));
1442         PyModule_AddObject(m, "ULONG_MAX", PyLong_FromUnsignedLong(ULONG_MAX));
1443         PyModule_AddObject(m, "FLT_MAX", PyFloat_FromDouble(FLT_MAX));
1444         PyModule_AddObject(m, "FLT_MIN", PyFloat_FromDouble(FLT_MIN));
1445         PyModule_AddObject(m, "DBL_MAX", PyFloat_FromDouble(DBL_MAX));
1446         PyModule_AddObject(m, "DBL_MIN", PyFloat_FromDouble(DBL_MIN));
1447         PyModule_AddObject(m, "LLONG_MAX", PyLong_FromLongLong(PY_LLONG_MAX));
1448         PyModule_AddObject(m, "LLONG_MIN", PyLong_FromLongLong(PY_LLONG_MIN));
1449         PyModule_AddObject(m, "ULLONG_MAX", PyLong_FromUnsignedLongLong(PY_ULLONG_MAX));
1450         PyModule_AddObject(m, "PY_SSIZE_T_MAX", PyLong_FromSsize_t(PY_SSIZE_T_MAX));
1451         PyModule_AddObject(m, "PY_SSIZE_T_MIN", PyLong_FromSsize_t(PY_SSIZE_T_MIN));
1452         PyModule_AddObject(m, "SIZEOF_PYGC_HEAD", PyLong_FromSsize_t(sizeof(PyGC_Head)));
1453         Py_INCREF(&PyInstanceMethod_Type);
1454         PyModule_AddObject(m, "instancemethod", (PyObject *)&PyInstanceMethod_Type);
1455
1456         TestError = PyErr_NewException("_testcapi.error", NULL, NULL);
1457         Py_INCREF(TestError);
1458         PyModule_AddObject(m, "error", TestError);
1459         return m;
1460 }