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
10static PyObject *
11TESTNAME(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}
183