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