Commit | Line | Data |
---|---|---|
920dae64 AT |
1 | import unittest |
2 | from test import test_support | |
3 | import sys | |
4 | ||
5 | import warnings, re | |
6 | warnings.filterwarnings("ignore", | |
7 | category=DeprecationWarning, | |
8 | message=".*integer argument expected, got float", | |
9 | module=__name__) | |
10 | warnings.filterwarnings("ignore", | |
11 | category=DeprecationWarning, | |
12 | message=".*integer argument expected, got float", | |
13 | module="unittest") | |
14 | ||
15 | """ | |
16 | > How about the following counterproposal. This also changes some of | |
17 | > the other format codes to be a little more regular. | |
18 | > | |
19 | > Code C type Range check | |
20 | > | |
21 | > b unsigned char 0..UCHAR_MAX | |
22 | > h signed short SHRT_MIN..SHRT_MAX | |
23 | > B unsigned char none ** | |
24 | > H unsigned short none ** | |
25 | > k * unsigned long none | |
26 | > I * unsigned int 0..UINT_MAX | |
27 | ||
28 | ||
29 | > i int INT_MIN..INT_MAX | |
30 | > l long LONG_MIN..LONG_MAX | |
31 | ||
32 | > K * unsigned long long none | |
33 | > L long long LLONG_MIN..LLONG_MAX | |
34 | ||
35 | > Notes: | |
36 | > | |
37 | > * New format codes. | |
38 | > | |
39 | > ** Changed from previous "range-and-a-half" to "none"; the | |
40 | > range-and-a-half checking wasn't particularly useful. | |
41 | ||
42 | Plus a C API or two, e.g. PyInt_AsLongMask() -> | |
43 | unsigned long and PyInt_AsLongLongMask() -> unsigned | |
44 | long long (if that exists). | |
45 | """ | |
46 | ||
47 | LARGE = 0x7FFFFFFF | |
48 | VERY_LARGE = 0xFF0000121212121212121242L | |
49 | ||
50 | from _testcapi import UCHAR_MAX, USHRT_MAX, UINT_MAX, ULONG_MAX, INT_MAX, \ | |
51 | INT_MIN, LONG_MIN, LONG_MAX | |
52 | ||
53 | # fake, they are not defined in Python's header files | |
54 | LLONG_MAX = 2**63-1 | |
55 | LLONG_MIN = -2**63 | |
56 | ULLONG_MAX = 2**64-1 | |
57 | ||
58 | class Long: | |
59 | def __int__(self): | |
60 | return 99L | |
61 | ||
62 | class Int: | |
63 | def __int__(self): | |
64 | return 99 | |
65 | ||
66 | class Unsigned_TestCase(unittest.TestCase): | |
67 | def test_b(self): | |
68 | from _testcapi import getargs_b | |
69 | # b returns 'unsigned char', and does range checking (0 ... UCHAR_MAX) | |
70 | self.failUnlessEqual(3, getargs_b(3.14)) | |
71 | self.failUnlessEqual(99, getargs_b(Long())) | |
72 | self.failUnlessEqual(99, getargs_b(Int())) | |
73 | ||
74 | self.assertRaises(OverflowError, getargs_b, -1) | |
75 | self.failUnlessEqual(0, getargs_b(0)) | |
76 | self.failUnlessEqual(UCHAR_MAX, getargs_b(UCHAR_MAX)) | |
77 | self.assertRaises(OverflowError, getargs_b, UCHAR_MAX + 1) | |
78 | ||
79 | self.failUnlessEqual(42, getargs_b(42)) | |
80 | self.failUnlessEqual(42, getargs_b(42L)) | |
81 | self.assertRaises(OverflowError, getargs_b, VERY_LARGE) | |
82 | ||
83 | def test_B(self): | |
84 | from _testcapi import getargs_B | |
85 | # B returns 'unsigned char', no range checking | |
86 | self.failUnlessEqual(3, getargs_B(3.14)) | |
87 | self.failUnlessEqual(99, getargs_B(Long())) | |
88 | self.failUnlessEqual(99, getargs_B(Int())) | |
89 | ||
90 | self.failUnlessEqual(UCHAR_MAX, getargs_B(-1)) | |
91 | self.failUnlessEqual(UCHAR_MAX, getargs_B(-1L)) | |
92 | self.failUnlessEqual(0, getargs_B(0)) | |
93 | self.failUnlessEqual(UCHAR_MAX, getargs_B(UCHAR_MAX)) | |
94 | self.failUnlessEqual(0, getargs_B(UCHAR_MAX+1)) | |
95 | ||
96 | self.failUnlessEqual(42, getargs_B(42)) | |
97 | self.failUnlessEqual(42, getargs_B(42L)) | |
98 | self.failUnlessEqual(UCHAR_MAX & VERY_LARGE, getargs_B(VERY_LARGE)) | |
99 | ||
100 | def test_H(self): | |
101 | from _testcapi import getargs_H | |
102 | # H returns 'unsigned short', no range checking | |
103 | self.failUnlessEqual(3, getargs_H(3.14)) | |
104 | self.failUnlessEqual(99, getargs_H(Long())) | |
105 | self.failUnlessEqual(99, getargs_H(Int())) | |
106 | ||
107 | self.failUnlessEqual(USHRT_MAX, getargs_H(-1)) | |
108 | self.failUnlessEqual(0, getargs_H(0)) | |
109 | self.failUnlessEqual(USHRT_MAX, getargs_H(USHRT_MAX)) | |
110 | self.failUnlessEqual(0, getargs_H(USHRT_MAX+1)) | |
111 | ||
112 | self.failUnlessEqual(42, getargs_H(42)) | |
113 | self.failUnlessEqual(42, getargs_H(42L)) | |
114 | ||
115 | self.failUnlessEqual(VERY_LARGE & USHRT_MAX, getargs_H(VERY_LARGE)) | |
116 | ||
117 | def test_I(self): | |
118 | from _testcapi import getargs_I | |
119 | # I returns 'unsigned int', no range checking | |
120 | self.failUnlessEqual(3, getargs_I(3.14)) | |
121 | self.failUnlessEqual(99, getargs_I(Long())) | |
122 | self.failUnlessEqual(99, getargs_I(Int())) | |
123 | ||
124 | self.failUnlessEqual(UINT_MAX, getargs_I(-1)) | |
125 | self.failUnlessEqual(0, getargs_I(0)) | |
126 | self.failUnlessEqual(UINT_MAX, getargs_I(UINT_MAX)) | |
127 | self.failUnlessEqual(0, getargs_I(UINT_MAX+1)) | |
128 | ||
129 | self.failUnlessEqual(42, getargs_I(42)) | |
130 | self.failUnlessEqual(42, getargs_I(42L)) | |
131 | ||
132 | self.failUnlessEqual(VERY_LARGE & UINT_MAX, getargs_I(VERY_LARGE)) | |
133 | ||
134 | def test_k(self): | |
135 | from _testcapi import getargs_k | |
136 | # k returns 'unsigned long', no range checking | |
137 | # it does not accept float, or instances with __int__ | |
138 | self.assertRaises(TypeError, getargs_k, 3.14) | |
139 | self.assertRaises(TypeError, getargs_k, Long()) | |
140 | self.assertRaises(TypeError, getargs_k, Int()) | |
141 | ||
142 | self.failUnlessEqual(ULONG_MAX, getargs_k(-1)) | |
143 | self.failUnlessEqual(0, getargs_k(0)) | |
144 | self.failUnlessEqual(ULONG_MAX, getargs_k(ULONG_MAX)) | |
145 | self.failUnlessEqual(0, getargs_k(ULONG_MAX+1)) | |
146 | ||
147 | self.failUnlessEqual(42, getargs_k(42)) | |
148 | self.failUnlessEqual(42, getargs_k(42L)) | |
149 | ||
150 | self.failUnlessEqual(VERY_LARGE & ULONG_MAX, getargs_k(VERY_LARGE)) | |
151 | ||
152 | class Signed_TestCase(unittest.TestCase): | |
153 | def test_i(self): | |
154 | from _testcapi import getargs_i | |
155 | # i returns 'int', and does range checking (INT_MIN ... INT_MAX) | |
156 | self.failUnlessEqual(3, getargs_i(3.14)) | |
157 | self.failUnlessEqual(99, getargs_i(Long())) | |
158 | self.failUnlessEqual(99, getargs_i(Int())) | |
159 | ||
160 | self.assertRaises(OverflowError, getargs_i, INT_MIN-1) | |
161 | self.failUnlessEqual(INT_MIN, getargs_i(INT_MIN)) | |
162 | self.failUnlessEqual(INT_MAX, getargs_i(INT_MAX)) | |
163 | self.assertRaises(OverflowError, getargs_i, INT_MAX+1) | |
164 | ||
165 | self.failUnlessEqual(42, getargs_i(42)) | |
166 | self.failUnlessEqual(42, getargs_i(42L)) | |
167 | self.assertRaises(OverflowError, getargs_i, VERY_LARGE) | |
168 | ||
169 | def test_l(self): | |
170 | from _testcapi import getargs_l | |
171 | # l returns 'long', and does range checking (LONG_MIN ... LONG_MAX) | |
172 | self.failUnlessEqual(3, getargs_l(3.14)) | |
173 | self.failUnlessEqual(99, getargs_l(Long())) | |
174 | self.failUnlessEqual(99, getargs_l(Int())) | |
175 | ||
176 | self.assertRaises(OverflowError, getargs_l, LONG_MIN-1) | |
177 | self.failUnlessEqual(LONG_MIN, getargs_l(LONG_MIN)) | |
178 | self.failUnlessEqual(LONG_MAX, getargs_l(LONG_MAX)) | |
179 | self.assertRaises(OverflowError, getargs_l, LONG_MAX+1) | |
180 | ||
181 | self.failUnlessEqual(42, getargs_l(42)) | |
182 | self.failUnlessEqual(42, getargs_l(42L)) | |
183 | self.assertRaises(OverflowError, getargs_l, VERY_LARGE) | |
184 | ||
185 | ||
186 | class LongLong_TestCase(unittest.TestCase): | |
187 | def test_L(self): | |
188 | from _testcapi import getargs_L | |
189 | # L returns 'long long', and does range checking (LLONG_MIN ... LLONG_MAX) | |
190 | self.failUnlessRaises(TypeError, getargs_L, "Hello") | |
191 | self.failUnlessEqual(3, getargs_L(3.14)) | |
192 | self.failUnlessEqual(99, getargs_L(Long())) | |
193 | self.failUnlessEqual(99, getargs_L(Int())) | |
194 | ||
195 | self.assertRaises(OverflowError, getargs_L, LLONG_MIN-1) | |
196 | self.failUnlessEqual(LLONG_MIN, getargs_L(LLONG_MIN)) | |
197 | self.failUnlessEqual(LLONG_MAX, getargs_L(LLONG_MAX)) | |
198 | self.assertRaises(OverflowError, getargs_L, LLONG_MAX+1) | |
199 | ||
200 | self.failUnlessEqual(42, getargs_L(42)) | |
201 | self.failUnlessEqual(42, getargs_L(42L)) | |
202 | self.assertRaises(OverflowError, getargs_L, VERY_LARGE) | |
203 | ||
204 | def test_K(self): | |
205 | from _testcapi import getargs_K | |
206 | # K return 'unsigned long long', no range checking | |
207 | self.assertRaises(TypeError, getargs_K, 3.14) | |
208 | self.assertRaises(TypeError, getargs_K, Long()) | |
209 | self.assertRaises(TypeError, getargs_K, Int()) | |
210 | self.failUnlessEqual(ULLONG_MAX, getargs_K(ULLONG_MAX)) | |
211 | self.failUnlessEqual(0, getargs_K(0)) | |
212 | self.failUnlessEqual(0, getargs_K(ULLONG_MAX+1)) | |
213 | ||
214 | self.failUnlessEqual(42, getargs_K(42)) | |
215 | self.failUnlessEqual(42, getargs_K(42L)) | |
216 | ||
217 | self.failUnlessEqual(VERY_LARGE & ULLONG_MAX, getargs_K(VERY_LARGE)) | |
218 | ||
219 | def test_main(): | |
220 | tests = [Signed_TestCase, Unsigned_TestCase] | |
221 | try: | |
222 | from _testcapi import getargs_L, getargs_K | |
223 | except ImportError: | |
224 | pass # PY_LONG_LONG not available | |
225 | else: | |
226 | tests.append(LongLong_TestCase) | |
227 | test_support.run_unittest(*tests) | |
228 | ||
229 | if __name__ == "__main__": | |
230 | test_main() |