Modules/testcapi_long.h

   1 /* Poor-man's template.  Macros used:
   2    TESTNAME     name of the test (like test_long_api_inner)
   3    TYPENAME     the signed type (like long)
   4    F_S_TO_PY    convert signed to pylong; TYPENAME -> PyObject*
   5    F_PY_TO_S    convert pylong to signed; PyObject* -> TYPENAME
   6    F_U_TO_PY    convert unsigned to pylong; unsigned TYPENAME -> PyObject*
   7    F_PY_TO_U    convert pylong to unsigned; PyObject* -> unsigned TYPENAME
   8 */
   9
  10 static PyObject *
  11 TESTNAME(PyObject *error(const char*))
  12 {
  13     const int NBITS = sizeof(TYPENAME) * 8;
  14     unsigned TYPENAME base;
  15     PyObject *pyresult;
  16     int i;
  17
  18     /* Note:  This test lets PyObjects leak if an error is raised.  Since
  19        an error should never be raised, leaks are impossible <wink>. */
  20
  21     /* Test native -> PyLong -> native roundtrip identity.
  22      * Generate all powers of 2, and test them and their negations,
  23      * plus the numbers +-1 off from them.
  24      */
  25     base = 1;
  26     for (i = 0;
  27          i < NBITS + 1;  /* on last, base overflows to 0 */
  28          ++i, base <<= 1)
  29     {
  30         int j;
  31         for (j = 0; j < 6; ++j) {
  32             TYPENAME in, out;
  33             unsigned TYPENAME uin, uout;
  34
  35             /* For 0, 1, 2 use base; for 3, 4, 5 use -base */
  36             uin = j < 3 ? base
  37                         : (unsigned TYPENAME)(-(TYPENAME)base);
  38
  39             /* For 0 & 3, subtract 1.
  40              * For 1 & 4, leave alone.
  41              * For 2 & 5, add 1.
  42              */
  43             uin += (unsigned TYPENAME)(TYPENAME)(j % 3 - 1);
  44
  45             pyresult = F_U_TO_PY(uin);
  46             if (pyresult == NULL)
  47                 return error(
  48                  "unsigned unexpected null result");
  49
  50             uout = F_PY_TO_U(pyresult);
  51             if (uout == (unsigned TYPENAME)-1 && PyErr_Occurred())
  52                 return error(
  53                     "unsigned unexpected -1 result");
  54             if (uout != uin)
  55                 return error(
  56                     "unsigned output != input");
  57             UNBIND(pyresult);
  58
  59             in = (TYPENAME)uin;
  60             pyresult = F_S_TO_PY(in);
  61             if (pyresult == NULL)
  62                 return error(
  63                     "signed unexpected null result");
  64
  65             out = F_PY_TO_S(pyresult);
  66             if (out == (TYPENAME)-1 && PyErr_Occurred())
  67                 return error(
  68                     "signed unexpected -1 result");
  69             if (out != in)
  70                 return error(
  71                     "signed output != input");
  72             UNBIND(pyresult);
  73         }
  74     }
  75
  76     /* Overflow tests.  The loop above ensured that all limit cases that
  77      * should not overflow don't overflow, so all we need to do here is
  78      * provoke one-over-the-limit cases (not exhaustive, but sharp).
  79      */
  80     {
  81         PyObject *one, *x, *y;
  82         TYPENAME out;
  83         unsigned TYPENAME uout;
  84
  85         one = PyLong_FromLong(1);
  86         if (one == NULL)
  87             return error(
  88                 "unexpected NULL from PyLong_FromLong");
  89
  90         /* Unsigned complains about -1? */
  91         x = PyNumber_Negative(one);
  92         if (x == NULL)
  93             return error(
  94                 "unexpected NULL from PyNumber_Negative");
  95
  96         uout = F_PY_TO_U(x);
  97         if (uout != (unsigned TYPENAME)-1 || !PyErr_Occurred())
  98             return error(
  99                 "PyLong_AsUnsignedXXX(-1) didn't complain");
 100         if (!PyErr_ExceptionMatches(PyExc_OverflowError))
 101             return error(
 102                 "PyLong_AsUnsignedXXX(-1) raised "
 103                 "something other than OverflowError");
 104         PyErr_Clear();
 105         UNBIND(x);
 106
 107         /* Unsigned complains about 2**NBITS? */
 108         y = PyLong_FromLong((long)NBITS);
 109         if (y == NULL)
 110             return error(
 111                 "unexpected NULL from PyLong_FromLong");
 112
 113         x = PyNumber_Lshift(one, y); /* 1L << NBITS, == 2**NBITS */
 114         UNBIND(y);
 115         if (x == NULL)
 116             return error(
 117                 "unexpected NULL from PyNumber_Lshift");
 118
 119         uout = F_PY_TO_U(x);
 120         if (uout != (unsigned TYPENAME)-1 || !PyErr_Occurred())
 121             return error(
 122                 "PyLong_AsUnsignedXXX(2**NBITS) didn't "
 123                 "complain");
 124         if (!PyErr_ExceptionMatches(PyExc_OverflowError))
 125             return error(
 126                 "PyLong_AsUnsignedXXX(2**NBITS) raised "
 127                 "something other than OverflowError");
 128         PyErr_Clear();
 129
 130         /* Signed complains about 2**(NBITS-1)?
 131            x still has 2**NBITS. */
 132         y = PyNumber_Rshift(x, one); /* 2**(NBITS-1) */
 133         UNBIND(x);
 134         if (y == NULL)
 135             return error(
 136                 "unexpected NULL from PyNumber_Rshift");
 137
 138         out = F_PY_TO_S(y);
 139         if (out != (TYPENAME)-1 || !PyErr_Occurred())
 140             return error(
 141                 "PyLong_AsXXX(2**(NBITS-1)) didn't "
 142                 "complain");
 143         if (!PyErr_ExceptionMatches(PyExc_OverflowError))
 144             return error(
 145                 "PyLong_AsXXX(2**(NBITS-1)) raised "
 146                 "something other than OverflowError");
 147         PyErr_Clear();
 148
 149         /* Signed complains about -2**(NBITS-1)-1?;
 150            y still has 2**(NBITS-1). */
 151         x = PyNumber_Negative(y);  /* -(2**(NBITS-1)) */
 152         UNBIND(y);
 153         if (x == NULL)
 154             return error(
 155                 "unexpected NULL from PyNumber_Negative");
 156
 157         y = PyNumber_Subtract(x, one); /* -(2**(NBITS-1))-1 */
 158         UNBIND(x);
 159         if (y == NULL)
 160             return error(
 161                 "unexpected NULL from PyNumber_Subtract");
 162
 163         out = F_PY_TO_S(y);
 164         if (out != (TYPENAME)-1 || !PyErr_Occurred())
 165             return error(
 166                 "PyLong_AsXXX(-2**(NBITS-1)-1) didn't "
 167                 "complain");
 168         if (!PyErr_ExceptionMatches(PyExc_OverflowError))
 169             return error(
 170                 "PyLong_AsXXX(-2**(NBITS-1)-1) raised "
 171                 "something other than OverflowError");
 172         PyErr_Clear();
 173         UNBIND(y);
 174
 175         Py_XDECREF(x);
 176         Py_XDECREF(y);
 177         Py_DECREF(one);
 178     }
 179
 180     Py_INCREF(Py_None);
 181     return Py_None;
 182 }