|
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 } |