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 | PyErr_Clear();
|
---|
101 | UNBIND(x);
|
---|
102 |
|
---|
103 | /* Unsigned complains about 2**NBITS? */
|
---|
104 | y = PyLong_FromLong((long)NBITS);
|
---|
105 | if (y == NULL)
|
---|
106 | return error(
|
---|
107 | "unexpected NULL from PyLong_FromLong");
|
---|
108 |
|
---|
109 | x = PyNumber_Lshift(one, y); /* 1L << NBITS, == 2**NBITS */
|
---|
110 | UNBIND(y);
|
---|
111 | if (x == NULL)
|
---|
112 | return error(
|
---|
113 | "unexpected NULL from PyNumber_Lshift");
|
---|
114 |
|
---|
115 | uout = F_PY_TO_U(x);
|
---|
116 | if (uout != (unsigned TYPENAME)-1 || !PyErr_Occurred())
|
---|
117 | return error(
|
---|
118 | "PyLong_AsUnsignedXXX(2**NBITS) didn't "
|
---|
119 | "complain");
|
---|
120 | PyErr_Clear();
|
---|
121 |
|
---|
122 | /* Signed complains about 2**(NBITS-1)?
|
---|
123 | x still has 2**NBITS. */
|
---|
124 | y = PyNumber_Rshift(x, one); /* 2**(NBITS-1) */
|
---|
125 | UNBIND(x);
|
---|
126 | if (y == NULL)
|
---|
127 | return error(
|
---|
128 | "unexpected NULL from PyNumber_Rshift");
|
---|
129 |
|
---|
130 | out = F_PY_TO_S(y);
|
---|
131 | if (out != (TYPENAME)-1 || !PyErr_Occurred())
|
---|
132 | return error(
|
---|
133 | "PyLong_AsXXX(2**(NBITS-1)) didn't "
|
---|
134 | "complain");
|
---|
135 | PyErr_Clear();
|
---|
136 |
|
---|
137 | /* Signed complains about -2**(NBITS-1)-1?;
|
---|
138 | y still has 2**(NBITS-1). */
|
---|
139 | x = PyNumber_Negative(y); /* -(2**(NBITS-1)) */
|
---|
140 | UNBIND(y);
|
---|
141 | if (x == NULL)
|
---|
142 | return error(
|
---|
143 | "unexpected NULL from PyNumber_Negative");
|
---|
144 |
|
---|
145 | y = PyNumber_Subtract(x, one); /* -(2**(NBITS-1))-1 */
|
---|
146 | UNBIND(x);
|
---|
147 | if (y == NULL)
|
---|
148 | return error(
|
---|
149 | "unexpected NULL from PyNumber_Subtract");
|
---|
150 |
|
---|
151 | out = F_PY_TO_S(y);
|
---|
152 | if (out != (TYPENAME)-1 || !PyErr_Occurred())
|
---|
153 | return error(
|
---|
154 | "PyLong_AsXXX(-2**(NBITS-1)-1) didn't "
|
---|
155 | "complain");
|
---|
156 | PyErr_Clear();
|
---|
157 | UNBIND(y);
|
---|
158 |
|
---|
159 | Py_XDECREF(x);
|
---|
160 | Py_XDECREF(y);
|
---|
161 | Py_DECREF(one);
|
---|
162 | }
|
---|
163 |
|
---|
164 | Py_INCREF(Py_None);
|
---|
165 | return Py_None;
|
---|
166 | }
|
---|